Oilpan: adjust GC policy under memory pressure (only.)

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 511 matching lines @@
     AtomicallyInitializedStaticReference(PersistentAnchor, anchor, new PersistentAnchor);
     return anchor;
 }
 
 Mutex& ThreadState::globalRootsMutex()
 {
     AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
     return mutex;
 }
 
+bool ThreadState::shouldForceMemoryPressureGC()
+{
+    // Avoid potential overflow by truncating to Kb.
+    size_t currentObjectSizeKb = (Heap::allocatedObjectSize() + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages()) >> 10;
+    if (currentObjectSizeKb < 300 * 1024)
+        return false;
+
+    size_t estimatedLiveObjectSizeKb = Heap::estimatedLiveObjectSize() >> 10;
+    // If we're consuming too much memory, trigger a conservative GC
+    // aggressively. This is a safe guard to avoid OOM.
+    return currentObjectSizeKb > (estimatedLiveObjectSizeKb * 3) / 2;
+}
+
 // TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldScheduleIdleGC()
 {
     if (gcState() != NoGCScheduled)
         return false;
 #if ENABLE(IDLE_GC)
+    // Avoid potential overflow by truncating to Kb.
+    size_t allocatedObjectSizeKb = Heap::allocatedObjectSize() >> 10;
     // 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();
+    size_t estimatedLiveObjectSizeKb = Heap::estimatedLiveObjectSize() >> 10;
     // Heap::markedObjectSize() may be underestimated if any thread has not
     // finished completeSweep().
-    size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    size_t currentObjectSizeKb = allocatedObjectSizeKb + ((Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages()) >> 10);
     // Schedule an idle GC if Oilpan has allocated more than 1 MB since
     // the last GC and the current memory usage is >50% larger than
     // the estimated live memory usage.
-    return allocatedObjectSize >= 1024 * 1024 && currentObjectSize > estimatedLiveObjectSize * 3 / 2;
+    return allocatedObjectSizeKb >= 1024 && currentObjectSizeKb > (estimatedLiveObjectSizeKb * 3) / 2;
 #else
     return false;
 #endif
 }
 
 // TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldSchedulePreciseGC()
 {
     if (gcState() != NoGCScheduled)
         return false;
 #if ENABLE(IDLE_GC)
     return false;
 #else
+    // Avoid potential overflow by truncating to Kb.
+    size_t allocatedObjectSizeKb = Heap::allocatedObjectSize() >> 10;
     // 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();
+    size_t estimatedLiveObjectSizeKb = Heap::estimatedLiveObjectSize() >> 10;
     // Heap::markedObjectSize() may be underestimated if any thread has not
     // finished completeSweep().
-    size_t currentObjectSize = allocatedObjectSize + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    size_t currentObjectSizeKb = allocatedObjectSizeKb + ((Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages()) >> 10);
     // Schedule a precise GC if Oilpan has allocated more than 1 MB since
     // the last GC and the current memory usage is >50% larger than
     // the estimated live memory usage.
-    return allocatedObjectSize >= 1024 * 1024 && currentObjectSize > estimatedLiveObjectSize * 3 / 2;
+    return allocatedObjectSizeKb >= 1024 && currentObjectSizeKb > (estimatedLiveObjectSizeKb * 3) / 2;
 #endif
 }
 
 // TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldForceConservativeGC()
 {
     if (UNLIKELY(isGCForbidden()))
         return false;
 
+    if (shouldForceMemoryPressureGC())
+        return true;
+
+    // Avoid potential overflow by truncating to Kb.
+    size_t allocatedObjectSizeKb = Heap::allocatedObjectSize() >> 10;
     // 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();
+    size_t estimatedLiveObjectSizeKb = Heap::estimatedLiveObjectSize() >> 10;
     // 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 currentObjectSize > estimatedLiveObjectSize * 3 / 2;
-    }
+    size_t currentObjectSizeKb = allocatedObjectSizeKb + ((Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages()) >> 10);
     // Schedule a conservative GC if Oilpan has allocated more than 32 MB since
     // the last GC and the current memory usage is >400% larger than
     // the estimated live memory usage.
     // TODO(haraken): 400% is too large. Lower the heap growing factor.
-    return allocatedObjectSize >= 32 * 1024 * 1024 && currentObjectSize > 5 * estimatedLiveObjectSize;
+    return allocatedObjectSizeKb >= 32 * 1024 && currentObjectSizeKb > 5 * estimatedLiveObjectSizeKb;
 }
 
 void ThreadState::scheduleGCIfNeeded()
 {
     checkThread();
     // Allocation is allowed during sweeping, but those allocations should not
     // trigger nested GCs.
     if (isSweepingInProgress())
         return;
     ASSERT(!sweepForbidden());
@@ skipping 180 matching lines @@
     m_gcState = gcState;
 }
 
 #undef VERIFY_STATE_TRANSITION
 
 ThreadState::GCState ThreadState::gcState() const
 {
     return m_gcState;
 }
 
-void ThreadState::didV8GC()
+void ThreadState::didV8MajorGC()
 {
     checkThread();
     if (isMainThread()) {
         // Lower the estimated live object size because the V8 major GC is
         // expected to have collected a lot of DOM wrappers and dropped
         // references to their DOM objects.
         Heap::setEstimatedLiveObjectSize(Heap::estimatedLiveObjectSize() / 2);
+
+#if 0
+        if (shouldForceMemoryPressureGC()) {
+            // Under memory pressure, force a conservative GC.
+            Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::ConservativeGC);
+            return;
+        }

[haraken, 2015/06/16 16:21:27]

Actually I don't fully understand an issue of calling scheduleGCIfNeeded() here.
What's wrong with it?

[sof, 2015/06/16 16:27:31]

Oops, #if 0 - will undo that, ofc.

It triggering conservative GCs for other reasons appears to be behind the perf
regression, reporting longer v8 GC totals. I can reproduce that locally, but not
able to just with this CL (there is some noise though, so I'm not 100% sure this
will sail past the perf bots.)

[haraken, 2015/06/16 16:36:44]

I'm OK with landing this CL, but that sounds like a subtle optimization that
avoids benchmark regressions. If we observe a 400% increase after doing a major
GC, it would make sense to trigger a conservative GC.

This CL is a clear improvement, so we can revisit the issue in a follow up.

+#endif
     }
 }
 
 void ThreadState::runScheduledGC(StackState stackState)
 {
     checkThread();
     if (stackState != NoHeapPointersOnStack)
         return;
 
     // If a safe point is entered while initiating a GC, we clearly do
@@ skipping 604 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