Move collectGarbage* methods to ThreadState

third_party/WebKit/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 21 matching lines @@
 
 #include "base/trace_event/process_memory_dump.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "platform/heap/BlinkGCMemoryDumpProvider.h"
 #include "platform/heap/CallbackStack.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/Heap.h"
+#include "platform/heap/PagePool.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/Visitor.h"
 #include "platform/web_memory_allocator_dump.h"
 #include "platform/web_process_memory_dump.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/DataLog.h"
@@ skipping 19 matching lines @@
 
 namespace blink {
 
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = nullptr;
 uintptr_t ThreadState::s_mainThreadStackStart = 0;
 uintptr_t ThreadState::s_mainThreadUnderestimatedStackSize = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
 
 const size_t defaultAllocatedObjectSizeThreshold = 100 * 1024;
 
+const char* gcReasonString(BlinkGC::GCReason reason)
+{
+    switch (reason) {
+    case BlinkGC::IdleGC:
+        return "IdleGC";
+    case BlinkGC::PreciseGC:
+        return "PreciseGC";
+    case BlinkGC::ConservativeGC:
+        return "ConservativeGC";
+    case BlinkGC::ForcedGC:
+        return "ForcedGC";
+    case BlinkGC::MemoryPressureGC:
+        return "MemoryPressureGC";
+    case BlinkGC::PageNavigationGC:
+        return "PageNavigationGC";
+    default:
+        NOTREACHED();
+    }
+    return "<Unknown>";
+}
+
+class ParkThreadsScope final {
+    STACK_ALLOCATED();
+public:
+    explicit ParkThreadsScope(ThreadState* state)
+        : m_state(state)
+        , m_shouldResumeThreads(false)
+    {
+    }
+
+    bool parkThreads()
+    {
+        TRACE_EVENT0("blink_gc", "ThreadHeap::ParkThreadsScope");
+        const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
+        if (m_state->isMainThread())
+            TRACE_EVENT_SET_SAMPLING_STATE("blink_gc", "BlinkGCWaiting");
+
+        // TODO(haraken): In an unlikely coincidence that two threads decide
+        // to collect garbage at the same time, avoid doing two GCs in
+        // a row and return false.
+        double startTime = WTF::currentTimeMS();
+
+        m_shouldResumeThreads = m_state->heap().park();
+
+        double timeForStoppingThreads = WTF::currentTimeMS() - startTime;
+        DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, timeToStopThreadsHistogram, new CustomCountHistogram("BlinkGC.TimeForStoppingThreads", 1, 1000, 50));
+        timeToStopThreadsHistogram.count(timeForStoppingThreads);
+
+        if (m_state->isMainThread())
+            TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
+        return m_shouldResumeThreads;
+    }
+
+    ~ParkThreadsScope()
+    {
+        // Only cleanup if we parked all threads in which case the GC happened
+        // and we need to resume the other threads.
+        if (m_shouldResumeThreads)
+            m_state->heap().resume();
+    }
+
+private:
+    ThreadState* m_state;
+    bool m_shouldResumeThreads;
+};
+
 ThreadState::ThreadState(bool perThreadHeapEnabled)
     : m_thread(currentThread())
     , m_persistentRegion(wrapUnique(new PersistentRegion()))
 #if OS(WIN) && COMPILER(MSVC)
     , m_threadStackSize(0)
 #endif
     , m_startOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_safePointScopeMarker(nullptr)
     , m_atSafePoint(false)
