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 "wtf/Atomics.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(MultiThreadGCGroup* gcGroup)
     : m_canResume(1)
     , m_unparkedThreadCount(0)
+    , m_gcGroup(gcGroup)
 {
 }
 
 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_gcGroup->lockThreadAttachMutex();
+    const HashSet<ThreadState*>& threads = m_gcGroup->threads();
 
     MutexLocker locker(m_mutex);
     atomicAdd(&m_unparkedThreadCount, threads.size());
     releaseStore(&m_canResume, 0);
 
     for (ThreadState* state : threads) {
-        if (state == current)
+        if (state->isAtSafePoint()) // MEMO: original code: if (state == current)

[haraken, 2016/01/28 15:52:50]

Why do you need to make this change?

This change may be correct but I don't want to touch the SafePoint's algorithm
as much as possible.

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

Done. Just thought it made more sense.

             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 HashSet<ThreadState*>& threads = m_gcGroup->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_gcGroup->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