Title: [206172] trunk/Source/_javascript_Core
Revision
206172
Author
fpi...@apple.com
Date
2016-09-20 14:04:06 -0700 (Tue, 20 Sep 2016)

Log Message

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):

Modified Paths

Diff

Modified: trunk/Source/_javascript_Core/ChangeLog (206171 => 206172)


--- trunk/Source/_javascript_Core/ChangeLog	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/ChangeLog	2016-09-20 21:04:06 UTC (rev 206172)
@@ -1,3 +1,122 @@
+2016-09-20  Filip Pizlo  <fpi...@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):
+
 2016-09-20  Ryan Haddad  <ryanhad...@apple.com>
 
         Rebaseline builtins generator tests after r206155.

Modified: trunk/Source/_javascript_Core/heap/CellContainer.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/CellContainer.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/CellContainer.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -78,13 +78,13 @@
         return *bitwise_cast<LargeAllocation*>(m_encodedPointer - isLargeAllocationBit);
     }
     
-    void aboutToMark(HeapVersion);
-    bool needsFlip() const;
+    void aboutToMark(HeapVersion markingVersion);
+    bool areMarksStale() const;
     
     bool isMarked(HeapCell*) const;
-    bool isMarked(HeapVersion, HeapCell*) const;
+    bool isMarked(HeapVersion markingVersion, HeapCell*) const;
     bool isMarkedOrNewlyAllocated(HeapCell*) const;
-    bool isMarkedOrNewlyAllocated(HeapVersion, HeapCell*) const;
+    bool isMarkedOrNewlyAllocated(HeapVersion markingVersion, HeapCell*) const;
     
     void noteMarked();
     

Modified: trunk/Source/_javascript_Core/heap/CellContainerInlines.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/CellContainerInlines.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/CellContainerInlines.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -52,11 +52,11 @@
     return markedBlock().isMarked(cell);
 }
 
-inline bool CellContainer::isMarked(HeapVersion version, HeapCell* cell) const
+inline bool CellContainer::isMarked(HeapVersion markingVersion, HeapCell* cell) const
 {
     if (isLargeAllocation())
         return largeAllocation().isMarked();
-    return markedBlock().isMarked(version, cell);
+    return markedBlock().isMarked(markingVersion, cell);
 }
 
 inline bool CellContainer::isMarkedOrNewlyAllocated(HeapCell* cell) const
@@ -66,11 +66,11 @@
     return markedBlock().isMarkedOrNewlyAllocated(cell);
 }
 
-inline bool CellContainer::isMarkedOrNewlyAllocated(HeapVersion version, HeapCell* cell) const
+inline bool CellContainer::isMarkedOrNewlyAllocated(HeapVersion markingVersion, HeapCell* cell) const
 {
     if (isLargeAllocation())
         return largeAllocation().isMarkedOrNewlyAllocated();
-    return markedBlock().isMarkedOrNewlyAllocated(version, cell);
+    return markedBlock().isMarkedOrNewlyAllocated(markingVersion, cell);
 }
 
 inline void CellContainer::noteMarked()
@@ -93,17 +93,17 @@
     return markedBlock().weakSet();
 }
 
-inline void CellContainer::aboutToMark(HeapVersion heapVersion)
+inline void CellContainer::aboutToMark(HeapVersion markingVersion)
 {
     if (!isLargeAllocation())
-        markedBlock().aboutToMark(heapVersion);
+        markedBlock().aboutToMark(markingVersion);
 }
 
-inline bool CellContainer::needsFlip() const
+inline bool CellContainer::areMarksStale() const
 {
     if (isLargeAllocation())
         return false;
-    return markedBlock().needsFlip();
+    return markedBlock().areMarksStale();
 }
 
 } // namespace JSC

Modified: trunk/Source/_javascript_Core/heap/ConservativeRoots.cpp (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/ConservativeRoots.cpp	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/ConservativeRoots.cpp	2016-09-20 21:04:06 UTC (rev 206172)
@@ -66,12 +66,12 @@
 }
 
 template<typename MarkHook>
