Oilpan: Consider PartitionAlloc's memory usage when triggering a GC

Source/platform/heap/ThreadState.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 24 matching lines @@
 #include "platform/TraceEvent.h"
 #include "platform/heap/AddressSanitizer.h"
 #include "platform/heap/CallbackStack.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/scheduler/Scheduler.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
+#include "wtf/Partitions.h"
 #include "wtf/ThreadingPrimitives.h"
 #if ENABLE(GC_PROFILING)
 #include "platform/TracedValue.h"
 #include "wtf/text/StringHash.h"
 #endif
 
 #if OS(WIN)
 #include <stddef.h>
 #include <windows.h>
 #include <winnt.h>
@@ skipping 438 matching lines @@
     AtomicallyInitializedStaticReference(PersistentNode, anchor, new PersistentAnchor);
     return anchor;
 }
 
 Mutex& ThreadState::globalRootsMutex()
 {
     AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
     return mutex;
 }
 
-// FIXME: We should improve the GC heuristics.
+// TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldScheduleIdleGC()
 {
     if (gcState() != NoGCScheduled)
         return false;
 #if ENABLE(OILPAN)
     // The estimated size is updated when the main thread finishes lazy
     // sweeping. If this thread reaches here before the main thread finishes
     // lazy sweeping, the thread will use the estimated size of the last GC.
     size_t estimatedLiveObjectSize = Heap::estimatedLiveObjectSize();
-    // Schedule an idle GC if more than 512 KB has been allocated since
-    // the last GC and the current memory usage (=allocated + estimated)
-    // is >50% larger than the estimated live memory usage.
     size_t allocatedObjectSize = Heap::allocatedObjectSize();
-    return allocatedObjectSize >= 512 * 1024 && allocatedObjectSize > estimatedLiveObjectSize / 2;
+    // Heap::markedObjectSize() may be underestimated if any thread has not
+    // finished completeSweep().
+    size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    // Schedule an idle GC if the current memory usage is >1MB
+    // and is >50% larger than the estimated live memory usage.
+    return currentObjectSize >= 1024 * 1024 && currentObjectSize > estimatedLiveObjectSize * 3 / 2;

[sof, 2015/04/23 15:20:33]

Re: (currentObjectSize >= 1024 * 1024) -- wouldn't this always be true since
PA's allocations are included?

And if so, wouldn't it schedule an idle GC without having allocated anything on
the heap (as estimatedLiveObjectSize is 0)?

 #else
     return false;
 #endif
 }
 
-// FIXME: We should improve the GC heuristics.
+// TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldSchedulePreciseGC()
 {
     if (gcState() != NoGCScheduled)
         return false;
 #if ENABLE(OILPAN)
     return false;
 #else
     // The estimated size is updated when the main thread finishes lazy
     // sweeping. If this thread reaches here before the main thread finishes
     // lazy sweeping, the thread will use the estimated size of the last GC.
     size_t estimatedLiveObjectSize = Heap::estimatedLiveObjectSize();
-    // Schedule a precise GC if more than 512 KB has been allocated since
-    // the last GC and the current memory usage (=allocated + estimated)
-    // is >50% larger than the estimated live memory usage.
     size_t allocatedObjectSize = Heap::allocatedObjectSize();
-    return allocatedObjectSize >= 512 * 1024 && allocatedObjectSize > estimatedLiveObjectSize / 2;
+    // Heap::markedObjectSize() may be underestimated if any thread has not
+    // finished completeSweep().
+    size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    // Schedule a precise GC if the current memory usage is >1MB
+    // and is >50% larger than the estimated live memory usage.
+    return currentObjectSize >= 1024 * 1024 && currentObjectSize > estimatedLiveObjectSize * 3 / 2;
 #endif
 }
 
