Oilpan: Clean up code around GC heuristics

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 551 matching lines @@
 {
     if (m_persistentAllocated >= m_persistentFreed)
         Heap::increasePersistentCount(m_persistentAllocated - m_persistentFreed);
     else
         Heap::decreasePersistentCount(m_persistentFreed - m_persistentAllocated);
     Heap::increaseCollectedPersistentCount(m_persistentFreed);
     m_persistentAllocated = 0;
     m_persistentFreed = 0;
 }
 
+size_t ThreadState::currentObjectSize()
+{
+    return Heap::allocatedObjectSize() + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+}
+
 size_t ThreadState::estimatedLiveObjectSize()
 {
     // 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 ThreadState::currentObjectSize()
+double ThreadState::heapGrowingRate()
 {
-    return Heap::allocatedObjectSize() + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    size_t currentSize = currentObjectSize();
+    size_t estimatedSize = estimatedLiveObjectSize();
+    double growingRate = 1.0 * currentSize / estimatedSize;
+    TRACE_COUNTER1("blink_gc", "ThreadState::currentHeapSizeKB", std::min(currentSize / 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 * growingRate));
+    return growingRate;
+}
+
+// TODO(haraken): We should improve the GC heuristics.
+// The heuristics affect performance significantly.
+bool ThreadState::judgeGCThreshold(size_t allocatedObjectSizeThreshold, double heapGrowingRateThreshold)
+{
+    // If the allocated object size is small enough, don't trigger a GC.
+    if (Heap::allocatedObjectSize() < allocatedObjectSizeThreshold)
+        return false;
+    // If the heap growing rate is large enough, trigger a GC.
+    return heapGrowingRate() >= heapGrowingRateThreshold;
 }
 
 bool ThreadState::shouldForceMemoryPressureGC()
 {
-    // Avoid potential overflow by truncating to Kb.
-    size_t currentObjectSizeKb = currentObjectSize() >> 10;
-    if (currentObjectSizeKb < 300 * 1024)
+    if (currentObjectSize() < 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);
 }
 
-// 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);
 #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 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);
 #endif
 }
 
 bool ThreadState::shouldSchedulePageNavigationGC(float estimatedRemovalRatio)
 {
     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 estimatedLiveObjectSizeKb = (estimatedLiveObjectSize() >> 10) * (1 - estimatedRemovalRatio);
-    // 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);
+}
+
+bool ThreadState::shouldForceConservativeGC()
+{
+    if (UNLIKELY(isGCForbidden()))
+        return false;
+
+    if (shouldForceMemoryPressureGC())
+        return true;
+
+    // TODO(haraken): 400% is too large. Lower the heap growing factor.
+    return judgeGCThreshold(32 * 1024 * 1024, 5.0);
 }
 
 void ThreadState::schedulePageNavigationGCIfNeeded(float estimatedRemovalRatio)
 {
     ASSERT(checkThread());
     // Finish on-going lazy sweeping.
     // TODO(haraken): It might not make sense to force completeSweep() for all
     // page navigations.
     completeSweep();
     ASSERT(!isSweepingInProgress());
     ASSERT(!sweepForbidden());
 
     Heap::reportMemoryUsageForTracing();
     if (shouldSchedulePageNavigationGC(estimatedRemovalRatio))
         schedulePageNavigationGC();
 }
 
 void ThreadState::schedulePageNavigationGC()
 {
     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()))
-        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;
-}
-
 void ThreadState::scheduleGCIfNeeded()
 {
     ASSERT(checkThread());
     // Allocation is allowed during sweeping, but those allocations should not
     // trigger nested GCs.
     if (isSweepingInProgress())
         return;
     ASSERT(!sweepForbidden());
 
     Heap::reportMemoryUsageForTracing();
@@ skipping 883 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