-inline void ConservativeRoots::genericAddPointer(void* p, HeapVersion version, TinyBloomFilter filter, MarkHook& markHook)
+inline void ConservativeRoots::genericAddPointer(void* p, HeapVersion markingVersion, TinyBloomFilter filter, MarkHook& markHook)
 {
     markHook.mark(p);
 
     HeapUtil::findGCObjectPointersForMarking(
-        m_heap, version, filter, p,
+        m_heap, markingVersion, filter, p,
         [&] (void* p) {
             if (m_size == m_capacity)
                 grow();
@@ -94,9 +94,9 @@
     RELEASE_ASSERT(isPointerAligned(end));
 
     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.
-    HeapVersion version = m_heap.objectSpace().version();
+    HeapVersion markingVersion = m_heap.objectSpace().markingVersion();
     for (char** it = static_cast<char**>(begin); it != static_cast<char**>(end); ++it)
-        genericAddPointer(*it, version, filter, markHook);
+        genericAddPointer(*it, markingVersion, filter, markHook);
 }
 
 class DummyMarkHook {

Modified: trunk/Source/_javascript_Core/heap/HeapInlines.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/HeapInlines.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/HeapInlines.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -82,7 +82,7 @@
         return cell->largeAllocation().isMarked();
     MarkedBlock& block = cell->markedBlock();
     return block.isMarked(
-        block.vm()->heap.objectSpace().version(), cell);
+        block.vm()->heap.objectSpace().markingVersion(), cell);
 }
 
 ALWAYS_INLINE bool Heap::isMarkedConcurrently(const void* rawCell)
@@ -92,16 +92,16 @@
         return cell->largeAllocation().isMarked();
     MarkedBlock& block = cell->markedBlock();
     return block.isMarkedConcurrently(
-        block.vm()->heap.objectSpace().version(), cell);
+        block.vm()->heap.objectSpace().markingVersion(), cell);
 }
 
-ALWAYS_INLINE bool Heap::testAndSetMarked(HeapVersion version, const void* rawCell)
+ALWAYS_INLINE bool Heap::testAndSetMarked(HeapVersion markingVersion, const void* rawCell)
 {
     HeapCell* cell = bitwise_cast<HeapCell*>(rawCell);
     if (cell->isLargeAllocation())
         return cell->largeAllocation().testAndSetMarked();
     MarkedBlock& block = cell->markedBlock();
-    block.aboutToMark(version);
+    block.aboutToMark(markingVersion);
     return block.testAndSetMarked(cell);
 }
 

Modified: trunk/Source/_javascript_Core/heap/HeapUtil.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/HeapUtil.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/HeapUtil.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -46,7 +46,7 @@
     // before liveness data is cleared to be accurate.
     template<typename Func>
     static void findGCObjectPointersForMarking(
-        Heap& heap, HeapVersion heapVersion, TinyBloomFilter filter, void* passedPointer,
+        Heap& heap, HeapVersion markingVersion, TinyBloomFilter filter, void* passedPointer,
         const Func& func)
     {
         const HashSet<MarkedBlock*>& set = heap.objectSpace().blocks().set();
@@ -85,7 +85,7 @@
                 && set.contains(previousCandidate)
                 && previousCandidate->handle().cellKind() == HeapCell::Auxiliary) {
                 previousPointer = static_cast<char*>(previousCandidate->handle().cellAlign(previousPointer));
-                if (previousCandidate->handle().isLiveCell(heapVersion, previousPointer))
+                if (previousCandidate->handle().isLiveCell(markingVersion, previousPointer))
                     func(previousPointer);
             }
         }
@@ -99,7 +99,7 @@
             return;
         
         auto tryPointer = [&] (void* pointer) {
-            if (candidate->handle().isLiveCell(heapVersion, pointer))
+            if (candidate->handle().isLiveCell(markingVersion, pointer))
                 func(pointer);
         };
     

