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 437 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.
+    bool shouldGC = currentObjectSize >= 1024 * 1024 && currentObjectSize > estimatedLiveObjectSize * 3 / 2;
+    /*
+    if (shouldGC) {
+        fprintf(stderr, "idle GC: allocatedObjectSize=%ld estimatedLiveObjectSize=%ld markedObjectSize=%ld totalSizeOfCommittedPages=%ld currentObjectSize=%ld\n", Heap::allocatedObjectSize() / 1024 / 1024, Heap::estimatedLiveObjectSize() / 1024 / 1024, Heap::markedObjectSize() / 1024 / 1024, WTF::Partitions::totalSizeOfCommittedPages() / 1024 / 1024, currentObjectSize / 1024 / 1024);
+    }
+    */
+    return shouldGC;
 #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();
+    // Heap::markedObjectSize() may be underestimated if any thread has not
+    // finished completeSweep().
+    size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
     if (Heap::markedObjectSize() + allocatedObjectSize >= 300 * 1024 * 1024) {

[sof, 2015/04/14 20:13:19]

If you change this to

  size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() +
WTF::Partitions::totalSizeOfCommittedPages();
  if (currentObjectSize >= 300 * 1024 * 1024) {
     return allocatedObjectSize > estimatedLiveObjectSize / 2;
  }

and you do not consider totalSizeOfCommittedPages() anywhere else, dom-modify
(or textarea-dom) no longer OOMs on win32. See
https://codereview.chromium.org/1085023002/

         // 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 >50% larger than the estimated live memory usage.
+    bool shouldGC = currentObjectSize >= 32 * 1024 * 1024 && currentObjectSize > 5 * estimatedLiveObjectSize;
+    /*
+    if (shouldGC) {
+        fprintf(stderr, "conservative GC: allocatedObjectSize=%ld estimatedLiveObjectSize=%ld markedObjectSize=%ld totalSizeOfCommittedPages=%ld currentObjectSize=%ld\n", Heap::allocatedObjectSize() / 1024 / 1024, Heap::estimatedLiveObjectSize() / 1024 / 1024, Heap::markedObjectSize() / 1024 / 1024, WTF::Partitions::totalSizeOfCommittedPages() / 1024 / 1024, currentObjectSize / 1024 / 1024);

[Daniel Bratell, 2015/04/16 08:58:45]

Need the fprintf to not be there when this lands.

+    }
+    */
+    return shouldGC;
 }
 
 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());

[sof, 2015/04/10 07:21:09]

Hmm, this feels like arbitrary measures to combine together.

I think it would be better if we kept the different components of a GC
scheduling policy apart, i.e., external allocation amounts (by way of a global
PartitionAlloc measurement, or targeted registration of external memory
allocations added like now on trunk) is considered as a triggering component
separately from the rest(*). Either because it is above some set threshold or
that the derivative suggests a GC might be in order & the dangers of not taking
a possibly imprecise conservative GC is greater than not doing so. And, if so,
effectively signal an urgent GC (which we can keep as a mechanism? methinks of
possible memory pressure listener uses of it.)

* - or you can make them conditional on one another to filter out 'pointless'
GCs.

+    }
 
     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