Revert of Prepare for multiple ThreadHeaps

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 44 matching lines @@
 class BasePage;
 class CallbackStack;
 struct GCInfo;
 class GarbageCollectedMixinConstructorMarker;
 class HeapObjectHeader;
 class PersistentNode;
 class PersistentRegion;
 class BaseArena;
 class SafePointAwareMutexLocker;
 class SafePointBarrier;
-class ThreadHeap;
 class ThreadState;
 class Visitor;
 
 // 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
@@ skipping 87 matching lines @@
         }
         ~SweepForbiddenScope()
         {
             ASSERT(m_state->m_sweepForbidden);
             m_state->m_sweepForbidden = false;
         }
     private:
         ThreadState* m_state;
     };
 
-    void lockThreadAttachMutex();
-    void unlockThreadAttachMutex();
+    // 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();
     bool isTerminating() { return m_isTerminating; }
 
     static void attachMainThread();
     static void detachMainThread();
     void cleanupMainThread();
 
+    // 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 attachCurrentThread();
+    static void attach();
 
     // Disassociate attached ThreadState from the current thread. The thread
     // can no longer use the garbage collected heap after this call.
-    static void detachCurrentThread();
+    static void detach();
 
     static ThreadState* current()
     {
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
         // TLS lookup is fast in these platforms.
         return **s_threadSpecific;
 #else
         uintptr_t dummy;
         uintptr_t addressDiff = s_mainThreadStackStart - reinterpret_cast<uintptr_t>(&dummy);
         // This is a fast way to judge if we are in the main thread.
         // If |&dummy| is within |s_mainThreadUnderestimatedStackSize| byte from
         // 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* mainThreadState()
     {
         return reinterpret_cast<ThreadState*>(s_mainThreadStateStorage);
     }
 
-    static ThreadState* fromObject(const void*);
-
     bool isMainThread() const { return this == mainThreadState(); }
 #if ENABLE(ASSERT)
     bool checkThread() const { return m_thread == currentThread(); }
 #endif
 
-    ThreadHeap& heap() { return *m_heap; }
-
-    // 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 runTerminationGC();
-
     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; }
 
     void addInterruptor(PassOwnPtr<BlinkGCInterruptor>);
@@ skipping 175 matching lines @@
 #if defined(LEAK_SANITIZER)
     void enterStaticReferenceRegistrationDisabledScope();
     void leaveStaticReferenceRegistrationDisabledScope();
 #endif
 
     void resetHeapCounters();
     void increaseAllocatedObjectSize(size_t);
     void decreaseAllocatedObjectSize(size_t);
     void increaseMarkedObjectSize(size_t);
 
-    void callThreadShutdownHooks();
-
 private:
     enum SnapshotType {
         HeapSnapshot,
         FreelistSnapshot
     };
 
     ThreadState();
     ~ThreadState();
 
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
@@ skipping 40 matching lines @@
 
     void runScheduledGC(BlinkGC::StackState);
 
     void eagerSweep();
 
 #if defined(ADDRESS_SANITIZER)
     void poisonEagerArena();
     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 clearArenaAges();
     int arenaIndexOfVectorArenaLeastRecentlyExpanded(int beginArenaIndex, int endArenaIndex);
 
     void reportMemoryToV8();
 
     // 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[];
 
-    ThreadHeap* m_heap;
     ThreadIdentifier m_thread;
     OwnPtr<PersistentRegion> m_persistentRegion;
     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;
@@ skipping 70 matching lines @@
 
 template<> class ThreadStateFor<AnyThread> {
     STATIC_ONLY(ThreadStateFor);
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h