Revert of Oilpan: Refactor the way we calculate heap statistics

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 645 matching lines @@
     json->beginArray("heaps");
     SNAPSHOT_HEAP(General1);
     SNAPSHOT_HEAP(General2);
     SNAPSHOT_HEAP(General3);
     SNAPSHOT_HEAP(General4);
     SNAPSHOT_HEAP(CollectionBacking);
     FOR_EACH_TYPED_HEAP(SNAPSHOT_HEAP);
     json->endArray();
 #undef SNAPSHOT_HEAP
 
-    json->setInteger("allocatedSpace", Heap::allocatedSpace());
-    json->setInteger("objectSpace", Heap::allocatedObjectSize());
+    json->setInteger("allocatedSpace", m_stats.totalAllocatedSpace());
+    json->setInteger("objectSpace", m_stats.totalObjectSpace());
     json->setInteger("pageCount", info.pageCount);
     json->setInteger("freeSize", info.freeSize);
 
     Vector<String> classNameVector(info.classTags.size());
     for (HashMap<const GCInfo*, size_t>::iterator it = info.classTags.begin(); it != info.classTags.end(); ++it)
         classNameVector[it->value] = it->key->m_className;
 
     size_t liveSize = 0;
     size_t deadSize = 0;
     json->beginArray("classes");
@@ skipping 46 matching lines @@
     AtomicallyInitializedStatic(PersistentNode*, anchor = new PersistentAnchor);
     return anchor;
 }
 
 Mutex& ThreadState::globalRootsMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
 
+// Trigger garbage collection on a 50% increase in size, but not for
+// less than 512kbytes.
+bool ThreadState::increasedEnoughToGC(size_t newSize, size_t oldSize)
+{
+    if (newSize < 1 << 19)
+        return false;
+    size_t limit = oldSize + (oldSize >> 1);
+    return newSize > limit;
+}
+
+// FIXME: The heuristics are local for a thread at this
+// point. Consider using heuristics that take memory for all threads
+// into account.
 bool ThreadState::shouldGC()
 {
-    // Do not GC during sweeping. We allow allocation during finalization,
-    // but those allocations are not allowed to lead to nested GCs.
-    if (m_sweepInProgress)
-        return false;
-
-    // Trigger garbage collection on a 50% increase in size,
-    // but not for less than 512 KB.
-    if (Heap::allocatedObjectSize() < 1 << 19)
-        return false;
-    size_t limit = Heap::markedObjectSize() + Heap::markedObjectSize() / 2;
-    return Heap::allocatedObjectSize() > limit;
+    // Do not GC during sweeping. We allow allocation during
+    // finalization, but those allocations are not allowed
+    // to lead to nested garbage collections.
+    return !m_sweepInProgress && increasedEnoughToGC(m_stats.totalObjectSpace(), m_statsAfterLastGC.totalObjectSpace());
 }
 
