Oilpan: simplify away StoppingOtherThreads pseudo GCState.

Source/platform/heap/Heap.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 91 matching lines @@
 
 #if ENABLE(GC_PROFILING)
 static String classOf(const void* object)
 {
     if (const GCInfo* gcInfo = Heap::findGCInfo(reinterpret_cast<Address>(const_cast<void*>(object))))
         return gcInfo->m_className;
     return "unknown";
 }
 #endif
 
+class GCForbiddenScope final {
+public:
+    explicit GCForbiddenScope(ThreadState* state)
+        : m_state(state)
+    {
+        // Prevent nested collectGarbage() invocations.
+        m_state->enterGCForbiddenScope();
+    }
+
+    ~GCForbiddenScope()
+    {
+        m_state->leaveGCForbiddenScope();
+    }
+
+private:
+    ThreadState* m_state;
+};
+
 class GCScope final {
 public:
-    GCScope(ThreadState::StackState stackState, ThreadState::GCType gcType)
-        : m_state(ThreadState::current())
+    GCScope(ThreadState* state, ThreadState::StackState stackState, ThreadState::GCType gcType)
+        : m_state(state)
+        , m_gcForbiddenScope(state)
+        // See collectGarbageForTerminatingThread() comment on why a
+        // safepoint scope isn't entered for its GCScope.
+        , m_safePointScope(stackState, gcType != ThreadState::ThreadTerminationGC ? state : nullptr)
         , m_gcType(gcType)
         , m_parkedAllThreads(false)
     {
         TRACE_EVENT0("blink_gc", "Heap::GCScope");
         const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
         if (m_state->isMainThread())
             TRACE_EVENT_SET_SAMPLING_STATE("blink_gc", "BlinkGCWaiting");
 
         m_state->checkThread();
 
-        // We explicitly do not enter a safepoint while doing thread specific
-        // garbage collection since we don't want to allow a global GC at the
-        // same time as a thread local GC.
-        if (gcType != ThreadState::ThreadTerminationGC) {
-            RELEASE_ASSERT(!ThreadState::current()->isAtSafePoint());
-            m_state->enterSafePoint(stackState, this);
-
-            // TODO(haraken): In an unlikely coincidence that two threads decide
-            // to collect garbage at the same time, avoid doing two GCs in
-            // a row.
-            if (LIKELY(ThreadState::stopThreads())) {
-                m_parkedAllThreads = true;
-            }
-        }
+        // TODO(haraken): In an unlikely coincidence that two threads decide
+        // to collect garbage at the same time, avoid doing two GCs in
+        // a row.
+        if (LIKELY(gcType != ThreadState::ThreadTerminationGC && ThreadState::stopThreads()))
+            m_parkedAllThreads = true;
 
         if (m_state->isMainThread())
             TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
     }
 
     bool allThreadsParked() { return m_parkedAllThreads; }
 
     ~GCScope()
     {
-        if (m_gcType != ThreadState::ThreadTerminationGC) {
-            // Only cleanup if we parked all threads in which case the GC happened
-            // and we need to resume the other threads.
-            if (LIKELY(m_parkedAllThreads)) {
-                ThreadState::resumeThreads();
-            }
-
-            m_state->leaveSafePoint();
-        }
+        // Only cleanup if we parked all threads in which case the GC happened
+        // and we need to resume the other threads.
+        if (LIKELY(m_gcType != ThreadState::ThreadTerminationGC && m_parkedAllThreads))
+            ThreadState::resumeThreads();
     }
 
 private:
     ThreadState* m_state;
+    // The ordering of the two scope objects matters: GCs must first be forbidden
+    // before entering the safe point scope. Prior to reaching the safe point,
+    // ThreadState::runScheduledGC() is called. See its comment why we need
+    // to be in a GC forbidden scope when doing so.
+    GCForbiddenScope m_gcForbiddenScope;
+    SafePointScope m_safePointScope;
     ThreadState::GCType m_gcType;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
 #if ENABLE(ASSERT)
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::zapMagic()
 {
     checkHeader();
     m_magic = zappedMagic;
@@ skipping 1716 matching lines @@
         STRINGIFY_REASON(ForcedGC);
 #undef STRINGIFY_REASON
     case NumberOfGCReason: ASSERT_NOT_REACHED();
     }
     return "<Unknown>";
 }
 
 void Heap::collectGarbage(ThreadState::StackState stackState, ThreadState::GCType gcType, GCReason reason)
 {
     ThreadState* state = ThreadState::current();
-    RELEASE_ASSERT(!state->isInGC());
+    // Nested collectGarbage() invocations aren't supported.
+    RELEASE_ASSERT(!state->isGCForbidden());
     state->completeSweep();
-    ThreadState::GCState originalGCState = state->gcState();
-    state->setGCState(ThreadState::StoppingOtherThreads);
 
-    GCScope gcScope(stackState, gcType);
+    GCScope gcScope(state, stackState, gcType);
     // Check if we successfully parked the other threads.  If not we bail out of
     // the GC.
-    if (!gcScope.allThreadsParked()) {
-        // Restore the original GCState.
-        if (LIKELY(state->gcState() == ThreadState::StoppingOtherThreads))
-            state->setGCState(originalGCState);
+    if (!gcScope.allThreadsParked())
         return;
-    }
 
     if (state->isMainThread())
         ScriptForbiddenScope::enter();
 
     s_lastGCWasConservative = false;
 
     TRACE_EVENT2("blink_gc", "Heap::collectGarbage",
         "lazySweeping", gcType == ThreadState::GCWithoutSweep,
         "gcReason", gcReasonString(reason));
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
@@ skipping 54 matching lines @@
     Heap::reportMemoryUsageHistogram();
     WTF::Partitions::reportMemoryUsageHistogram();
 
     if (state->isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 void Heap::collectGarbageForTerminatingThread(ThreadState* state)
 {
     {
-        GCScope gcScope(ThreadState::NoHeapPointersOnStack, ThreadState::ThreadTerminationGC);
+        // 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. GCScope will not enter also a safepoint scope for
+        // ThreadTerminationGC.
+        GCScope gcScope(state, ThreadState::NoHeapPointersOnStack, ThreadState::ThreadTerminationGC);
 
         MarkingVisitor<Visitor::ThreadLocalMarking> markingVisitor;
         ThreadState::NoAllocationScope noAllocationScope(state);
 
         state->preGC();
         StackFrameDepthScope stackDepthScope;
 
         // 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
@@ skipping 249 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 // We don't want to use 0 KB for the initial value because it may end up
 // triggering the first GC of some thread too prematurely.
 size_t Heap::s_estimatedLiveObjectSize = 512 * 1024;
 size_t Heap::s_externalObjectSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 
 } // namespace blink