Oilpan: Make the GC heuristics saner

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 79 matching lines @@
     : m_thread(currentThread())
     , m_persistentRegion(adoptPtr(new PersistentRegion()))
     , m_startOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_safePointScopeMarker(nullptr)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_sweepForbidden(false)
     , m_noAllocationCount(0)
     , m_gcForbiddenCount(0)
-    , m_persistentAllocated(0)
-    , m_persistentFreed(0)
+    , m_wrapperAllocated(0)
+    , m_wrapperFreed(0)
     , m_vectorBackingHeapIndex(Vector1HeapIndex)
     , m_currentHeapAges(0)
     , m_isTerminating(false)
     , m_gcMixinMarker(nullptr)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_gcState(NoGCScheduled)
     , m_traceDOMWrappers(nullptr)
 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
@@ skipping 439 matching lines @@
     if (isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 CrossThreadPersistentRegion& ThreadState::crossThreadPersistentRegion()
 {
     AtomicallyInitializedStaticReference(CrossThreadPersistentRegion, persistentRegion, new CrossThreadPersistentRegion());
     return persistentRegion;
 }
 
-void ThreadState::updatePersistentCounters()
+void ThreadState::updateWrapperCounters()
 {
-    if (m_persistentAllocated >= m_persistentFreed)
-        Heap::increasePersistentCount(m_persistentAllocated - m_persistentFreed);
+    if (m_wrapperAllocated >= m_wrapperFreed)
+        Heap::increaseWrapperCount(m_wrapperAllocated - m_wrapperFreed);
     else
-        Heap::decreasePersistentCount(m_persistentFreed - m_persistentAllocated);
-    Heap::increaseCollectedPersistentCount(m_persistentFreed);
-    m_persistentAllocated = 0;
-    m_persistentFreed = 0;
+        Heap::decreaseWrapperCount(m_wrapperFreed - m_wrapperAllocated);
+    Heap::increaseCollectedWrapperCount(m_wrapperFreed);
+    m_wrapperAllocated = 0;
+    m_wrapperFreed = 0;
 }
 
-size_t ThreadState::estimatedLiveObjectSize()
+double ThreadState::partitionAllocGrowingRate()
 {
-    // We estimate the live object size with the following equations.
-    //
-    //   heapSizePerPersistent = (marked(t0, t1) + partitionAlloc(t0)) / persistentCount(t0)
-    //   estimatedLiveObjectSize = marked(t0, t) + allocated(t0, t) + partitionAlloc(t) - heapSizePerPersistent * collectedPersistentCount(t0, t)
-    //
-    // t0:                 The time when the last collectGarbage runs.
-    // t1:                 The time when the last completeSweep runs.
-    // t:                  The current time.
-    // marked(t0, t):      The size of marked objects between t0 and t.
-    // allocated(t0, t):   The size of newly allocated objects between t0 and t.
-    // persistentCount(t): The number of existing persistent handles at t.
-    // collectedPersistentCount(t0, t):
-    //                     The number of persistent handles collected between
-    //                     t0 and t.
-    // partitionAlloc(t):  The size of allocated memory in PartitionAlloc at t.
-    size_t currentHeapSize = currentObjectSize();
-    size_t heapSizeRetainedByCollectedPersistents = Heap::heapSizePerPersistent() * Heap::collectedPersistentCount();
-    size_t estimatedSize = 0;
-    if (currentHeapSize > heapSizeRetainedByCollectedPersistents)
-        estimatedSize = currentHeapSize - heapSizeRetainedByCollectedPersistents;
-    TRACE_COUNTER1("blink_gc", "ThreadState::currentHeapSizeKB", std::min(currentHeapSize / 1024, static_cast<size_t>(INT_MAX)));
-    TRACE_COUNTER1("blink_gc", "ThreadState::estimatedLiveObjectSizeKB", std::min(estimatedSize / 1024, static_cast<size_t>(INT_MAX)));
-    TRACE_COUNTER1("blink_gc", "ThreadState::heapGrowingRate", static_cast<int>(100.0 * currentHeapSize / estimatedSize));
-    return estimatedSize;
+    size_t sizeAtLastGC = Heap::partitionAllocSizeAtLastGC();
+    size_t wrapperCountAtLastGC = Heap::wrapperCountAtLastGC();
+    size_t sizeRetainedByCollectedPersistents = wrapperCountAtLastGC ? Heap::collectedWrapperCount() * sizeAtLastGC / wrapperCountAtLastGC : 0;
+    size_t estimatedLiveSize = sizeAtLastGC > sizeRetainedByCollectedPersistents ? sizeAtLastGC - sizeRetainedByCollectedPersistents : 0;
+    double growingRate = estimatedLiveSize ? 1.0 * WTF::Partitions::totalSizeOfCommittedPages() / estimatedLiveSize : 0;
+    TRACE_COUNTER1("blink_gc", "ThreadState::estimatedLivePartitionAllocSizeKB", std::min(estimatedLiveSize / 1024, static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "ThreadState::partitionAllocGrowingRate", static_cast<int>(100 * growingRate));
+    return growingRate;
 }
 
-size_t ThreadState::currentObjectSize()
+double ThreadState::heapGrowingRate()
 {
-    return Heap::allocatedObjectSize() + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    size_t markedObjectSize = Heap::markedObjectSizeAtLastCompleteSweep();
+    size_t currentObjectSize = Heap::allocatedObjectSize() + markedObjectSize;
+    double growingRate = markedObjectSize ? 1.0 * currentObjectSize / markedObjectSize : 0;
+    TRACE_COUNTER1("blink_gc", "ThreadState::currentObjectSizeKB", std::min(currentObjectSize / 1024, static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "ThreadState::heapGrowingRate", static_cast<int>(100 * growingRate));
+    return growingRate;
+}
+
+// TODO(haraken): We should improve the GC heuristics. These heuristics
+// significantly affect performance.
+bool ThreadState::judgeGCThreshold(size_t allocatedObjectSizeThreshold, double heapGrowingRateThreshold, double partitionAllocGrowingRateThreshold)
+{
+    if (Heap::allocatedObjectSize() < allocatedObjectSizeThreshold)
+        return false;
+    if (heapGrowingRate() >= heapGrowingRateThreshold)
+        return true;
+    return partitionAllocGrowingRate() >= partitionAllocGrowingRateThreshold;
 }
 
 bool ThreadState::shouldForceMemoryPressureGC()
 {
-    // Avoid potential overflow by truncating to Kb.
-    size_t currentObjectSizeKb = currentObjectSize() >> 10;
-    if (currentObjectSizeKb < 300 * 1024)
+    size_t totalObjectSize = Heap::allocatedObjectSize() + Heap::markedObjectSizeAtLastCompleteSweep() + WTF::Partitions::totalSizeOfCommittedPages();
+    if (totalObjectSize < 300 * 1024 * 1024)
         return false;
-
-    size_t estimatedLiveObjectSizeKb = 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;
+    return judgeGCThreshold(0, 1.5, 1.5);
 }
 
-// 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 estimatedLiveObjectSizeKb = estimatedLiveObjectSize() >> 10;
-    // Heap::markedObjectSize() may be underestimated if any thread has not
-    // finished completeSweep().
-    size_t currentObjectSizeKb = currentObjectSize() >> 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 allocatedObjectSizeKb >= 1024 && currentObjectSizeKb > (estimatedLiveObjectSizeKb * 3) / 2;
+    return judgeGCThreshold(1024 * 1024, 1.5, 1.5);
 #else
     return false;
 #endif
 }
 
-// TODO(haraken): We should improve the GC heuristics.
-// These heuristics affect performance significantly.
 bool ThreadState::shouldSchedulePreciseGC()
 {
-    if (gcState() != NoGCScheduled)
+    if (isGCForbidden())
         return false;
+
+    if (shouldForceMemoryPressureGC())
+        return true;
+
 #if ENABLE(IDLE_GC)
-    return false;
+    return judgeGCThreshold(32 * 1024 * 1024, 4.0, 4.0);
+    // 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 estimatedLiveObjectSizeKb = estimatedLiveObjectSize() >> 10;
-    // Heap::markedObjectSize() may be underestimated if any thread has not
-    // finished completeSweep().
-    size_t currentObjectSizeKb = currentObjectSize() >> 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 allocatedObjectSizeKb >= 1024 && currentObjectSizeKb > (estimatedLiveObjectSizeKb * 3) / 2;
+    return judgeGCThreshold(1024 * 1024, 1.5, 1.5);
 #endif
 }
 
 bool ThreadState::shouldSchedulePageNavigationGC(float estimatedRemovalRatio)
 {
     if (UNLIKELY(isGCForbidden()))
         return false;
 
     if (shouldForceMemoryPressureGC())
         return true;
@@ skipping 32 matching lines @@
 {
     ASSERT(checkThread());
     ASSERT(!isSweepingInProgress());
     setGCState(PageNavigationGCScheduled);
 }
 
 // TODO(haraken): We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldForceConservativeGC()
 {
-    if (UNLIKELY(isGCForbidden()))
+    if (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 estimatedLiveObjectSizeKb = estimatedLiveObjectSize() >> 10;
-    // Heap::markedObjectSize() may be underestimated if any thread has not
-    // finished completeSweep().
-    size_t currentObjectSizeKb = currentObjectSize() >> 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 allocatedObjectSizeKb >= 32 * 1024 && currentObjectSizeKb > 5 * estimatedLiveObjectSizeKb;
+    return judgeGCThreshold(32 * 1024 * 1024, 5.0, 5.0);
 }
 
 void ThreadState::scheduleGCIfNeeded()
 {
     ASSERT(checkThread());
     // Allocation is allowed during sweeping, but those allocations should not
     // trigger nested GCs.
     if (isSweepingInProgress())
         return;
     ASSERT(!sweepForbidden());
@@ skipping 184 matching lines @@
 #endif
 }
 
 #undef VERIFY_STATE_TRANSITION
 
 ThreadState::GCState ThreadState::gcState() const
 {
     return m_gcState;
 }
 
-void ThreadState::didV8MajorGC()
-{
-    ASSERT(checkThread());
-    if (isMainThread()) {
-        if (shouldForceMemoryPressureGC()) {
-            // Under memory pressure, force a conservative GC.
-            Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::ConservativeGC);
-            return;
-        }
-    }
-}
-
 void ThreadState::runScheduledGC(StackState stackState)
 {
     ASSERT(checkThread());
     if (stackState != NoHeapPointersOnStack)
         return;
 
     // If a safe point is entered while initiating a GC, we clearly do
     // not want to do another as part that -- the safe point is only
     // entered after checking if a scheduled GC ought to run first.
     // Prevent that from happening by marking GCs as forbidden while
@@ skipping 42 matching lines @@
         m_heaps[i]->makeConsistentForMutator();
 }
 
 void ThreadState::preGC()
 {
     ASSERT(!isInGC());
     setGCState(GCRunning);
     makeConsistentForGC();
     flushHeapDoesNotContainCacheIfNeeded();
     clearHeapAges();
-    updatePersistentCounters();
+    updateWrapperCounters();
 }
 
 void ThreadState::postGC(GCType gcType)
 {
     ASSERT(isInGC());
 
 #if ENABLE(GC_PROFILING)
     // We snapshot the heap prior to sweeping to get numbers for both resources
     // that have been allocated since the last GC and for resources that are
     // going to be freed.
@@ skipping 160 matching lines @@
 
     postSweep();
 }
 
 void ThreadState::postSweep()
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
     if (isMainThread()) {
-        // See the comment in estimatedLiveObjectSize() for what we're
-        // calculating here.
-        //
         // Heap::markedObjectSize() may be underestimated here if any other
         // thread has not yet finished lazy sweeping.
-        if (Heap::persistentCountAtLastGC() > 0) {
-            TRACE_EVENT1("blink_gc", "ThreadState::postSweep", "collection rate", 1.0 * Heap::markedObjectSize() / Heap::objectSizeAtLastGC());
-            Heap::setHeapSizePerPersistent((Heap::markedObjectSize() + Heap::partitionAllocSizeAtLastGC()) / Heap::persistentCountAtLastGC());
+        if (Heap::objectSizeAtLastGC()) {
+            TRACE_EVENT1("blink_gc", "ThreadState::postSweep", "collection rate", 1 - 1.0 * Heap::markedObjectSize() / Heap::objectSizeAtLastGC());
+            Heap::setMarkedObjectSizeAtLastCompleteSweep(Heap::markedObjectSize());
         }
     }
 
     switch (gcState()) {
     case Sweeping:
         setGCState(NoGCScheduled);
         break;
     case SweepingAndPreciseGCScheduled:
         setGCState(PreciseGCScheduled);
         break;
@@ skipping 418 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