Refactor the Heap into ThreadHeap to prepare for per thread heaps

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 43 matching lines @@
 class CallbackStack;
 struct GCInfo;
 class GarbageCollectedMixinConstructorMarker;
 class HeapObjectHeader;
 class PersistentNode;
 class PersistentRegion;
 class BaseHeap;
 class SafePointAwareMutexLocker;
 class SafePointBarrier;
 class ThreadState;
+class OrphanedPagePool;
 class Visitor;
+class PageMemoryRegion;
+class RegionTree;
+class FreePagePool;
+class HeapDoesNotContainCache;
 
 // 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.
 //
@@ skipping 36 matching lines @@
     return true;                                    \
 }                                                   \
 using UsingPreFinalizerMacroNeedsTrailingSemiColon = 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
 
+using ThreadStateSet = HashSet<ThreadState*>;
+
+// Stats for heap in a GCGroup.
+class GCHeapStats {
+public:
+    GCHeapStats();
+    void setMarkedObjectSizeAtLastCompleteSweep(size_t size) { releaseStore(&m_markedObjectSizeAtLastCompleteSweep, size); }
+    size_t markedObjectSizeAtLastCompleteSweep() { return acquireLoad(&m_markedObjectSizeAtLastCompleteSweep); }
+    void increaseAllocatedObjectSize(size_t delta);
+    void decreaseAllocatedObjectSize(size_t delta);
+    size_t allocatedObjectSize() { return acquireLoad(&m_allocatedObjectSize); }
+    void increaseMarkedObjectSize(size_t delta);
+    size_t markedObjectSize() { return acquireLoad(&m_markedObjectSize); }
+    void increaseAllocatedSpace(size_t delta);
+    void decreaseAllocatedSpace(size_t delta);
+    size_t allocatedSpace() { return acquireLoad(&m_allocatedSpace); }
+    size_t objectSizeAtLastGC() { return acquireLoad(&m_objectSizeAtLastGC); }
+    void increaseWrapperCount(size_t delta) { atomicAdd(&m_wrapperCount, static_cast<long>(delta)); }
+    void decreaseWrapperCount(size_t delta) { atomicSubtract(&m_wrapperCount, static_cast<long>(delta)); }
+    size_t wrapperCount() { return acquireLoad(&m_wrapperCount); }
+    size_t wrapperCountAtLastGC() { return acquireLoad(&m_wrapperCountAtLastGC); }
+    void increaseCollectedWrapperCount(size_t delta) { atomicAdd(&m_collectedWrapperCount, static_cast<long>(delta)); }
+    size_t collectedWrapperCount() { return acquireLoad(&m_collectedWrapperCount); }
+    size_t partitionAllocSizeAtLastGC() { return acquireLoad(&m_partitionAllocSizeAtLastGC); }
+    void setEstimatedMarkingTimePerByte(double estimatedMarkingTimePerByte) { m_estimatedMarkingTimePerByte = estimatedMarkingTimePerByte; }
+    double estimatedMarkingTimePerByte() const { return m_estimatedMarkingTimePerByte; }
+    double estimatedMarkingTime();
+    void reset();
+
+private:
+    size_t m_allocatedSpace;
+    size_t m_allocatedObjectSize;
+    size_t m_objectSizeAtLastGC;
+    size_t m_markedObjectSize;
+    size_t m_markedObjectSizeAtLastCompleteSweep;
+    size_t m_wrapperCount;
+    size_t m_wrapperCountAtLastGC;
+    size_t m_collectedWrapperCount;
+    size_t m_partitionAllocSizeAtLastGC;
+    double m_estimatedMarkingTimePerByte;
+};
+
+class PLATFORM_EXPORT GCGroup {
+public:
+    virtual ~GCGroup();
+    virtual void attach(ThreadState*) = 0;
+    virtual void detach(ThreadState*) = 0;
+    virtual bool park() = 0;
+    virtual void resume() = 0;
+    virtual bool isParked() const = 0;
+    virtual void lockThreadAttachMutex() = 0;
+    virtual void unlockThreadAttachMutex() = 0;
+#if ENABLE(ASSERT)
+    virtual BasePage* findPageFromAddress(Address) = 0;
+#endif
+    virtual void preGC() = 0;
+    virtual void postGC(BlinkGC::GCType) = 0;
+    virtual size_t objectPayloadSizeForTesting() = 0;
+    virtual size_t size() const = 0;
+    virtual void checkAndPark(ThreadState*, SafePointAwareMutexLocker*) = 0;
+    virtual void enterSafePoint(ThreadState*) = 0;
+    virtual void leaveSafePoint(ThreadState*, SafePointAwareMutexLocker*) = 0;
+    virtual void shutdownIfNecessary() = 0;
+
+    // Trace all persistent roots, called when marking the managed heap objects.
+    virtual void visitPersistentRoots(Visitor*) = 0;
+
+    // Trace all objects found on the stack, used when doing conservative GCs.
+    virtual void visitStackRoots(Visitor*) = 0;
+
+    void flushHeapDoesNotContainCache();
+    HeapDoesNotContainCache* heapDoesNotContainCache() { return m_heapDoesNotContainCache.get(); }
+
+    // This look-up uses the region search tree and a negative contains cache to
+    // provide an efficient mapping from arbitrary addresses to the containing
+    // heap-page if one exists.
+    BasePage* lookupPageForAddress(Address);
+    void addPageMemoryRegion(PageMemoryRegion*);
+    void removePageMemoryRegion(PageMemoryRegion*);
+    GCHeapStats& heapStats() { return m_stats; }
+
+    static HashSet<GCGroup*>& all();
+
+protected:
+    GCGroup();
+
+private:
+    GCHeapStats m_stats;
+    Mutex m_regionTreeMutex;
+    RegionTree* m_regionTree;
+    OwnPtr<HeapDoesNotContainCache> m_heapDoesNotContainCache;
+};
+
+class PLATFORM_EXPORT MultiThreadGCGroup : public GCGroup {

[haraken, 2016/02/12 11:28:53]

Is it really worth distinguishing MultiThreadGCGroup from GCGroup? I guess we
can just unify the two classes into the GCGroup.

[keishi, 2016/02/29 06:02:34]

For per thread heap enabled threads I'm thinking of using SingleThreadGCGroup

+public:
+    MultiThreadGCGroup();
+    ~MultiThreadGCGroup();
+    void attach(ThreadState*) override;
+    void detach(ThreadState*) override;
+    bool park() override;
+    void resume() override;
+    bool isParked() const override;
+    void lockThreadAttachMutex() override;
+    void unlockThreadAttachMutex() override;
+#if ENABLE(ASSERT)
+    BasePage* findPageFromAddress(Address) override;
+#endif
+    void preGC() override;
+    void postGC(BlinkGC::GCType) override;
+    size_t objectPayloadSizeForTesting() override;
+    size_t size() const override;
+    void visitPersistentRoots(Visitor*) override;
+    void visitStackRoots(Visitor*) override;
+    void checkAndPark(ThreadState*, SafePointAwareMutexLocker*) override;
+    void enterSafePoint(ThreadState*) override;
+    void leaveSafePoint(ThreadState*, SafePointAwareMutexLocker*) override;
+    void shutdownIfNecessary() override;
+    FreePagePool* freePagePool() { return m_freePagePool.get(); }
+    OrphanedPagePool* orphanedPagePool() { return m_orphanedPagePool.get(); }
+
+    const ThreadStateSet& threads() const { return m_threads; }
+    SafePointBarrier* safePointBarrier() { return m_safePointBarrier.get(); }
+    RecursiveMutex& threadAttachMutex() { return m_threadAttachMutex; }
+
+private:
+    void shutdown();
+
+    RecursiveMutex m_threadAttachMutex;
+    ThreadStateSet m_threads;
+    OwnPtr<SafePointBarrier> m_safePointBarrier;
+    OwnPtr<FreePagePool> m_freePagePool;
+    OwnPtr<OrphanedPagePool> m_orphanedPagePool;
+};
+
 class PLATFORM_EXPORT ThreadState {
     WTF_MAKE_NONCOPYABLE(ThreadState);
 public:
     typedef std::pair<void*, PreFinalizerCallback> PreFinalizer;
 
     // See setGCState() for possible state transitions.
     enum GCState {
         NoGCScheduled,
         IdleGCScheduled,
         PreciseGCScheduled,
@@ skipping 36 matching lines @@
             m_state->m_sweepForbidden = false;
         }
     private:
         ThreadState* m_state;
     };
 
     // The set of ThreadStates for all threads attached to the Blink
     // garbage collector.
     using AttachedThreadStateSet = HashSet<ThreadState*>;
     static AttachedThreadStateSet& attachedThreads();
