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 37 matching lines @@
 
 namespace v8 {
 class Isolate;
 };
 
 namespace blink {
 
 class BasePage;
 class CallbackStack;
 class CrossThreadPersistentRegion;
+class FreePagePool;
 struct GCInfo;
 class GarbageCollectedMixinConstructorMarker;
+class HeapDoesNotContainCache;
 class HeapObjectHeader;
+class OrphanedPagePool;
 class PersistentRegion;
+class XThreadPersistentRegion;
 class BaseHeap;
 class SafePointAwareMutexLocker;
 class SafePointBarrier;
 class ThreadState;
 class Visitor;
+class PageMemoryRegion;
 
 // 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 41 matching lines @@
 #define WILL_BE_USING_PRE_FINALIZER(Class, method) USING_PRE_FINALIZER(Class, method)
 #else
 #define WILL_BE_USING_PRE_FINALIZER(Class, method)
 #endif
 
 class PLATFORM_EXPORT ThreadState {
     WTF_MAKE_NONCOPYABLE(ThreadState);
 public:
     typedef std::pair<void*, PreFinalizerCallback> PreFinalizer;
 
+    // A RegionTree is a simple binary search tree of PageMemoryRegions sorted
+    // by base addresses.
+    class RegionTree {
+    public:
+        explicit RegionTree(PageMemoryRegion* region) : m_region(region), m_left(nullptr), m_right(nullptr) { }
+        ~RegionTree()
+        {
+            delete m_left;
+            delete m_right;
+        }
+        PageMemoryRegion* lookup(Address);
+        static void add(RegionTree*, RegionTree**);
+        static void remove(PageMemoryRegion*, RegionTree**);
+    private:
+        PageMemoryRegion* m_region;
+        RegionTree* m_left;
+        RegionTree* m_right;
+    };
+
     // See setGCState() for possible state transitions.
     enum GCState {
         NoGCScheduled,
         IdleGCScheduled,
         PreciseGCScheduled,
         FullGCScheduled,
         PageNavigationGCScheduled,
         GCRunning,
         EagerSweepScheduled,
         LazySweepScheduled,
@@ skipping 80 matching lines @@
         // the stack start of the main thread, we judge that we are in
         // the main thread.
         if (LIKELY(addressDiff < s_mainThreadUnderestimatedStackSize)) {
             ASSERT(**s_threadSpecific == mainThreadState());
             return mainThreadState();
         }
         // TLS lookup is slow.
         return **s_threadSpecific;
 #endif
     }
+    static ThreadState* terminating()
+    {
+        // TLS lookup is fast in these platforms.
+        return **s_threadSpecificTerminating;
+    }
 
     static ThreadState* mainThreadState()
     {
         return reinterpret_cast<ThreadState*>(s_mainThreadStateStorage);
     }
 
+    CallbackStack* markingStack() const { return m_markingStack.get(); }
+    CallbackStack* postMarkingCallbackStack() const { return m_postMarkingCallbackStack.get(); }
+    CallbackStack* globalWeakCallbackStack() const { return m_globalWeakCallbackStack.get(); }
+    CallbackStack* ephemeronStack() const { return m_ephemeronStack.get(); }
+    FreePagePool* freePagePool() const { return m_freePagePool.get(); }
+    void setMarkedObjectSizeAtLastCompleteSweep(size_t size) { releaseStore(&m_markedObjectSizeAtLastCompleteSweep, size); }
+    size_t markedObjectSizeAtLastCompleteSweep() { return acquireLoad(&m_markedObjectSizeAtLastCompleteSweep); }
+    void increaseAllocatedObjectSize(size_t delta) { atomicAdd(&m_allocatedObjectSize, static_cast<long>(delta)); }
+    void decreaseAllocatedObjectSize(size_t delta) { atomicSubtract(&m_allocatedObjectSize, static_cast<long>(delta)); }
+    size_t allocatedObjectSize() { return acquireLoad(&m_allocatedObjectSize); }
+    void increaseMarkedObjectSize(size_t delta) { atomicAdd(&m_markedObjectSize, static_cast<long>(delta)); }
+    size_t markedObjectSize() { return acquireLoad(&m_markedObjectSize); }
+    void increaseAllocatedSpace(size_t delta) { atomicAdd(&m_allocatedSpace, static_cast<long>(delta)); }
+    void decreaseAllocatedSpace(size_t delta) { atomicSubtract(&m_allocatedSpace, static_cast<long>(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; }
+    void setShutdownCalled(bool shutdownCalled) { m_shutdownCalled = shutdownCalled; }
+    bool shutdownCalled() const { return m_shutdownCalled; }
+    HeapDoesNotContainCache* heapDoesNotContainCache() const { return m_heapDoesNotContainCache.get(); }
+    RegionTree* regionTree() const { return m_regionTree; }
+    void setRegionTree(RegionTree* tree) { m_regionTree = tree; }
+
+    double estimatedMarkingTime();
+    void reportMemoryUsageHistogram();
+    void reportMemoryUsageForTracing();
+
+#if ENABLE(ASSERT)
+    void incrementGcGeneration() {
+        if (++m_gcGeneration == 0)
+            m_gcGeneration = 1;
+    }
+    uint16_t gcGeneration() { return m_gcGeneration; }
+#endif
+
+    void flushHeapDoesNotContainCache();
+    OrphanedPagePool* orphanedPagePool() { return m_orphanedPagePool.get(); }
+
+    // Reset counters that track live and allocated-since-last-GC sizes.
+    void resetHeapCounters();
+
     bool isMainThread() const { return this == mainThreadState(); }
 #if ENABLE(ASSERT)
     bool checkThread() const { return m_thread == currentThread(); }
 #endif
 
     void performIdleGC(double deadlineSeconds);
     void performIdleLazySweep(double deadlineSeconds);
 
     void scheduleIdleGC();
     void scheduleIdleLazySweep();
@@ skipping 117 matching lines @@
 #if ENABLE(ASSERT)
     // 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
 
     // A region of PersistentNodes allocated on the given thread.
     PersistentRegion* persistentRegion() const { return m_persistentRegion.get(); }
+    XThreadPersistentRegion* xThreadPersistentRegion() const { return m_xThreadPersistentRegion.get(); }
     // A region of PersistentNodes not owned by any particular thread.
     static CrossThreadPersistentRegion& crossThreadPersistentRegion();
 
     // Visit local thread stack and trace all pointers conservatively.
     void visitStack(Visitor*);
 
     // Visit the asan fake stack frame corresponding to a slot on the
     // real machine stack if there is one.
     void visitAsanFakeStackForPointer(Visitor*, Address);
 
@@ skipping 122 matching lines @@
     }
     void allocationPointAdjusted(int heapIndex);
     void promptlyFreed(size_t gcInfoIndex);
 
     void accumulateSweepingTime(double time) { m_accumulatedSweepingTime += time; }
 
 #if OS(WIN) && COMPILER(MSVC)
     size_t threadStackSize();
 #endif
 
+    void setIsolated(bool isolated) { m_isolated = isolated; }
+    bool isolated() { return m_isolated; }
+
 private:
     enum SnapshotType {
         HeapSnapshot,
         FreelistSnapshot
     };
 
     ThreadState();
     ~ThreadState();
 
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
@@ skipping 66 matching lines @@
     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 WTF::ThreadSpecific<ThreadState*>* s_threadSpecificTerminating;
     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;
+    bool m_isolated;
     OwnPtr<PersistentRegion> m_persistentRegion;
+    OwnPtr<XThreadPersistentRegion> m_xThreadPersistentRegion;
     BlinkGC::StackState m_stackState;
 #if OS(WIN) && COMPILER(MSVC)
     size_t m_threadStackSize;
 #endif
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
 
     void* m_safePointScopeMarker;
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
@@ skipping 28 matching lines @@
     void* m_asanFakeStack;
 #endif
 
     // Ideally we want to allocate an array of size |gcInfoTableMax| but it will
     // waste memory. Thus we limit the array size to 2^8 and share one entry
     // with multiple types of vectors. This won't be an issue in practice,
     // since there will be less than 2^8 types of objects in common cases.
     static const int likelyToBePromptlyFreedArraySize = (1 << 8);
     static const int likelyToBePromptlyFreedArrayMask = likelyToBePromptlyFreedArraySize - 1;
     OwnPtr<int[]> m_likelyToBePromptlyFreed;
+
+    OwnPtr<CallbackStack> m_markingStack;
+    OwnPtr<CallbackStack> m_postMarkingCallbackStack;
+    OwnPtr<CallbackStack> m_globalWeakCallbackStack;
+    OwnPtr<CallbackStack> m_ephemeronStack;
+    OwnPtr<FreePagePool> m_freePagePool;
+    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;
+#if ENABLE(ASSERT)
+    uint16_t m_gcGeneration;
+#endif
+    OwnPtr<HeapDoesNotContainCache> m_heapDoesNotContainCache;
+    bool m_shutdownCalled;
+    OwnPtr<OrphanedPagePool> m_orphanedPagePool;
+    RegionTree* m_regionTree;
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
 template<> class ThreadStateFor<MainThreadOnly> {
 public:
     static ThreadState* state()
     {
         // This specialization must only be used from the main thread.
         ASSERT(ThreadState::current()->isMainThread());
         return ThreadState::mainThreadState();
     }
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h