@@ skipping 140 matching lines @@
     prepareForThreadStateTermination();
 
     ProcessHeap::crossThreadPersistentRegion().prepareForThreadStateTermination(this);
 
     // Do thread local GC's as long as the count of thread local Persistents
     // changes and is above zero.
     int oldCount = -1;
     int currentCount = getPersistentRegion()->numberOfPersistents();
     ASSERT(currentCount >= 0);
     while (currentCount != oldCount) {
-        ThreadHeap::collectGarbageForTerminatingThread(this);
+        collectGarbageForTerminatingThread();
         // Release the thread-local static persistents that were
         // instantiated while running the termination GC.
         releaseStaticPersistentNodes();
         oldCount = currentCount;
         currentCount = getPersistentRegion()->numberOfPersistents();
     }
     // We should not have any persistents left when getting to this point,
     // if we have it is probably a bug so adding a debug ASSERT to catch this.
     ASSERT(!currentCount);
     // All of pre-finalizers should be consumed.
     ASSERT(m_orderedPreFinalizers.isEmpty());
     RELEASE_ASSERT(gcState() == NoGCScheduled);
 
     // Add pages to the orphaned page pool to ensure any global GCs from this point
     // on will not trace objects on this thread's arenas.
     cleanupPages();
 }
 
 void ThreadState::cleanupMainThread()
 {
     ASSERT(isMainThread());
 
 #if defined(LEAK_SANITIZER)
     // See comment below, clear out most garbage before releasing static
     // persistents should some of the finalizers depend on touching
     // these persistents.
-    ThreadHeap::collectAllGarbage();
+    collectAllGarbage();
 #endif
 
     releaseStaticPersistentNodes();
 
 #if defined(LEAK_SANITIZER)
     // If LSan is about to perform leak detection, after having released all
     // the registered static Persistent<> root references to global caches
     // that Blink keeps, follow up with a round of GCs to clear out all
     // what they referred to.
     //
     // This is not needed for caches over non-Oilpan objects, as they're
     // not scanned by LSan due to being held in non-global storage
     // ("static" references inside functions/methods.)
-    ThreadHeap::collectAllGarbage();
+    collectAllGarbage();
 #endif
 
     // Finish sweeping before shutting down V8. Otherwise, some destructor
     // may access V8 and cause crashes.
     completeSweep();
 
     // It is unsafe to trigger GCs after this point because some
     // destructor may access already-detached V8 and cause crashes.
     // Also it is useless. So we forbid GCs.
     enterGCForbiddenScope();
@@ skipping 322 matching lines @@
     // TODO(haraken): It might not make sense to force completeSweep() for all
     // page navigations.
     completeSweep();
     ASSERT(!isSweepingInProgress());
     ASSERT(!sweepForbidden());
 
     if (shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled MemoryPressureGC\n");
 #endif
-        ThreadHeap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::MemoryPressureGC);
+        collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::MemoryPressureGC);
         return;
     }
     if (shouldSchedulePageNavigationGC(estimatedRemovalRatio)) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled PageNavigationGC\n");
 #endif
         schedulePageNavigationGC();
     }
 }
 
@@ skipping 23 matching lines @@
     ASSERT(!sweepForbidden());
 
     reportMemoryToV8();
 
     if (shouldForceMemoryPressureGC()) {
         completeSweep();
         if (shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
             dataLogF("Scheduled MemoryPressureGC\n");
 #endif
-            ThreadHeap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::MemoryPressureGC);
+            collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::MemoryPressureGC);
             return;
         }
     }
 
     if (shouldForceConservativeGC()) {
         completeSweep();
         if (shouldForceConservativeGC()) {
 #if PRINT_HEAP_STATS
             dataLogF("Scheduled ConservativeGC\n");
 #endif
-            ThreadHeap::collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::ConservativeGC);
+            collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::ConservativeGC);
             return;
         }
     }
     if (shouldScheduleIdleGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled IdleGC\n");
 #endif
         scheduleIdleGC();
         return;
     }
@@ skipping 25 matching lines @@
 
     double idleDeltaInSeconds = deadlineSeconds - monotonicallyIncreasingTime();
     if (idleDeltaInSeconds <= m_heap->heapStats().estimatedMarkingTime() && !Platform::current()->currentThread()->scheduler()->canExceedIdleDeadlineIfRequired()) {
         // If marking is estimated to take longer than the deadline and we can't
         // exceed the deadline, then reschedule for the next idle period.
         scheduleIdleGC();
         return;
     }
 
     TRACE_EVENT2("blink_gc", "ThreadState::performIdleGC", "idleDeltaInSeconds", idleDeltaInSeconds, "estimatedMarkingTime", m_heap->heapStats().estimatedMarkingTime());