Modified: trunk/Source/_javascript_Core/heap/MarkedAllocator.cpp (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/MarkedAllocator.cpp	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/MarkedAllocator.cpp	2016-09-20 21:04:06 UTC (rev 206172)
@@ -55,8 +55,8 @@
         MarkedBlock::Handle* block = m_blocks[index];
         if (block) {
             // Forces us to touch the memory of the block, but has no semantic effect.
-            if (block->needsFlip())
-                block->block().resetVersion();
+            if (block->areMarksStale())
+                block->block().resetMarkingVersion();
         }
         ++itersSinceLastTimeCheck;
         if (itersSinceLastTimeCheck >= Heap::s_timeCheckResolution) {

Modified: trunk/Source/_javascript_Core/heap/MarkedBlock.cpp (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/MarkedBlock.cpp	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/MarkedBlock.cpp	2016-09-20 21:04:06 UTC (rev 206172)
@@ -77,13 +77,13 @@
 }
 
 MarkedBlock::MarkedBlock(VM& vm, Handle& handle)
-    : m_version(MarkedSpace::nullVersion)
+    : m_markingVersion(MarkedSpace::nullVersion)
     , m_handle(handle)
     , m_vm(&vm)
 {
 }
 
-template<MarkedBlock::Handle::EmptyMode emptyMode, MarkedBlock::Handle::SweepMode sweepMode, DestructionMode destructionMode, MarkedBlock::Handle::ScribbleMode scribbleMode, MarkedBlock::Handle::NewlyAllocatedMode newlyAllocatedMode, MarkedBlock::Handle::FlipMode flipMode>
+template<MarkedBlock::Handle::EmptyMode emptyMode, MarkedBlock::Handle::SweepMode sweepMode, DestructionMode destructionMode, MarkedBlock::Handle::ScribbleMode scribbleMode, MarkedBlock::Handle::NewlyAllocatedMode newlyAllocatedMode, MarkedBlock::Handle::MarksMode marksMode>
 FreeList MarkedBlock::Handle::specializedSweep()
 {
     RELEASE_ASSERT(!(destructionMode == DoesNotNeedDestruction && sweepMode == SweepOnly));
@@ -98,7 +98,7 @@
     if (Options::useBumpAllocator()
         && emptyMode == IsEmpty
         && newlyAllocatedMode == DoesNotHaveNewlyAllocated) {
-        ASSERT(flipMode == NeedsFlip);
+        ASSERT(marksMode == MarksStale);
         
         char* startOfLastCell = static_cast<char*>(cellAlign(block.atoms() + m_endAtom - 1));
         char* payloadEnd = startOfLastCell + cellSize();
@@ -124,7 +124,7 @@
     bool isEmpty = true;
     for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell) {
         if (emptyMode == NotEmpty
-            && ((flipMode == DoesNotNeedFlip && block.m_marks.get(i))
+            && ((marksMode == MarksNotStale && block.m_marks.get(i))
                 || (newlyAllocatedMode == HasNewlyAllocated && m_newlyAllocated->get(i)))) {
             isEmpty = false;
             continue;
@@ -216,16 +216,16 @@
 FreeList MarkedBlock::Handle::sweepHelperSelectSweepMode(SweepMode sweepMode)
 {
     if (sweepMode == SweepToFreeList)
-        return sweepHelperSelectFlipMode<emptyMode, SweepToFreeList, destructionMode, scribbleMode, newlyAllocatedMode>();
-    return sweepHelperSelectFlipMode<emptyMode, SweepOnly, destructionMode, scribbleMode, newlyAllocatedMode>();
+        return sweepHelperSelectMarksMode<emptyMode, SweepToFreeList, destructionMode, scribbleMode, newlyAllocatedMode>();
+    return sweepHelperSelectMarksMode<emptyMode, SweepOnly, destructionMode, scribbleMode, newlyAllocatedMode>();
 }
 
 template<MarkedBlock::Handle::EmptyMode emptyMode, MarkedBlock::Handle::SweepMode sweepMode, DestructionMode destructionMode, MarkedBlock::Handle::ScribbleMode scribbleMode, MarkedBlock::Handle::NewlyAllocatedMode newlyAllocatedMode>
-FreeList MarkedBlock::Handle::sweepHelperSelectFlipMode()
+FreeList MarkedBlock::Handle::sweepHelperSelectMarksMode()
 {
-    if (needsFlip())
-        return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, NeedsFlip>();
-    return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, DoesNotNeedFlip>();
+    if (areMarksStale())
+        return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, MarksStale>();
+    return specializedSweep<emptyMode, sweepMode, destructionMode, scribbleMode, newlyAllocatedMode, MarksNotStale>();
 }
 
 void MarkedBlock::Handle::unsweepWithNoNewlyAllocated()
@@ -342,12 +342,12 @@
     }
 }
 
-void MarkedBlock::aboutToMarkSlow(HeapVersion heapVersion)
+void MarkedBlock::aboutToMarkSlow(HeapVersion markingVersion)
 {
     ASSERT(vm()->heap.objectSpace().isMarking());
     LockHolder locker(m_lock);
-    if (needsFlip(heapVersion)) {
-        clearMarks(heapVersion);
+    if (areMarksStale(markingVersion)) {
+        clearMarks(markingVersion);
         // This means we're the first ones to mark any object in this block.
         handle().allocator()->atomicSetAndCheckIsMarkingNotEmpty(&handle(), true);
     }
@@ -355,47 +355,47 @@
 
 void MarkedBlock::clearMarks()
 {
-    clearMarks(vm()->heap.objectSpace().version());
+    clearMarks(vm()->heap.objectSpace().markingVersion());
 }
 
-void MarkedBlock::clearMarks(HeapVersion heapVersion)
+void MarkedBlock::clearMarks(HeapVersion markingVersion)
 {
     m_marks.clearAll();
     clearHasAnyMarked();
     WTF::storeStoreFence();
-    m_version = heapVersion;
+    m_markingVersion = markingVersion;
 }
 
 #if !ASSERT_DISABLED
-void MarkedBlock::assertFlipped()
+void MarkedBlock::assertMarksNotStale()
 {
-    ASSERT(m_version == vm()->heap.objectSpace().version());
+    ASSERT(m_markingVersion == vm()->heap.objectSpace().markingVersion());
 }
 #endif // !ASSERT_DISABLED
 
-bool MarkedBlock::needsFlip()
+bool MarkedBlock::areMarksStale()
 {
-    return needsFlip(vm()->heap.objectSpace().version());
+    return areMarksStale(vm()->heap.objectSpace().markingVersion());
 }
 
-bool MarkedBlock::Handle::needsFlip()
+bool MarkedBlock::Handle::areMarksStale()
 {
-    return m_block->needsFlip();
+    return m_block->areMarksStale();
 }
 
 bool MarkedBlock::isMarked(const void* p)
 {
-    return isMarked(vm()->heap.objectSpace().version(), p);
+    return isMarked(vm()->heap.objectSpace().markingVersion(), p);
 }
 
 bool MarkedBlock::Handle::isMarkedOrNewlyAllocated(const HeapCell* cell)
 {
-    return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().version(), cell);
+    return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().markingVersion(), cell);
 }
 
 bool MarkedBlock::isMarkedOrNewlyAllocated(const HeapCell* cell)
 {
-    return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().version(), cell);
+    return isMarkedOrNewlyAllocated(vm()->heap.objectSpace().markingVersion(), cell);
 }
 
 void MarkedBlock::Handle::didConsumeFreeList()
@@ -409,7 +409,7 @@
 
 size_t MarkedBlock::markCount()
 {
-    return needsFlip() ? 0 : m_marks.count();
+    return areMarksStale() ? 0 : m_marks.count();
 }
 
 bool MarkedBlock::Handle::isEmpty()
@@ -476,12 +476,12 @@
 
 bool MarkedBlock::Handle::isLive(const HeapCell* cell)
 {
-    return isLive(vm()->heap.objectSpace().version(), cell);
+    return isLive(vm()->heap.objectSpace().markingVersion(), cell);
 }
 
 bool MarkedBlock::Handle::isLiveCell(const void* p)
 {
-    return isLiveCell(vm()->heap.objectSpace().version(), p);
+    return isLiveCell(vm()->heap.objectSpace().markingVersion(), p);
 }
 
 } // namespace JSC

Modified: trunk/Source/_javascript_Core/heap/MarkedBlock.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/MarkedBlock.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/MarkedBlock.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -154,14 +154,14 @@
         size_t markCount();
         size_t size();
             
-        inline bool isLive(HeapVersion, const HeapCell*);
-        inline bool isLiveCell(HeapVersion, const void*);
+        inline bool isLive(HeapVersion markingVersion, const HeapCell*);
+        inline bool isLiveCell(HeapVersion markingVersion, const void*);
 
         bool isLive(const HeapCell*);
         bool isLiveCell(const void*);
 
         bool isMarkedOrNewlyAllocated(const HeapCell*);
-        bool isMarkedOrNewlyAllocated(HeapVersion, const HeapCell*);
+        bool isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell*);
             
         bool isNewlyAllocated(const void*);
         void setNewlyAllocated(const void*);
@@ -173,9 +173,9 @@
         template <typename Functor> inline IterationStatus forEachLiveCell(const Functor&);
         template <typename Functor> inline IterationStatus forEachDeadCell(const Functor&);
             
-        bool needsFlip();
+        bool areMarksStale();
         
-        void assertFlipped();
+        void assertMarksNotStale();
             
         bool isFreeListed() const { return m_isFreeListed; }
         
@@ -208,11 +208,11 @@
         FreeList sweepHelperSelectSweepMode(SweepMode = SweepOnly);
         
         template<EmptyMode, SweepMode, DestructionMode, ScribbleMode, NewlyAllocatedMode>
-        FreeList sweepHelperSelectFlipMode();
+        FreeList sweepHelperSelectMarksMode();
         
-        enum FlipMode { NeedsFlip, DoesNotNeedFlip };
+        enum MarksMode { MarksStale, MarksNotStale };
         
-        template<EmptyMode, SweepMode, DestructionMode, ScribbleMode, NewlyAllocatedMode, FlipMode>
+        template<EmptyMode, SweepMode, DestructionMode, ScribbleMode, NewlyAllocatedMode, MarksMode>
         FreeList specializedSweep();
             
         template<typename Func>
@@ -252,12 +252,12 @@
     size_t markCount();
 
     bool isMarked(const void*);
-    bool isMarked(HeapVersion, const void*);
-    bool isMarkedConcurrently(HeapVersion, const void*);
+    bool isMarked(HeapVersion markingVersion, const void*);
+    bool isMarkedConcurrently(HeapVersion markingVersion, const void*);
     bool testAndSetMarked(const void*);
         
     bool isMarkedOrNewlyAllocated(const HeapCell*);
-    bool isMarkedOrNewlyAllocated(HeapVersion, const HeapCell*);
+    bool isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell*);
     
     bool isAtom(const void*);
     void clearMarked(const void*);
