Changeset 96738 in webkit for trunk/Source/JavaScriptCore/heap

Timestamp:

Oct 5, 2011, 12:07:18 PM (14 years ago)

Author:

[email protected]

Message:

Add rudimentary filtering to write barriers
​https://bugs.webkit.org/show_bug.cgi?id=69392

Reviewed by Filip Pizlo.

../../../../Volumes/Data/git/WebKit/OpenSource/Source/JavaScriptCore:

Add approximate filtering for write barriers based on the
target's mark bit. Also add some macros to support dumping
GC phase timings.

• dfg/DFGJITCodeGenerator.cpp:

(JSC::DFG::JITCodeGenerator::markCellCard):

• heap/Heap.cpp:

(JSC::GCTimer::GCTimerScope::GCTimerScope):
(JSC::GCTimer::GCTimerScope::~GCTimerScope):
(JSC::Heap::markRoots):
(JSC::Heap::collect):

Add phase timing information.

• heap/MarkedBlock.h:

(JSC::MarkedBlock::offsetOfMarks):
(JSC::MarkedBlock::gatherDirtyCells):

• jit/JITPropertyAccess.cpp:

(JSC::JIT::emitWriteBarrier):

../../../../Volumes/Data/git/WebKit/OpenSource/Tools:

When we're recording gc phase times Heap.o picks up
some exit time destructors, so we'll just ignore Heap.o
in this check.

• Scripts/check-for-exit-time-destructors:

Location:

trunk/Source/JavaScriptCore/heap

Files:

• Heap.cpp (modified) (6 diffs)
• MarkedBlock.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -44 +44 @@
 static const size_t largeHeapSize = 16 * 1024 * 1024;
 static const size_t smallHeapSize = 512 * 1024;
+
+#if ENABLE(GC_LOGGING)
+    
+struct GCTimer {
+    GCTimer(const char* name)
+        : m_time(0)
+        , m_min(100000000)
+        , m_max(0)
+        , m_count(0)
+        , m_name(name)
+    {
+    }
+    ~GCTimer()
+    {
+        printf("%s: %.2lfms (avg. %.2lf, min. %.2lf, max. %.2lf)\n", m_name, m_time * 1000, m_time * 1000 / m_count, m_min*1000, m_max*1000);
+    }
+    double m_time;
+    double m_min;
+    double m_max;
+    size_t m_count;
+    const char* m_name;
+};
+
+struct GCTimerScope {
+    GCTimerScope(GCTimer* timer)
+        : m_timer(timer)
+        , m_start(WTF::currentTime())
+    {
+    }
+    ~GCTimerScope()
+    {
+        double delta = WTF::currentTime() - m_start;
+        if (delta < m_timer->m_min)
+            m_timer->m_min = delta;
+        if (delta > m_timer->m_max)
+            m_timer->m_max = delta;
+        m_timer->m_count++;
+        m_timer->m_time += delta;
+    }
+    GCTimer* m_timer;
+    double m_start;
+};
+
+#define GCPHASE(name) static GCTimer name##Timer(#name); GCTimerScope name##TimerScope(&name##Timer)
+#define COND_GCPHASE(cond, name1, name2) static GCTimer name1##Timer(#name1); static GCTimer name2##Timer(#name2); GCTimerScope name1##CondTimerScope(cond ? &name1##Timer : &name2##Timer)
+
+#else
+
+#define GCPHASE(name) do { } while (false)
+#define COND_GCPHASE(cond, name1, name2) do { } while (false)
+
+#endif
 
 static size_t heapSizeForHint(HeapSize heapSize)
