Refactored the Heap to move more MarkedSpace logic into MarkedSpace

https://bugs.webkit.org/show_bug.cgi?id=86790

Reviewed by Gavin Barraclough.

* heap/Heap.cpp:
(JSC::Heap::lastChanceToFinalize):
(JSC::Heap::markRoots):
(JSC):
(JSC::Heap::objectCount):
(JSC::Heap::size):
(JSC::Heap::capacity):
(JSC::Heap::collect):
* heap/Heap.h:
(Heap): Took all the functors from here...

* heap/MarkedBlock.h:
(CountFunctor):
(JSC::MarkedBlock::CountFunctor::CountFunctor):
(JSC::MarkedBlock::CountFunctor::count):
(JSC::MarkedBlock::CountFunctor::returnValue):
(MarkedBlock):
* heap/MarkedSpace.h:
(JSC::ClearMarks::operator()):
(JSC):
(JSC::Sweep::operator()):
(JSC::MarkCount::operator()):
(JSC::Size::operator()):
(JSC::Capacity::operator()):
(MarkedSpace):
(JSC::MarkedSpace::clearMarks):
(JSC::MarkedSpace::sweep):
(JSC::MarkedSpace::objectCount):
(JSC::MarkedSpace::size):
(JSC::MarkedSpace::capacity): and put them here.

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@117517 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
index cc08cd5..9961212 100644 (file)
--- a/Source/JavaScriptCore/ChangeLog
+++ b/Source/JavaScriptCore/ChangeLog
@@ -1,5 +1,43 @@
 2012-05-17  Geoffrey Garen  <ggaren@apple.com>
 
+        Refactored the Heap to move more MarkedSpace logic into MarkedSpace
+        https://bugs.webkit.org/show_bug.cgi?id=86790
+
+        Reviewed by Gavin Barraclough.
+
+        * heap/Heap.cpp:
+        (JSC::Heap::lastChanceToFinalize):
+        (JSC::Heap::markRoots):
+        (JSC):
+        (JSC::Heap::objectCount):
+        (JSC::Heap::size):
+        (JSC::Heap::capacity):
+        (JSC::Heap::collect):
+        * heap/Heap.h:
+        (Heap): Took all the functors from here...
+
+        * heap/MarkedBlock.h:
+        (CountFunctor):
+        (JSC::MarkedBlock::CountFunctor::CountFunctor):
+        (JSC::MarkedBlock::CountFunctor::count):
+        (JSC::MarkedBlock::CountFunctor::returnValue):
+        (MarkedBlock):
+        * heap/MarkedSpace.h:
+        (JSC::ClearMarks::operator()):
+        (JSC):
+        (JSC::Sweep::operator()):
+        (JSC::MarkCount::operator()):
+        (JSC::Size::operator()):
+        (JSC::Capacity::operator()):
+        (MarkedSpace):
+        (JSC::MarkedSpace::clearMarks):
+        (JSC::MarkedSpace::sweep):
+        (JSC::MarkedSpace::objectCount):
+        (JSC::MarkedSpace::size):
+        (JSC::MarkedSpace::capacity): and put them here.
+
+2012-05-17  Geoffrey Garen  <ggaren@apple.com>
+
         Increase the GC allocation trigger
         https://bugs.webkit.org/show_bug.cgi?id=86699
 

diff --git a/Source/JavaScriptCore/heap/Heap.cpp b/Source/JavaScriptCore/heap/Heap.cpp
index 22e764c..2e1c97f 100644 (file)
--- a/Source/JavaScriptCore/heap/Heap.cpp
+++ b/Source/JavaScriptCore/heap/Heap.cpp
@@ -178,100 +178,20 @@ static inline bool isValidThreadState(JSGlobalData* globalData)
     return true;
 }
 
