Oilpan: Introduce a state transition model for Oilpan GC states

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 121 matching lines @@
 #else
     return 0;
 #endif
 }
 
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = 0;
 uintptr_t ThreadState::s_mainThreadStackStart = 0;
 uintptr_t ThreadState::s_mainThreadUnderestimatedStackSize = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
 SafePointBarrier* ThreadState::s_safePointBarrier = 0;
-bool ThreadState::s_inGC = false;
 
 static Mutex& threadAttachMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
 
 static double lockingTimeout()
 {
     // Wait time for parking all threads is at most 100 MS.
@@ skipping 167 matching lines @@
 };
 
 ThreadState::ThreadState()
     : m_thread(currentThread())
     , m_persistents(adoptPtr(new PersistentAnchor()))
     , m_startOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_safePointScopeMarker(0)
     , m_atSafePoint(false)
     , m_interruptors()
-    , m_gcRequested(false)
     , m_didV8GCAfterLastGC(false)
     , m_forcePreciseGCForTesting(false)
-    , m_sweepRequested(0)
     , m_sweepInProgress(false)
     , m_noAllocationCount(0)
-    , m_inGC(false)
     , m_isTerminating(false)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_lowCollectionRate(false)
+    , m_gcState(NoGCScheduled)
     , m_traceDOMWrappers(0)
 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
 {
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     if (isMainThread()) {
         s_mainThreadStackStart = reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
         s_mainThreadUnderestimatedStackSize = getUnderestimatedStackSize() - sizeof(void*);
     }
 
     InitializeHeaps<NumberOfHeaps>::init(m_heaps, this);
 
     m_weakCallbackStack = new CallbackStack();
 }
 
 ThreadState::~ThreadState()
 {
     checkThread();
+    ASSERT(gcState() == NoGCScheduled);
     delete m_weakCallbackStack;
     m_weakCallbackStack = 0;
     for (int i = 0; i < NumberOfHeaps; i++)
         delete m_heaps[i];
     deleteAllValues(m_interruptors);
     **s_threadSpecific = 0;
     if (isMainThread()) {
         s_mainThreadStackStart = 0;
         s_mainThreadUnderestimatedStackSize = 0;
     }
@@ skipping 387 matching lines @@
         return newSize >= 4 * 1024 * 1024 && newSize > 2 * Heap::markedObjectSize();
     }
     // Otherwise, trigger a conservative GC on a 300% increase in size, but not
     // for less than 32MB.  We set the higher limits in this case because Oilpan
     // GC might waste time to trace a lot of unused DOM wrappers or to find
     // small amount of garbage.
     // FIXME: Is 32MB reasonable?
     return newSize >= 32 * 1024 * 1024 && newSize > 4 * Heap::markedObjectSize();
 }
 