+// Trigger conservative garbage collection on a 100% increase in size,
+// but not for less than 4Mbytes. If the system currently has a low
+// collection rate, then require a 300% increase in size.
+bool ThreadState::increasedEnoughToForceConservativeGC(size_t newSize, size_t oldSize)
+{
+    if (newSize < 1 << 22)
+        return false;
+    size_t limit = (m_lowCollectionRate ? 4 : 2) * oldSize;
+    return newSize > limit;
+}
+
+// FIXME: The heuristics are local for a thread at this
+// point. Consider using heuristics that take memory for all threads
+// into account.
 bool ThreadState::shouldForceConservativeGC()
 {
-    // Do not GC during sweeping. We allow allocation during finalization,
-    // but those allocations are not allowed to lead to nested GCs.
-    if (m_sweepInProgress)
-        return false;
-
-    // Trigger conservative garbage collection on a 100% increase in size,
-    // but not for less than 4Mbytes. If the system currently has a low
-    // collection rate, then require a 300% increase in size.
-    if (Heap::allocatedObjectSize() < 1 << 22)
-        return false;
-    size_t limit = (m_lowCollectionRate ? 4 : 2) * Heap::markedObjectSize();
-    return Heap::allocatedObjectSize() > limit;
+    // Do not GC during sweeping. We allow allocation during
+    // finalization, but those allocations are not allowed
+    // to lead to nested garbage collections.
+    return !m_sweepInProgress && increasedEnoughToForceConservativeGC(m_stats.totalObjectSpace(), m_statsAfterLastGC.totalObjectSpace());
 }
 
 bool ThreadState::sweepRequested()
 {
     ASSERT(isAnyThreadInGC() || checkThread());
     return m_sweepRequested;
 }
 
 void ThreadState::setSweepRequested()
 {
@@ skipping 112 matching lines @@
 
 BaseHeapPage* ThreadState::heapPageFromAddress(Address address)
 {
     for (int i = 0; i < NumberOfHeaps; i++) {
         if (BaseHeapPage* page = m_heaps[i]->heapPageFromAddress(address))
             return page;
     }
     return 0;
 }
 
-size_t ThreadState::objectPayloadSizeForTesting()
+void ThreadState::getStats(HeapStats& stats)
+{
+    stats = m_stats;
+}
+
+void ThreadState::getStatsForTesting(HeapStats& stats)
 {
     ASSERT(isConsistentForSweeping());
-    size_t objectPayloadSize = 0;
     for (int i = 0; i < NumberOfHeaps; i++)
-        objectPayloadSize += m_heaps[i]->objectPayloadSizeForTesting();
-    return objectPayloadSize;
+        m_heaps[i]->getStatsForTesting(stats);
 }
 
 bool ThreadState::stopThreads()
 {
     return s_safePointBarrier->parkOthers();
 }
 
 void ThreadState::resumeThreads()
 {
     s_safePointBarrier->resumeOthers();
@@ skipping 108 matching lines @@
 {
     TRACE_EVENT0("blink_gc", "ThreadState::waitUntilSweepersDone");
     MutexLocker locker(m_sweepMutex);
     while (m_numberOfSweeperTasks > 0)
         m_sweepThreadCondition.wait(m_sweepMutex);
 }
 
 
 class SweepNonFinalizedHeapTask final : public WebThread::Task {
 public:
-    SweepNonFinalizedHeapTask(ThreadState* state, BaseHeap* heap)
+    SweepNonFinalizedHeapTask(ThreadState* state, BaseHeap* heap, HeapStats* stats)
         : m_threadState(state)
         , m_heap(heap)
+        , m_stats(stats)
     {
         m_threadState->registerSweepingTask();
     }
 
     virtual ~SweepNonFinalizedHeapTask()
     {
         m_threadState->unregisterSweepingTask();
     }
 
     virtual void run()
     {
         TRACE_EVENT0("blink_gc", "ThreadState::sweepNonFinalizedHeaps");
-        m_heap->sweep();
+        m_heap->sweep(m_stats);
     }
 
 private:
     ThreadState* m_threadState;
     BaseHeap* m_heap;
+    HeapStats* m_stats;
 };
 
 void ThreadState::performPendingSweep()
 {
     if (!sweepRequested())
         return;
 
 #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)
+    if (gcTracingEnabled && m_stats.totalObjectSpace() > 0)
         snapshot();
 #endif
 
     TRACE_EVENT0("blink_gc", "ThreadState::performPendingSweep");
 
     double timeStamp = WTF::currentTimeMS();
     const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
     if (isMainThread()) {
         ScriptForbiddenScope::enter();
         TRACE_EVENT_SET_SAMPLING_STATE("blink", "BlinkGCSweeping");
     }
 
-    size_t allocatedObjectSizeBeforeSweeping = Heap::allocatedObjectSize();
+    size_t objectSpaceBeforeSweep = m_stats.totalObjectSpace();
     {
         NoSweepScope scope(this);
 
         // Disallow allocation during weak processing.
         enterNoAllocationScope();
         {
             TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
             // Perform thread-specific weak processing.
             while (popAndInvokeWeakPointerCallback(Heap::s_markingVisitor)) { }
         }
         {
             TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
             invokePreFinalizers(*Heap::s_markingVisitor);
         }
         leaveNoAllocationScope();
 
         // Perform sweeping and finalization.
         performPendingSweepInParallel();
     }
 
     clearGCRequested();
     clearSweepRequested();
-
-    // If we collected less than 50% of objects, record that the collection rate
-    // is low which we use to determine when to perform the next GC.
-    // FIXME: We should make m_lowCollectionRate available in non-main threads.
-    // FIXME: Heap::markedObjectSize() may not be accurate because other threads
-    // may not have finished sweeping.
-    if (isMainThread())
-        m_lowCollectionRate = Heap::markedObjectSize() > (allocatedObjectSizeBeforeSweeping / 2);
+    // If we collected less than 50% of objects, record that the
+    // collection rate is low which we use to determine when to
+    // perform the next GC.
+    setLowCollectionRate(m_stats.totalObjectSpace() > (objectSpaceBeforeSweep / 2));
 
     if (Platform::current()) {
         Platform::current()->histogramCustomCounts("BlinkGC.PerformPendingSweep", WTF::currentTimeMS() - timeStamp, 0, 10 * 1000, 50);
     }
 
     if (isMainThread()) {
         TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
         ScriptForbiddenScope::exit();
     }
 }
 
 void ThreadState::performPendingSweepInParallel()
 {
+    // Sweeping will recalculate the stats
+    m_stats.clear();
+
     // Sweep the non-finalized heap pages on multiple threads.
     // Attempt to load-balance by having the sweeper thread sweep as
     // close to half of the pages as possible.
     int nonFinalizedPages = 0;
     for (int i = 0; i < NumberOfNonFinalizedHeaps; i++)
         nonFinalizedPages += m_heaps[FirstNonFinalizedHeap + i]->normalPageCount();
 
     int finalizedPages = 0;
     for (int i = 0; i < NumberOfFinalizedHeaps; i++)
         finalizedPages += m_heaps[FirstFinalizedHeap + i]->normalPageCount();
 
     int pagesToSweepInParallel = nonFinalizedPages < finalizedPages ? nonFinalizedPages : ((nonFinalizedPages + finalizedPages) / 2);
 
     // Start the sweeper thread for the non finalized heaps. No
     // finalizers need to run and therefore the pages can be
     // swept on other threads.
     static const int minNumberOfPagesForParallelSweep = 10;
+    HeapStats heapStatsVector[NumberOfNonFinalizedHeaps];
     OwnPtr<BaseHeap> splitOffHeaps[NumberOfNonFinalizedHeaps];
     for (int i = 0; i < NumberOfNonFinalizedHeaps && pagesToSweepInParallel > 0; i++) {
         BaseHeap* heap = m_heaps[FirstNonFinalizedHeap + i];
         int pageCount = heap->normalPageCount();
         // Only use the sweeper thread if it exists and there are
         // pages to sweep.
         if (m_sweeperThread && pageCount > minNumberOfPagesForParallelSweep) {
             // Create a new thread heap instance to make sure that the
             // state modified while sweeping is separate for the
             // sweeper thread and the owner thread.
             int pagesToSplitOff = std::min(pageCount, pagesToSweepInParallel);
             pagesToSweepInParallel -= pagesToSplitOff;
             splitOffHeaps[i] = heap->split(pagesToSplitOff);
-            m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOffHeaps[i].get()));
+            HeapStats* stats = &heapStatsVector[i];
+            m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOffHeaps[i].get(), stats));
         }
     }
 
     {
         // Sweep the remainder of the non-finalized pages (or all of them
         // if there is no sweeper thread).
         TRACE_EVENT0("blink_gc", "ThreadState::sweepNonFinalizedHeaps");
         for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
-            m_heaps[FirstNonFinalizedHeap + i]->sweep();
+            HeapStats stats;
+            m_heaps[FirstNonFinalizedHeap + i]->sweep(&stats);
+            m_stats.add(&stats);
         }
     }
 
     {
         // Sweep the finalized pages.
         TRACE_EVENT0("blink_gc", "ThreadState::sweepFinalizedHeaps");
         for (int i = 0; i < NumberOfFinalizedHeaps; i++) {
-            m_heaps[FirstFinalizedHeap + i]->sweep();
+            HeapStats stats;
+            m_heaps[FirstFinalizedHeap + i]->sweep(&stats);
+            m_stats.add(&stats);
         }
     }
 
+    // Wait for the sweeper threads and update the heap stats with the
+    // stats for the heap portions swept by those threads.
     waitUntilSweepersDone();
     for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
+        m_stats.add(&heapStatsVector[i]);
         if (splitOffHeaps[i])
             m_heaps[FirstNonFinalizedHeap + i]->merge(splitOffHeaps[i].release());
     }
 
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->postSweepProcessing();
+
+    getStats(m_statsAfterLastGC);
 }
 
 void ThreadState::addInterruptor(Interruptor* interruptor)
 {
     SafePointScope scope(HeapPointersOnStack, SafePointScope::AllowNesting);
 
     {
         MutexLocker locker(threadAttachMutex());
         m_interruptors.append(interruptor);
     }
@@ skipping 60 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 } // namespace blink