-class CountFunctor {
-public:
-    typedef size_t ReturnType;
-
-    CountFunctor();
-    void count(size_t);
-    ReturnType returnValue();
-
-private:
-    ReturnType m_count;
-};
-
-inline CountFunctor::CountFunctor()
-    : m_count(0)
-{
-}
-
-inline void CountFunctor::count(size_t count)
-{
-    m_count += count;
-}
-
-inline CountFunctor::ReturnType CountFunctor::returnValue()
-{
-    return m_count;
-}
-
-struct ClearMarks : MarkedBlock::VoidFunctor {
-    void operator()(MarkedBlock*);
-};
-
-inline void ClearMarks::operator()(MarkedBlock* block)
-{
-    block->clearMarks();
-}
-
-struct Sweep : MarkedBlock::VoidFunctor {
-    void operator()(MarkedBlock*);
-};
-
-inline void Sweep::operator()(MarkedBlock* block)
-{
-    block->sweep();
-}
-
-struct MarkCount : CountFunctor {
-    void operator()(MarkedBlock*);
-};
-
-inline void MarkCount::operator()(MarkedBlock* block)
-{
-    count(block->markCount());
-}
-
-struct Size : CountFunctor {
-    void operator()(MarkedBlock*);
-};
-
-inline void Size::operator()(MarkedBlock* block)
-{
-    count(block->markCount() * block->cellSize());
-}
-
-struct Capacity : CountFunctor {
-    void operator()(MarkedBlock*);
-};
-
-inline void Capacity::operator()(MarkedBlock* block)
-{
-    count(block->capacity());
-}
-
-struct Count : public CountFunctor {
-    void operator()(JSCell*);
+struct Count : public MarkedBlock::CountFunctor {
+    void operator()(JSCell*) { count(1); }
 };
 
-inline void Count::operator()(JSCell*)
-{
-    count(1);
-}
-
-struct CountIfGlobalObject : CountFunctor {
-    void operator()(JSCell*);
+struct CountIfGlobalObject : MarkedBlock::CountFunctor {
+    void operator()(JSCell* cell) {
+        if (!cell->isObject())
+            return;
+        if (!asObject(cell)->isGlobalObject())
+            return;
+        count(1);
+    }
 };
 
-inline void CountIfGlobalObject::operator()(JSCell* cell)
-{
-    if (!cell->isObject())
-        return;
-    if (!asObject(cell)->isGlobalObject())
-        return;
-    count(1);
-}
-
 class RecordType {
 public:
     typedef PassOwnPtr<TypeCountSet> ReturnType;
@@ -363,9 +283,9 @@ void Heap::lastChanceToFinalize()
         WTFLogAlways("ERROR: JavaScriptCore heap deallocated while %ld values were still protected", static_cast<unsigned long>(size));
 
     m_weakSet.finalizeAll();
-    canonicalizeCellLivenessData();
-    clearMarks();
-    sweep();
+    m_objectSpace.canonicalizeCellLivenessData();
+    m_objectSpace.clearMarks();
+    m_objectSpace.sweep();
     m_globalData->smallStrings.finalizeSmallStrings();
 
 #if ENABLE(SIMPLE_HEAP_PROFILING)
@@ -540,7 +460,7 @@ void Heap::markRoots(bool fullGC)
 #endif
     {
         GCPHASE(clearMarks);
-        clearMarks();
+        m_objectSpace.clearMarks();
     }
 
     m_storageSpace.startedCopying();
@@ -661,29 +581,19 @@ void Heap::markRoots(bool fullGC)
     m_operationInProgress = NoOperation;
 }
 
-void Heap::clearMarks()
-{
-    m_objectSpace.forEachBlock<ClearMarks>();
-}
-
-void Heap::sweep()
-{
-    m_objectSpace.forEachBlock<Sweep>();
-}
-
 size_t Heap::objectCount()
 {
-    return m_objectSpace.forEachBlock<MarkCount>();
+    return m_objectSpace.objectCount();
 }
 
 size_t Heap::size()
 {
-    return m_objectSpace.forEachBlock<Size>() + m_storageSpace.size();
+    return m_objectSpace.size() + m_storageSpace.size();
 }
 
 size_t Heap::capacity()
 {
-    return m_objectSpace.forEachBlock<Capacity>() + m_storageSpace.capacity();
+    return m_objectSpace.capacity() + m_storageSpace.capacity();
 }
 
 size_t Heap::protectedGlobalObjectCount()
@@ -758,7 +668,7 @@ void Heap::collect(SweepToggle sweepToggle)
 #endif
     {
         GCPHASE(Canonicalize);
-        canonicalizeCellLivenessData();
+        m_objectSpace.canonicalizeCellLivenessData();
     }
 
     markRoots(fullGC);
@@ -777,8 +687,9 @@ void Heap::collect(SweepToggle sweepToggle)
     JAVASCRIPTCORE_GC_MARKED();
 
     {
-        GCPHASE(ResetAllocator);
-        resetAllocators();
+        GCPHASE(ResetAllocators);
+        m_objectSpace.resetAllocators();
+        m_weakSet.resetAllocator();
     }
     
     {
@@ -789,7 +700,7 @@ void Heap::collect(SweepToggle sweepToggle)
     if (sweepToggle == DoSweep) {
         SamplingRegion samplingRegion("Garbage Collection: Sweeping");
         GCPHASE(Sweeping);
-        sweep();
+        m_objectSpace.sweep();
         m_objectSpace.shrink();
         m_weakSet.shrink();
         m_bytesAbandoned = 0;
@@ -810,17 +721,6 @@ void Heap::collect(SweepToggle sweepToggle)
     JAVASCRIPTCORE_GC_END();
 }
 
-void Heap::canonicalizeCellLivenessData()
-{
-    m_objectSpace.canonicalizeCellLivenessData();
-}
-
-void Heap::resetAllocators()
-{
-    m_objectSpace.resetAllocators();
-    m_weakSet.resetAllocator();
-}
-
 void Heap::setActivityCallback(PassOwnPtr<GCActivityCallback> activityCallback)
 {
     m_activityCallback = activityCallback;

diff --git a/Source/JavaScriptCore/heap/Heap.h b/Source/JavaScriptCore/heap/Heap.h
index 397bd08..6bf82e4 100644 (file)
--- a/Source/JavaScriptCore/heap/Heap.h
+++ b/Source/JavaScriptCore/heap/Heap.h
@@ -188,22 +188,12 @@ namespace JSC {
         JS_EXPORT_PRIVATE bool isValidAllocation(size_t);
         JS_EXPORT_PRIVATE void reportExtraMemoryCostSlowCase(size_t);
 
-        // Call this function before any operation that needs to know which cells
-        // in the heap are live. (For example, call this function before
-        // conservative marking, eager sweeping, or iterating the cells in a MarkedBlock.)
-        void canonicalizeCellLivenessData();
-
-        void resetAllocators();
-
-        void clearMarks();
         void markRoots(bool fullGC);
         void markProtectedObjects(HeapRootVisitor&);
         void markTempSortVectors(HeapRootVisitor&);
         void harvestWeakReferences();
         void finalizeUnconditionalFinalizers();
         
-        void sweep();
-
         RegisterFile& registerFile();
         BlockAllocator& blockAllocator();
 

diff --git a/Source/JavaScriptCore/heap/MarkedBlock.h b/Source/JavaScriptCore/heap/MarkedBlock.h
index 429b7c0..aa99ebf 100644 (file)
--- a/Source/JavaScriptCore/heap/MarkedBlock.h
+++ b/Source/JavaScriptCore/heap/MarkedBlock.h
@@ -100,6 +100,18 @@ namespace JSC {
             void returnValue() { }
         };
 
+        class CountFunctor {
+        public:
+            typedef size_t ReturnType;
+
+            CountFunctor() : m_count(0) { }
+            void count(size_t count) { m_count += count; }
+            ReturnType returnValue() { return m_count; }
+
+        private:
+            ReturnType m_count;
+        };
+
         static MarkedBlock* create(Heap*, size_t cellSize, bool cellsNeedDestruction);
         static MarkedBlock* recycle(MarkedBlock*, Heap*, size_t cellSize, bool cellsNeedDestruction);
         static void destroy(MarkedBlock*);

diff --git a/Source/JavaScriptCore/heap/MarkedSpace.h b/Source/JavaScriptCore/heap/MarkedSpace.h
index 19061a1..7bd5ca5 100644 (file)
--- a/Source/JavaScriptCore/heap/MarkedSpace.h
+++ b/Source/JavaScriptCore/heap/MarkedSpace.h
@@ -45,6 +45,26 @@ class LLIntOffsetsExtractor;
 class WeakGCHandle;
 class SlotVisitor;
 
+struct ClearMarks : MarkedBlock::VoidFunctor {
+    void operator()(MarkedBlock* block) { block->clearMarks(); }
+};
+
+struct Sweep : MarkedBlock::VoidFunctor {
+    void operator()(MarkedBlock* block) { block->sweep(); }
+};
+
+struct MarkCount : MarkedBlock::CountFunctor {
+    void operator()(MarkedBlock* block) { count(block->markCount()); }
+};
+
+struct Size : MarkedBlock::CountFunctor {
+    void operator()(MarkedBlock* block) { count(block->markCount() * block->cellSize()); }
+};
+
+struct Capacity : MarkedBlock::CountFunctor {
+    void operator()(MarkedBlock* block) { count(block->capacity()); }
+};
+
 class MarkedSpace {
     WTF_MAKE_NONCOPYABLE(MarkedSpace);
 public:
@@ -73,11 +93,18 @@ public:
     template<typename Functor> typename Functor::ReturnType forEachBlock();
     
     void shrink();
+    void freeAllBlocks();
     void freeBlocks(MarkedBlock* head);
 
     void didAddBlock(MarkedBlock*);
     void didConsumeFreeList(MarkedBlock*);
 
+    void clearMarks();
+    void sweep();
+    size_t objectCount();
+    size_t size();
+    size_t capacity();
+
     bool isPagedOut(double deadline);
 
 private:
@@ -185,6 +212,31 @@ inline void MarkedSpace::didAddBlock(MarkedBlock* block)
     m_blocks.add(block);
 }
 
+inline void MarkedSpace::clearMarks()
+{
+    forEachBlock<ClearMarks>();
+}
+
+inline void MarkedSpace::sweep()
+{
+    forEachBlock<Sweep>();
+}
+
+inline size_t MarkedSpace::objectCount()
+{
+    return forEachBlock<MarkCount>();
+}
+
+inline size_t MarkedSpace::size()
+{
+    return forEachBlock<Size>();
+}
+
+inline size_t MarkedSpace::capacity()
+{
+    return forEachBlock<Capacity>();
+}
+
 } // namespace JSC
 
 #endif // MarkedSpace_h