@@ -270,16 +270,16 @@
         
     WeakSet& weakSet();
     
-    bool needsFlip(HeapVersion);
-    bool needsFlip();
+    bool areMarksStale(HeapVersion markingVersion);
+    bool areMarksStale();
     
-    void aboutToMark(HeapVersion);
+    void aboutToMark(HeapVersion markingVersion);
         
-    void assertFlipped();
+    void assertMarksNotStale();
         
     bool needsDestruction() const { return m_needsDestruction; }
     
-    inline void resetVersion();
+    inline void resetMarkingVersion();
     
 private:
     static const size_t atomAlignmentMask = atomSize - 1;
@@ -289,9 +289,9 @@
     MarkedBlock(VM&, Handle&);
     Atom* atoms();
         
-    void aboutToMarkSlow(HeapVersion);
+    void aboutToMarkSlow(HeapVersion markingVersion);
     void clearMarks();
-    void clearMarks(HeapVersion);
+    void clearMarks(HeapVersion markingVersion);
     void clearHasAnyMarked();
     
     void noteMarkedSlow();
@@ -328,7 +328,7 @@
     //     m_biasedMarkCount != m_markCountBias
     int16_t m_markCountBias;
 
-    HeapVersion m_version;
+    HeapVersion m_markingVersion;
     
     Handle& m_handle;
     VM* m_vm;