@@ -457 +509 @@
 void Heap::markRoots(bool fullGC)
 {
+    COND_GCPHASE(fullGC, MarkFullRoots, MarkYoungRoots);
     UNUSED_PARAM(fullGC);
     ASSERT(isValidThreadState(m_globalData));
@@ -468 +521 @@
     // gathering uses the mark bits to determine whether a reference is valid.
     ConservativeRoots machineThreadRoots(&m_objectSpace.blocks());
-    m_machineThreads.gatherConservativeRoots(machineThreadRoots, &dummy);
+    {
+        GCPHASE(GatherConservativeRoots);
+        m_machineThreads.gatherConservativeRoots(machineThreadRoots, &dummy);
+    }
 
     ConservativeRoots registerFileRoots(&m_objectSpace.blocks());
     m_jettisonedCodeBlocks.clearMarks();
-    registerFile().gatherConservativeRoots(registerFileRoots, m_jettisonedCodeBlocks);
+    {
+        GCPHASE(GatherRegisterFileRoots);
+        registerFile().gatherConservativeRoots(registerFileRoots, m_jettisonedCodeBlocks);
+    }
     m_jettisonedCodeBlocks.deleteUnmarkedCodeBlocks();
 #if ENABLE(GGC)
     MarkedBlock::DirtyCellVector dirtyCells;
-    if (!fullGC)
+    if (!fullGC) {
+        GCPHASE(GatheringDirtyCells);
         m_objectSpace.gatherDirtyCells(dirtyCells);
-    else
+    } else
 #endif
+    {
+        GCPHASE(clearMarks);
         clearMarks();
-
+    }
 
     SlotVisitor& visitor = m_slotVisitor;
@@ -487 +549 @@
 
 #if ENABLE(GGC)
-    size_t dirtyCellCount = dirtyCells.size();
-    for (size_t i = 0; i < dirtyCellCount; i++) {
-        heapRootVisitor.visitChildren(dirtyCells[i]);
+    if (size_t dirtyCellCount = dirtyCells.size()) {
+        GCPHASE(VisitDirtyCells);
+        for (size_t i = 0; i < dirtyCellCount; i++) {
+            heapRootVisitor.visitChildren(dirtyCells[i]);
+            visitor.drain();
+        }
+    }
+#endif
+
+    {
+        GCPHASE(VisitMachineRoots);
+        visitor.append(machineThreadRoots);
         visitor.drain();
     }
-#endif
-
-    visitor.append(machineThreadRoots);
-    visitor.drain();
-
-    visitor.append(registerFileRoots);
-    visitor.drain();
-
-    markProtectedObjects(heapRootVisitor);
-    visitor.drain();
-    
-    markTempSortVectors(heapRootVisitor);
-    visitor.drain();
-
-    if (m_markListSet && m_markListSet->size())
-        MarkedArgumentBuffer::markLists(heapRootVisitor, *m_markListSet);
-    if (m_globalData->exception)
+    {
+        GCPHASE(VisitRegisterFileRoots);
+        visitor.append(registerFileRoots);
+        visitor.drain();
+    }
+    {
+        GCPHASE(VisitProtectedObjects);
+        markProtectedObjects(heapRootVisitor);
+        visitor.drain();
+    }
+    {
+        GCPHASE(VisitTempSortVectors);
+        markTempSortVectors(heapRootVisitor);
+        visitor.drain();
+    }
+
+    {
+        GCPHASE(MarkingArgumentBuffers);
+        if (m_markListSet && m_markListSet->size()) {
+            MarkedArgumentBuffer::markLists(heapRootVisitor, *m_markListSet);
+            visitor.drain();
+        }
+    }
+    if (m_globalData->exception) {
+        GCPHASE(MarkingException);
         heapRootVisitor.visit(&m_globalData->exception);
-    visitor.drain();
-
-    m_handleHeap.visitStrongHandles(heapRootVisitor);
-    visitor.drain();
-
-    m_handleStack.visit(heapRootVisitor);
-    visitor.drain();
-    
-    m_jettisonedCodeBlocks.traceCodeBlocks(visitor);
-    visitor.drain();
+        visitor.drain();
+    }
+    
+    {
+        GCPHASE(VisitStrongHandles);
+        m_handleHeap.visitStrongHandles(heapRootVisitor);
+        visitor.drain();
+    }
+    
+    {
+        GCPHASE(HandleStack);
+        m_handleStack.visit(heapRootVisitor);
+        visitor.drain();
+    }
+    
+    {
+        GCPHASE(TraceCodeBlocks);
+        m_jettisonedCodeBlocks.traceCodeBlocks(visitor);
+        visitor.drain();
+    }
 
     // Weak handles must be marked last, because their owners use the set of
     // opaque roots to determine reachability.
-    int lastOpaqueRootCount;
-    do {
-        lastOpaqueRootCount = visitor.opaqueRootCount();
-        m_handleHeap.visitWeakHandles(heapRootVisitor);
-        visitor.drain();
-    // If the set of opaque roots has grown, more weak handles may have become reachable.
-    } while (lastOpaqueRootCount != visitor.opaqueRootCount());
-
+    {
+        GCPHASE(VisitingWeakHandles);
+        int lastOpaqueRootCount;
+        do {
+            lastOpaqueRootCount = visitor.opaqueRootCount();
+            m_handleHeap.visitWeakHandles(heapRootVisitor);
+            visitor.drain();
+            // If the set of opaque roots has grown, more weak handles may have become reachable.
+        } while (lastOpaqueRootCount != visitor.opaqueRootCount());
+    }
     visitor.reset();
 
@@ -598 +689 @@
 void Heap::collect(SweepToggle sweepToggle)
 {
+    GCPHASE(Collect);
     ASSERT(globalData()->identifierTable == wtfThreadData().currentIdentifierTable());
     ASSERT(m_isSafeToCollect);
     JAVASCRIPTCORE_GC_BEGIN();
+#if ENABLE(GGC)
     bool fullGC = sweepToggle == DoSweep;
     if (!fullGC)
         fullGC = (capacity() > 4 * m_lastFullGCSize);  
-    canonicalizeCellLivenessData();
+#else
+    bool fullGC = true;
+#endif
+    {
+        GCPHASE(Canonicalize);
+        canonicalizeCellLivenessData();
+    }
 
     markRoots(fullGC);
 
-    harvestWeakReferences();
-    m_handleHeap.finalizeWeakHandles();
-    m_globalData->smallStrings.finalizeSmallStrings();
+    {
+        GCPHASE(HarvestWeakReferences);
+        harvestWeakReferences();
+        m_handleHeap.finalizeWeakHandles();
+        m_globalData->smallStrings.finalizeSmallStrings();
+    }
 
     JAVASCRIPTCORE_GC_MARKED();
-    
-    resetAllocator();
+
+    {
+        GCPHASE(ResetAllocator);
+        resetAllocator();
+    }
 
     if (sweepToggle == DoSweep) {
+        GCPHASE(Sweeping);
         sweep();
         shrink();
@@ -625 +731 @@
     // proportion is a bit arbitrary. A 2X multiplier gives a 1:1 (heap size :
     // new bytes allocated) proportion, and seems to work well in benchmarks.
-    size_t proportionalBytes = 2 * size();
-    if (fullGC)
-        m_lastFullGCSize = proportionalBytes / 2;
-    
-    m_objectSpace.setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle));
+    size_t newSize = size();
+    size_t proportionalBytes = 2 * newSize;
+    if (fullGC) {
+        m_lastFullGCSize = newSize;
+        m_objectSpace.setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle));
+    }
     JAVASCRIPTCORE_GC_END();
 