-    static RecursiveMutex& threadAttachMutex();
-    static void lockThreadAttachMutex();
-    static void unlockThreadAttachMutex();
 
     // Initialize threading infrastructure. Should be called from the main
     // thread.
     static void init();
     static void shutdown();
-    static void shutdownHeapIfNecessary();
     bool isTerminating() { return m_isTerminating; }
 
-    static void attachMainThread();
+    static void prepareForMainThread();
     static void detachMainThread();
 
-    // Trace all persistent roots, called when marking the managed heap objects.
-    static void visitPersistentRoots(Visitor*);
-
-    // Trace all objects found on the stack, used when doing conservative GCs.
-    static void visitStackRoots(Visitor*);
-
     // Associate ThreadState object with the current thread. After this
     // call thread can start using the garbage collected heap infrastructure.
     // It also has to periodically check for safepoints.
-    static void attach();
+    static void prepareForCurrentThread(bool prepareForCurrentThread = false);
 
     // Disassociate attached ThreadState from the current thread. The thread
     // can no longer use the garbage collected heap after this call.
     static void detach();
 
     static ThreadState* current()
     {
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
         // TLS lookup is fast in these platforms.
         return **s_threadSpecific;
@@ skipping 11 matching lines @@
         // TLS lookup is slow.
         return **s_threadSpecific;
 #endif
     }
 
     static ThreadState* mainThreadState()
     {
         return reinterpret_cast<ThreadState*>(s_mainThreadStateStorage);
     }
 
