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

Timestamp:

Apr 18, 2012, 9:18:32 AM (13 years ago)

Author:

[email protected]

Message:

GC activity timer should be tied to allocation, not collection
​https://bugs.webkit.org/show_bug.cgi?id=83919

Reviewed by Geoffrey Garen.

• API/JSContextRef.cpp: Used the new didAbandonObjectGraph callback to indicate that now that we've

released a global object, we're abandoning a potentially large number of objects that JSC might want
to collect.

• heap/CopiedSpace.cpp:

(JSC::CopiedSpace::tryAllocateSlowCase): Added the call to timer's willAllocate function to indicate
that we've hit a slow path and are allocating now, so schedule the timer.

• heap/Heap.cpp:

(JSC::Heap::Heap):
(JSC::Heap::collectAllGarbage): Removed the call to discardAllCompiledCode because it was causing us to
throw away too much code during our benchmarks (especially vp8, which is very large and thus has large
amounts of compiled code).
(JSC::Heap::collect): Added the new call to didCollect at the conclusion of a collection so that we
can cancel the timer if we no longer need to run a collection. Also added a check at the beginning of a
collection to see if we should throw away our compiled code. Currently this is set to happen about once
every minute.

• heap/Heap.h: Added field to keep track of the last time we threw away our compiled code.
• heap/MarkedAllocator.cpp:

(JSC::MarkedAllocator::allocateSlowCase): Added call to willAllocate on the allocation slow path, just like
in CopiedSpace.

• runtime/GCActivityCallback.cpp: Added default stubs for non-CF platforms.

(JSC::DefaultGCActivityCallback::willAllocate):
(JSC):
(JSC::DefaultGCActivityCallback::didCollect):
(JSC::DefaultGCActivityCallback::didAbandonObjectGraph):

• runtime/GCActivityCallback.h: Added new functions to make JSC's GC timer less arcane. This includes replacing

the operator () with willAllocate() and adding an explicit didCollect() to cancel the timer after a collection
occurs rather than relying on the way the timer is invoked to cancel itself. Also added a callback for
when somebody else (e.g. WebCore or the JSC API) to notify JSC that they have just abandoned an entire graph of
objects and that JSC might want to clean them up.
(JSC::GCActivityCallback::~GCActivityCallback):
(JSC::GCActivityCallback::willAllocate):
(JSC::GCActivityCallback::didCollect):
(JSC::GCActivityCallback::didAbandonObjectGraph):
(JSC::GCActivityCallback::synchronize):
(DefaultGCActivityCallback):

• runtime/GCActivityCallbackCF.cpp: Re-wired all the run loop stuff to implement the aforementioned functions.

We added a flag to check whether the timer was active because the call to CFRunLoopTimerSetNextFireDate actually
turned out to be quite expensive (although Instruments couldn't tell us this).
(DefaultGCActivityCallbackPlatformData):
(JSC):
(JSC::DefaultGCActivityCallbackPlatformData::timerDidFire):
(JSC::DefaultGCActivityCallback::commonConstructor):
(JSC::scheduleTimer):
(JSC::cancelTimer):
(JSC::DefaultGCActivityCallback::willAllocate):
(JSC::DefaultGCActivityCallback::didCollect):
(JSC::DefaultGCActivityCallback::didAbandonObjectGraph):

Location:

trunk/Source/JavaScriptCore/heap

Files:

• CopiedSpace.cpp (modified) (2 diffs)
• Heap.cpp (modified) (4 diffs)
• Heap.h (modified) (1 diff)
• MarkedAllocator.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/heap/CopiedSpace.cpp

@@ -28 +28 @@
 
 #include "CopiedSpaceInlineMethods.h"
+#include "GCActivityCallback.h"
 
 namespace JSC {
@@ -52 +53 @@
 CheckedBoolean CopiedSpace::tryAllocateSlowCase(size_t bytes, void** outPtr)
 {
+    m_heap->activityCallback()->willAllocate();
+    
     if (isOversize(bytes))
         return tryAllocateOversize(bytes, outPtr);

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -329 +329 @@
     , m_globalData(globalData)
     , m_lastGCLength(0)
-{
-    (*m_activityCallback)();
+    , m_lastCodeDiscardTime(WTF::currentTime())
+{
     m_numberOfFreeBlocks = 0;
     m_blockFreeingThread = createThread(blockFreeingThreadStartFunc, this, "JavaScriptCore::BlockFree");
@@ -784 +784 @@
     if (!m_isSafeToCollect)
         return;
-    discardAllCompiledCode();
 
     collect(DoSweep);
 }
+
+static double minute = 60.0;
 
 void Heap::collect(SweepToggle sweepToggle)
@@ -797 +798 @@
     ASSERT(m_isSafeToCollect);
     JAVASCRIPTCORE_GC_BEGIN();
+
     double lastGCStartTime = WTF::currentTime();
+    if (lastGCStartTime - m_lastCodeDiscardTime > minute) {
+        discardAllCompiledCode();
+        m_lastCodeDiscardTime = WTF::currentTime();
+    }
+
 #if ENABLE(GGC)
     bool fullGC = sweepToggle == DoSweep;
@@ -856 +863 @@
     JAVASCRIPTCORE_GC_END();
 
-    (*m_activityCallback)();
+    m_activityCallback->didCollect();
 }
 

trunk/Source/JavaScriptCore/heap/Heap.h

@@ -248 +248 @@
         JSGlobalData* m_globalData;
         double m_lastGCLength;
+        double m_lastCodeDiscardTime;
 
         DoublyLinkedList<FunctionExecutable> m_functions;

trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp

@@ -2 +2 @@
 #include "MarkedAllocator.h"
 
+#include "GCActivityCallback.h"
 #include "Heap.h"
 
@@ -41 +42 @@
     ASSERT(m_heap->m_operationInProgress == NoOperation);
 #endif
+    
+    m_heap->activityCallback()->willAllocate();
     
     void* result = tryAllocate();