Oilpan: Remove Heap::s_heapSizePerPersistent

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 558 matching lines @@
     m_persistentFreed = 0;
 }
 
 size_t ThreadState::currentObjectSize()
 {
     return Heap::allocatedObjectSize() + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
 }
 
 size_t ThreadState::estimatedLiveObjectSize()
 {
+    if (Heap::persistentCountAtLastGC() == 0) {
+        // We'll reach here only before hitting the first GC.
+        return 0;
+    }
+
     // 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 heapSizeRetainedByCollectedPersistents = static_cast<size_t>(1.0 * (Heap::markedObjectSizeAtLastCompleteSweep() + Heap::partitionAllocSizeAtLastGC()) / Heap::persistentCountAtLastGC() * Heap::collectedPersistentCount());
     size_t currentHeapSize = currentObjectSize();
-    size_t heapSizeRetainedByCollectedPersistents = Heap::heapSizePerPersistent() * Heap::collectedPersistentCount();
-    size_t estimatedSize = 0;
-    if (currentHeapSize > heapSizeRetainedByCollectedPersistents)
-        estimatedSize = currentHeapSize - heapSizeRetainedByCollectedPersistents;
-    return estimatedSize;
+    if (currentHeapSize < heapSizeRetainedByCollectedPersistents)
+        return 0;
+    return currentHeapSize - heapSizeRetainedByCollectedPersistents;
 }
 
 double ThreadState::heapGrowingRate()
 {
     size_t currentSize = currentObjectSize();
     size_t estimatedSize = estimatedLiveObjectSize();
-    double growingRate = 1.0 * currentSize / estimatedSize;
+    // If the estimatedSize is 0, we set a very high growing rate
+    // to trigger a GC.
+    double growingRate = estimatedSize > 0 ? 1.0 * currentSize / estimatedSize : 100;
     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)
 {
@@ skipping 31 matching lines @@
         return false;
 #if ENABLE(IDLE_GC)
     return false;
 #else
     return judgeGCThreshold(1024 * 1024, 1.5);
 #endif
 }
 
 bool ThreadState::shouldSchedulePageNavigationGC(float estimatedRemovalRatio)
 {
-    if (isGCForbidden())
-        return false;
-
     return judgeGCThreshold(1024 * 1024, 1.5);
 }
 
 bool ThreadState::shouldForceConservativeGC()
 {
-    if (isGCForbidden())
-        return false;
-
     // 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());
+    if (isGCForbidden())
+        return;
+
     // 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);
 }
 
 void ThreadState::scheduleGCIfNeeded()
 {
     ASSERT(checkThread());
+    if (isGCForbidden())
+        return;
+
     // Allocation is allowed during sweeping, but those allocations should not
     // trigger nested GCs.
     if (isSweepingInProgress())
         return;
     ASSERT(!sweepForbidden());
 
     Heap::reportMemoryUsageForTracing();
 
     if (shouldForceMemoryPressureGC()) {
         Heap::collectGarbage(HeapPointersOnStack, GCWithoutSweep, Heap::ConservativeGC);
@@ skipping 431 matching lines @@
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
     if (isMainThread()) {
         double collectionRate = 0;
         if (Heap::objectSizeAtLastGC() > 0)
             collectionRate = 1 - 1.0 * Heap::markedObjectSize() / Heap::objectSizeAtLastGC();
         TRACE_COUNTER1("blink_gc", "ThreadState::collectionRate", static_cast<int>(100 * collectionRate));
 
-        // 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) {
-            Heap::setHeapSizePerPersistent((Heap::markedObjectSize() + Heap::partitionAllocSizeAtLastGC()) / Heap::persistentCountAtLastGC());
-        }
+        Heap::setMarkedObjectSizeAtLastCompleteSweep(Heap::markedObjectSize());
     }
 
     switch (gcState()) {
     case Sweeping:
         setGCState(NoGCScheduled);
         break;
     case SweepingAndPreciseGCScheduled:
         setGCState(PreciseGCScheduled);
         break;
     case SweepingAndIdleGCScheduled:
@@ skipping 417 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