Oilpan: Introduce a state transition model for Oilpan GC states

Source/platform/heap/ThreadState.h

 /*
  * 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 302 matching lines @@
         NoHeapPointersOnStack,
         HeapPointersOnStack
     };
 
     // When profiling we would like to identify forced GC requests.
     enum CauseOfGC {
         NormalGC,
         ForcedGC
     };
 
+    // See setGCState() for possible state transitions.
+    enum GCState {
+        NoGCScheduled,
+        GCScheduled,
+        StoppingOtherThreads,
+        GCRunning,

[tkent, 2014/11/26 02:27:07]

What's 'GC' here? Does this contains both of marking and sweeping?

+        SweepScheduled,
+        Sweeping,
+    };
+
     class NoSweepScope {
     public:
         explicit NoSweepScope(ThreadState* state) : m_state(state)
         {
             ASSERT(!m_state->m_sweepInProgress);
             m_state->m_sweepInProgress = true;
         }
         ~NoSweepScope()
         {
             ASSERT(m_state->m_sweepInProgress);
@@ skipping 59 matching lines @@
         return reinterpret_cast<ThreadState*>(s_mainThreadStateStorage);
     }
 
     bool isMainThread() const { return this == mainThreadState(); }
     inline bool checkThread() const
     {
         ASSERT(m_thread == currentThread());
         return true;
     }
 
-    // If gcRequested returns true when a thread returns to its event
-    // loop the thread will initiate a garbage collection.
-    bool gcRequested();
-    void setGCRequested();

[tkent, 2014/11/26 02:27:07]

nit: I'd like to keep setGCRequested() as an alias of setGCState(GCScheduled)
for code readability.
(and rename it to requestGC() optionally)

[haraken, 2014/11/26 05:27:01]

Done.

-    void clearGCRequested();
     void didV8GC();
 
     // shouldGC and shouldForceConservativeGC implement the heuristics
     // that are used to determine when to collect garbage. If
     // shouldForceConservativeGC returns true, we force the garbage
     // collection immediately. Otherwise, if shouldGC returns true, we
     // record that we should garbage collect the next time we return
     // to the event loop. If both return false, we don't need to
     // collect garbage at this point.
     bool shouldGC();
     bool shouldForceConservativeGC();
 
+    void setGCState(GCState);
+    GCState gcState() const;
+
     // Was the last GC forced for testing? This is set when garbage collection
     // is forced for testing and there are pointers on the stack. It remains
     // set until a garbage collection is triggered with no pointers on the stack.
     // This is used for layout tests that trigger GCs and check if objects are
     // dead at a given point in time. That only reliably works when we get
     // precise GCs with no conservative stack scanning.
     void setForcePreciseGCForTesting(bool);
     bool forcePreciseGCForTesting();
 
-    bool sweepRequested();
-    void setSweepRequested();
-    void clearSweepRequested();
     void performPendingSweep();
 
     // Support for disallowing allocation. Mainly used for sanity
     // checks asserts.
     bool isAllocationAllowed() const { return !isAtSafePoint() && !m_noAllocationCount; }
     void enterNoAllocationScope() { m_noAllocationCount++; }
     void leaveNoAllocationScope() { m_noAllocationCount--; }
 
     // Before performing GC the thread-specific heap state should be
     // made consistent for sweeping.
     void makeConsistentForSweeping();
 #if ENABLE(ASSERT)
     bool isConsistentForSweeping();
 #endif
 
-    // Is the thread corresponding to this thread state currently
-    // performing GC?
-    bool isInGC() const { return m_inGC; }
-
-    // Is any of the threads registered with the blink garbage collection
-    // infrastructure currently performing GC?
-    static bool isAnyThreadInGC() { return s_inGC; }
-
-    void enterGC()
-    {
-        ASSERT(!m_inGC);
-        ASSERT(!s_inGC);
-        m_inGC = true;
-        s_inGC = true;
-    }
-
-    void leaveGC()
-    {
-        m_inGC = false;
-        s_inGC = false;
-    }
-
-    // Is the thread corresponding to this thread state currently
-    // sweeping?
+    // Is this thread currently sweeping?
     bool isSweepInProgress() const { return m_sweepInProgress; }
 
     void prepareRegionTree();
     void flushHeapDoesNotContainCacheIfNeeded();
-    void prepareForGC();
+    void preGC();
+    void postGC();
 
     // Safepoint related functionality.
     //
     // When a thread attempts to perform GC it needs to stop all other threads
     // that use the heap or at least guarantee that they will not touch any
     // heap allocated object until GC is complete.
     //
     // We say that a thread is at a safepoint if this thread is guaranteed to
     // not touch any heap allocated object or any heap related functionality until
     // it leaves the safepoint.
@@ skipping 249 matching lines @@
     void cleanupPages();
 
     void unregisterPreFinalizerInternal(void*);
     void invokePreFinalizers(Visitor&);
 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static uintptr_t s_mainThreadStackStart;
     static uintptr_t s_mainThreadUnderestimatedStackSize;
     static SafePointBarrier* s_safePointBarrier;
 
-    // This variable is flipped to true after all threads are stoped
-    // and outermost GC has started.
-    static bool s_inGC;
-
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
     // We would like to manage lifetime of the ThreadState attached
     // to the main thread explicitly instead and still use normal
     // constructor and destructor for the ThreadState class.
     // For this we reserve static storage for the main ThreadState
     // and lazily construct ThreadState in it using placement new.
     static uint8_t s_mainThreadStateStorage[];
 
     ThreadIdentifier m_thread;
     OwnPtr<PersistentNode> m_persistents;
     StackState m_stackState;
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
     void* m_safePointScopeMarker;
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
     Vector<Interruptor*> m_interruptors;
-    bool m_gcRequested;
     bool m_didV8GCAfterLastGC;
     bool m_forcePreciseGCForTesting;
-    volatile int m_sweepRequested;
     bool m_sweepInProgress;
     size_t m_noAllocationCount;
-    bool m_inGC;
     BaseHeap* m_heaps[NumberOfHeaps];
 
     Vector<OwnPtr<CleanupTask> > m_cleanupTasks;
     bool m_isTerminating;
 
     bool m_shouldFlushHeapDoesNotContainCache;
     bool m_lowCollectionRate;
+    GCState m_gcState;
 
     CallbackStack* m_weakCallbackStack;
     HashMap<void*, bool (*)(void*, Visitor&)> m_preFinalizers;
 
     v8::Isolate* m_isolate;
     void (*m_traceDOMWrappers)(v8::Isolate*, Visitor*);
 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
@@ skipping 115 matching lines @@
     // HeapPage header. We use some of the bits to determine
     // whether the page is part of a terminting thread or
     // if the page is traced after being terminated (orphaned).
     uintptr_t m_terminating : 1;
     uintptr_t m_promptlyFreedSize : 17; // == blinkPageSizeLog2
 };
 
 } // namespace blink
 
 #endif // ThreadState_h