@@ -469,37 +469,37 @@
     return (reinterpret_cast<Bits>(p) - reinterpret_cast<Bits>(this)) / atomSize;
 }
 
-inline bool MarkedBlock::needsFlip(HeapVersion heapVersion)
+inline bool MarkedBlock::areMarksStale(HeapVersion markingVersion)
 {
-    return heapVersion != m_version;
+    return markingVersion != m_markingVersion;
 }
 
-inline void MarkedBlock::aboutToMark(HeapVersion heapVersion)
+inline void MarkedBlock::aboutToMark(HeapVersion markingVersion)
 {
-    if (UNLIKELY(needsFlip(heapVersion)))
-        aboutToMarkSlow(heapVersion);
+    if (UNLIKELY(areMarksStale(markingVersion)))
+        aboutToMarkSlow(markingVersion);
     WTF::loadLoadFence();
 }
 
 #if ASSERT_DISABLED
-inline void MarkedBlock::assertFlipped()
+inline void MarkedBlock::assertMarksNotStale()
 {
 }
 #endif // ASSERT_DISABLED
 
-inline void MarkedBlock::Handle::assertFlipped()
+inline void MarkedBlock::Handle::assertMarksNotStale()
 {
-    block().assertFlipped();
+    block().assertMarksNotStale();
 }
 
