Oilpan: Factor out GC-related enum definitions to BlinkGC.h

third_party/WebKit/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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ThreadState_h
 #define ThreadState_h
 
 #include "platform/PlatformExport.h"
+#include "platform/heap/BlinkGC.h"
 #include "platform/heap/ThreadingTraits.h"
 #include "public/platform/WebThread.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/Threading.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/text/WTFString.h"
 
 namespace v8 {
 class Isolate;
 };
 
 namespace blink {
 
-#define PRINT_HEAP_STATS 0 // Enable this macro to print heap stats to stderr.
-
 class BasePage;
 class CallbackStack;
 class CrossThreadPersistentRegion;
 struct GCInfo;
 class GarbageCollectedMixinConstructorMarker;
 class HeapObjectHeader;
 class PersistentRegion;
 class BaseHeap;
 class SafePointAwareMutexLocker;
 class SafePointBarrier;
 class ThreadState;
 class Visitor;
 
-using Address = uint8_t*;
-
-using FinalizationCallback = void (*)(void*);
-using VisitorCallback = void (*)(Visitor*, void* self);
-using TraceCallback = VisitorCallback;
-using WeakCallback = VisitorCallback;
-using EphemeronCallback = VisitorCallback;
-using PreFinalizerCallback = bool(*)(void*);
-
 // Declare that a class has a pre-finalizer. The pre-finalizer is called
 // before any object gets swept, so it is safe to touch on-heap objects
 // that may be collected in the same GC cycle. If you cannot avoid touching
 // on-heap objects in a destructor (which is not allowed), you can consider
 // using the pre-finalizer. The only restriction is that the pre-finalizer
 // must not resurrect dead objects (e.g., store unmarked objects into
 // Members etc). The pre-finalizer is called on the thread that registered
 // the pre-finalizer.
 //
 // Since a pre-finalizer adds pressure on GC performance, you should use it
@@ skipping 35 matching lines @@
     return true;                                    \
 }                                                   \
 using UsingPreFinazlizerMacroNeedsTrailingSemiColon = char
 
 #if ENABLE(OILPAN)
 #define WILL_BE_USING_PRE_FINALIZER(Class, method) USING_PRE_FINALIZER(Class, method)
 #else
 #define WILL_BE_USING_PRE_FINALIZER(Class, method)
 #endif
 
