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", m_stats.totalAllocatedSpace());
-    json->setInteger("objectSpace", m_stats.totalObjectSpace());
+    json->setInteger("allocatedSpace", Heap::allocatedSpace());
+    json->setInteger("objectSpace", Heap::allocatedObjectSize());
     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)
+bool ThreadState::shouldGC()
 {
-    if (newSize < 1 << 19)
+    // 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;
-    size_t limit = oldSize + (oldSize >> 1);
-    return newSize > limit;
+
+    // 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;
 }
 
-// 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 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 garbage collections.
-    return !m_sweepInProgress && increasedEnoughToForceConservativeGC(m_stats.totalObjectSpace(), m_statsAfterLastGC.totalObjectSpace());
+    // 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;
 }
 
 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;
 }
 
-void ThreadState::getStats(HeapStats& stats)
-{
-    stats = m_stats;
-}
-
-void ThreadState::getStatsForTesting(HeapStats& stats)
+size_t ThreadState::objectPayloadSizeForTesting()
 {
     ASSERT(isConsistentForSweeping());
+    size_t objectPayloadSize = 0;
     for (int i = 0; i < NumberOfHeaps; i++)
-        m_heaps[i]->getStatsForTesting(stats);
+        objectPayloadSize += m_heaps[i]->objectPayloadSizeForTesting();
+    return objectPayloadSize;
 }
 
 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, HeapStats* stats)
+    SweepNonFinalizedHeapTask(ThreadState* state, BaseHeap* heap)
         : 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_stats);
+        m_heap->sweep();
     }
 
 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 && m_stats.totalObjectSpace() > 0)
+    if (gcTracingEnabled)
         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 objectSpaceBeforeSweep = m_stats.totalObjectSpace();
+    size_t allocatedObjectSizeBeforeSweeping = Heap::allocatedObjectSize();
     {
         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.
-    setLowCollectionRate(m_stats.totalObjectSpace() > (objectSpaceBeforeSweep / 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.
+    // 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 (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);
-            HeapStats* stats = &heapStatsVector[i];
-            m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOffHeaps[i].get(), stats));
+            m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOffHeaps[i].get()));
         }
     }
 
     {
         // 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++) {
-            HeapStats stats;
-            m_heaps[FirstNonFinalizedHeap + i]->sweep(&stats);
-            m_stats.add(&stats);
+            m_heaps[FirstNonFinalizedHeap + i]->sweep();
         }
     }
 
     {
         // Sweep the finalized pages.
         TRACE_EVENT0("blink_gc", "ThreadState::sweepFinalizedHeaps");
         for (int i = 0; i < NumberOfFinalizedHeaps; i++) {
-            HeapStats stats;
-            m_heaps[FirstFinalizedHeap + i]->sweep(&stats);
-            m_stats.add(&stats);
+            m_heaps[FirstFinalizedHeap + i]->sweep();
         }
     }
 
-    // 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