Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/SafePoint.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/heap/SafePoint.h"
 
+#include "platform/heap/Heap.h"
 #include "wtf/Atomics.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 using PushAllRegistersCallback = void (*)(SafePointBarrier*, ThreadState*, intptr_t*);
 extern "C" void pushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback);
 
 static double lockingTimeout()
 {
     // Wait time for parking all threads is at most 100 ms.
     return 0.100;
 }
 
-SafePointBarrier::SafePointBarrier()
+SafePointBarrier::SafePointBarrier(Heap* heap)
     : m_canResume(1)
     , m_unparkedThreadCount(0)
+    , m_heap(heap)
 {
 }
 
 SafePointBarrier::~SafePointBarrier()
 {
 }
 
 bool SafePointBarrier::parkOthers()
 {
     ASSERT(ThreadState::current()->isAtSafePoint());
 
     ThreadState* current = ThreadState::current();
     // Lock threadAttachMutex() to prevent threads from attaching.
-    ThreadState::lockThreadAttachMutex();
-    ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
+    m_heap->lockThreadAttachMutex();
+    const ThreadStateSet& threads = m_heap->threads();

[haraken, 2016/02/29 11:17:45]

It would be better to move lockThreadAttachMutex(), threads() etc from Heap to
ThreadState. Then SafePointBarrier doesn't need to know the heap. You can just
use |current| here.

[keishi, 2016/03/02 06:01:03]

Done.

 
     MutexLocker locker(m_mutex);
     atomicAdd(&m_unparkedThreadCount, threads.size());
     releaseStore(&m_canResume, 0);
 
     for (ThreadState* state : threads) {
         if (state == current)
             continue;
 
         for (auto& interruptor : state->interruptors())
             interruptor->requestInterrupt();
     }
 
     while (acquireLoad(&m_unparkedThreadCount) > 0) {
         double expirationTime = currentTime() + lockingTimeout();
         if (!m_parked.timedWait(m_mutex, expirationTime)) {
             // One of the other threads did not return to a safepoint within the maximum
             // time we allow for threads to be parked. Abandon the GC and resume the
             // currently parked threads.
             resumeOthers(true);
             return false;
         }
     }
     return true;
 }
 
 void SafePointBarrier::resumeOthers(bool barrierLocked)
 {
-    ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
+    const ThreadStateSet& threads = m_heap->threads();
     atomicSubtract(&m_unparkedThreadCount, threads.size());
     releaseStore(&m_canResume, 1);
 
     if (UNLIKELY(barrierLocked)) {
         m_resume.broadcast();
     } else {
         // FIXME: Resumed threads will all contend for m_mutex just
         // to unlock it later which is a waste of resources.
         MutexLocker locker(m_mutex);
         m_resume.broadcast();
     }
 
-    ThreadState::unlockThreadAttachMutex();
+    m_heap->unlockThreadAttachMutex();
     ASSERT(ThreadState::current()->isAtSafePoint());
 }
 
 void SafePointBarrier::checkAndPark(ThreadState* state, SafePointAwareMutexLocker* locker)
 {
     ASSERT(!state->sweepForbidden());
     if (!acquireLoad(&m_canResume)) {
         // If we are leaving the safepoint from a SafePointAwareMutexLocker
         // call out to release the lock before going to sleep. This enables the
         // lock to be acquired in the sweep phase, e.g. during weak processing
@@ skipping 40 matching lines @@
     // If no other thread is waiting for other threads to park then
     // this counter can be negative: if N threads are at safe-points
     // the counter will be -N.
     if (!atomicDecrement(&m_unparkedThreadCount)) {
         MutexLocker locker(m_mutex);
         m_parked.signal(); // Safe point reached.
     }
 }
 
 } // namespace blink