-bool ThreadState::sweepRequested()
+void ThreadState::setGCState(GCState gcState)
 {
-    ASSERT(isAnyThreadInGC() || checkThread());
-    return m_sweepRequested;
+    switch (gcState) {
+    case NoGCScheduled:
+        checkThread();
+        RELEASE_ASSERT(m_gcState == Sweeping);
+        break;
+    case GCScheduled:
+        checkThread();
+        RELEASE_ASSERT(m_gcState == NoGCScheduled || m_gcState == GCScheduled || m_gcState == StoppingOtherThreads);
+        break;
+    case StoppingOtherThreads:
+        checkThread();
+        break;
+    case GCRunning:
+        break;
+    case SweepScheduled:
+        RELEASE_ASSERT(m_gcState == GCRunning);
+        break;
+    case Sweeping:
+        checkThread();
+        RELEASE_ASSERT(m_gcState == SweepScheduled);
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+    m_gcState = gcState;
 }
 
-void ThreadState::setSweepRequested()
+ThreadState::GCState ThreadState::gcState() const
 {
-    // Sweep requested is set from the thread that initiates garbage
-    // collection which could be different from the thread for this
-    // thread state. Therefore the setting of m_sweepRequested needs a
-    // barrier.
-    atomicTestAndSetToOne(&m_sweepRequested);
-}
-
-void ThreadState::clearSweepRequested()
-{
-    checkThread();
-    m_sweepRequested = 0;
-}
-
-bool ThreadState::gcRequested()
-{
-    checkThread();
-    return m_gcRequested;
-}
-
-void ThreadState::setGCRequested()
-{
-    checkThread();
-    m_gcRequested = true;
-}
-
-void ThreadState::clearGCRequested()
-{
-    checkThread();
-    m_gcRequested = false;
+    return m_gcState;
 }
 
 void ThreadState::didV8GC()
 {
     checkThread();
     m_didV8GCAfterLastGC = true;
 }
 
 void ThreadState::performPendingGC(StackState stackState)
 {
     if (stackState == NoHeapPointersOnStack) {
         if (forcePreciseGCForTesting()) {
             setForcePreciseGCForTesting(false);
             Heap::collectAllGarbage();
-        } else if (gcRequested()) {
+        } else if (gcState() == GCScheduled) {
             Heap::collectGarbage(NoHeapPointersOnStack);
         }
     }
 }
 
 void ThreadState::setForcePreciseGCForTesting(bool value)
 {
     checkThread();
     m_forcePreciseGCForTesting = value;
 }
@@ skipping 30 matching lines @@
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded()
 {
     if (m_shouldFlushHeapDoesNotContainCache) {
         Heap::flushHeapDoesNotContainCache();
         m_shouldFlushHeapDoesNotContainCache = false;
     }
 }
 
-void ThreadState::prepareForGC()
+void ThreadState::preGC()
 {
     for (int i = 0; i < NumberOfHeaps; i++) {
         BaseHeap* heap = m_heaps[i];
         heap->makeConsistentForSweeping();
         // If a new GC is requested before this thread got around to sweep, ie. due to the
         // thread doing a long running operation, we clear the mark bits and mark any of
         // the dead objects as dead. The latter is used to ensure the next GC marking does
         // not trace already dead objects. If we trace a dead object we could end up tracing
         // into garbage or the middle of another object via the newly conservatively found
         // object.
-        if (sweepRequested())
+        if (gcState() == ThreadState::SweepScheduled)
             heap->markUnmarkedObjectsDead();
     }
     prepareRegionTree();
-    setSweepRequested();
+    setGCState(ThreadState::GCRunning);
     flushHeapDoesNotContainCacheIfNeeded();
 }
 
+void ThreadState::postGC()
+{
+    setGCState(ThreadState::SweepScheduled);
+}
+
 void ThreadState::setupHeapsForTermination()
 {
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->prepareHeapForTermination();
 }
 
 BaseHeapPage* ThreadState::pageFromAddress(Address address)
 {
     for (int i = 0; i < NumberOfHeaps; i++) {
         if (BaseHeapPage* page = m_heaps[i]->pageFromAddress(address))
@@ skipping 107 matching lines @@
 
     ASSERT(!m_safePointStackCopy.size());
     m_safePointStackCopy.resize(slotCount);
     for (size_t i = 0; i < slotCount; ++i) {
         m_safePointStackCopy[i] = from[i];
     }
 }
 
 void ThreadState::performPendingSweep()
 {
-    if (!sweepRequested())
+    if (gcState() != SweepScheduled)
         return;
+    setGCState(Sweeping);
 
 #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 35 matching lines @@
             TRACE_EVENT0("blink_gc", "ThreadState::sweepFinalizedHeaps");
             for (int i = 0; i < NumberOfFinalizedHeaps; i++) {
                 m_heaps[FirstFinalizedHeap + i]->sweep();
             }
         }
 
         for (int i = 0; i < NumberOfHeaps; i++)
             m_heaps[i]->postSweepProcessing();
     }
 
-    clearGCRequested();
     m_didV8GCAfterLastGC = false;
-    clearSweepRequested();
+    setGCState(ThreadState::NoGCScheduled);
 
     // 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()) {
@@ skipping 58 matching lines @@
         if (entry.value(entry.key, visitor))
             deadObjects.append(entry.key);
     }
     // FIXME: removeAll is inefficient.  It can shrink repeatedly.
     m_preFinalizers.removeAll(deadObjects);
 }
 
 #if ENABLE(GC_PROFILE_MARKING)
 const GCInfo* ThreadState::findGCInfoFromAllThreads(Address address)
 {
-    bool needLockForIteration = !isAnyThreadInGC();
+    bool needLockForIteration = !Heap::isInGC();
     if (needLockForIteration)
         threadAttachMutex().lock();
 
     ThreadState::AttachedThreadStateSet& threads = attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         if (const GCInfo* gcInfo = (*it)->findGCInfo(address)) {
             if (needLockForIteration)
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 } // namespace blink