-    ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::IdleGC);
+    collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::IdleGC);
 }
 
 void ThreadState::performIdleLazySweep(double deadlineSeconds)
 {
     ASSERT(checkThread());
     ASSERT(isMainThread());
 
     // If we are not in a sweeping phase, there is nothing to do here.
     if (!isSweepingInProgress())
         return;
@@ skipping 155 matching lines @@
     // If a safe point is entered while initiating a GC, we clearly do
     // not want to do another as part that -- the safe point is only
     // entered after checking if a scheduled GC ought to run first.
     // Prevent that from happening by marking GCs as forbidden while
     // one is initiated and later running.
     if (isGCForbidden())
         return;
 
     switch (gcState()) {
     case FullGCScheduled:
-        ThreadHeap::collectAllGarbage();
+        collectAllGarbage();
         break;
     case PreciseGCScheduled:
-        ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::PreciseGC);
+        collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::PreciseGC);
         break;
     case PageNavigationGCScheduled:
-        ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::PageNavigationGC);
+        collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::PageNavigationGC);
         break;
     case IdleGCScheduled:
         // Idle time GC will be scheduled by Blink Scheduler.
         break;
     default:
         break;
     }
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded()
@@ skipping 610 matching lines @@
     threadDump->AddScalar("live_count", "objects", totalLiveCount);
     threadDump->AddScalar("dead_count", "objects", totalDeadCount);
     threadDump->AddScalar("live_size", "bytes", totalLiveSize);
     threadDump->AddScalar("dead_size", "bytes", totalDeadSize);
 
     base::trace_event::MemoryAllocatorDump* heapsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(heapsDumpName);
     base::trace_event::MemoryAllocatorDump* classesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
     BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->AddOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
