Changeset 128084 in webkit for trunk/Source/JavaScriptCore/heap/MarkStackInlineMethods.h

Timestamp:

Sep 10, 2012, 11:41:05 AM (13 years ago)

Author:

[email protected]

Message:

Combine MarkStack and SlotVisitor into single class
​https://bugs.webkit.org/show_bug.cgi?id=96043

Reviewed by Geoff Garen.

Move all of MarkStack into SlotVisitor. The remaining stuff in MarkStack.cpp actually has to do
with MarkStack management/allocation. Cleaned up a few of the header files while I was at it.

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• bytecode/CodeBlock.cpp:
• dfg/DFGCommon.h:
• heap/GCThreadSharedData.cpp:
• heap/GCThreadSharedData.h:

(GCThreadSharedData):

• heap/HeapRootVisitor.h:
• heap/MarkStack.cpp:

(JSC):

• heap/MarkStack.h:

(JSC):
(MarkStackSegment):
(JSC::MarkStackSegment::data):
(JSC::MarkStackSegment::capacityFromSize):
(JSC::MarkStackSegment::sizeFromCapacity):
(MarkStackSegmentAllocator):
(MarkStackArray):

• heap/MarkStackInlineMethods.h:

(JSC::MarkStackArray::postIncTop):
(JSC):
(JSC::MarkStackArray::preDecTop):
(JSC::MarkStackArray::setTopForFullSegment):
(JSC::MarkStackArray::setTopForEmptySegment):
(JSC::MarkStackArray::top):
(JSC::MarkStackArray::validatePrevious):
(JSC::MarkStackArray::append):
(JSC::MarkStackArray::canRemoveLast):
(JSC::MarkStackArray::removeLast):
(JSC::MarkStackArray::isEmpty):
(JSC::MarkStackArray::size):

• heap/SlotVisitor.cpp: Added.

(JSC):
(JSC::SlotVisitor::SlotVisitor):
(JSC::SlotVisitor::~SlotVisitor):
(JSC::SlotVisitor::setup):
(JSC::SlotVisitor::reset):
(JSC::SlotVisitor::append):
(JSC::visitChildren):
(JSC::SlotVisitor::donateKnownParallel):
(JSC::SlotVisitor::drain):
(JSC::SlotVisitor::drainFromShared):
(JSC::SlotVisitor::mergeOpaqueRoots):
(JSC::SlotVisitor::startCopying):
(JSC::SlotVisitor::allocateNewSpaceSlow):
(JSC::SlotVisitor::allocateNewSpaceOrPin):
(JSC::JSString::tryHashConstLock):
(JSC::JSString::releaseHashConstLock):
(JSC::JSString::shouldTryHashConst):
(JSC::SlotVisitor::internalAppend):
(JSC::SlotVisitor::copyAndAppend):
(JSC::SlotVisitor::doneCopying):
(JSC::SlotVisitor::harvestWeakReferences):
(JSC::SlotVisitor::finalizeUnconditionalFinalizers):
(JSC::SlotVisitor::validate):

• heap/SlotVisitor.h:

(JSC):
(SlotVisitor):
(JSC::SlotVisitor::sharedData):
(JSC::SlotVisitor::isEmpty):
(JSC::SlotVisitor::visitCount):
(JSC::SlotVisitor::resetChildCount):
(JSC::SlotVisitor::childCount):
(JSC::SlotVisitor::incrementChildCount):
(ParallelModeEnabler):
(JSC::ParallelModeEnabler::ParallelModeEnabler):
(JSC::ParallelModeEnabler::~ParallelModeEnabler):

• heap/SlotVisitorInlineMethods.h:

(JSC::SlotVisitor::append):
(JSC):
(JSC::SlotVisitor::appendUnbarrieredPointer):
(JSC::SlotVisitor::appendUnbarrieredValue):
(JSC::SlotVisitor::internalAppend):
(JSC::SlotVisitor::addWeakReferenceHarvester):
(JSC::SlotVisitor::addUnconditionalFinalizer):
(JSC::SlotVisitor::addOpaqueRoot):
(JSC::SlotVisitor::containsOpaqueRoot):
(JSC::SlotVisitor::opaqueRootCount):
(JSC::SlotVisitor::mergeOpaqueRootsIfNecessary):
(JSC::SlotVisitor::mergeOpaqueRootsIfProfitable):
(JSC::SlotVisitor::donate):
(JSC::SlotVisitor::donateAndDrain):

