Changeset 97642 in webkit for trunk/Source/JavaScriptCore/heap/MarkStack.cpp

Timestamp:

Oct 17, 2011, 1:43:43 PM (14 years ago)

Author:

[email protected]

Message:

Simplified GC marking logic
​https://bugs.webkit.org/show_bug.cgi?id=70258

Reviewed by Filip Pizlo.

No perf. change.

This is a first step toward GC allocating string backing stores, starting
with ropes. It also enables future simplifications and optimizations.

• Replaced some complex mark stack logic with a simple linear stack of

JSCell pointers.

• Replaced logic for short-circuiting marking based on JSType and/or

Structure flags with special cases for object, array, and string.

• Fiddled with inlining for better codegen.

• JavaScriptCore.exp:
• heap/HandleStack.cpp: Build!

• heap/Heap.cpp:

(JSC::Heap::Heap): Provide more vptrs to SlotVisitor, for use in marking.

• heap/HeapRootVisitor.h: Removed unused functions that no longer build.

• heap/MarkStack.cpp:

(JSC::MarkStackArray::MarkStackArray):
(JSC::MarkStackArray::~MarkStackArray):
(JSC::MarkStackArray::expand):
(JSC::MarkStackArray::shrinkAllocation):
(JSC::MarkStack::reset):
(JSC::visitChildren):
(JSC::SlotVisitor::drain):

• heap/MarkStack.h:

(JSC::MarkStack::MarkStack):
(JSC::MarkStack::~MarkStack):
(JSC::MarkStackArray::append):
(JSC::MarkStackArray::removeLast):
(JSC::MarkStackArray::isEmpty):
(JSC::MarkStack::append):
(JSC::MarkStack::appendUnbarrieredPointer):
(JSC::MarkStack::internalAppend): Replaced complex mark set logic with
simple linear stack.

• heap/SlotVisitor.h:

(JSC::SlotVisitor::SlotVisitor): Updated for above changes.

• runtime/JSArray.cpp:

(JSC::JSArray::visitChildren):

• runtime/JSArray.h:
• runtime/JSObject.cpp:

(JSC::JSObject::visitChildren):

• runtime/JSObject.h: Don't inline visitChildren; it's too big.

• runtime/Structure.h:

(JSC::MarkStack::internalAppend): Nixed the short-circuit for CompoundType
because it prevented strings from owning GC pointers.

• runtime/WriteBarrier.h:

(JSC::MarkStack::appendValues): No need to validate; internalAppend will
do that for us.

File:

• trunk/Source/JavaScriptCore/heap/MarkStack.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/heap/MarkStack.cpp

@@ -34 +34 @@
 #include "ScopeChain.h"
 #include "Structure.h"
+#include "WriteBarrier.h"
 
 namespace JSC {
+
+MarkStackArray::MarkStackArray()
+    : m_top(0)
+    , m_allocated(pageSize())
+{
+    m_data = static_cast<const JSCell**>(MarkStack::allocateStack(m_allocated));
+    m_capacity = m_allocated / sizeof(JSCell*);
+}
+
+MarkStackArray::~MarkStackArray()
+{
+    MarkStack::releaseStack(m_data, m_allocated);
+}
+
+void MarkStackArray::expand()
+{
+    size_t oldAllocation = m_allocated;
+    m_allocated *= 2;
+    m_capacity = m_allocated / sizeof(JSCell*);
+    void* newData = MarkStack::allocateStack(m_allocated);
+    memcpy(newData, m_data, oldAllocation);
+    MarkStack::releaseStack(m_data, oldAllocation);
+    m_data = static_cast<const JSCell**>(newData);
+}
+
+void MarkStackArray::shrinkAllocation(size_t size)
+{
+    ASSERT(size <= m_allocated);
+    ASSERT(isPageAligned(size));
+    if (size == m_allocated)
+        return;
+#if OS(WINDOWS)
+    // We cannot release a part of a region with VirtualFree. To get around this,
+    // we'll release the entire region and reallocate the size that we want.
+    MarkStack::releaseStack(m_data, m_allocated);
+    m_data = static_cast<JSCell*>(MarkStack::allocateStack(size));
+#else
+    MarkStack::releaseStack(reinterpret_cast<char*>(m_data) + size, m_allocated - size);
+#endif
+    m_allocated = size;
+    m_capacity = m_allocated / sizeof(JSCell*);
+}
 
 void MarkStack::reset()
 {
     m_visitCount = 0;
-    m_values.shrinkAllocation(pageSize());
-    m_markSets.shrinkAllocation(pageSize());
+    m_stack.shrinkAllocation(pageSize());
     m_opaqueRoots.clear();
 }
@@ -53 +95 @@
 }
 