-inline bool MarkedBlock::isMarked(HeapVersion heapVersion, const void* p)
+inline bool MarkedBlock::isMarked(HeapVersion markingVersion, const void* p)
 {
-    return needsFlip(heapVersion) ? false : m_marks.get(atomNumber(p));
+    return areMarksStale(markingVersion) ? false : m_marks.get(atomNumber(p));
 }
 
-inline bool MarkedBlock::isMarkedConcurrently(HeapVersion heapVersion, const void* p)
+inline bool MarkedBlock::isMarkedConcurrently(HeapVersion markingVersion, const void* p)
 {
-    if (needsFlip(heapVersion))
+    if (areMarksStale(markingVersion))
         return false;
     WTF::loadLoadFence();
     return m_marks.get(atomNumber(p));
@@ -507,7 +507,7 @@
 
 inline bool MarkedBlock::testAndSetMarked(const void* p)
 {
-    assertFlipped();
+    assertMarksNotStale();
     return m_marks.concurrentTestAndSet(atomNumber(p));
 }
 
@@ -535,14 +535,14 @@
     return false;
 }
 
-inline bool MarkedBlock::Handle::isMarkedOrNewlyAllocated(HeapVersion version, const HeapCell* cell)
+inline bool MarkedBlock::Handle::isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell* cell)
 {
-    return m_block->isMarked(version, cell) || (m_newlyAllocated && isNewlyAllocated(cell));
+    return m_block->isMarked(markingVersion, cell) || (m_newlyAllocated && isNewlyAllocated(cell));
 }
 
-inline bool MarkedBlock::isMarkedOrNewlyAllocated(HeapVersion version, const HeapCell* cell)
+inline bool MarkedBlock::isMarkedOrNewlyAllocated(HeapVersion markingVersion, const HeapCell* cell)
 {
-    return isMarked(version, cell) || (m_handle.m_newlyAllocated && m_handle.isNewlyAllocated(cell));
+    return isMarked(markingVersion, cell) || (m_handle.m_newlyAllocated && m_handle.isNewlyAllocated(cell));
 }
 
 inline bool MarkedBlock::isAtom(const void* p)

