Remove ThreadHeap::m_threads

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

 /*
  * 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 128 matching lines @@
   atomicAdd(&m_allocatedSpace, static_cast<long>(delta));
   ProcessHeap::increaseTotalAllocatedSpace(delta);
 }
 
 void ThreadHeapStats::decreaseAllocatedSpace(size_t delta) {
   atomicSubtract(&m_allocatedSpace, static_cast<long>(delta));
   ProcessHeap::decreaseTotalAllocatedSpace(delta);
 }
 
 ThreadHeap::ThreadHeap()
-    : m_regionTree(WTF::makeUnique<RegionTree>()),
+    : m_threadState(nullptr),
+      m_regionTree(WTF::makeUnique<RegionTree>()),
       m_heapDoesNotContainCache(WTF::wrapUnique(new HeapDoesNotContainCache)),
       m_safePointBarrier(WTF::makeUnique<SafePointBarrier>()),
       m_freePagePool(WTF::wrapUnique(new PagePool)),
       m_markingStack(CallbackStack::create()),
       m_postMarkingCallbackStack(CallbackStack::create()),
       m_globalWeakCallbackStack(CallbackStack::create()),
       m_ephemeronStack(CallbackStack::create()) {
   if (ThreadState::current()->isMainThread())
     s_mainThreadHeap = this;
 
   MutexLocker locker(ThreadHeap::allHeapsMutex());
   allHeaps().insert(this);
 }
 
 ThreadHeap::~ThreadHeap() {
   MutexLocker locker(ThreadHeap::allHeapsMutex());
   allHeaps().remove(this);
 }
 
 RecursiveMutex& ThreadHeap::allHeapsMutex() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(RecursiveMutex, mutex, (new RecursiveMutex));
   return mutex;
 }
 
 HashSet<ThreadHeap*>& ThreadHeap::allHeaps() {
   DEFINE_STATIC_LOCAL(HashSet<ThreadHeap*>, heaps, ());
   return heaps;
 }
 
-void ThreadHeap::attach(ThreadState* thread) {
-  MutexLocker locker(m_threadAttachMutex);
-  m_threads.insert(thread);
+void ThreadHeap::attach(ThreadState* threadState) {
+  DCHECK(!m_threadState);
+  m_threadState = threadState;
 }
 
-void ThreadHeap::detach(ThreadState* thread) {
-  ASSERT(ThreadState::current() == thread);
-  bool isLastThread = false;
-  {
-    // Grab the threadAttachMutex to ensure only one thread can shutdown at
-    // a time and that no other thread can do a global GC. It also allows
-    // safe iteration of the m_threads set which happens as part of
-    // thread local GC asserts. We enter a safepoint while waiting for the
-    // lock to avoid a dead-lock where another thread has already requested
-    // GC.
-    MutexLocker locker(m_threadAttachMutex);
-    thread->runTerminationGC();
-    ASSERT(m_threads.contains(thread));
-    m_threads.remove(thread);
-    isLastThread = m_threads.isEmpty();
-  }
-  if (thread->isMainThread())
+void ThreadHeap::detach(ThreadState* threadState) {
+  DCHECK(ThreadState::current() == threadState);
+  DCHECK(m_threadState == threadState);
+  threadState->runTerminationGC();
+  if (threadState->isMainThread())
     DCHECK_EQ(heapStats().allocatedSpace(), 0u);
-  if (isLastThread)
-    delete this;
+  delete this;

[sof, 2017/02/15 08:26:32]

Would it work for |ThreadState::m_heap| to be a |std::unique_ptr<ThreadHeap>| ?
And it is a bit odd for detach() now to call methods on the ThreadState while
(also) shutting down -- runTerminationGC() could be a private method on
ThreadState afaict.

 }
 
 #if DCHECK_IS_ON()
 BasePage* ThreadHeap::findPageFromAddress(Address address) {
-  MutexLocker locker(m_threadAttachMutex);
-  for (ThreadState* state : m_threads) {
-    if (BasePage* page = state->findPageFromAddress(address))
-      return page;
-  }
-  return nullptr;
+  return m_threadState->findPageFromAddress(address);
 }
 
 bool ThreadHeap::isAtSafePoint() {
-  MutexLocker locker(m_threadAttachMutex);
-  for (ThreadState* state : m_threads) {
-    if (!state->isAtSafePoint())
-      return false;
-  }
-  return true;
+  return m_threadState->isAtSafePoint();
 }
 #endif
 
 Address ThreadHeap::checkAndMarkPointer(Visitor* visitor, Address address) {
   ASSERT(ThreadState::current()->isInGC());
 
 #if !DCHECK_IS_ON()
   if (m_heapDoesNotContainCache->lookup(address))
     return nullptr;
 #endif
@@ skipping 131 matching lines @@
 
 void ThreadHeap::decommitCallbackStacks() {
   m_markingStack->decommit();
   m_postMarkingCallbackStack->decommit();
   m_globalWeakCallbackStack->decommit();
   m_ephemeronStack->decommit();
 }
 
 void ThreadHeap::preGC() {
   ASSERT(!ThreadState::current()->isInGC());
-  for (ThreadState* state : m_threads)
-    state->preGC();
+  m_threadState->preGC();
 }
 
 void ThreadHeap::postGC(BlinkGC::GCType gcType) {
   ASSERT(ThreadState::current()->isInGC());
-  for (ThreadState* state : m_threads)
-    state->postGC(gcType);
+  m_threadState->postGC(gcType);
 }
 
 void ThreadHeap::preSweep(BlinkGC::GCType gcType) {
-  for (ThreadState* state : m_threads)
-    state->preSweep(gcType);
+  m_threadState->preSweep(gcType);
 }
 
 void ThreadHeap::processMarkingStack(Visitor* visitor) {
   // Ephemeron fixed point loop.
   do {
     {
       // Iteratively mark all objects that are reachable from the objects
       // currently pushed onto the marking stack.
       TRACE_EVENT0("blink_gc", "ThreadHeap::processMarkingStackSingleThreaded");
       while (popAndInvokeTraceCallback(visitor)) {
@@ skipping 131 matching lines @@
                  "ThreadHeap::partitionAllocSizeAtLastGCKB",
                  std::min(heap.heapStats().partitionAllocSizeAtLastGC() / 1024,
                           static_cast<size_t>(INT_MAX)));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"),
                  "Partitions::totalSizeOfCommittedPagesKB",
                  std::min(WTF::Partitions::totalSizeOfCommittedPages() / 1024,
                           static_cast<size_t>(INT_MAX)));
 }
 
 size_t ThreadHeap::objectPayloadSizeForTesting() {
-  // MEMO: is threadAttachMutex locked?
   size_t objectPayloadSize = 0;
-  for (ThreadState* state : m_threads) {
-    state->setGCState(ThreadState::GCRunning);
-    state->makeConsistentForGC();
-    objectPayloadSize += state->objectPayloadSizeForTesting();
-    state->setGCState(ThreadState::Sweeping);
-    state->setGCState(ThreadState::NoGCScheduled);
-  }
+  m_threadState->setGCState(ThreadState::GCRunning);
+  m_threadState->makeConsistentForGC();
+  objectPayloadSize += m_threadState->objectPayloadSizeForTesting();
+  m_threadState->setGCState(ThreadState::Sweeping);
+  m_threadState->setGCState(ThreadState::NoGCScheduled);
   return objectPayloadSize;
 }
 
 void ThreadHeap::visitPersistentRoots(Visitor* visitor) {
   ASSERT(ThreadState::current()->isInGC());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitPersistentRoots");
   ProcessHeap::crossThreadPersistentRegion().tracePersistentNodes(visitor);
 
-  for (ThreadState* state : m_threads)
-    state->visitPersistents(visitor);
+  m_threadState->visitPersistents(visitor);
 }
 
 void ThreadHeap::visitStackRoots(Visitor* visitor) {
   ASSERT(ThreadState::current()->isInGC());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitStackRoots");
-  for (ThreadState* state : m_threads)
-    state->visitStack(visitor);
+  m_threadState->visitStack(visitor);
 }
 
 void ThreadHeap::enterSafePoint(ThreadState* threadState) {
   m_safePointBarrier->enterSafePoint(threadState);
 }
 
 void ThreadHeap::leaveSafePoint() {
   m_safePointBarrier->leaveSafePoint();
 }
 
 BasePage* ThreadHeap::lookupPageForAddress(Address address) {
   ASSERT(ThreadState::current()->isInGC());
   if (PageMemoryRegion* region = m_regionTree->lookup(address)) {
     return region->pageFromAddress(address);
   }
   return nullptr;
 }
 
 void ThreadHeap::resetHeapCounters() {
   ASSERT(ThreadState::current()->isInGC());
 
   ThreadHeap::reportMemoryUsageForTracing();
 
   ProcessHeap::decreaseTotalAllocatedObjectSize(m_stats.allocatedObjectSize());
   ProcessHeap::decreaseTotalMarkedObjectSize(m_stats.markedObjectSize());
 
   m_stats.reset();
-  for (ThreadState* state : m_threads)
-    state->resetHeapCounters();
+  m_threadState->resetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::s_mainThreadHeap = nullptr;
 
 }  // namespace blink