Changeset 118416 in webkit for trunk/Source/JavaScriptCore/heap/Heap.cpp

Timestamp:

May 24, 2012, 2:18:10 PM (13 years ago)

Author:

[email protected]

Message:

Made WeakSet per-block instead of per-heap
​https://bugs.webkit.org/show_bug.cgi?id=87401

Reviewed by Oliver Hunt.

This allows us fast access to the set of all weak pointers for a block,
which is a step toward lazy finalization.

No performance change.

• heap/Heap.cpp:

(JSC::Heap::Heap):
(JSC::Heap::lastChanceToFinalize): Removed the per-heap weak set, since
it's per-block now.

(JSC::Heap::markRoots): Delegate weak set visiting to the marked space,
since it knows how to iterate all blocks.

(JSC::Heap::collect): Moved the reaping outside of markRoots, since it
doesn't mark anything.

Make sure to reset allocators after shrinking, since shrinking may
deallocate the current allocator.

• heap/Heap.h:

(Heap): No more per-heap weak set, since it's per-block now.

• heap/MarkedBlock.cpp:

(JSC::MarkedBlock::MarkedBlock):

• heap/MarkedBlock.h:

(MarkedBlock):
(JSC::MarkedBlock::lastChanceToFinalize): Migrated finalization logic
here from the heap, so the heap doesn't need to know about our internal
data structures like our weak set.

(JSC::MarkedBlock::heap):
(JSC::MarkedBlock::weakSet):
(JSC::MarkedBlock::shrink):
(JSC::MarkedBlock::resetAllocator):
(JSC::MarkedBlock::visitWeakSet):
(JSC::MarkedBlock::reapWeakSet):
(JSC::MarkedBlock::sweepWeakSet):

• heap/MarkedSpace.cpp:

(JSC::VisitWeakSet::VisitWeakSet):
(JSC::VisitWeakSet::operator()):
(VisitWeakSet):
(JSC):
(JSC::ReapWeakSet::operator()):
(JSC::SweepWeakSet::operator()):
(JSC::LastChanceToFinalize::operator()):
(JSC::MarkedSpace::lastChanceToFinalize):
(JSC::ResetAllocator::operator()):
(JSC::MarkedSpace::resetAllocators):
(JSC::MarkedSpace::visitWeakSets):
(JSC::MarkedSpace::reapWeakSets):
(JSC::MarkedSpace::sweepWeakSets):
(JSC::Shrink::operator()):
(JSC::MarkedSpace::shrink):

• heap/MarkedSpace.h:

(MarkedSpace): Make sure to account for our weak sets when sweeping,
shrinking, etc.

• heap/WeakSet.cpp:

(JSC):

• heap/WeakSet.h:

(WeakSet):
(JSC::WeakSet::heap):
(JSC):
(JSC::WeakSet::lastChanceToFinalize):
(JSC::WeakSet::visit):
(JSC::WeakSet::reap):
(JSC::WeakSet::shrink):
(JSC::WeakSet::resetAllocator): Inlined some things since they're called
once per block now instead of once per heap.

• heap/WeakSetInlines.h:

(JSC::WeakSet::allocate): Use the per-block weak set since there is no
per-heap weak set anymore.

File:

• trunk/Source/JavaScriptCore/heap/Heap.cpp (modified) (7 diffs)

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -249 +249 @@
     , m_sharedData(globalData)
     , m_slotVisitor(m_sharedData)
-    , m_weakSet(this)
     , m_handleSet(globalData)
     , m_isSafeToCollect(false)
@@ -279 +278 @@
         WTFLogAlways("ERROR: JavaScriptCore heap deallocated while %ld values were still protected", static_cast<unsigned long>(size));
 
-    m_weakSet.lastChanceToFinalize();
     m_objectSpace.lastChanceToFinalize();
 
@@ -562 +560 @@
         GCPHASE(VisitingLiveWeakHandles);
         while (true) {
-            m_weakSet.visit(heapRootVisitor);
+            m_objectSpace.visitWeakSets(heapRootVisitor);
             harvestWeakReferences();
             if (visitor.isEmpty())
@@ -576 +574 @@
     }
 
-    {
-        GCPHASE(ReapingWeakHandles);
-        m_weakSet.reap();
-    }
-
     GCCOUNTER(VisitedValueCount, visitor.visitCount());
 
@@ -684 +677 @@
     
     {
+        GCPHASE(ReapingWeakHandles);
+        m_objectSpace.reapWeakSets();
+    }
+
+    {
         GCPHASE(FinalizeUnconditionalFinalizers);
         finalizeUnconditionalFinalizers();
     }
-        
+
     {
         GCPHASE(FinalizeWeakHandles);
-        m_weakSet.sweep();
+        m_objectSpace.sweepWeakSets();
         m_globalData->smallStrings.finalizeSmallStrings();
     }
@@ -696 +694 @@
     JAVASCRIPTCORE_GC_MARKED();
 
-    {
-        GCPHASE(ResetAllocators);
-        m_objectSpace.resetAllocators();
-        m_weakSet.resetAllocator();
-    }
-    
     {
         GCPHASE(DeleteCodeBlocks);
@@ -712 +704 @@
         m_objectSpace.sweep();
         m_objectSpace.shrink();
-        m_weakSet.shrink();
         m_bytesAbandoned = 0;
     }
 
+    {
+        GCPHASE(ResetAllocators);
+        m_objectSpace.resetAllocators();
+    }
+    
     size_t currentHeapSize = size();
     if (fullGC) {