• jit/JITWriteBarrier.h:

(JSC::SlotVisitor::append):

• jit/JumpReplacementWatchpoint.cpp:
• runtime/JSCell.h:
• runtime/Structure.h:

(JSC::SlotVisitor::internalAppend):

• runtime/WriteBarrier.h:

(JSC):
(JSC::SlotVisitor::append):
(JSC::SlotVisitor::appendValues):

• yarr/YarrJIT.cpp:

File:

• trunk/Source/JavaScriptCore/heap/MarkStackInlineMethods.h (modified) (1 diff)

trunk/Source/JavaScriptCore/heap/MarkStackInlineMethods.h

@@ -32 +32 @@
 namespace JSC {
 
-ALWAYS_INLINE void MarkStack::append(JSValue* slot, size_t count)
+inline size_t MarkStackArray::postIncTop()
 {
-    for (size_t i = 0; i < count; ++i) {
-        JSValue& value = slot[i];
-        internalAppend(value);
-    }
+    size_t result = m_top++;
+    ASSERT(result == m_topSegment->m_top++);
+    return result;
+}
+        
+inline size_t MarkStackArray::preDecTop()
+{
+    size_t result = --m_top;
+    ASSERT(result == --m_topSegment->m_top);
+    return result;
+}
+        
+inline void MarkStackArray::setTopForFullSegment()
+{
+    ASSERT(m_topSegment->m_top == m_segmentCapacity);
+    m_top = m_segmentCapacity;
 }
 
-template<typename T>
-inline void MarkStack::appendUnbarrieredPointer(T** slot)
+inline void MarkStackArray::setTopForEmptySegment()
 {
-    ASSERT(slot);
-    JSCell* cell = *slot;
-    internalAppend(cell);
+    ASSERT(!m_topSegment->m_top);
+    m_top = 0;
 }
 
-ALWAYS_INLINE void MarkStack::append(JSValue* slot)
+inline size_t MarkStackArray::top()
 {
-    ASSERT(slot);
-    internalAppend(*slot);
+    ASSERT(m_top == m_topSegment->m_top);
+    return m_top;
 }
 
-ALWAYS_INLINE void MarkStack::appendUnbarrieredValue(JSValue* slot)
+#if ASSERT_DISABLED
+inline void MarkStackArray::validatePrevious() { }
+#else
+inline void MarkStackArray::validatePrevious()
 {
-    ASSERT(slot);
-    internalAppend(*slot);
+    unsigned count = 0;
+    for (MarkStackSegment* current = m_topSegment->m_previous; current; current = current->m_previous)
+        count++;
+    ASSERT(count == m_numberOfPreviousSegments);
+}
+#endif
+
+inline void MarkStackArray::append(const JSCell* cell)
+{
+    if (m_top == m_segmentCapacity)
+        expand();
+    m_topSegment->data()[postIncTop()] = cell;
 }
 
-ALWAYS_INLINE void MarkStack::append(JSCell** slot)
+inline bool MarkStackArray::canRemoveLast()
 {
-    ASSERT(slot);
-    internalAppend(*slot);
+    return !!m_top;
 }
 
-ALWAYS_INLINE void MarkStack::internalAppend(JSValue value)
+inline const JSCell* MarkStackArray::removeLast()
 {
-    if (!value || !value.isCell())
-        return;
-    internalAppend(value.asCell());
+    return m_topSegment->data()[preDecTop()];
 }
 
-inline void MarkStack::addWeakReferenceHarvester(WeakReferenceHarvester* weakReferenceHarvester)
+inline bool MarkStackArray::isEmpty()
 {
-    m_shared.m_weakReferenceHarvesters.addThreadSafe(weakReferenceHarvester);
+    if (m_top)
+        return false;
+    if (m_topSegment->m_previous) {
+        ASSERT(m_topSegment->m_previous->m_top == m_segmentCapacity);
+        return false;
+    }
+    return true;
 }
 
-inline void MarkStack::addUnconditionalFinalizer(UnconditionalFinalizer* unconditionalFinalizer)
+inline size_t MarkStackArray::size()
 {
-    m_shared.m_unconditionalFinalizers.addThreadSafe(unconditionalFinalizer);
-}
-
-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
+    return m_top + m_segmentCapacity * m_numberOfPreviousSegments;
 }