-// List of typed heaps. The list is used to generate the implementation
-// of typed heap related methods.
-//
-// To create a new typed heap add a H(<ClassName>) to the
-// FOR_EACH_TYPED_HEAP macro below.
-#define FOR_EACH_TYPED_HEAP(H)              \
-    H(Node)                                 \
-    H(CSSValue)
-
-#define TypedHeapEnumName(Type) Type##HeapIndex,
-
 #if ENABLE(GC_PROFILING)
 const size_t numberOfGenerationsToTrack = 8;
 const size_t maxHeapObjectAge = numberOfGenerationsToTrack - 1;
 
 struct AgeCounts {
     int ages[numberOfGenerationsToTrack];
     AgeCounts() { std::fill(ages, ages + numberOfGenerationsToTrack, 0); }
 };
 typedef HashMap<String, AgeCounts> ClassAgeCountsMap;
 #endif
 
 class PLATFORM_EXPORT ThreadState {
     WTF_MAKE_NONCOPYABLE(ThreadState);
 public:
     typedef std::pair<void*, PreFinalizerCallback> PreFinalizer;
 
-    // When garbage collecting we need to know whether or not there
-    // can be pointers to Blink GC managed objects on the stack for
-    // each thread. When threads reach a safe point they record
-    // whether or not they have pointers on the stack.
-    enum StackState {
-        NoHeapPointersOnStack,
-        HeapPointersOnStack
-    };
-
-    enum GCType {
-        // Both of the marking task and the sweeping task run in
-        // Heap::collectGarbage().
-        GCWithSweep,
-        // Only the marking task runs in Heap::collectGarbage().
-        // The sweeping task is split into chunks and scheduled lazily.
-        GCWithoutSweep,
-        // Only the marking task runs just to take a heap snapshot.
-        // The sweeping task doesn't run. The marks added in the marking task
-        // are just cleared.
-        TakeSnapshot,
-        // The marking task does not mark objects outside the heap of the GCing
-        // thread.
-        ThreadTerminationGC,
-    };
-
     // See setGCState() for possible state transitions.
     enum GCState {
         NoGCScheduled,
         IdleGCScheduled,
         PreciseGCScheduled,
         FullGCScheduled,
         PageNavigationGCScheduled,
         GCRunning,
         EagerSweepScheduled,
         LazySweepScheduled,
         Sweeping,
         SweepingAndIdleGCScheduled,
         SweepingAndPreciseGCScheduled,
     };
 
-    enum HeapIndices {
-        EagerSweepHeapIndex = 0,
-        NormalPage1HeapIndex,
-        NormalPage2HeapIndex,
-        NormalPage3HeapIndex,
-        NormalPage4HeapIndex,
-        Vector1HeapIndex,
-        Vector2HeapIndex,
-        Vector3HeapIndex,
-        Vector4HeapIndex,
-        InlineVectorHeapIndex,
-        HashTableHeapIndex,
-        FOR_EACH_TYPED_HEAP(TypedHeapEnumName)
-        LargeObjectHeapIndex,
-        // Values used for iteration of heap segments.
-        NumberOfHeaps,
-    };
-
-#if defined(ADDRESS_SANITIZER)
-    // Heaps can have their object payloads be poisoned, or cleared
-    // of their poisoning.
-    enum Poisoning {
-        SetPoison,
-        ClearPoison,
-    };
-
-    enum ObjectsToPoison {
-        UnmarkedOnly,
-        MarkedAndUnmarked,
-    };
-#endif
-
-    enum V8GCType {
-        V8MinorGC,
-        V8MajorGC,
-    };
-
     // The NoAllocationScope class is used in debug mode to catch unwanted
     // allocations. E.g. allocations during GC.
     class NoAllocationScope final {
     public:
         explicit NoAllocationScope(ThreadState* state) : m_state(state)
         {
             m_state->enterNoAllocationScope();
         }
         ~NoAllocationScope()
         {
@@ skipping 82 matching lines @@
 #if ENABLE(ASSERT)
     bool checkThread() const { return m_thread == currentThread(); }
 #endif
 
     void performIdleGC(double deadlineSeconds);
     void performIdleLazySweep(double deadlineSeconds);
 
     void scheduleIdleGC();
     void scheduleIdleLazySweep();
     void schedulePreciseGC();
-    void scheduleV8FollowupGCIfNeeded(V8GCType);
+    void scheduleV8FollowupGCIfNeeded(BlinkGC::V8GCType);
     void schedulePageNavigationGCIfNeeded(float estimatedRemovalRatio);
     void schedulePageNavigationGC();
     void scheduleGCIfNeeded();
     void willStartV8GC();
     void setGCState(GCState);
-    GCState gcState() const;
+    GCState gcState() const { return m_gcState; }
     bool isInGC() const { return gcState() == GCRunning; }
     bool isSweepingInProgress() const
     {
         return gcState() == Sweeping || gcState() == SweepingAndPreciseGCScheduled || gcState() == SweepingAndIdleGCScheduled;
     }
 
     // A GC runs in the following sequence.
     //
     // 1) All threads park at safe points.
     // 2) The GCing thread calls preGC() for all ThreadStates.
@@ skipping 10 matching lines @@
     // - We stop the world between 1) and 5).
     // - isInGC() returns true between 2) and 4).
     // - isSweepingInProgress() returns true between 6) and 7).
     // - It is valid that the next GC is scheduled while some thread
     //   has not yet completed its lazy sweeping of the last GC.
     //   In this case, the next GC just cancels the remaining lazy sweeping.
     //   Specifically, preGC() of the next GC calls makeConsistentForGC()
     //   and it marks all not-yet-swept objets as dead.
     void makeConsistentForGC();
     void preGC();
-    void postGC(GCType);
+    void postGC(BlinkGC::GCType);
     void preSweep();
     void completeSweep();
     void postSweep();
     // makeConsistentForMutator() drops marks from marked objects and rebuild
     // free lists. This is called after taking a snapshot and before resuming
     // the executions of mutators.
     void makeConsistentForMutator();
 
     // Support for disallowing allocation. Mainly used for sanity
     // checks asserts.
@@ skipping 33 matching lines @@
     //   - register an Interruptor that can interrupt long running loops that have no calls to safePoint and
     //     are not wrapped in a SafePointScope (e.g. Interruptor for JavaScript code)
     //
 
     // Request all other threads to stop. Must only be called if the current thread is at safepoint.
     static bool stopThreads();
     static void resumeThreads();
 
     // Check if GC is requested by another thread and pause this thread if this is the case.
     // Can only be called when current thread is in a consistent state.
-    void safePoint(StackState);
+    void safePoint(BlinkGC::StackState);
 
     // Mark current thread as running inside safepoint.
-    void enterSafePoint(StackState, void*);
+    void enterSafePoint(BlinkGC::StackState, void*);
     void leaveSafePoint(SafePointAwareMutexLocker* = nullptr);
     bool isAtSafePoint() const { return m_atSafePoint; }
 
     // If attached thread enters long running loop that can call back
     // into Blink and leaving and reentering safepoint at every
     // transition between this loop and Blink is deemed too expensive
     // then instead of marking this loop as a GC safepoint thread
     // can provide an interruptor object which would allow GC
     // to temporarily interrupt and pause this long running loop at
     // an arbitrary moment creating a safepoint for a GC.
@@ skipping 19 matching lines @@
     {
         m_endOfStack = endOfStack;
     }
 
     // Get one of the heap structures for this thread.
     // The thread heap is split into multiple heap parts based on object types
     // and object sizes.
     BaseHeap* heap(int heapIndex) const
     {
         ASSERT(0 <= heapIndex);
-        ASSERT(heapIndex < NumberOfHeaps);
+        ASSERT(heapIndex < BlinkGC::NumberOfHeaps);
         return m_heaps[heapIndex];
     }
 
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Infrastructure to determine if an address is within one of the
     // address ranges for the Blink heap. If the address is in the Blink
     // heap the containing heap page is returned.
     BasePage* findPageFromAddress(Address);
     BasePage* findPageFromAddress(const void* pointer) { return findPageFromAddress(reinterpret_cast<Address>(const_cast<void*>(pointer))); }
 #endif
@@ skipping 156 matching lines @@
     {
         ASSERT(checkThread());
         size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
         --m_likelyToBePromptlyFreed[entryIndex];
         int heapIndex = m_vectorBackingHeapIndex;
         // If m_likelyToBePromptlyFreed[entryIndex] > 0, that means that
         // more than 33% of vectors of the type have been promptly freed
         // since the last GC.
         if (m_likelyToBePromptlyFreed[entryIndex] > 0) {
             m_heapAges[heapIndex] = ++m_currentHeapAges;
-            m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(Vector1HeapIndex, Vector4HeapIndex);
+            m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
         }
         ASSERT(isVectorHeapIndex(heapIndex));
         return m_heaps[heapIndex];
     }
     BaseHeap* expandedVectorBackingHeap(size_t gcInfoIndex);
     static bool isVectorHeapIndex(int heapIndex)
     {
-        return Vector1HeapIndex <= heapIndex && heapIndex <= Vector4HeapIndex;
+        return BlinkGC::Vector1HeapIndex <= heapIndex && heapIndex <= BlinkGC::Vector4HeapIndex;
     }
     void allocationPointAdjusted(int heapIndex);
     void promptlyFreed(size_t gcInfoIndex);
 
 private:
     enum SnapshotType {
         HeapSnapshot,
         FreelistSnapshot
     };
 
@@ skipping 35 matching lines @@
     // Returns true if shouldForceMemoryPressureGC() held and a
     // conservative GC was performed to handle the emergency.
     bool forceMemoryPressureGCIfNeeded();
 
     size_t estimatedLiveSize(size_t currentSize, size_t sizeAtLastGC);
     size_t totalMemorySize();
     double heapGrowingRate();
     double partitionAllocGrowingRate();
     bool judgeGCThreshold(size_t allocatedObjectSizeThreshold, double heapGrowingRateThreshold);
 
-    void runScheduledGC(StackState);
+    void runScheduledGC(BlinkGC::StackState);
 
     void eagerSweep();
 
 #if defined(ADDRESS_SANITIZER)
-    void poisonEagerHeap(Poisoning);
+    void poisonEagerHeap(BlinkGC::Poisoning);
     void poisonAllHeaps();
 #endif
 
     // When ThreadState is detaching from non-main thread its
     // heap is expected to be empty (because it is going away).
     // Perform registered cleanup tasks and garbage collection
     // to sweep away any objects that are left on this heap.
     // We assert that nothing must remain after this cleanup.
     // If assertion does not hold we crash as we are potentially
     // in the dangling pointer situation.
@@ skipping 29 matching lines @@
     // 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<PersistentRegion> m_persistentRegion;
-    StackState m_stackState;
+    BlinkGC::StackState m_stackState;
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
     void* m_safePointScopeMarker;
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
     InterruptorVector m_interruptors;
     bool m_sweepForbidden;
     size_t m_noAllocationCount;
     size_t m_gcForbiddenCount;
-    BaseHeap* m_heaps[NumberOfHeaps];
+    BaseHeap* m_heaps[BlinkGC::NumberOfHeaps];
 
     int m_vectorBackingHeapIndex;
-    size_t m_heapAges[NumberOfHeaps];
+    size_t m_heapAges[BlinkGC::NumberOfHeaps];
     size_t m_currentHeapAges;
 
     bool m_isTerminating;
     GarbageCollectedMixinConstructorMarker* m_gcMixinMarker;
 
     bool m_shouldFlushHeapDoesNotContainCache;
     GCState m_gcState;
 
     CallbackStack* m_threadLocalWeakCallbackStack;
 
@@ skipping 34 matching lines @@
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h