Modified: trunk/Source/_javascript_Core/heap/MarkedBlockInlines.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/MarkedBlockInlines.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/MarkedBlockInlines.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -30,7 +30,7 @@
 
 namespace JSC {
 
-inline bool MarkedBlock::Handle::isLive(HeapVersion version, const HeapCell* cell)
+inline bool MarkedBlock::Handle::isLive(HeapVersion markingVersion, const HeapCell* cell)
 {
     ASSERT(!isFreeListed());
     
@@ -44,17 +44,17 @@
     if (allocator()->isAllocated(this))
         return true;
     
-    if (block.needsFlip(version))
+    if (block.areMarksStale(markingVersion))
         return false;
 
     return block.isMarked(cell);
 }
 
-inline bool MarkedBlock::Handle::isLiveCell(HeapVersion version, const void* p)
+inline bool MarkedBlock::Handle::isLiveCell(HeapVersion markingVersion, const void* p)
 {
     if (!m_block->isAtom(p))
         return false;
-    return isLive(version, static_cast<const HeapCell*>(p));
+    return isLive(markingVersion, static_cast<const HeapCell*>(p));
 }
 
 template <typename Functor>
@@ -87,9 +87,9 @@
     return IterationStatus::Continue;
 }
 
-inline void MarkedBlock::resetVersion()
+inline void MarkedBlock::resetMarkingVersion()
 {
-    m_version = MarkedSpace::nullVersion;
+    m_markingVersion = MarkedSpace::nullVersion;
 }
 
 } // namespace JSC

Modified: trunk/Source/_javascript_Core/heap/MarkedSpace.cpp (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/MarkedSpace.cpp	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/MarkedSpace.cpp	2016-09-20 21:04:06 UTC (rev 206172)
@@ -458,13 +458,13 @@
                 return IterationStatus::Continue;
             });
 
-        m_version = nextVersion(m_version);
+        m_markingVersion = nextVersion(m_markingVersion);
         