-// FIXME: We should improve the GC heuristics.
+// TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldForceConservativeGC()
 {
     if (UNLIKELY(m_gcForbiddenCount))
         return false;
 
-    if (Heap::isUrgentGCRequested())
-        return true;
-
     // The estimated size is updated when the main thread finishes lazy
     // sweeping. If this thread reaches here before the main thread finishes
     // lazy sweeping, the thread will use the estimated size of the last GC.
     size_t estimatedLiveObjectSize = Heap::estimatedLiveObjectSize();
     size_t allocatedObjectSize = Heap::allocatedObjectSize();
-    if (Heap::markedObjectSize() + allocatedObjectSize >= 300 * 1024 * 1024) {
+    // Heap::markedObjectSize() may be underestimated if any thread has not
+    // finished completeSweep().
+    size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    if (currentObjectSize >= 300 * 1024 * 1024) {
         // If we're consuming too much memory, trigger a conservative GC
         // aggressively. This is a safe guard to avoid OOM.
-        return allocatedObjectSize > estimatedLiveObjectSize / 2;
+        return currentObjectSize > estimatedLiveObjectSize * 3 / 2;
     }
-    // Schedule a conservative GC if more than 32 MB has been allocated since
-    // the last GC and the current memory usage (=allocated + estimated)
-    // is >500% larger than the estimated live memory usage.
-    return allocatedObjectSize >= 32 * 1024 * 1024 && allocatedObjectSize > 4 * estimatedLiveObjectSize;
+    // Schedule a conservative GC if the current memory usage is >32MB
+    // and is >400% larger than the estimated live memory usage.
+    // TODO(haraken): 400% is too large. Lower the heap growing factor.
+    return currentObjectSize >= 32 * 1024 * 1024 && currentObjectSize > 5 * estimatedLiveObjectSize;
 }
 
 void ThreadState::scheduleGCIfNeeded()
 {
     checkThread();
     // Allocation is allowed during sweeping, but those allocations should not
-    // trigger nested GCs. Does not apply if an urgent GC has been requested.
-    if (isSweepingInProgress() && UNLIKELY(!Heap::isUrgentGCRequested()))
+    // trigger nested GCs.
+    if (isSweepingInProgress())
         return;
     ASSERT(!sweepForbidden());
 
     if (shouldForceConservativeGC()) {
-        if (Heap::isUrgentGCRequested()) {
-            // If GC is deemed urgent, eagerly sweep and finalize any external allocations right away.
-            Heap::collectGarbage(HeapPointersOnStack, GCWithSweep, Heap::ConservativeGC);
-        } else {
-            // Otherwise, schedule a lazy sweeping in an idle task.
-            Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::ConservativeGC);
-        }
+        Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::ConservativeGC);
         return;
     }
     if (shouldSchedulePreciseGC())
         schedulePreciseGC();
     else if (shouldScheduleIdleGC())
         scheduleIdleGC();
 }
 
 void ThreadState::performIdleGC(double deadlineSeconds)
 {
@@ skipping 241 matching lines @@
 
         if (isMainThread())
             ScriptForbiddenScope::exit();
     }
 
     postSweep();
 }
 
 void ThreadState::postSweep()
 {
-    if (isMainThread())
-        Heap::setEstimatedLiveObjectSize(Heap::markedObjectSize());
+    if (isMainThread()) {
+        // At the point where the main thread finishes lazy sweeping,
+        // we estimate the live object size. Heap::markedObjectSize()
+        // may be underestimated if any other thread has not finished
+        // lazy sweeping.
+        Heap::setEstimatedLiveObjectSize(Heap::markedObjectSize() + Heap::externalObjectSizeAtLastGC());
+    }
 
     switch (gcState()) {
     case Sweeping:
         setGCState(NoGCScheduled);
         break;
     case SweepingAndPreciseGCScheduled:
         setGCState(PreciseGCScheduled);
         break;
     case SweepingAndIdleGCScheduled:
         setGCState(NoGCScheduled);
@@ skipping 431 matching lines @@
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
 } // namespace blink