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

Timestamp:

May 10, 2012, 10:32:39 AM (13 years ago)

Author:

[email protected]

Message:

Enh: Hash Const JSString in Backing Stores to Save Memory
​https://bugs.webkit.org/show_bug.cgi?id=86024

Reviewed by Filip Pizlo.

During garbage collection, each marking thread keeps a HashMap of
strings. While visiting via MarkStack::copyAndAppend(), we check to
see if the string we are visiting is already in the HashMap. If not
we add it. If so, we change the reference to the current string we're
visiting to the prior string.

To somewhat reduce the performance impact of this change, if a string
is unique at the end of a marking it will not be checked during further
GC phases. In some cases this won't catch all duplicates, but we are
trying to catch the growth of duplicate strings.

• heap/Heap.cpp:

(JSC::Heap::markRoots):

• heap/MarkStack.cpp:

(JSC::MarkStackThreadSharedData::resetChildren): New method called by the
main thread to reset the slave threads. This is primarily done to
clear the m_uniqueStrings HashMap.
(JSC):
(JSC::MarkStackThreadSharedData::markingThreadMain):
(JSC::MarkStackThreadSharedData::markingThreadStartFunc):
(JSC::MarkStackThreadSharedData::MarkStackThreadSharedData):
(JSC::MarkStackThreadSharedData::reset):
(JSC::MarkStack::reset): Added call to clear m_uniqueStrings.
(JSC::MarkStack::internalAppend): New method that performs the hash consting.
(JSC::SlotVisitor::copyAndAppend): Changed to call the new hash consting
internalAppend()

• heap/MarkStack.h:

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

• runtime/JSString.h:

(JSString): Added m_isHashConstSingleton flag, accessors for the flag and
code to initialize the flag.
(JSC::JSString::finishCreation):
(JSC::JSString::isHashConstSingleton):
(JSC::JSString::clearHashConstSingleton):
(JSC::JSString::setHashConstSingleton):
(JSC::JSRopeString::finishCreation):

File:

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

trunk/Source/JavaScriptCore/heap/MarkStack.cpp

@@ -37 +37 @@
 #include "ScopeChain.h"
 #include "Structure.h"
+#include "UString.h"
 #include "WriteBarrier.h"
 #include <wtf/MainThread.h>
@@ -219 +220 @@
 
 #if ENABLE(PARALLEL_GC)
-void MarkStackThreadSharedData::markingThreadMain()
+void MarkStackThreadSharedData::resetChildren()
+{
+    for (unsigned i = 0; i < m_slaveMarkStacks.size(); ++i)
+       m_slaveMarkStacks[i]->reset();
+}
+
+void MarkStackThreadSharedData::markingThreadMain(SlotVisitor* slotVisitor)
 {
     WTF::registerGCThread();
-    SlotVisitor slotVisitor(*this);
-    ParallelModeEnabler enabler(slotVisitor);
-    slotVisitor.drainFromShared(SlotVisitor::SlaveDrain);
-}
-
-void MarkStackThreadSharedData::markingThreadStartFunc(void* shared)
-{
-    static_cast<MarkStackThreadSharedData*>(shared)->markingThreadMain();
+    ParallelModeEnabler enabler(*slotVisitor);
+    slotVisitor->drainFromShared(SlotVisitor::SlaveDrain);
+    delete slotVisitor;
+}
+
+void MarkStackThreadSharedData::markingThreadStartFunc(void* myVisitor)
+{
+    SlotVisitor* slotVisitor = static_cast<SlotVisitor*>(myVisitor);
+    slotVisitor->sharedData().markingThreadMain(slotVisitor);
 }
 #endif
@@ -242 +250 @@
 #if ENABLE(PARALLEL_GC)
     for (unsigned i = 1; i < Options::numberOfGCMarkers; ++i) {
-        m_markingThreads.append(createThread(markingThreadStartFunc, this, "JavaScriptCore::Marking"));
+        SlotVisitor* slotVisitor = new SlotVisitor(*this);
+        m_slaveMarkStacks.append(slotVisitor);
+        m_markingThreads.append(createThread(markingThreadStartFunc, slotVisitor, "JavaScriptCore::Marking"));
         ASSERT(m_markingThreads.last());
     }
@@ -274 +284 @@
     ASSERT(m_opaqueRoots.isEmpty());
 #endif
-    
     m_weakReferenceHarvesters.removeAll();
 }
@@ -287 +296 @@
     m_opaqueRoots.clear();
 #endif
+    m_uniqueStrings.clear();
 }
 
@@ -487 +497 @@
 }
 
+inline void MarkStack::internalAppend(JSValue* slot)
+{
+    ASSERT(slot);
+    JSValue value = *slot;
+    ASSERT(value);
+    if (!value.isCell())
+        return;
+
+    if (value.isString()) {
+        JSString* string = jsCast<JSString*>(value.asCell());
+        if (!string->isHashConstSingleton() && string->length() > 1 && !string->isRope()) {
+            UniqueStringMap::AddResult addResult = m_uniqueStrings.add(string->string().impl(), value);
+            if (addResult.isNewEntry)
+                string->setHashConstSingleton();
+            else {
+                JSValue existingJSValue = addResult.iterator->second;
+                if (value != existingJSValue)
+                    jsCast<JSString*>(existingJSValue.asCell())->clearHashConstSingleton();
+                *slot = existingJSValue;
+                return;
+            }
+        }
+    }
+
+    internalAppend(value.asCell());
+}
+
+
 void SlotVisitor::copyAndAppend(void** ptr, size_t bytes, JSValue* values, unsigned length)
 {
@@ -500 +538 @@
             if (!value)
                 continue;
-            internalAppend(value);
+            internalAppend(&newValues[i]);
         }