-        if (UNLIKELY(m_version == initialVersion)) {
+        if (UNLIKELY(m_markingVersion == initialVersion)) {
             // Oh no! Version wrap-around! We handle this by setting all block versions to null.
             forEachBlock(
                 [&] (MarkedBlock::Handle* handle) {
-                    handle->block().resetVersion();
+                    handle->block().resetMarkingVersion();
                 });
         }
         
@@ -475,7 +475,7 @@
     if (!ASSERT_DISABLED) {
         forEachBlock(
             [&] (MarkedBlock::Handle* block) {
-                if (block->needsFlip())
+                if (block->areMarksStale())
                     return;
                 ASSERT(!block->isFreeListed());
             });

Modified: trunk/Source/_javascript_Core/heap/MarkedSpace.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/MarkedSpace.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/MarkedSpace.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -166,7 +166,7 @@
 
     bool isPagedOut(double deadline);
     
-    HeapVersion version() const { return m_version; }
+    HeapVersion markingVersion() const { return m_markingVersion; }
 
     const Vector<LargeAllocation*>& largeAllocations() const { return m_largeAllocations; }
     unsigned largeAllocationsNurseryOffset() const { return m_largeAllocationsNurseryOffset; }
@@ -212,7 +212,7 @@
     Subspace m_auxiliarySpace;
 
     Heap* m_heap;
-    HeapVersion m_version { initialVersion };
+    HeapVersion m_markingVersion { initialVersion };
     size_t m_capacity;
     bool m_isIterating;
     bool m_isMarking { false };

Modified: trunk/Source/_javascript_Core/heap/SlotVisitor.cpp (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/SlotVisitor.cpp	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/SlotVisitor.cpp	2016-09-20 21:04:06 UTC (rev 206172)
@@ -78,7 +78,7 @@
     , m_bytesCopied(0)
     , m_visitCount(0)
     , m_isInParallelMode(false)
-    , m_version(MarkedSpace::initialVersion)
+    , m_markingVersion(MarkedSpace::initialVersion)
     , m_heap(heap)
 #if !ASSERT_DISABLED
     , m_isCheckingForDefaultMarkViolation(false)
@@ -102,7 +102,7 @@
     if (HeapProfiler* heapProfiler = vm().heapProfiler())
         m_heapSnapshotBuilder = heapProfiler->activeSnapshotBuilder();
     
-    m_version = heap()->objectSpace().version();
+    m_markingVersion = heap()->objectSpace().markingVersion();
 }
 
 void SlotVisitor::reset()
@@ -134,7 +134,7 @@
     
     ASSERT(!m_isCheckingForDefaultMarkViolation);
     
-    if (Heap::testAndSetMarked(m_version, heapCell))
+    if (Heap::testAndSetMarked(m_markingVersion, heapCell))
         return;
     
     switch (heapCell->cellKind()) {
@@ -200,7 +200,7 @@
 template<typename ContainerType>
 ALWAYS_INLINE void SlotVisitor::setMarkedAndAppendToMarkStack(ContainerType& container, JSCell* cell)
 {
-    container.aboutToMark(m_version);
+    container.aboutToMark(m_markingVersion);
     
     if (container.testAndSetMarked(cell))
         return;
@@ -248,7 +248,7 @@
     
     ASSERT(cell->heap() == heap());
     
-    if (Heap::testAndSetMarked(m_version, cell))
+    if (Heap::testAndSetMarked(m_markingVersion, cell))
         return;
     
     noteLiveAuxiliaryCell(cell);

Modified: trunk/Source/_javascript_Core/heap/SlotVisitor.h (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/SlotVisitor.h	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/SlotVisitor.h	2016-09-20 21:04:06 UTC (rev 206172)
@@ -124,7 +124,7 @@
 
     bool isBuildingHeapSnapshot() const { return !!m_heapSnapshotBuilder; }
     
-    HeapVersion version() const { return m_version; }
+    HeapVersion markingVersion() const { return m_markingVersion; }
 
 private:
     friend class ParallelModeEnabler;
@@ -161,7 +161,7 @@
     size_t m_visitCount;
     bool m_isInParallelMode;
     
-    HeapVersion m_version;
+    HeapVersion m_markingVersion;
     
     Heap& m_heap;
 

Modified: trunk/Source/_javascript_Core/heap/WeakBlock.cpp (206171 => 206172)


--- trunk/Source/_javascript_Core/heap/WeakBlock.cpp	2016-09-20 20:57:31 UTC (rev 206171)
+++ trunk/Source/_javascript_Core/heap/WeakBlock.cpp	2016-09-20 21:04:06 UTC (rev 206172)
@@ -101,7 +101,7 @@
 {
     SlotVisitor& visitor = heapRootVisitor.visitor();
     
-    HeapVersion version = visitor.version();
+    HeapVersion markingVersion = visitor.markingVersion();
 
     for (size_t i = 0; i < weakImplCount(); ++i) {
         WeakImpl* weakImpl = &weakImpls()[i];
@@ -113,7 +113,7 @@
             continue;
 
         const JSValue& jsValue = weakImpl->jsValue();
-        if (container.isMarkedConcurrently(version, jsValue.asCell()))
+        if (container.isMarkedConcurrently(markingVersion, jsValue.asCell()))
             continue;
         
         if (!weakHandleOwner->isReachableFromOpaqueRoots(Handle<Unknown>::wrapSlot(&const_cast<JSValue&>(jsValue)), weakImpl->context(), visitor))
@@ -147,7 +147,7 @@
     // If this WeakBlock doesn't belong to a CellContainer, we won't even be here.
     ASSERT(m_container);
     
-    HeapVersion version = m_container.heap()->objectSpace().version();
+    HeapVersion markingVersion = m_container.heap()->objectSpace().markingVersion();
 
     for (size_t i = 0; i < weakImplCount(); ++i) {
         WeakImpl* weakImpl = &weakImpls()[i];
@@ -154,7 +154,7 @@
         if (weakImpl->state() > WeakImpl::Dead)
             continue;
 
-        if (m_container.isMarked(version, weakImpl->jsValue().asCell())) {
+        if (m_container.isMarked(markingVersion, weakImpl->jsValue().asCell())) {
             ASSERT(weakImpl->state() == WeakImpl::Live);
             continue;
         }
_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to