<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[206172] trunk/Source/JavaScriptCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/206172">206172</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2016-09-20 14:04:06 -0700 (Tue, 20 Sep 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Rename MarkedSpace::version/MarkedBlock::version to MarkedSpace::markingVersion/MarkedBlock::markingVersion
https://bugs.webkit.org/show_bug.cgi?id=162310
Reviewed by Geoffrey Garen.
In bug 162309, which is part of my concurrent GC work, I'll need to introduce a second
version-based flip. This one will be for newlyAllocated bits. This will allow me to
cheaply preserve per-object live state during marking. MarkedBlock::aboutToMarkSlow() will
do this instead of clearMarks():
- Walk the mark bits, simultaneously counting the number of set bits and clearing
them.
- If the count is zero, then we're done.
- If the count is equal to the max number of cells in the block, then set the
allocated bit for the block.
- If the count is something else, create a newlyAllocated vector.
The hope is that the last mode is going to be rare, since most blocks are not fragmented
at end of GC. Usually, we will fill them in with objects by allocating! But if we do
create newlyAllocated bits then we need to have some way of blowing them away later.
This is where a second version comes in. We can have a version for newlyAllocated bits,
which we increment at the end of marking, at around the same time that we clear all
allocated bits.
This means that the MarkedBlock will have two different version-based flips, so terms like
"flip" and "version" aren't enough.
This patch gets rid of the term "flip" entirely. It's a term of art in GCs that refers to
the state change at the beginning or end of GC. It refers to the logical state change, not
the physical one. It doesn't actually make sense to speak of a block being flipped
independently of other blocks. It's true that our implementation of the flip makes some
state updates happen lazily, but the block updating itself in some way (like clearing mark
bits) isn't the flip - the flip already happened when the version was incremented.
We no longer refer to a version without qualifying what kind of version it is. The type is
HeapVersion. All of the version members were renamed to markingVersion, to reflect the
fact that this version is just used for doing things to marking state. Instead of asking
if the block needsFlip(), we ask if areMarksStale().
This will let us introduce a second version for newlyAllocated, and will let us speak of
the two versions unambiguously.
* heap/CellContainer.h:
* heap/CellContainerInlines.h:
(JSC::CellContainer::isMarked):
(JSC::CellContainer::isMarkedOrNewlyAllocated):
(JSC::CellContainer::aboutToMark):
(JSC::CellContainer::areMarksStale):
(JSC::CellContainer::needsFlip): Deleted.
* heap/ConservativeRoots.cpp:
(JSC::ConservativeRoots::genericAddPointer):
(JSC::ConservativeRoots::genericAddSpan):
* heap/HeapInlines.h:
(JSC::Heap::isMarked):
(JSC::Heap::isMarkedConcurrently):
(JSC::Heap::testAndSetMarked):
* heap/HeapUtil.h:
(JSC::HeapUtil::findGCObjectPointersForMarking):
* heap/MarkedAllocator.cpp:
(JSC::MarkedAllocator::isPagedOut):
* heap/MarkedBlock.cpp:
(JSC::MarkedBlock::MarkedBlock):
(JSC::MarkedBlock::Handle::specializedSweep):
(JSC::MarkedBlock::Handle::sweepHelperSelectSweepMode):
(JSC::MarkedBlock::Handle::sweepHelperSelectMarksMode):
(JSC::MarkedBlock::aboutToMarkSlow):
(JSC::MarkedBlock::clearMarks):
(JSC::MarkedBlock::assertMarksNotStale):
(JSC::MarkedBlock::areMarksStale):
(JSC::MarkedBlock::Handle::areMarksStale):
(JSC::MarkedBlock::isMarked):
(JSC::MarkedBlock::Handle::isMarkedOrNewlyAllocated):
(JSC::MarkedBlock::isMarkedOrNewlyAllocated):
(JSC::MarkedBlock::markCount):
(JSC::MarkedBlock::Handle::isLive):
(JSC::MarkedBlock::Handle::isLiveCell):
(JSC::MarkedBlock::Handle::sweepHelperSelectFlipMode): Deleted.
(JSC::MarkedBlock::assertFlipped): Deleted.
(JSC::MarkedBlock::needsFlip): Deleted.
(JSC::MarkedBlock::Handle::needsFlip): Deleted.
* heap/MarkedBlock.h:
(JSC::MarkedBlock::areMarksStale):
(JSC::MarkedBlock::aboutToMark):
(JSC::MarkedBlock::assertMarksNotStale):
(JSC::MarkedBlock::Handle::assertMarksNotStale):
(JSC::MarkedBlock::isMarked):
(JSC::MarkedBlock::isMarkedConcurrently):
(JSC::MarkedBlock::testAndSetMarked):
(JSC::MarkedBlock::Handle::isMarkedOrNewlyAllocated):
(JSC::MarkedBlock::isMarkedOrNewlyAllocated):
(JSC::MarkedBlock::needsFlip): Deleted.
(JSC::MarkedBlock::assertFlipped): Deleted.
(JSC::MarkedBlock::Handle::assertFlipped): Deleted.
* heap/MarkedBlockInlines.h:
(JSC::MarkedBlock::Handle::isLive):
(JSC::MarkedBlock::Handle::isLiveCell):
(JSC::MarkedBlock::resetMarkingVersion):
(JSC::MarkedBlock::resetVersion): Deleted.
* heap/MarkedSpace.cpp:
(JSC::MarkedSpace::beginMarking):
* heap/MarkedSpace.h:
(JSC::MarkedSpace::markingVersion):
(JSC::MarkedSpace::version): Deleted.
* heap/SlotVisitor.cpp:
(JSC::SlotVisitor::SlotVisitor):
(JSC::SlotVisitor::didStartMarking):
(JSC::SlotVisitor::appendJSCellOrAuxiliary):
(JSC::SlotVisitor::setMarkedAndAppendToMarkStack):
(JSC::SlotVisitor::markAuxiliary):
* heap/SlotVisitor.h:
(JSC::SlotVisitor::markingVersion):
(JSC::SlotVisitor::version): Deleted.
* heap/WeakBlock.cpp:
(JSC::WeakBlock::specializedVisit):
(JSC::WeakBlock::reap):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapCellContainerh">trunk/Source/JavaScriptCore/heap/CellContainer.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapCellContainerInlinesh">trunk/Source/JavaScriptCore/heap/CellContainerInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapConservativeRootscpp">trunk/Source/JavaScriptCore/heap/ConservativeRoots.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapHeapInlinesh">trunk/Source/JavaScriptCore/heap/HeapInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapHeapUtilh">trunk/Source/JavaScriptCore/heap/HeapUtil.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapMarkedAllocatorcpp">trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapMarkedBlockcpp">trunk/Source/JavaScriptCore/heap/MarkedBlock.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapMarkedBlockh">trunk/Source/JavaScriptCore/heap/MarkedBlock.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapMarkedBlockInlinesh">trunk/Source/JavaScriptCore/heap/MarkedBlockInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapMarkedSpacecpp">trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapMarkedSpaceh">trunk/Source/JavaScriptCore/heap/MarkedSpace.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapSlotVisitorcpp">trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapSlotVisitorh">trunk/Source/JavaScriptCore/heap/SlotVisitor.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreheapWeakBlockcpp">trunk/Source/JavaScriptCore/heap/WeakBlock.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -1,3 +1,122 @@
</span><ins>+2016-09-20 Filip Pizlo <fpizlo@apple.com>
+
+ Rename MarkedSpace::version/MarkedBlock::version to MarkedSpace::markingVersion/MarkedBlock::markingVersion
+ https://bugs.webkit.org/show_bug.cgi?id=162310
+
+ Reviewed by Geoffrey Garen.
+
+ In bug 162309, which is part of my concurrent GC work, I'll need to introduce a second
+ version-based flip. This one will be for newlyAllocated bits. This will allow me to
+ cheaply preserve per-object live state during marking. MarkedBlock::aboutToMarkSlow() will
+ do this instead of clearMarks():
+
+ - Walk the mark bits, simultaneously counting the number of set bits and clearing
+ them.
+ - If the count is zero, then we're done.
+ - If the count is equal to the max number of cells in the block, then set the
+ allocated bit for the block.
+ - If the count is something else, create a newlyAllocated vector.
+
+ The hope is that the last mode is going to be rare, since most blocks are not fragmented
+ at end of GC. Usually, we will fill them in with objects by allocating! But if we do
+ create newlyAllocated bits then we need to have some way of blowing them away later.
+
+ This is where a second version comes in. We can have a version for newlyAllocated bits,
+ which we increment at the end of marking, at around the same time that we clear all
+ allocated bits.
+
+ This means that the MarkedBlock will have two different version-based flips, so terms like
+ "flip" and "version" aren't enough.
+
+ This patch gets rid of the term "flip" entirely. It's a term of art in GCs that refers to
+ the state change at the beginning or end of GC. It refers to the logical state change, not
+ the physical one. It doesn't actually make sense to speak of a block being flipped
+ independently of other blocks. It's true that our implementation of the flip makes some
+ state updates happen lazily, but the block updating itself in some way (like clearing mark
+ bits) isn't the flip - the flip already happened when the version was incremented.
+
+ We no longer refer to a version without qualifying what kind of version it is. The type is
+ HeapVersion. All of the version members were renamed to markingVersion, to reflect the
+ fact that this version is just used for doing things to marking state. Instead of asking
+ if the block needsFlip(), we ask if areMarksStale().
+
+ This will let us introduce a second version for newlyAllocated, and will let us speak of
+ the two versions unambiguously.
+
+ * heap/CellContainer.h:
+ * heap/CellContainerInlines.h:
+ (JSC::CellContainer::isMarked):
+ (JSC::CellContainer::isMarkedOrNewlyAllocated):
+ (JSC::CellContainer::aboutToMark):
+ (JSC::CellContainer::areMarksStale):
+ (JSC::CellContainer::needsFlip): Deleted.
+ * heap/ConservativeRoots.cpp:
+ (JSC::ConservativeRoots::genericAddPointer):
+ (JSC::ConservativeRoots::genericAddSpan):
+ * heap/HeapInlines.h:
+ (JSC::Heap::isMarked):
+ (JSC::Heap::isMarkedConcurrently):
+ (JSC::Heap::testAndSetMarked):
+ * heap/HeapUtil.h:
+ (JSC::HeapUtil::findGCObjectPointersForMarking):
+ * heap/MarkedAllocator.cpp:
+ (JSC::MarkedAllocator::isPagedOut):
+ * heap/MarkedBlock.cpp:
+ (JSC::MarkedBlock::MarkedBlock):
+ (JSC::MarkedBlock::Handle::specializedSweep):
+ (JSC::MarkedBlock::Handle::sweepHelperSelectSweepMode):
+ (JSC::MarkedBlock::Handle::sweepHelperSelectMarksMode):
+ (JSC::MarkedBlock::aboutToMarkSlow):
+ (JSC::MarkedBlock::clearMarks):
+ (JSC::MarkedBlock::assertMarksNotStale):
+ (JSC::MarkedBlock::areMarksStale):
+ (JSC::MarkedBlock::Handle::areMarksStale):
+ (JSC::MarkedBlock::isMarked):
+ (JSC::MarkedBlock::Handle::isMarkedOrNewlyAllocated):
+ (JSC::MarkedBlock::isMarkedOrNewlyAllocated):
+ (JSC::MarkedBlock::markCount):
+ (JSC::MarkedBlock::Handle::isLive):
+ (JSC::MarkedBlock::Handle::isLiveCell):
+ (JSC::MarkedBlock::Handle::sweepHelperSelectFlipMode): Deleted.
+ (JSC::MarkedBlock::assertFlipped): Deleted.
+ (JSC::MarkedBlock::needsFlip): Deleted.
+ (JSC::MarkedBlock::Handle::needsFlip): Deleted.
+ * heap/MarkedBlock.h:
+ (JSC::MarkedBlock::areMarksStale):
+ (JSC::MarkedBlock::aboutToMark):
+ (JSC::MarkedBlock::assertMarksNotStale):
+ (JSC::MarkedBlock::Handle::assertMarksNotStale):
+ (JSC::MarkedBlock::isMarked):
+ (JSC::MarkedBlock::isMarkedConcurrently):
+ (JSC::MarkedBlock::testAndSetMarked):
+ (JSC::MarkedBlock::Handle::isMarkedOrNewlyAllocated):
+ (JSC::MarkedBlock::isMarkedOrNewlyAllocated):
+ (JSC::MarkedBlock::needsFlip): Deleted.
+ (JSC::MarkedBlock::assertFlipped): Deleted.
+ (JSC::MarkedBlock::Handle::assertFlipped): Deleted.
+ * heap/MarkedBlockInlines.h:
+ (JSC::MarkedBlock::Handle::isLive):
+ (JSC::MarkedBlock::Handle::isLiveCell):
+ (JSC::MarkedBlock::resetMarkingVersion):
+ (JSC::MarkedBlock::resetVersion): Deleted.
+ * heap/MarkedSpace.cpp:
+ (JSC::MarkedSpace::beginMarking):
+ * heap/MarkedSpace.h:
+ (JSC::MarkedSpace::markingVersion):
+ (JSC::MarkedSpace::version): Deleted.
+ * heap/SlotVisitor.cpp:
+ (JSC::SlotVisitor::SlotVisitor):
+ (JSC::SlotVisitor::didStartMarking):
+ (JSC::SlotVisitor::appendJSCellOrAuxiliary):
+ (JSC::SlotVisitor::setMarkedAndAppendToMarkStack):
+ (JSC::SlotVisitor::markAuxiliary):
+ * heap/SlotVisitor.h:
+ (JSC::SlotVisitor::markingVersion):
+ (JSC::SlotVisitor::version): Deleted.
+ * heap/WeakBlock.cpp:
+ (JSC::WeakBlock::specializedVisit):
+ (JSC::WeakBlock::reap):
+
</ins><span class="cx"> 2016-09-20 Ryan Haddad <ryanhaddad@apple.com>
</span><span class="cx">
</span><span class="cx"> Rebaseline builtins generator tests after r206155.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapCellContainerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/CellContainer.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/CellContainer.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/CellContainer.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -78,13 +78,13 @@
</span><span class="cx"> return *bitwise_cast<LargeAllocation*>(m_encodedPointer - isLargeAllocationBit);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void aboutToMark(HeapVersion);
- bool needsFlip() const;
</del><ins>+ void aboutToMark(HeapVersion markingVersion);
+ bool areMarksStale() const;
</ins><span class="cx">
</span><span class="cx"> bool isMarked(HeapCell*) const;
</span><del>- bool isMarked(HeapVersion, HeapCell*) const;
</del><ins>+ bool isMarked(HeapVersion markingVersion, HeapCell*) const;
</ins><span class="cx"> bool isMarkedOrNewlyAllocated(HeapCell*) const;
</span><del>- bool isMarkedOrNewlyAllocated(HeapVersion, HeapCell*) const;
</del><ins>+ bool isMarkedOrNewlyAllocated(HeapVersion markingVersion, HeapCell*) const;
</ins><span class="cx">
</span><span class="cx"> void noteMarked();
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapCellContainerInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/CellContainerInlines.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/CellContainerInlines.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/CellContainerInlines.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -52,11 +52,11 @@
</span><span class="cx"> return markedBlock().isMarked(cell);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool CellContainer::isMarked(HeapVersion version, HeapCell* cell) const
</del><ins>+inline bool CellContainer::isMarked(HeapVersion markingVersion, HeapCell* cell) const
</ins><span class="cx"> {
</span><span class="cx"> if (isLargeAllocation())
</span><span class="cx"> return largeAllocation().isMarked();
</span><del>- return markedBlock().isMarked(version, cell);
</del><ins>+ return markedBlock().isMarked(markingVersion, cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool CellContainer::isMarkedOrNewlyAllocated(HeapCell* cell) const
</span><span class="lines">@@ -66,11 +66,11 @@
</span><span class="cx"> return markedBlock().isMarkedOrNewlyAllocated(cell);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool CellContainer::isMarkedOrNewlyAllocated(HeapVersion version, HeapCell* cell) const
</del><ins>+inline bool CellContainer::isMarkedOrNewlyAllocated(HeapVersion markingVersion, HeapCell* cell) const
</ins><span class="cx"> {
</span><span class="cx"> if (isLargeAllocation())
</span><span class="cx"> return largeAllocation().isMarkedOrNewlyAllocated();
</span><del>- return markedBlock().isMarkedOrNewlyAllocated(version, cell);
</del><ins>+ return markedBlock().isMarkedOrNewlyAllocated(markingVersion, cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline void CellContainer::noteMarked()
</span><span class="lines">@@ -93,17 +93,17 @@
</span><span class="cx"> return markedBlock().weakSet();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline void CellContainer::aboutToMark(HeapVersion heapVersion)
</del><ins>+inline void CellContainer::aboutToMark(HeapVersion markingVersion)
</ins><span class="cx"> {
</span><span class="cx"> if (!isLargeAllocation())
</span><del>- markedBlock().aboutToMark(heapVersion);
</del><ins>+ markedBlock().aboutToMark(markingVersion);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool CellContainer::needsFlip() const
</del><ins>+inline bool CellContainer::areMarksStale() const
</ins><span class="cx"> {
</span><span class="cx"> if (isLargeAllocation())
</span><span class="cx"> return false;
</span><del>- return markedBlock().needsFlip();
</del><ins>+ return markedBlock().areMarksStale();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapConservativeRootscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/ConservativeRoots.cpp (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/ConservativeRoots.cpp 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/ConservativeRoots.cpp 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -66,12 +66,12 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename MarkHook>
</span><del>-inline void ConservativeRoots::genericAddPointer(void* p, HeapVersion version, TinyBloomFilter filter, MarkHook& markHook)
</del><ins>+inline void ConservativeRoots::genericAddPointer(void* p, HeapVersion markingVersion, TinyBloomFilter filter, MarkHook& markHook)
</ins><span class="cx"> {
</span><span class="cx"> markHook.mark(p);
</span><span class="cx">
</span><span class="cx"> HeapUtil::findGCObjectPointersForMarking(
</span><del>- m_heap, version, filter, p,
</del><ins>+ m_heap, markingVersion, filter, p,
</ins><span class="cx"> [&] (void* p) {
</span><span class="cx"> if (m_size == m_capacity)
</span><span class="cx"> grow();
</span><span class="lines">@@ -94,9 +94,9 @@
</span><span class="cx"> RELEASE_ASSERT(isPointerAligned(end));
</span><span class="cx">
</span><span class="cx"> TinyBloomFilter filter = m_heap.objectSpace().blocks().filter(); // Make a local copy of filter to show the compiler it won't alias, and can be register-allocated.
</span><del>- HeapVersion version = m_heap.objectSpace().version();
</del><ins>+ HeapVersion markingVersion = m_heap.objectSpace().markingVersion();
</ins><span class="cx"> for (char** it = static_cast<char**>(begin); it != static_cast<char**>(end); ++it)
</span><del>- genericAddPointer(*it, version, filter, markHook);
</del><ins>+ genericAddPointer(*it, markingVersion, filter, markHook);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> class DummyMarkHook {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapHeapInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/HeapInlines.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/HeapInlines.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/HeapInlines.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -82,7 +82,7 @@
</span><span class="cx"> return cell->largeAllocation().isMarked();
</span><span class="cx"> MarkedBlock& block = cell->markedBlock();
</span><span class="cx"> return block.isMarked(
</span><del>- block.vm()->heap.objectSpace().version(), cell);
</del><ins>+ block.vm()->heap.objectSpace().markingVersion(), cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE bool Heap::isMarkedConcurrently(const void* rawCell)
</span><span class="lines">@@ -92,16 +92,16 @@
</span><span class="cx"> return cell->largeAllocation().isMarked();
</span><span class="cx"> MarkedBlock& block = cell->markedBlock();
</span><span class="cx"> return block.isMarkedConcurrently(
</span><del>- block.vm()->heap.objectSpace().version(), cell);
</del><ins>+ block.vm()->heap.objectSpace().markingVersion(), cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE bool Heap::testAndSetMarked(HeapVersion version, const void* rawCell)
</del><ins>+ALWAYS_INLINE bool Heap::testAndSetMarked(HeapVersion markingVersion, const void* rawCell)
</ins><span class="cx"> {
</span><span class="cx"> HeapCell* cell = bitwise_cast<HeapCell*>(rawCell);
</span><span class="cx"> if (cell->isLargeAllocation())
</span><span class="cx"> return cell->largeAllocation().testAndSetMarked();
</span><span class="cx"> MarkedBlock& block = cell->markedBlock();
</span><del>- block.aboutToMark(version);
</del><ins>+ block.aboutToMark(markingVersion);
</ins><span class="cx"> return block.testAndSetMarked(cell);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapHeapUtilh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/HeapUtil.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/HeapUtil.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/HeapUtil.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -46,7 +46,7 @@
</span><span class="cx"> // before liveness data is cleared to be accurate.
</span><span class="cx"> template<typename Func>
</span><span class="cx"> static void findGCObjectPointersForMarking(
</span><del>- Heap& heap, HeapVersion heapVersion, TinyBloomFilter filter, void* passedPointer,
</del><ins>+ Heap& heap, HeapVersion markingVersion, TinyBloomFilter filter, void* passedPointer,
</ins><span class="cx"> const Func& func)
</span><span class="cx"> {
</span><span class="cx"> const HashSet<MarkedBlock*>& set = heap.objectSpace().blocks().set();
</span><span class="lines">@@ -85,7 +85,7 @@
</span><span class="cx"> && set.contains(previousCandidate)
</span><span class="cx"> && previousCandidate->handle().cellKind() == HeapCell::Auxiliary) {
</span><span class="cx"> previousPointer = static_cast<char*>(previousCandidate->handle().cellAlign(previousPointer));
</span><del>- if (previousCandidate->handle().isLiveCell(heapVersion, previousPointer))
</del><ins>+ if (previousCandidate->handle().isLiveCell(markingVersion, previousPointer))
</ins><span class="cx"> func(previousPointer);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -99,7 +99,7 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> auto tryPointer = [&] (void* pointer) {
</span><del>- if (candidate->handle().isLiveCell(heapVersion, pointer))
</del><ins>+ if (candidate->handle().isLiveCell(markingVersion, pointer))
</ins><span class="cx"> func(pointer);
</span><span class="cx"> };
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapMarkedAllocatorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -55,8 +55,8 @@
</span><span class="cx"> MarkedBlock::Handle* block = m_blocks[index];
</span><span class="cx"> if (block) {
</span><span class="cx"> // Forces us to touch the memory of the block, but has no semantic effect.
</span><del>- if (block->needsFlip())
- block->block().resetVersion();
</del><ins>+ if (block->areMarksStale())
+ block->block().resetMarkingVersion();
</ins><span class="cx"> }
</span><span class="cx"> ++itersSinceLastTimeCheck;
</span><span class="cx"> if (itersSinceLastTimeCheck >= Heap::s_timeCheckResolution) {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapMarkedBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/MarkedBlock.cpp (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/MarkedBlock.cpp 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/MarkedBlock.cpp 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -77,13 +77,13 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> MarkedBlock::MarkedBlock(VM& vm, Handle& handle)
</span><del>- : m_version(MarkedSpace::nullVersion)
</del><ins>+ : m_markingVersion(MarkedSpace::nullVersion)
</ins><span class="cx"> , m_handle(handle)
</span><span class="cx"> , m_vm(&vm)
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>-template<MarkedBlock::Handle::EmptyMode emptyMode, MarkedBlock::Handle::SweepMode sweepMode, DestructionMode destructionMode, MarkedBlock::Handle::ScribbleMode scribbleMode, MarkedBlock::Handle::NewlyAllocatedMode newlyAllocatedMode, MarkedBlock::Handle::FlipMode flipMode>
</del><ins>+template<MarkedBlock::Handle::EmptyMode emptyMode, MarkedBlock::Handle::SweepMode sweepMode, DestructionMode destructionMode, MarkedBlock::Handle::ScribbleMode scribbleMode, MarkedBlock::Handle::NewlyAllocatedMode newlyAllocatedMode, MarkedBlock::Handle::MarksMode marksMode>
</ins><span class="cx"> FreeList MarkedBlock::Handle::specializedSweep()
</span><span class="cx"> {
</span><span class="cx"> RELEASE_ASSERT(!(destructionMode == DoesNotNeedDestruction && sweepMode == SweepOnly));
</span><span class="lines">@@ -98,7 +98,7 @@
</span><span class="cx"> if (Options::useBumpAllocator()
</span><span class="cx"> && emptyMode == IsEmpty
</span><span class="cx"> && newlyAllocatedMode == DoesNotHaveNewlyAllocated) {
</span><del>- ASSERT(flipMode == NeedsFlip);
</del><ins>+ ASSERT(marksMode == MarksStale);
</ins><span class="cx">
</span><span class="cx"> char* startOfLastCell = static_cast<char*>(cellAlign(block.atoms() + m_endAtom - 1));
</span><span class="cx"> char* payloadEnd = startOfLastCell + cellSize();
</span><span class="lines">@@ -124,7 +124,7 @@
</span><span class="cx"> bool isEmpty = true;
</span><span class="cx"> for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell) {
</span><span class="cx"> if (emptyMode == NotEmpty
</span><del>- && ((flipMode == DoesNotNeedFlip && block.m_marks.get(i))
</del><ins>+ && ((marksMode == MarksNotStale && block.m_marks.get(i))
</ins><span class="cx"> || (newlyAllocatedMode == HasNewlyAllocated && m_newlyAllocated->get(i)))) {
</span><span class="cx"> isEmpty = false;
</span><span class="cx"> continue;
</span><span class="lines">@@ -216,16 +216,16 @@
</span><span class="cx"> FreeList MarkedBlock::Handle::sweepHelperSelectSweepMode(SweepMode sweepMode)
</span><span class="cx"> {
</span><span class="cx"> if (sweepMode == SweepToFreeList)
</span><del>- return sweepHelperSelectFlipMode<emptyMode, SweepToFreeList, destructionMode, scribbleMode, newlyAllocatedMode>();
- return sweepHelperSelectFlipMode<emptyMode, SweepOnly, destructionMode, scribbleMode, newlyAllocatedMode>();
</del><ins>+ return sweepHelperSelectMarksMode<emptyMode, SweepToFreeList, destructionMode, scribbleMode, newlyAllocatedMode>();
+ return sweepHelperSelectMarksMode<emptyMode, SweepOnly, destructionMode, scribbleMode, newlyAllocatedMode>();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<MarkedBlock::Handle::EmptyMode emptyMode, MarkedBlock::Handle::SweepMode sweepMode, DestructionMode destructionMode, MarkedBlock::Handle::ScribbleMode scribbleMode, MarkedBlock::Handle::NewlyAllocatedMode newlyAllocatedMode>
</span><del>-FreeList MarkedBlock::Handle::sweepHelperSelectFlipMode()
</del><ins>+FreeList MarkedBlock::Handle::sweepHelperSelectMarksMode()
</ins><span class="cx"> {
</span><del>- if (needsFlip())
- return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, NeedsFlip>();
- return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, DoesNotNeedFlip>();
</del><ins>+ if (areMarksStale())
+ return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, MarksStale>();
+ return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, MarksNotStale>();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void MarkedBlock::Handle::unsweepWithNoNewlyAllocated()
</span><span class="lines">@@ -342,12 +342,12 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void MarkedBlock::aboutToMarkSlow(HeapVersion heapVersion)
</del><ins>+void MarkedBlock::aboutToMarkSlow(HeapVersion markingVersion)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(vm()->heap.objectSpace().isMarking());
</span><span class="cx"> LockHolder locker(m_lock);
</span><del>- if (needsFlip(heapVersion)) {
- clearMarks(heapVersion);
</del><ins>+ if (areMarksStale(markingVersion)) {
+ clearMarks(markingVersion);
</ins><span class="cx"> // This means we're the first ones to mark any object in this block.
</span><span class="cx"> handle().allocator()->atomicSetAndCheckIsMarkingNotEmpty(&handle(), true);
</span><span class="cx"> }
</span><span class="lines">@@ -355,47 +355,47 @@
</span><span class="cx">
</span><span class="cx"> void MarkedBlock::clearMarks()
</span><span class="cx"> {
</span><del>- clearMarks(vm()->heap.objectSpace().version());
</del><ins>+ clearMarks(vm()->heap.objectSpace().markingVersion());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void MarkedBlock::clearMarks(HeapVersion heapVersion)
</del><ins>+void MarkedBlock::clearMarks(HeapVersion markingVersion)
</ins><span class="cx"> {
</span><span class="cx"> m_marks.clearAll();
</span><span class="cx"> clearHasAnyMarked();
</span><span class="cx"> WTF::storeStoreFence();
</span><del>- m_version = heapVersion;
</del><ins>+ m_markingVersion = markingVersion;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if !ASSERT_DISABLED
</span><del>-void MarkedBlock::assertFlipped()
</del><ins>+void MarkedBlock::assertMarksNotStale()
</ins><span class="cx"> {
</span><del>- ASSERT(m_version == vm()->heap.objectSpace().version());
</del><ins>+ ASSERT(m_markingVersion == vm()->heap.objectSpace().markingVersion());
</ins><span class="cx"> }
</span><span class="cx"> #endif // !ASSERT_DISABLED
</span><span class="cx">
</span><del>-bool MarkedBlock::needsFlip()
</del><ins>+bool MarkedBlock::areMarksStale()
</ins><span class="cx"> {
</span><del>- return needsFlip(vm()->heap.objectSpace().version());
</del><ins>+ return areMarksStale(vm()->heap.objectSpace().markingVersion());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool MarkedBlock::Handle::needsFlip()
</del><ins>+bool MarkedBlock::Handle::areMarksStale()
</ins><span class="cx"> {
</span><del>- return m_block->needsFlip();
</del><ins>+ return m_block->areMarksStale();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool MarkedBlock::isMarked(const void* p)
</span><span class="cx"> {
</span><del>- return isMarked(vm()->heap.objectSpace().version(), p);
</del><ins>+ return isMarked(vm()->heap.objectSpace().markingVersion(), p);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool MarkedBlock::Handle::isMarkedOrNewlyAllocated(const HeapCell* cell)
</span><span class="cx"> {
</span><del>- return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().version(), cell);
</del><ins>+ return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().markingVersion(), cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool MarkedBlock::isMarkedOrNewlyAllocated(const HeapCell* cell)
</span><span class="cx"> {
</span><del>- return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().version(), cell);
</del><ins>+ return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().markingVersion(), cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void MarkedBlock::Handle::didConsumeFreeList()
</span><span class="lines">@@ -409,7 +409,7 @@
</span><span class="cx">
</span><span class="cx"> size_t MarkedBlock::markCount()
</span><span class="cx"> {
</span><del>- return needsFlip() ? 0 : m_marks.count();
</del><ins>+ return areMarksStale() ? 0 : m_marks.count();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool MarkedBlock::Handle::isEmpty()
</span><span class="lines">@@ -476,12 +476,12 @@
</span><span class="cx">
</span><span class="cx"> bool MarkedBlock::Handle::isLive(const HeapCell* cell)
</span><span class="cx"> {
</span><del>- return isLive(vm()->heap.objectSpace().version(), cell);
</del><ins>+ return isLive(vm()->heap.objectSpace().markingVersion(), cell);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool MarkedBlock::Handle::isLiveCell(const void* p)
</span><span class="cx"> {
</span><del>- return isLiveCell(vm()->heap.objectSpace().version(), p);
</del><ins>+ return isLiveCell(vm()->heap.objectSpace().markingVersion(), p);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapMarkedBlockh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/MarkedBlock.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/MarkedBlock.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/MarkedBlock.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -154,14 +154,14 @@
</span><span class="cx"> size_t markCount();
</span><span class="cx"> size_t size();
</span><span class="cx">
</span><del>- inline bool isLive(HeapVersion, const HeapCell*);
- inline bool isLiveCell(HeapVersion, const void*);
</del><ins>+ inline bool isLive(HeapVersion markingVersion, const HeapCell*);
+ inline bool isLiveCell(HeapVersion markingVersion, const void*);
</ins><span class="cx">
</span><span class="cx"> bool isLive(const HeapCell*);
</span><span class="cx"> bool isLiveCell(const void*);
</span><span class="cx">
</span><span class="cx"> bool isMarkedOrNewlyAllocated(const HeapCell*);
</span><del>- bool isMarkedOrNewlyAllocated(HeapVersion, const HeapCell*);
</del><ins>+ bool isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell*);
</ins><span class="cx">
</span><span class="cx"> bool isNewlyAllocated(const void*);
</span><span class="cx"> void setNewlyAllocated(const void*);
</span><span class="lines">@@ -173,9 +173,9 @@
</span><span class="cx"> template <typename Functor> inline IterationStatus forEachLiveCell(const Functor&);
</span><span class="cx"> template <typename Functor> inline IterationStatus forEachDeadCell(const Functor&);
</span><span class="cx">
</span><del>- bool needsFlip();
</del><ins>+ bool areMarksStale();
</ins><span class="cx">
</span><del>- void assertFlipped();
</del><ins>+ void assertMarksNotStale();
</ins><span class="cx">
</span><span class="cx"> bool isFreeListed() const { return m_isFreeListed; }
</span><span class="cx">
</span><span class="lines">@@ -208,11 +208,11 @@
</span><span class="cx"> FreeList sweepHelperSelectSweepMode(SweepMode = SweepOnly);
</span><span class="cx">
</span><span class="cx"> template<EmptyMode, SweepMode, DestructionMode, ScribbleMode, NewlyAllocatedMode>
</span><del>- FreeList sweepHelperSelectFlipMode();
</del><ins>+ FreeList sweepHelperSelectMarksMode();
</ins><span class="cx">
</span><del>- enum FlipMode { NeedsFlip, DoesNotNeedFlip };
</del><ins>+ enum MarksMode { MarksStale, MarksNotStale };
</ins><span class="cx">
</span><del>- template<EmptyMode, SweepMode, DestructionMode, ScribbleMode, NewlyAllocatedMode, FlipMode>
</del><ins>+ template<EmptyMode, SweepMode, DestructionMode, ScribbleMode, NewlyAllocatedMode, MarksMode>
</ins><span class="cx"> FreeList specializedSweep();
</span><span class="cx">
</span><span class="cx"> template<typename Func>
</span><span class="lines">@@ -252,12 +252,12 @@
</span><span class="cx"> size_t markCount();
</span><span class="cx">
</span><span class="cx"> bool isMarked(const void*);
</span><del>- bool isMarked(HeapVersion, const void*);
- bool isMarkedConcurrently(HeapVersion, const void*);
</del><ins>+ bool isMarked(HeapVersion markingVersion, const void*);
+ bool isMarkedConcurrently(HeapVersion markingVersion, const void*);
</ins><span class="cx"> bool testAndSetMarked(const void*);
</span><span class="cx">
</span><span class="cx"> bool isMarkedOrNewlyAllocated(const HeapCell*);
</span><del>- bool isMarkedOrNewlyAllocated(HeapVersion, const HeapCell*);
</del><ins>+ bool isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell*);
</ins><span class="cx">
</span><span class="cx"> bool isAtom(const void*);
</span><span class="cx"> void clearMarked(const void*);
</span><span class="lines">@@ -270,16 +270,16 @@
</span><span class="cx">
</span><span class="cx"> WeakSet& weakSet();
</span><span class="cx">
</span><del>- bool needsFlip(HeapVersion);
- bool needsFlip();
</del><ins>+ bool areMarksStale(HeapVersion markingVersion);
+ bool areMarksStale();
</ins><span class="cx">
</span><del>- void aboutToMark(HeapVersion);
</del><ins>+ void aboutToMark(HeapVersion markingVersion);
</ins><span class="cx">
</span><del>- void assertFlipped();
</del><ins>+ void assertMarksNotStale();
</ins><span class="cx">
</span><span class="cx"> bool needsDestruction() const { return m_needsDestruction; }
</span><span class="cx">
</span><del>- inline void resetVersion();
</del><ins>+ inline void resetMarkingVersion();
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> static const size_t atomAlignmentMask = atomSize - 1;
</span><span class="lines">@@ -289,9 +289,9 @@
</span><span class="cx"> MarkedBlock(VM&, Handle&);
</span><span class="cx"> Atom* atoms();
</span><span class="cx">
</span><del>- void aboutToMarkSlow(HeapVersion);
</del><ins>+ void aboutToMarkSlow(HeapVersion markingVersion);
</ins><span class="cx"> void clearMarks();
</span><del>- void clearMarks(HeapVersion);
</del><ins>+ void clearMarks(HeapVersion markingVersion);
</ins><span class="cx"> void clearHasAnyMarked();
</span><span class="cx">
</span><span class="cx"> void noteMarkedSlow();
</span><span class="lines">@@ -328,7 +328,7 @@
</span><span class="cx"> // m_biasedMarkCount != m_markCountBias
</span><span class="cx"> int16_t m_markCountBias;
</span><span class="cx">
</span><del>- HeapVersion m_version;
</del><ins>+ HeapVersion m_markingVersion;
</ins><span class="cx">
</span><span class="cx"> Handle& m_handle;
</span><span class="cx"> VM* m_vm;
</span><span class="lines">@@ -469,37 +469,37 @@
</span><span class="cx"> return (reinterpret_cast<Bits>(p) - reinterpret_cast<Bits>(this)) / atomSize;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool MarkedBlock::needsFlip(HeapVersion heapVersion)
</del><ins>+inline bool MarkedBlock::areMarksStale(HeapVersion markingVersion)
</ins><span class="cx"> {
</span><del>- return heapVersion != m_version;
</del><ins>+ return markingVersion != m_markingVersion;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline void MarkedBlock::aboutToMark(HeapVersion heapVersion)
</del><ins>+inline void MarkedBlock::aboutToMark(HeapVersion markingVersion)
</ins><span class="cx"> {
</span><del>- if (UNLIKELY(needsFlip(heapVersion)))
- aboutToMarkSlow(heapVersion);
</del><ins>+ if (UNLIKELY(areMarksStale(markingVersion)))
+ aboutToMarkSlow(markingVersion);
</ins><span class="cx"> WTF::loadLoadFence();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ASSERT_DISABLED
</span><del>-inline void MarkedBlock::assertFlipped()
</del><ins>+inline void MarkedBlock::assertMarksNotStale()
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx"> #endif // ASSERT_DISABLED
</span><span class="cx">
</span><del>-inline void MarkedBlock::Handle::assertFlipped()
</del><ins>+inline void MarkedBlock::Handle::assertMarksNotStale()
</ins><span class="cx"> {
</span><del>- block().assertFlipped();
</del><ins>+ block().assertMarksNotStale();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool MarkedBlock::isMarked(HeapVersion heapVersion, const void* p)
</del><ins>+inline bool MarkedBlock::isMarked(HeapVersion markingVersion, const void* p)
</ins><span class="cx"> {
</span><del>- return needsFlip(heapVersion) ? false : m_marks.get(atomNumber(p));
</del><ins>+ return areMarksStale(markingVersion) ? false : m_marks.get(atomNumber(p));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool MarkedBlock::isMarkedConcurrently(HeapVersion heapVersion, const void* p)
</del><ins>+inline bool MarkedBlock::isMarkedConcurrently(HeapVersion markingVersion, const void* p)
</ins><span class="cx"> {
</span><del>- if (needsFlip(heapVersion))
</del><ins>+ if (areMarksStale(markingVersion))
</ins><span class="cx"> return false;
</span><span class="cx"> WTF::loadLoadFence();
</span><span class="cx"> return m_marks.get(atomNumber(p));
</span><span class="lines">@@ -507,7 +507,7 @@
</span><span class="cx">
</span><span class="cx"> inline bool MarkedBlock::testAndSetMarked(const void* p)
</span><span class="cx"> {
</span><del>- assertFlipped();
</del><ins>+ assertMarksNotStale();
</ins><span class="cx"> return m_marks.concurrentTestAndSet(atomNumber(p));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -535,14 +535,14 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool MarkedBlock::Handle::isMarkedOrNewlyAllocated(HeapVersion version, const HeapCell* cell)
</del><ins>+inline bool MarkedBlock::Handle::isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell* cell)
</ins><span class="cx"> {
</span><del>- return m_block->isMarked(version, cell) || (m_newlyAllocated && isNewlyAllocated(cell));
</del><ins>+ return m_block->isMarked(markingVersion, cell) || (m_newlyAllocated && isNewlyAllocated(cell));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool MarkedBlock::isMarkedOrNewlyAllocated(HeapVersion version, const HeapCell* cell)
</del><ins>+inline bool MarkedBlock::isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell* cell)
</ins><span class="cx"> {
</span><del>- return isMarked(version, cell) || (m_handle.m_newlyAllocated && m_handle.isNewlyAllocated(cell));
</del><ins>+ return isMarked(markingVersion, cell) || (m_handle.m_newlyAllocated && m_handle.isNewlyAllocated(cell));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool MarkedBlock::isAtom(const void* p)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapMarkedBlockInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/MarkedBlockInlines.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/MarkedBlockInlines.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/MarkedBlockInlines.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -30,7 +30,7 @@
</span><span class="cx">
</span><span class="cx"> namespace JSC {
</span><span class="cx">
</span><del>-inline bool MarkedBlock::Handle::isLive(HeapVersion version, const HeapCell* cell)
</del><ins>+inline bool MarkedBlock::Handle::isLive(HeapVersion markingVersion, const HeapCell* cell)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!isFreeListed());
</span><span class="cx">
</span><span class="lines">@@ -44,17 +44,17 @@
</span><span class="cx"> if (allocator()->isAllocated(this))
</span><span class="cx"> return true;
</span><span class="cx">
</span><del>- if (block.needsFlip(version))
</del><ins>+ if (block.areMarksStale(markingVersion))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> return block.isMarked(cell);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool MarkedBlock::Handle::isLiveCell(HeapVersion version, const void* p)
</del><ins>+inline bool MarkedBlock::Handle::isLiveCell(HeapVersion markingVersion, const void* p)
</ins><span class="cx"> {
</span><span class="cx"> if (!m_block->isAtom(p))
</span><span class="cx"> return false;
</span><del>- return isLive(version, static_cast<const HeapCell*>(p));
</del><ins>+ return isLive(markingVersion, static_cast<const HeapCell*>(p));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template <typename Functor>
</span><span class="lines">@@ -87,9 +87,9 @@
</span><span class="cx"> return IterationStatus::Continue;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline void MarkedBlock::resetVersion()
</del><ins>+inline void MarkedBlock::resetMarkingVersion()
</ins><span class="cx"> {
</span><del>- m_version = MarkedSpace::nullVersion;
</del><ins>+ m_markingVersion = MarkedSpace::nullVersion;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapMarkedSpacecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -458,13 +458,13 @@
</span><span class="cx"> return IterationStatus::Continue;
</span><span class="cx"> });
</span><span class="cx">
</span><del>- m_version = nextVersion(m_version);
</del><ins>+ m_markingVersion = nextVersion(m_markingVersion);
</ins><span class="cx">
</span><del>- if (UNLIKELY(m_version == initialVersion)) {
</del><ins>+ if (UNLIKELY(m_markingVersion == initialVersion)) {
</ins><span class="cx"> // Oh no! Version wrap-around! We handle this by setting all block versions to null.
</span><span class="cx"> forEachBlock(
</span><span class="cx"> [&] (MarkedBlock::Handle* handle) {
</span><del>- handle->block().resetVersion();
</del><ins>+ handle->block().resetMarkingVersion();
</ins><span class="cx"> });
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -475,7 +475,7 @@
</span><span class="cx"> if (!ASSERT_DISABLED) {
</span><span class="cx"> forEachBlock(
</span><span class="cx"> [&] (MarkedBlock::Handle* block) {
</span><del>- if (block->needsFlip())
</del><ins>+ if (block->areMarksStale())
</ins><span class="cx"> return;
</span><span class="cx"> ASSERT(!block->isFreeListed());
</span><span class="cx"> });
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapMarkedSpaceh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/MarkedSpace.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/MarkedSpace.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/MarkedSpace.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -166,7 +166,7 @@
</span><span class="cx">
</span><span class="cx"> bool isPagedOut(double deadline);
</span><span class="cx">
</span><del>- HeapVersion version() const { return m_version; }
</del><ins>+ HeapVersion markingVersion() const { return m_markingVersion; }
</ins><span class="cx">
</span><span class="cx"> const Vector<LargeAllocation*>& largeAllocations() const { return m_largeAllocations; }
</span><span class="cx"> unsigned largeAllocationsNurseryOffset() const { return m_largeAllocationsNurseryOffset; }
</span><span class="lines">@@ -212,7 +212,7 @@
</span><span class="cx"> Subspace m_auxiliarySpace;
</span><span class="cx">
</span><span class="cx"> Heap* m_heap;
</span><del>- HeapVersion m_version { initialVersion };
</del><ins>+ HeapVersion m_markingVersion { initialVersion };
</ins><span class="cx"> size_t m_capacity;
</span><span class="cx"> bool m_isIterating;
</span><span class="cx"> bool m_isMarking { false };
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapSlotVisitorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -78,7 +78,7 @@
</span><span class="cx"> , m_bytesCopied(0)
</span><span class="cx"> , m_visitCount(0)
</span><span class="cx"> , m_isInParallelMode(false)
</span><del>- , m_version(MarkedSpace::initialVersion)
</del><ins>+ , m_markingVersion(MarkedSpace::initialVersion)
</ins><span class="cx"> , m_heap(heap)
</span><span class="cx"> #if !ASSERT_DISABLED
</span><span class="cx"> , m_isCheckingForDefaultMarkViolation(false)
</span><span class="lines">@@ -102,7 +102,7 @@
</span><span class="cx"> if (HeapProfiler* heapProfiler = vm().heapProfiler())
</span><span class="cx"> m_heapSnapshotBuilder = heapProfiler->activeSnapshotBuilder();
</span><span class="cx">
</span><del>- m_version = heap()->objectSpace().version();
</del><ins>+ m_markingVersion = heap()->objectSpace().markingVersion();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void SlotVisitor::reset()
</span><span class="lines">@@ -134,7 +134,7 @@
</span><span class="cx">
</span><span class="cx"> ASSERT(!m_isCheckingForDefaultMarkViolation);
</span><span class="cx">
</span><del>- if (Heap::testAndSetMarked(m_version, heapCell))
</del><ins>+ if (Heap::testAndSetMarked(m_markingVersion, heapCell))
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> switch (heapCell->cellKind()) {
</span><span class="lines">@@ -200,7 +200,7 @@
</span><span class="cx"> template<typename ContainerType>
</span><span class="cx"> ALWAYS_INLINE void SlotVisitor::setMarkedAndAppendToMarkStack(ContainerType& container, JSCell* cell)
</span><span class="cx"> {
</span><del>- container.aboutToMark(m_version);
</del><ins>+ container.aboutToMark(m_markingVersion);
</ins><span class="cx">
</span><span class="cx"> if (container.testAndSetMarked(cell))
</span><span class="cx"> return;
</span><span class="lines">@@ -248,7 +248,7 @@
</span><span class="cx">
</span><span class="cx"> ASSERT(cell->heap() == heap());
</span><span class="cx">
</span><del>- if (Heap::testAndSetMarked(m_version, cell))
</del><ins>+ if (Heap::testAndSetMarked(m_markingVersion, cell))
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> noteLiveAuxiliaryCell(cell);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapSlotVisitorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/SlotVisitor.h (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/SlotVisitor.h 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/SlotVisitor.h 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -124,7 +124,7 @@
</span><span class="cx">
</span><span class="cx"> bool isBuildingHeapSnapshot() const { return !!m_heapSnapshotBuilder; }
</span><span class="cx">
</span><del>- HeapVersion version() const { return m_version; }
</del><ins>+ HeapVersion markingVersion() const { return m_markingVersion; }
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> friend class ParallelModeEnabler;
</span><span class="lines">@@ -161,7 +161,7 @@
</span><span class="cx"> size_t m_visitCount;
</span><span class="cx"> bool m_isInParallelMode;
</span><span class="cx">
</span><del>- HeapVersion m_version;
</del><ins>+ HeapVersion m_markingVersion;
</ins><span class="cx">
</span><span class="cx"> Heap& m_heap;
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreheapWeakBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/heap/WeakBlock.cpp (206171 => 206172)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/heap/WeakBlock.cpp 2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/JavaScriptCore/heap/WeakBlock.cpp 2016-09-20 21:04:06 UTC (rev 206172)
</span><span class="lines">@@ -101,7 +101,7 @@
</span><span class="cx"> {
</span><span class="cx"> SlotVisitor& visitor = heapRootVisitor.visitor();
</span><span class="cx">
</span><del>- HeapVersion version = visitor.version();
</del><ins>+ HeapVersion markingVersion = visitor.markingVersion();
</ins><span class="cx">
</span><span class="cx"> for (size_t i = 0; i < weakImplCount(); ++i) {
</span><span class="cx"> WeakImpl* weakImpl = &weakImpls()[i];
</span><span class="lines">@@ -113,7 +113,7 @@
</span><span class="cx"> continue;
</span><span class="cx">
</span><span class="cx"> const JSValue& jsValue = weakImpl->jsValue();
</span><del>- if (container.isMarkedConcurrently(version, jsValue.asCell()))
</del><ins>+ if (container.isMarkedConcurrently(markingVersion, jsValue.asCell()))
</ins><span class="cx"> continue;
</span><span class="cx">
</span><span class="cx"> if (!weakHandleOwner->isReachableFromOpaqueRoots(Handle<Unknown>::wrapSlot(&const_cast<JSValue&>(jsValue)), weakImpl->context(), visitor))
</span><span class="lines">@@ -147,7 +147,7 @@
</span><span class="cx"> // If this WeakBlock doesn't belong to a CellContainer, we won't even be here.
</span><span class="cx"> ASSERT(m_container);
</span><span class="cx">
</span><del>- HeapVersion version = m_container.heap()->objectSpace().version();
</del><ins>+ HeapVersion markingVersion = m_container.heap()->objectSpace().markingVersion();
</ins><span class="cx">
</span><span class="cx"> for (size_t i = 0; i < weakImplCount(); ++i) {
</span><span class="cx"> WeakImpl* weakImpl = &weakImpls()[i];
</span><span class="lines">@@ -154,7 +154,7 @@
</span><span class="cx"> if (weakImpl->state() > WeakImpl::Dead)
</span><span class="cx"> continue;
</span><span class="cx">
</span><del>- if (m_container.isMarked(version, weakImpl->jsValue().asCell())) {
</del><ins>+ if (m_container.isMarked(markingVersion, weakImpl->jsValue().asCell())) {
</ins><span class="cx"> ASSERT(weakImpl->state() == WeakImpl::Live);
</span><span class="cx"> continue;
</span><span class="cx"> }
</span></span></pre>
</div>
</div>
</body>
</html>