Changeset 126354 in webkit for trunk/Source/JavaScriptCore/heap/MarkStack.h

Timestamp:

Aug 22, 2012, 2:49:16 PM (13 years ago)

Author:

[email protected]

Message:

Separate MarkStackThreadSharedData from MarkStack
​https://bugs.webkit.org/show_bug.cgi?id=94294

Reviewed by Filip Pizlo.

MarkStackThreadSharedData is soon going to have data to allow for a parallel copying
mode too, so to separate our concerns we should split it out into its own set of files
and rename it to GCThreadSharedData. For now this is purely a cosmetic refactoring.

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• heap/GCThreadSharedData.cpp: Added.

(JSC):
(JSC::GCThreadSharedData::resetChildren):
(JSC::GCThreadSharedData::childVisitCount):
(JSC::GCThreadSharedData::markingThreadMain):
(JSC::GCThreadSharedData::markingThreadStartFunc):
(JSC::GCThreadSharedData::GCThreadSharedData):
(JSC::GCThreadSharedData::~GCThreadSharedData):
(JSC::GCThreadSharedData::reset):

• heap/GCThreadSharedData.h: Added.

(JSC):
(GCThreadSharedData):

• heap/Heap.h:

(Heap):

• heap/ListableHandler.h:

(ListableHandler):

• heap/MarkStack.cpp:

(JSC::MarkStack::MarkStack):
(JSC::MarkStack::~MarkStack):

• heap/MarkStack.h:

(JSC):
(MarkStack):
(JSC::MarkStack::sharedData):

• heap/MarkStackInlineMethods.h: Added.

(JSC):
(JSC::MarkStack::append):
(JSC::MarkStack::appendUnbarrieredPointer):
(JSC::MarkStack::appendUnbarrieredValue):
(JSC::MarkStack::internalAppend):
(JSC::MarkStack::addWeakReferenceHarvester):
(JSC::MarkStack::addUnconditionalFinalizer):
(JSC::MarkStack::addOpaqueRoot):
(JSC::MarkStack::containsOpaqueRoot):
(JSC::MarkStack::opaqueRootCount):

• heap/SlotVisitor.h:

(JSC):
(SlotVisitor):
(JSC::SlotVisitor::SlotVisitor):

File:

• trunk/Source/JavaScriptCore/heap/MarkStack.h (modified) (8 diffs)

trunk/Source/JavaScriptCore/heap/MarkStack.h

@@ -75 +75 @@
     class JSGlobalData;
     class MarkStack;
+    class GCThreadSharedData;
     class ParallelModeEnabler;
     class Register;
@@ -193 +194 @@
     };
 
-    class MarkStackThreadSharedData {
-    public:
-        MarkStackThreadSharedData(JSGlobalData*);
-        ~MarkStackThreadSharedData();
-        
-        void reset();
-
-#if ENABLE(PARALLEL_GC)
-        void resetChildren();
-        size_t childVisitCount();
-        size_t childDupStrings();
-#endif
-    
-    private:
-        friend class MarkStack;
-        friend class SlotVisitor;
-
-#if ENABLE(PARALLEL_GC)
-        void markingThreadMain(SlotVisitor*);
-        static void markingThreadStartFunc(void* heap);
-#endif
-
-        JSGlobalData* m_globalData;
-        CopiedSpace* m_copiedSpace;
-        
-        MarkStackSegmentAllocator m_segmentAllocator;
-        
-        bool m_shouldHashConst;
-
-        Vector<ThreadIdentifier> m_markingThreads;
-        Vector<MarkStack*> m_markingThreadsMarkStack;
-        
-        Mutex m_markingLock;
-        ThreadCondition m_markingCondition;
-        MarkStackArray m_sharedMarkStack;
-        unsigned m_numberOfActiveParallelMarkers;
-        bool m_parallelMarkersShouldExit;
-
-        Mutex m_opaqueRootsLock;
-        HashSet<void*> m_opaqueRoots;
-
-        ListableHandler<WeakReferenceHarvester>::List m_weakReferenceHarvesters;
-        ListableHandler<UnconditionalFinalizer>::List m_unconditionalFinalizers;
-    };
-
     class MarkStack {
         WTF_MAKE_NONCOPYABLE(MarkStack);
@@ -243 +199 @@
 
     public:
-        MarkStack(MarkStackThreadSharedData&);
+        MarkStack(GCThreadSharedData&);
         ~MarkStack();
 
@@ -260 +216 @@
         int opaqueRootCount();
 
-        MarkStackThreadSharedData& sharedData() { return m_shared; }
+        GCThreadSharedData& sharedData() { return m_shared; }
         bool isEmpty() { return m_stack.isEmpty(); }
 
@@ -272 +228 @@
 #endif
 
-        void addWeakReferenceHarvester(WeakReferenceHarvester* weakReferenceHarvester)
-        {
-            m_shared.m_weakReferenceHarvesters.addThreadSafe(weakReferenceHarvester);
-        }
-        
-        void addUnconditionalFinalizer(UnconditionalFinalizer* unconditionalFinalizer)
-        {
-            m_shared.m_unconditionalFinalizers.addThreadSafe(unconditionalFinalizer);
-        }
+        void addWeakReferenceHarvester(WeakReferenceHarvester*);
+        void addUnconditionalFinalizer(UnconditionalFinalizer*);
 
 #if ENABLE(OBJECT_MARK_LOGGING)
@@ -329 +278 @@
         bool m_isInParallelMode;
         
-        MarkStackThreadSharedData& m_shared;
+        GCThreadSharedData& m_shared;
 
         bool m_shouldHashConst; // Local per-thread copy of shared flag for performance reasons
@@ -339 +288 @@
 #endif
     };
