Changeset 112624 in webkit for trunk/Source/JavaScriptCore/heap

Timestamp:

Mar 29, 2012, 5:36:37 PM (13 years ago)

Author:

[email protected]

Message:

Refactor recompileAllJSFunctions() to be less expensive
​https://bugs.webkit.org/show_bug.cgi?id=80330

Reviewed by Filip Pizlo.

This change is performance neutral on the JS benchmarks we track. It's mostly to improve page
load performance, which currently does at least a couple full GCs per navigation.

• heap/Heap.cpp:

(JSC::Heap::discardAllCompiledCode): Rename recompileAllJSFunctions to discardAllCompiledCode
because the function doesn't actually recompile anything (and never did); it simply throws code
away for it to be recompiled later if we determine we should do so.
(JSC):
(JSC::Heap::collectAllGarbage):
(JSC::Heap::addFunctionExecutable): Adds a newly created FunctionExecutable to the Heap's list.
(JSC::Heap::removeFunctionExecutable): Removes the specified FunctionExecutable from the Heap's list.

• heap/Heap.h:

(JSC):
(Heap):

• runtime/Executable.cpp: Added next and prev fields to FunctionExecutables so that they can

be used in DoublyLinkedLists.
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::FunctionExecutable::finalize): Removes the FunctionExecutable from the Heap's list.

• runtime/Executable.h:

(FunctionExecutable):
(JSC::FunctionExecutable::create): Adds the FunctionExecutable to the Heap's list.

• runtime/JSGlobalData.cpp: Remove recompileAllJSFunctions, as it's the Heap's job to own and manage

the list of FunctionExecutables.

• runtime/JSGlobalData.h:

(JSGlobalData):

• runtime/JSGlobalObject.cpp:

(JSC::DynamicGlobalObjectScope::DynamicGlobalObjectScope): Use the new discardAllCompiledCode.

Location:

trunk/Source/JavaScriptCore/heap

Files:

• Heap.cpp (modified) (3 diffs)
• Heap.h (modified) (4 diffs)

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -766 +766 @@
 }
 
+void Heap::discardAllCompiledCode()
+{
+    // If JavaScript is running, it's not safe to recompile, since we'll end
+    // up throwing away code that is live on the stack.
+    ASSERT(!m_globalData->dynamicGlobalObject);
+    
+    for (FunctionExecutable* current = m_functions.head(); current; current = current->next())
+        current->discardCode();
+}
+
 void Heap::collectAllGarbage()
 {
@@ -771 +781 @@
         return;
     if (!m_globalData->dynamicGlobalObject)
-        m_globalData->recompileAllJSFunctions();
+        discardAllCompiledCode();
 
     collect(DoSweep);
@@ -926 +936 @@
 }
 
+void Heap::addFunctionExecutable(FunctionExecutable* executable)
+{
+    m_functions.append(executable);
+}
+
+void Heap::removeFunctionExecutable(FunctionExecutable* executable)
+{
+    m_functions.remove(executable);
+}
+
 } // namespace JSC

trunk/Source/JavaScriptCore/heap/Heap.h

@@ -43 +43 @@
     class CopiedSpace;
     class CodeBlock;
+    class FunctionExecutable;
     class GCActivityCallback;
     class GlobalCodeBlock;
@@ -106 +107 @@
         typedef void (*Finalizer)(JSCell*);
         JS_EXPORT_PRIVATE void addFinalizer(JSCell*, Finalizer);
+        void addFunctionExecutable(FunctionExecutable*);
+        void removeFunctionExecutable(FunctionExecutable*);
 
         void notifyIsSafeToCollect() { m_isSafeToCollect = true; }
@@ -140 +143 @@
 
         double lastGCLength() { return m_lastGCLength; }
+
+        void discardAllCompiledCode();
 
     private:
@@ -241 +246 @@
         JSGlobalData* m_globalData;
         double m_lastGCLength;
+
+        DoublyLinkedList<FunctionExecutable> m_functions;
     };