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()) {
-        // FIXME: Heap::markedObjectSize() may not be accurate because other
-        // threads may not have finished sweeping.
-        m_collectionRate = 1.0 * Heap::markedObjectSize() / m_allocatedObjectSizeBeforeSweeping;
-    } else {
-        // FIXME: We should make m_lowCollectionRate 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);
+    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_allocatedObjectSizeBeforeGC;

[haraken, 2015/01/14 01:36:26]

Heap::markedObjectSize() is accumulated in the (lazy) sweeping phase, and thus
Heap::markedObjectSize() would be 0 at this point in most cases, wouldn't it?
Things happen in the order of preGC => marking => postGC => lazy sweeping.

(However, if that is the case, m_collectionRate will be evaluated as 0 in most
cases and thus shouldForceConservativeGC() will use the not-high-collection-mode
condition to trigger conservative GCs. I'm wondering why it doesn't regress
performance of LargeDistribution.)

[sof, 2015/01/14 06:14:27]

Thanks, I realized the same overnight. Sorry about the pointless CL churn, will
address.
The miscalculation above represents the other extreme, in a sense. I'll gather
some more data on what&how conservative GCs that triggers, once the rate
calculation has been sorted out.

[sof, 2015/01/14 09:53:24]

Now tidied, to some extent. The lagging sweeps across threads is a bit confusing
to interpret in a sense-making manner.

Re: LargeDistributionWithoutLayout -- the conservative GCs that it triggers
aren't via the two special cases in shouldForceConservativeGC(), so there's no
change in behavior to be expected wrt it and this CL.

+        ASSERT(m_collectionRate >= 0. && m_collectionRate <= 1.);
+    } else {
+        // FIXME: We should make m_collectionRate available in non-main threads.
+        m_collectionRate = 1.0;
+    }
+
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->prepareForSweep();
 }
 
 void ThreadState::prepareHeapForTermination()
 {
     checkThread();
     for (int i = 0; i < NumberOfHeaps; ++i)
         m_heaps[i]->prepareHeapForTermination();
 }
@@ skipping 118 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