-void SlotVisitor::visitChildren(JSCell* cell)
+ALWAYS_INLINE static void visitChildren(SlotVisitor& visitor, const JSCell* cell, void* jsFinalObjectVPtr, void* jsArrayVPtr, void* jsStringVPtr)
 {
 #if ENABLE(SIMPLE_HEAP_PROFILING)
@@ -60 +102 @@
 
     ASSERT(Heap::isMarked(cell));
-    if (cell->structure()->typeInfo().type() < CompoundType) {
-        JSCell::visitChildren(cell, *this);
+
+    if (cell->vptr() == jsStringVPtr)
+        return;
+
+    if (cell->vptr() == jsFinalObjectVPtr) {
+        JSObject::visitChildren(const_cast<JSCell*>(cell), visitor);
         return;
     }
 
-    if (!cell->structure()->typeInfo().overridesVisitChildren()) {
-        ASSERT(cell->isObject());
-#ifdef NDEBUG
-        asObject(cell)->visitChildrenDirect(*this);
-#else
-        ASSERT(!m_isCheckingForDefaultMarkViolation);
-        m_isCheckingForDefaultMarkViolation = true;
-        cell->methodTable()->visitChildren(cell, *this);
-        ASSERT(m_isCheckingForDefaultMarkViolation);
-        m_isCheckingForDefaultMarkViolation = false;
-#endif
+    if (cell->vptr() == jsArrayVPtr) {
+        JSArray::visitChildren(const_cast<JSCell*>(cell), visitor);
         return;
     }
-    if (cell->vptr() == m_jsArrayVPtr) {
-        asArray(cell)->visitChildrenDirect(*this);
-        return;
-    }
-    cell->methodTable()->visitChildren(cell, *this);
+
+    cell->methodTable()->visitChildren(const_cast<JSCell*>(cell), visitor);
 }
 
 void SlotVisitor::drain()
 {
-#if !ASSERT_DISABLED
-    ASSERT(!m_isDraining);
-    m_isDraining = true;
-#endif
-    while (!m_markSets.isEmpty() || !m_values.isEmpty()) {
-        while (!m_markSets.isEmpty() && m_values.size() < 50) {
-            ASSERT(!m_markSets.isEmpty());
-            MarkSet& current = m_markSets.last();
-            ASSERT(current.m_values);
-            JSValue* end = current.m_end;
-            ASSERT(current.m_values);
-            ASSERT(current.m_values != end);
-        findNextUnmarkedNullValue:
-            ASSERT(current.m_values != end);
-            JSValue value = *current.m_values;
-            current.m_values++;
+    void* jsFinalObjectVPtr = m_jsFinalObjectVPtr;
+    void* jsArrayVPtr = m_jsArrayVPtr;
+    void* jsStringVPtr = m_jsStringVPtr;
 
-            JSCell* cell;
-            if (!value || !value.isCell() || Heap::testAndSetMarked(cell = value.asCell())) {
-                if (current.m_values == end) {
-                    m_markSets.removeLast();
-                    continue;
-                }
-                goto findNextUnmarkedNullValue;
-            }
-
-            if (cell->structure()->typeInfo().type() < CompoundType) {
-#if ENABLE(SIMPLE_HEAP_PROFILING)
-                m_visitedTypeCounts.count(cell);
-#endif
-                JSCell::visitChildren(cell, *this);
-                if (current.m_values == end) {
-                    m_markSets.removeLast();
-                    continue;
-                }
-                goto findNextUnmarkedNullValue;
-            }
-
-            if (current.m_values == end)
-                m_markSets.removeLast();
-
-            visitChildren(cell);
-        }
-        while (!m_values.isEmpty())
-            visitChildren(m_values.removeLast());
-    }
-#if !ASSERT_DISABLED
-    m_isDraining = false;
-#endif
+    while (!m_stack.isEmpty())
+        visitChildren(*this, m_stack.removeLast(), jsFinalObjectVPtr, jsArrayVPtr, jsStringVPtr);
 }
 
@@ -150 +141 @@
 
 #if ENABLE(GC_VALIDATION)
-void MarkStack::validateSet(JSValue* values, size_t count)
+void MarkStack::validate(JSCell* cell)
 {
-    for (size_t i = 0; i < count; i++) {
-        if (values[i])
-            validateValue(values[i]);
-    }
-}
-
-void MarkStack::validateValue(JSValue value)
-{
-    if (!value)
-        CRASH();
-    if (!value.isCell())
-        return;
-    JSCell* cell = value.asCell();
     if (!cell)
         CRASH();
@@ -177 +155 @@
 }
 #else
-void MarkStack::validateValue(JSValue)
+void MarkStack::validate(JSCell*)
 {
-} 
+}
 #endif