+void ThreadState::collectGarbage(BlinkGC::StackState stackState, BlinkGC::GCType gcType, BlinkGC::GCReason reason)
+{
+    DCHECK_NE(gcType, BlinkGC::ThreadTerminationGC);
+
+    // Nested collectGarbage() invocations aren't supported.
+    RELEASE_ASSERT(!isGCForbidden());
+    completeSweep();
+
+    std::unique_ptr<Visitor> visitor = Visitor::create(this, gcType);
+
+    SafePointScope safePointScope(stackState, this);
+
+    // Resume all parked threads upon leaving this scope.
+    ParkThreadsScope parkThreadsScope(this);
+
+    // Try to park the other threads. If we're unable to, bail out of the GC.
+    if (!parkThreadsScope.parkThreads())
+        return;
+
+    ScriptForbiddenIfMainThreadScope scriptForbidden;
+
+    TRACE_EVENT2("blink_gc,devtools.timeline", "BlinkGCMarking",
+        "lazySweeping", gcType == BlinkGC::GCWithoutSweep,
+        "gcReason", gcReasonString(reason));
+    TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
+    double startTime = WTF::currentTimeMS();
+
+    if (gcType == BlinkGC::TakeSnapshot)
+        BlinkGCMemoryDumpProvider::instance()->clearProcessDumpForCurrentGC();
+
+    // Disallow allocation during garbage collection (but not during the
+    // finalization that happens when the visitorScope is torn down).
+    ThreadState::NoAllocationScope noAllocationScope(this);
+
+    heap().commitCallbackStacks();
+    heap().preGC();
+
+    StackFrameDepthScope stackDepthScope(&heap().stackFrameDepth());
+
+    size_t totalObjectSize = heap().heapStats().allocatedObjectSize() + heap().heapStats().markedObjectSize();
+    if (gcType != BlinkGC::TakeSnapshot)
+        heap().resetHeapCounters();
+
+    {
+        // Access to the CrossThreadPersistentRegion has to be prevented while
+        // marking and global weak processing is in progress. If not, threads
+        // not attached to Oilpan and participating in this GC are able
+        // to allocate & free PersistentNodes, something the marking phase isn't
+        // capable of handling.
+        CrossThreadPersistentRegion::LockScope persistentLock(ProcessHeap::crossThreadPersistentRegion());
+
+        // 1. Trace persistent roots.
+        heap().visitPersistentRoots(visitor.get());
+
+        // 2. Trace objects reachable from the stack.  We do this independent of the
+        // given stackState since other threads might have a different stack state.
+        heap().visitStackRoots(visitor.get());
+
+        // 3. Transitive closure to trace objects including ephemerons.
+        heap().processMarkingStack(visitor.get());
+
+        heap().postMarkingProcessing(visitor.get());
+        heap().globalWeakProcessing(visitor.get());
+    }
+
+    // Now we can delete all orphaned pages because there are no dangling
+    // pointers to the orphaned pages.  (If we have such dangling pointers,
+    // we should have crashed during marking before getting here.)
+    heap().getOrphanedPagePool()->decommitOrphanedPages();
+
+    double markingTimeInMilliseconds = WTF::currentTimeMS() - startTime;
+    heap().heapStats().setEstimatedMarkingTimePerByte(totalObjectSize ? (markingTimeInMilliseconds / 1000 / totalObjectSize) : 0);
+
+#if PRINT_HEAP_STATS
+    dataLogF("ThreadHeap::collectGarbage (gcReason=%s, lazySweeping=%d, time=%.1lfms)\n", gcReasonString(reason), gcType == BlinkGC::GCWithoutSweep, markingTimeInMilliseconds);
+#endif
+
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, markingTimeHistogram, new CustomCountHistogram("BlinkGC.CollectGarbage", 0, 10 * 1000, 50));
+    markingTimeHistogram.count(markingTimeInMilliseconds);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, totalObjectSpaceHistogram, new CustomCountHistogram("BlinkGC.TotalObjectSpace", 0, 4 * 1024 * 1024, 50));
+    totalObjectSpaceHistogram.count(ProcessHeap::totalAllocatedObjectSize() / 1024);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, totalAllocatedSpaceHistogram, new CustomCountHistogram("BlinkGC.TotalAllocatedSpace", 0, 4 * 1024 * 1024, 50));
+    totalAllocatedSpaceHistogram.count(ProcessHeap::totalAllocatedSpace() / 1024);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, gcReasonHistogram, new EnumerationHistogram("BlinkGC.GCReason", BlinkGC::NumberOfGCReason));
+    gcReasonHistogram.count(reason);
+
+    heap().m_lastGCReason = reason;
+
+    ThreadHeap::reportMemoryUsageHistogram();
+    WTF::Partitions::reportMemoryUsageHistogram();
+
+    heap().postGC(gcType);
+    heap().decommitCallbackStacks();
+}
+
+void ThreadState::collectGarbageForTerminatingThread()
+{
+    {
+        // A thread-specific termination GC must not allow other global GCs to go
+        // ahead while it is running, hence the termination GC does not enter a
+        // safepoint. VisitorScope will not enter also a safepoint scope for
+        // ThreadTerminationGC.
+        std::unique_ptr<Visitor> visitor = Visitor::create(this, BlinkGC::ThreadTerminationGC);
+
+        ThreadState::NoAllocationScope noAllocationScope(this);
+
+        heap().commitCallbackStacks();
+        preGC();
+
+        // 1. Trace the thread local persistent roots. For thread local GCs we
+        // don't trace the stack (ie. no conservative scanning) since this is
+        // only called during thread shutdown where there should be no objects
+        // on the stack.
+        // We also assume that orphaned pages have no objects reachable from
+        // persistent handles on other threads or CrossThreadPersistents.  The
+        // only cases where this could happen is if a subsequent conservative
+        // global GC finds a "pointer" on the stack or due to a programming
+        // error where an object has a dangling cross-thread pointer to an
+        // object on this heap.
+        visitPersistents(visitor.get());
+
+        // 2. Trace objects reachable from the thread's persistent roots
+        // including ephemerons.
+        heap().processMarkingStack(visitor.get());
+
+        heap().postMarkingProcessing(visitor.get());
+        heap().globalWeakProcessing(visitor.get());
+
+        postGC(BlinkGC::GCWithSweep);
+        heap().decommitCallbackStacks();
+    }
+    preSweep();
+}
+
+void ThreadState::collectAllGarbage()
+{
+    // We need to run multiple GCs to collect a chain of persistent handles.
+    size_t previousLiveObjects = 0;
+    for (int i = 0; i < 5; ++i) {
+        collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
+        size_t liveObjects = heap().heapStats().markedObjectSize();
+        if (liveObjects == previousLiveObjects)
+            break;
+        previousLiveObjects = liveObjects;
+    }
+}
+
 } // namespace blink