trunk/Source/JavaScriptCore/heap/MarkedBlock.h

@@ -70 +70 @@
         // object the heap will commonly allocate is four words.
         static const size_t atomSize = 4 * sizeof(void*);
+        static const size_t atomShift = 5;
         static const size_t blockSize = 16 * KB;
         static const size_t blockMask = ~(blockSize - 1); // blockSize must be a power of two.
 
         static const size_t atomsPerBlock = blockSize / atomSize; // ~0.4% overhead
+        static const size_t atomMask = atomsPerBlock - 1;
         static const int cardShift = 10; // This is log2 of bytes per card.
         static const size_t bytesPerCard = 1 << cardShift;
@@ -140 +142 @@
         {
             return OBJECT_OFFSETOF(MarkedBlock, m_cards);
+        }
+
+        static inline size_t offsetOfMarks()
+        {
+            return OBJECT_OFFSETOF(MarkedBlock, m_marks);
         }
 
@@ -312 +319 @@
 void MarkedBlock::gatherDirtyCells(DirtyCellVector& dirtyCells)
 {
-    COMPILE_ASSERT(m_cards.cardCount == cardCount, MarkedBlockCardCountsMatch);
+    COMPILE_ASSERT((int)m_cards.cardCount == (int)cardCount, MarkedBlockCardCountsMatch);
 
     ASSERT(m_state != New && m_state != FreeListed);