+    static ThreadState* forObject(const void*);
+
     bool isMainThread() const { return this == mainThreadState(); }
 #if ENABLE(ASSERT)
     bool checkThread() const { return m_thread == currentThread(); }
 #endif
 
+    bool perThreadHeapEnabled() const { return m_perThreadHeapEnabled; }
+
+    // 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.
+    void cleanupCallback();
+
     void performIdleGC(double deadlineSeconds);
     void performIdleLazySweep(double deadlineSeconds);
 
     void scheduleIdleGC();
     void scheduleIdleLazySweep();
     void schedulePreciseGC();
     void scheduleV8FollowupGCIfNeeded(BlinkGC::V8GCType);
     void schedulePageNavigationGCIfNeeded(float estimatedRemovalRatio);
     void schedulePageNavigationGC();
     void scheduleGCIfNeeded();
@@ skipping 71 matching lines @@
     // there is a GC in progress.
     //
     // Each thread that has ThreadState attached must:
     //   - periodically check if GC is requested from another thread by calling a safePoint() method;
     //   - use SafePointScope around long running loops that have no safePoint() invocation inside,
     //     such loops must not touch any heap object;
     //   - register an BlinkGCInterruptor that can interrupt long running loops that have no calls to safePoint and
     //     are not wrapped in a SafePointScope (e.g. BlinkGCInterruptor 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(BlinkGC::StackState);
 
     // Mark current thread as running inside safepoint.
     void enterSafePoint(BlinkGC::StackState, void*);
     void leaveSafePoint(SafePointAwareMutexLocker* = nullptr);
     bool isAtSafePoint() const { return m_atSafePoint; }
 
+    MultiThreadGCGroup* gcGroup() const { return m_gcGroup; }
+
     void addInterruptor(PassOwnPtr<BlinkGCInterruptor>);
     void removeInterruptor(BlinkGCInterruptor*);
 
     void recordStackEnd(intptr_t* endOfStack)
     {
         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
@@ skipping 163 matching lines @@
     void enterStaticReferenceRegistrationDisabledScope();
     void leaveStaticReferenceRegistrationDisabledScope();
 #endif
 
 private:
     enum SnapshotType {
         HeapSnapshot,
         FreelistSnapshot
     };
 
-    ThreadState();
+    ThreadState(bool perThreadHeapEnabled);
     ~ThreadState();
 
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
     {
         m_safePointStackCopy.clear();
         m_safePointScopeMarker = nullptr;
     }
 
     // shouldSchedule{Precise,Idle}GC and shouldForceConservativeGC
@@ skipping 33 matching lines @@
 
     void runScheduledGC(BlinkGC::StackState);
 
     void eagerSweep();
 
 #if defined(ADDRESS_SANITIZER)
     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.
-    void cleanup();
     void cleanupPages();
 
     void prepareForThreadStateTermination();
 
     void invokePreFinalizers();
 
     void takeSnapshot(SnapshotType);
     void clearHeapAges();
     int heapIndexOfVectorHeapLeastRecentlyExpanded(int beginHeapIndex, int endHeapIndex);
 
     // Should only be called under protection of threadAttachMutex().
     const Vector<OwnPtr<BlinkGCInterruptor>>& interruptors() const { return m_interruptors; }
 
     friend class SafePointAwareMutexLocker;
     friend class SafePointBarrier;
     friend class SafePointScope;
 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static uintptr_t s_mainThreadStackStart;
     static uintptr_t s_mainThreadUnderestimatedStackSize;
-    static SafePointBarrier* s_safePointBarrier;
 
     // 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<PersistentRegion> m_persistentRegion;
     BlinkGC::StackState m_stackState;
 #if OS(WIN) && COMPILER(MSVC)
     size_t m_threadStackSize;
 #endif
+    bool m_perThreadHeapEnabled;
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
 
     void* m_safePointScopeMarker;
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
     Vector<OwnPtr<BlinkGCInterruptor>> m_interruptors;
     bool m_sweepForbidden;
     size_t m_noAllocationCount;
     size_t m_gcForbiddenCount;
@@ skipping 13 matching lines @@
     CallbackStack* m_threadLocalWeakCallbackStack;
 
     // Pre-finalizers are called in the reverse order in which they are
     // registered by the constructors (including constructors of Mixin objects)
     // for an object, by processing the m_orderedPreFinalizers back-to-front.
     ListHashSet<PreFinalizer> m_orderedPreFinalizers;
 
     v8::Isolate* m_isolate;
     void (*m_traceDOMWrappers)(v8::Isolate*, Visitor*);
 
+    MultiThreadGCGroup* m_gcGroup;
+
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 
 #if defined(LEAK_SANITIZER)
     // PersistentNodes that are stored in static references;
     // references we have to clear before initiating LSan's leak detection.
     HashSet<PersistentNode*> m_staticPersistents;
 
     // Count that controls scoped disabling of persistent registration.
@@ skipping 22 matching lines @@
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h