-
-    inline MarkStack::MarkStack(MarkStackThreadSharedData& shared)
-        : m_stack(shared.m_segmentAllocator)
-#if !ASSERT_DISABLED
-        , m_isCheckingForDefaultMarkViolation(false)
-        , m_isDraining(false)
-#endif
-        , m_visitCount(0)
-        , m_isInParallelMode(false)
-        , m_shared(shared)
-        , m_shouldHashConst(false)
-    {
-    }
-
-    inline MarkStack::~MarkStack()
-    {
-        ASSERT(m_stack.isEmpty());
-    }
-
-    inline void MarkStack::addOpaqueRoot(void* root)
-    {
-#if ENABLE(PARALLEL_GC)
-        if (Options::numberOfGCMarkers() == 1) {
-            // Put directly into the shared HashSet.
-            m_shared.m_opaqueRoots.add(root);
-            return;
-        }
-        // Put into the local set, but merge with the shared one every once in
-        // a while to make sure that the local sets don't grow too large.
-        mergeOpaqueRootsIfProfitable();
-        m_opaqueRoots.add(root);
-#else
-        m_opaqueRoots.add(root);
-#endif
-    }
-
-    inline bool MarkStack::containsOpaqueRoot(void* root)
-    {
-        ASSERT(!m_isInParallelMode);
-#if ENABLE(PARALLEL_GC)
-        ASSERT(m_opaqueRoots.isEmpty());
-        return m_shared.m_opaqueRoots.contains(root);
-#else
-        return m_opaqueRoots.contains(root);
-#endif
-    }
-
-    inline int MarkStack::opaqueRootCount()
-    {
-        ASSERT(!m_isInParallelMode);
-#if ENABLE(PARALLEL_GC)
-        ASSERT(m_opaqueRoots.isEmpty());
-        return m_shared.m_opaqueRoots.size();
-#else
-        return m_opaqueRoots.size();
-#endif
-    }
 
     inline void MarkStackArray::append(const JSCell* cell)
@@ -430 +322 @@
     }
 
-    ALWAYS_INLINE void MarkStack::append(JSValue* slot, size_t count)
-    {
-        for (size_t i = 0; i < count; ++i) {
-            JSValue& value = slot[i];
-            if (!value)
-                continue;
-            internalAppend(value);
-        }
-    }
-
-    template<typename T>
-    inline void MarkStack::appendUnbarrieredPointer(T** slot)
-    {
-        ASSERT(slot);
-        JSCell* cell = *slot;
-        if (cell)
-            internalAppend(cell);
-    }
-    
-    ALWAYS_INLINE void MarkStack::append(JSValue* slot)
-    {
-        ASSERT(slot);
-        internalAppend(*slot);
-    }
-
-    ALWAYS_INLINE void MarkStack::appendUnbarrieredValue(JSValue* slot)
-    {
-        ASSERT(slot);
-        internalAppend(*slot);
-    }
-
-    ALWAYS_INLINE void MarkStack::append(JSCell** slot)
-    {
-        ASSERT(slot);
-        internalAppend(*slot);
-    }
-
-    ALWAYS_INLINE void MarkStack::internalAppend(JSValue value)
-    {
-        ASSERT(value);
-        if (!value.isCell())
-            return;
-        internalAppend(value.asCell());
-    }
-
     class ParallelModeEnabler {
     public: