Oilpan: fix computation of ThreadState::m_collectionRate.

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 839 matching lines @@
     if (sweepForbidden())
         return;
 
     ThreadState::SweepForbiddenScope scope(this);
     {
         TRACE_EVENT0("blink_gc", "ThreadState::completeSweep");
         for (int i = 0; i < NumberOfHeaps; i++)
             m_heaps[i]->completeSweep();
     }
 
-    if (isMainThread()) {
+    if (isMainThread() && m_allocatedObjectSizeBeforeGC) {
         // FIXME: Heap::markedObjectSize() may not be accurate because other
         // threads may not have finished sweeping.
-        m_collectionRate = 1.0 * Heap::markedObjectSize() / m_allocatedObjectSizeBeforeSweeping;
+        m_collectionRate = 1.0 * Heap::markedObjectSize() / m_allocatedObjectSizeBeforeGC;
+        ASSERT(m_collectionRate >= 0);
+
+        // The main thread might be at a safe point, with other
+        // threads leaving theirs and accumulating marked object size
+        // while continuing to sweep. That accumulated size might end up
+        // exceeding what the main thread sampled in preGC() (recorded
+        // in m_allocatedObjectSizeBeforeGC), resulting in a non-sensical
+        // > 1.0 rate.
+        //
+        // This is rare (cf. HeapTest.Threading for a case though);
+        // reset the invalid rate if encountered.
+        //
+        if (m_collectionRate > 1.0)
+            m_collectionRate = 1.0;
     } else {
-        // FIXME: We should make m_lowCollectionRate available in non-main
-        // threads.
+        // FIXME: We should make m_collectionRate available in non-main threads.
         m_collectionRate = 1.0;
     }
 
     setGCState(gcState() == Sweeping ? NoGCScheduled : GCScheduled);
 }
 
 void ThreadState::prepareRegionTree()
 {
     // Add the regions allocated by this thread to the region search tree.
     for (PageMemoryRegion* region : m_allocatedRegionsSinceLastGC)
         Heap::addPageMemoryRegion(region);
     m_allocatedRegionsSinceLastGC.clear();
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded()
 {
     if (m_shouldFlushHeapDoesNotContainCache) {
         Heap::flushHeapDoesNotContainCache();
         m_shouldFlushHeapDoesNotContainCache = false;
     }
 }
 
 void ThreadState::preGC()
 {
     ASSERT(!isInGC());
     setGCState(GCRunning);
     makeConsistentForSweeping();
     prepareRegionTree();
     flushHeapDoesNotContainCacheIfNeeded();
+    if (isMainThread())
+        m_allocatedObjectSizeBeforeGC = Heap::allocatedObjectSize() + Heap::markedObjectSize();
 }
 
 void ThreadState::postGC(GCType gcType)
 {
     ASSERT(isInGC());
     setGCState(gcType == GCWithSweep ? EagerSweepScheduled : LazySweepScheduled);
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->prepareForSweep();
 }
 
@@ skipping 124 matching lines @@
     }
 }
 
 void ThreadState::postGCProcessing()
 {
     checkThread();
     if (gcState() != EagerSweepScheduled && gcState() != LazySweepScheduled)
         return;
 
     m_didV8GCAfterLastGC = false;
-    if (isMainThread())
-        m_allocatedObjectSizeBeforeSweeping = Heap::allocatedObjectSize();
 
 #if ENABLE(GC_PROFILE_HEAP)
     // 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.
     bool gcTracingEnabled;
     TRACE_EVENT_CATEGORY_GROUP_ENABLED("blink_gc", &gcTracingEnabled);
     if (gcTracingEnabled)
         snapshot();
 #endif
@@ skipping 110 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return nullptr;
 }
 #endif
 
 } // namespace blink