Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/ThreadState.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 54 matching lines @@
 #endif
 
 #include <v8.h>
 
 namespace blink {
 
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = nullptr;
 uintptr_t ThreadState::s_mainThreadStackStart = 0;
 uintptr_t ThreadState::s_mainThreadUnderestimatedStackSize = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
-SafePointBarrier* ThreadState::s_safePointBarrier = nullptr;
-
-RecursiveMutex& ThreadState::threadAttachMutex()
-{
-    DEFINE_THREAD_SAFE_STATIC_LOCAL(RecursiveMutex, mutex, (new RecursiveMutex));
-    return mutex;
-}
 
 ThreadState::ThreadState()
     : m_thread(currentThread())
     , m_persistentRegion(adoptPtr(new PersistentRegion()))
 #if OS(WIN) && COMPILER(MSVC)
     , m_threadStackSize(0)
 #endif
     , m_startOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_safePointScopeMarker(nullptr)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_sweepForbidden(false)
     , m_noAllocationCount(0)
     , m_gcForbiddenCount(0)
     , m_accumulatedSweepingTime(0)
-    , m_vectorBackingHeapIndex(BlinkGC::Vector1HeapIndex)
+    , m_vectorBackingArenaIndex(BlinkGC::Vector1ArenaIndex)
     , m_currentHeapAges(0)
     , m_isTerminating(false)
     , m_gcMixinMarker(nullptr)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_gcState(NoGCScheduled)
     , m_isolate(nullptr)
     , m_traceDOMWrappers(nullptr)
 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
 #if defined(LEAK_SANITIZER)
     , m_disabledStaticPersistentsRegistration(0)
 #endif
     , m_allocatedObjectSize(0)
     , m_markedObjectSize(0)
     , m_reportedMemoryToV8(0)
 {
     ASSERT(checkThread());
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     if (isMainThread()) {
         s_mainThreadStackStart = reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
         size_t underestimatedStackSize = StackFrameDepth::getUnderestimatedStackSize();
         if (underestimatedStackSize > sizeof(void*))
             s_mainThreadUnderestimatedStackSize = underestimatedStackSize - sizeof(void*);
+        m_heap = new Heap();
+    } else {
+        m_heap = &ThreadState::mainThreadState()->heap();
     }
+    ASSERT(m_heap);
+    m_heap->attach(this);
 
-    for (int heapIndex = 0; heapIndex < BlinkGC::LargeObjectHeapIndex; heapIndex++)
-        m_heaps[heapIndex] = new NormalPageHeap(this, heapIndex);
-    m_heaps[BlinkGC::LargeObjectHeapIndex] = new LargeObjectHeap(this, BlinkGC::LargeObjectHeapIndex);
+    for (int arenaIndex = 0; arenaIndex < BlinkGC::LargeObjectArenaIndex; arenaIndex++)
+        m_arenas[arenaIndex] = new NormalPageArena(this, arenaIndex);
+    m_arenas[BlinkGC::LargeObjectArenaIndex] = new LargeObjectArena(this, BlinkGC::LargeObjectArenaIndex);
 
     m_likelyToBePromptlyFreed = adoptArrayPtr(new int[likelyToBePromptlyFreedArraySize]);
     clearHeapAges();
 
     m_threadLocalWeakCallbackStack = new CallbackStack();
 }
 
 ThreadState::~ThreadState()
 {
     ASSERT(checkThread());
     delete m_threadLocalWeakCallbackStack;
     m_threadLocalWeakCallbackStack = nullptr;
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        delete m_heaps[i];
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        delete m_arenas[i];
 
     **s_threadSpecific = nullptr;
     if (isMainThread()) {
         s_mainThreadStackStart = 0;
         s_mainThreadUnderestimatedStackSize = 0;
     }
 }
 
 void ThreadState::init()
 {
     s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
-    s_safePointBarrier = new SafePointBarrier;
 }
 
 void ThreadState::shutdown()
 {
-    delete s_safePointBarrier;
-    s_safePointBarrier = nullptr;
-
     // Thread-local storage shouldn't be disposed, so we don't call ~ThreadSpecific().
 }
 
 #if OS(WIN) && COMPILER(MSVC)
 size_t ThreadState::threadStackSize()
 {
     if (m_threadStackSize)
         return m_threadStackSize;
 
     // Notice that we cannot use the TIB's StackLimit for the stack end, as it
@@ skipping 21 matching lines @@
     // explains the details.
     RELEASE_ASSERT(m_threadStackSize > 4 * 0x1000);
     m_threadStackSize -= 4 * 0x1000;
     return m_threadStackSize;
 }
 #endif
 
 void ThreadState::attachMainThread()
 {
     RELEASE_ASSERT(!Heap::s_shutdownCalled);
-    MutexLocker locker(threadAttachMutex());
-    ThreadState* state = new(s_mainThreadStateStorage) ThreadState();
-    attachedThreads().add(state);
+    new(s_mainThreadStateStorage) ThreadState();
+}
+
+void ThreadState::attach()
+{
+    RELEASE_ASSERT(!Heap::s_shutdownCalled);
+    new ThreadState();
+}
+
+void ThreadState::cleanupPages()
+{
+    ASSERT(checkThread());
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->cleanupPages();
+}
+
+void ThreadState::cleanup()

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

cleanup => runThreadTerminationGC

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

Done.

+{
+    if (isMainThread()) {
+        cleanupPages();
+        return;
+    }
+    ASSERT(checkThread());
+
+    // 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 attachedThreads 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.
+    // MEMO: move comment
+
+    // Finish sweeping.
+    completeSweep();
+
+    // From here on ignore all conservatively discovered
+    // pointers into the heap owned by this thread.
+    m_isTerminating = true;
+
+    // Set the terminate flag on all heap pages of this thread. This is used to
+    // ensure we don't trace pages on other threads that are not part of the
+    // thread local GC.
+    prepareForThreadStateTermination();
+
+    Heap::crossThreadPersistentRegion().prepareForThreadStateTermination(this);
+
+    // Do thread local GC's as long as the count of thread local Persistents
+    // changes and is above zero.
+    int oldCount = -1;
+    int currentCount = persistentRegion()->numberOfPersistents();
+    ASSERT(currentCount >= 0);
+    while (currentCount != oldCount) {
+        Heap::collectGarbageForTerminatingThread(this);
+        oldCount = currentCount;
+        currentCount = persistentRegion()->numberOfPersistents();
+    }
+    // We should not have any persistents left when getting to this point,
+    // if we have it is probably a bug so adding a debug ASSERT to catch this.
+    ASSERT(!currentCount);
+    // All of pre-finalizers should be consumed.
+    ASSERT(m_orderedPreFinalizers.isEmpty());
+    RELEASE_ASSERT(gcState() == NoGCScheduled);
+
+    // Add pages to the orphaned page pool to ensure any global GCs from this point
+    // on will not trace objects on this thread's heaps.
+    cleanupPages();
 }
 
 void ThreadState::detachMainThread()
 {
     // Enter a safe point before trying to acquire threadAttachMutex
     // to avoid dead lock if another thread is preparing for GC, has acquired
     // threadAttachMutex and waiting for other threads to pause or reach a
     // safepoint.
     ThreadState* state = mainThreadState();
 
     // 1. Finish sweeping.
     state->completeSweep();
-    {
-        SafePointAwareMutexLocker locker(threadAttachMutex(), BlinkGC::NoHeapPointersOnStack);
-
-        // 2. Add the main thread's heap pages to the orphaned pool.
-        state->cleanupPages();
-
-        // 3. Detach the main thread.
-        ASSERT(attachedThreads().contains(state));
-        attachedThreads().remove(state);
-        state->~ThreadState();
-    }
-    shutdownHeapIfNecessary();
+    state->detach();
 }
 
-void ThreadState::shutdownHeapIfNecessary()
+void ThreadState::detachCurrentThread()
 {
-    // We don't need to enter a safe point before acquiring threadAttachMutex
-    // because this thread is already detached.
-
-    MutexLocker locker(threadAttachMutex());
-    // We start shutting down the heap if there is no running thread
-    // and Heap::shutdown() is already called.
-    if (!attachedThreads().size() && Heap::s_shutdownCalled)
-        Heap::doShutdown();
-}
-
-void ThreadState::attach()
-{
-    RELEASE_ASSERT(!Heap::s_shutdownCalled);
-    MutexLocker locker(threadAttachMutex());
-    ThreadState* state = new ThreadState();
-    attachedThreads().add(state);
-}
-
-void ThreadState::cleanupPages()
-{
-    ASSERT(checkThread());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->cleanupPages();
-}
-
-void ThreadState::cleanup()
-{
-    ASSERT(checkThread());
-    {
-        // 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 attachedThreads 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.
-        SafePointAwareMutexLocker locker(threadAttachMutex(), BlinkGC::NoHeapPointersOnStack);
-
-        // Finish sweeping.
-        completeSweep();
-
-        // From here on ignore all conservatively discovered
-        // pointers into the heap owned by this thread.
-        m_isTerminating = true;
-
-        // Set the terminate flag on all heap pages of this thread. This is used to
-        // ensure we don't trace pages on other threads that are not part of the
-        // thread local GC.
-        prepareForThreadStateTermination();
-
-        Heap::crossThreadPersistentRegion().prepareForThreadStateTermination(this);
-
-        // Do thread local GC's as long as the count of thread local Persistents
-        // changes and is above zero.
-        int oldCount = -1;
-        int currentCount = persistentRegion()->numberOfPersistents();
-        ASSERT(currentCount >= 0);
-        while (currentCount != oldCount) {
-            Heap::collectGarbageForTerminatingThread(this);
-            oldCount = currentCount;
-            currentCount = persistentRegion()->numberOfPersistents();
-        }
-        // We should not have any persistents left when getting to this point,
-        // if we have it is probably a bug so adding a debug ASSERT to catch this.
-        ASSERT(!currentCount);
-        // All of pre-finalizers should be consumed.
-        ASSERT(m_orderedPreFinalizers.isEmpty());
-        RELEASE_ASSERT(gcState() == NoGCScheduled);
-
-        // Add pages to the orphaned page pool to ensure any global GCs from this point
-        // on will not trace objects on this thread's heaps.
-        cleanupPages();
-
-        ASSERT(attachedThreads().contains(this));
-        attachedThreads().remove(this);
-    }
+    current()->detach();
 }
 
 void ThreadState::detach()
 {
-    ThreadState* state = current();
-    state->cleanup();
-    RELEASE_ASSERT(state->gcState() == ThreadState::NoGCScheduled);
-    delete state;
-    shutdownHeapIfNecessary();
-}
-
-void ThreadState::visitPersistentRoots(Visitor* visitor)
-{
-    TRACE_EVENT0("blink_gc", "ThreadState::visitPersistentRoots");
-    Heap::crossThreadPersistentRegion().tracePersistentNodes(visitor);
-
-    for (ThreadState* state : attachedThreads())
-        state->visitPersistents(visitor);
-}
-
-void ThreadState::visitStackRoots(Visitor* visitor)
-{
-    TRACE_EVENT0("blink_gc", "ThreadState::visitStackRoots");
-    for (ThreadState* state : attachedThreads())
-        state->visitStack(visitor);
+    m_heap->detach(this);
+    RELEASE_ASSERT(gcState() == ThreadState::NoGCScheduled);
+    if (isMainThread())
+        this->~ThreadState();

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

Is this different from 'delete this'?

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

mainThreadState is stored in s_mainThreadStateStorage so it shouldn't be
deleted.

+    else
+        delete this;
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr)
 {
 #if defined(ADDRESS_SANITIZER)
     Address* start = reinterpret_cast<Address*>(m_startOfStack);
     Address* end = reinterpret_cast<Address*>(m_endOfStack);
     Address* fakeFrameStart = nullptr;
     Address* fakeFrameEnd = nullptr;
     Address* maybeFakeFrame = reinterpret_cast<Address*>(ptr);
     Address* realFrameForFakeFrame =
         reinterpret_cast<Address*>(
             __asan_addr_is_in_fake_stack(
                 m_asanFakeStack, maybeFakeFrame,
                 reinterpret_cast<void**>(&fakeFrameStart),
                 reinterpret_cast<void**>(&fakeFrameEnd)));
     if (realFrameForFakeFrame) {
         // This is a fake frame from the asan fake stack.
         if (realFrameForFakeFrame > end && start > realFrameForFakeFrame) {
             // The real stack address for the asan fake frame is
             // within the stack range that we need to scan so we need
             // to visit the values in the fake frame.
             for (Address* p = fakeFrameStart; p < fakeFrameEnd; ++p)
-                Heap::checkAndMarkPointer(visitor, *p);
+                m_heap->checkAndMarkPointer(visitor, *p);
         }
     }
 #endif
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitStack(Visitor* visitor)
 {
     if (m_stackState == BlinkGC::NoHeapPointersOnStack)
         return;
@@ skipping 15 matching lines @@
     for (; current < start; ++current) {
         Address ptr = *current;
 #if defined(MEMORY_SANITIZER)
         // |ptr| may be uninitialized by design. Mark it as initialized to keep
         // MSan from complaining.
         // Note: it may be tempting to get rid of |ptr| and simply use |current|
         // here, but that would be incorrect. We intentionally use a local
         // variable because we don't want to unpoison the original stack.
         __msan_unpoison(&ptr, sizeof(ptr));
 #endif
-        Heap::checkAndMarkPointer(visitor, ptr);
+        m_heap->checkAndMarkPointer(visitor, ptr);
         visitAsanFakeStackForPointer(visitor, ptr);
     }
 
     for (Address ptr : m_safePointStackCopy) {
 #if defined(MEMORY_SANITIZER)
         // See the comment above.
         __msan_unpoison(&ptr, sizeof(ptr));
 #endif
-        Heap::checkAndMarkPointer(visitor, ptr);
+        m_heap->checkAndMarkPointer(visitor, ptr);
         visitAsanFakeStackForPointer(visitor, ptr);
     }
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     m_persistentRegion->tracePersistentNodes(visitor);
     if (m_traceDOMWrappers) {
         TRACE_EVENT0("blink_gc", "V8GCController::traceDOMWrappers");
         m_traceDOMWrappers(m_isolate, visitor);
@@ skipping 80 matching lines @@
 
     if (isMainThread()) {
         double timeForThreadLocalWeakProcessing = WTF::currentTimeMS() - startTime;
         DEFINE_STATIC_LOCAL(CustomCountHistogram, timeForWeakHistogram, ("BlinkGC.timeForThreadLocalWeakProcessing", 1, 10 * 1000, 50));
         timeForWeakHistogram.count(timeForThreadLocalWeakProcessing);
     }
 }
 
 size_t ThreadState::totalMemorySize()
 {
-    return Heap::allocatedObjectSize() + Heap::markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
+    return m_heap->heapStats().allocatedObjectSize() + m_heap->heapStats().markedObjectSize() + WTF::Partitions::totalSizeOfCommittedPages();
 }
 
 size_t ThreadState::estimatedLiveSize(size_t estimationBaseSize, size_t sizeAtLastGC)
 {
-    if (Heap::wrapperCountAtLastGC() == 0) {
+    if (m_heap->heapStats().wrapperCountAtLastGC() == 0) {
         // We'll reach here only before hitting the first GC.
         return 0;
     }
 
     // (estimated size) = (estimation base size) - (heap size at the last GC) / (# of persistent handles at the last GC) * (# of persistent handles collected since the last GC);
-    size_t sizeRetainedByCollectedPersistents = static_cast<size_t>(1.0 * sizeAtLastGC / Heap::wrapperCountAtLastGC() * Heap::collectedWrapperCount());
+    size_t sizeRetainedByCollectedPersistents = static_cast<size_t>(1.0 * sizeAtLastGC / m_heap->heapStats().wrapperCountAtLastGC() * m_heap->heapStats().collectedWrapperCount());
     if (estimationBaseSize < sizeRetainedByCollectedPersistents)
         return 0;
     return estimationBaseSize - sizeRetainedByCollectedPersistents;
 }
 
 double ThreadState::heapGrowingRate()
 {
-    size_t currentSize = Heap::allocatedObjectSize() + Heap::markedObjectSize();
-    size_t estimatedSize = estimatedLiveSize(Heap::markedObjectSizeAtLastCompleteSweep(), Heap::markedObjectSizeAtLastCompleteSweep());
+    size_t currentSize = m_heap->heapStats().allocatedObjectSize() + m_heap->heapStats().markedObjectSize();
+    size_t estimatedSize = estimatedLiveSize(m_heap->heapStats().markedObjectSizeAtLastCompleteSweep(), m_heap->heapStats().markedObjectSizeAtLastCompleteSweep());
 
     // If the estimatedSize is 0, we set a high growing rate to trigger a GC.
     double growingRate = estimatedSize > 0 ? 1.0 * currentSize / estimatedSize : 100;
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "ThreadState::heapEstimatedSizeKB", std::min(estimatedSize / 1024, static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "ThreadState::heapGrowingRate", static_cast<int>(100 * growingRate));
     return growingRate;
 }
 
 double ThreadState::partitionAllocGrowingRate()
 {
     size_t currentSize = WTF::Partitions::totalSizeOfCommittedPages();
-    size_t estimatedSize = estimatedLiveSize(currentSize, Heap::partitionAllocSizeAtLastGC());
+    size_t estimatedSize = estimatedLiveSize(currentSize, m_heap->heapStats().partitionAllocSizeAtLastGC());
 
     // If the estimatedSize is 0, we set a high growing rate to trigger a GC.
     double growingRate = estimatedSize > 0 ? 1.0 * currentSize / estimatedSize : 100;
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "ThreadState::partitionAllocEstimatedSizeKB", std::min(estimatedSize / 1024, static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "ThreadState::partitionAllocGrowingRate", static_cast<int>(100 * growingRate));
     return growingRate;
 }
 
 // TODO(haraken): We should improve the GC heuristics. The heuristics affect
 // performance significantly.
 bool ThreadState::judgeGCThreshold(size_t totalMemorySizeThreshold, double heapGrowingRateThreshold)
 {
     // If the allocated object size or the total memory size is small, don't trigger a GC.
-    if (Heap::allocatedObjectSize() < 100 * 1024 || totalMemorySize() < totalMemorySizeThreshold)
+    if (m_heap->heapStats().allocatedObjectSize() < 100 * 1024 || totalMemorySize() < totalMemorySizeThreshold)
         return false;
     // If the growing rate of Oilpan's heap or PartitionAlloc is high enough,
     // trigger a GC.
 #if PRINT_HEAP_STATS
     dataLogF("heapGrowingRate=%.1lf, partitionAllocGrowingRate=%.1lf\n", heapGrowingRate(), partitionAllocGrowingRate());
 #endif
     return heapGrowingRate() >= heapGrowingRateThreshold || partitionAllocGrowingRate() >= heapGrowingRateThreshold;
 }
 
 bool ThreadState::shouldScheduleIdleGC()
@@ skipping 162 matching lines @@
     }
     if (shouldScheduleIdleGC()) {
 #if PRINT_HEAP_STATS
         dataLogF("Scheduled IdleGC\n");
 #endif
         scheduleIdleGC();
         return;
     }
 }
 
+ThreadState* ThreadState::fromObject(const void* object)
+{
+    if (!object)
+        return nullptr;
+    BasePage* page = pageFromObject(object);
+    ASSERT(page);
+    ASSERT(page->arena());
+    return page->arena()->threadState();
+}
+
 void ThreadState::performIdleGC(double deadlineSeconds)
 {
     ASSERT(checkThread());
     ASSERT(isMainThread());
     ASSERT(Platform::current()->currentThread()->scheduler());
 
     if (gcState() != IdleGCScheduled)
         return;
 
     double idleDeltaInSeconds = deadlineSeconds - monotonicallyIncreasingTime();
-    TRACE_EVENT2("blink_gc", "ThreadState::performIdleGC", "idleDeltaInSeconds", idleDeltaInSeconds, "estimatedMarkingTime", Heap::estimatedMarkingTime());
-    if (idleDeltaInSeconds <= Heap::estimatedMarkingTime() && !Platform::current()->currentThread()->scheduler()->canExceedIdleDeadlineIfRequired()) {
+    TRACE_EVENT2("blink_gc", "ThreadState::performIdleGC", "idleDeltaInSeconds", idleDeltaInSeconds, "estimatedMarkingTime", m_heap->heapStats().estimatedMarkingTime());
+    if (idleDeltaInSeconds <= m_heap->heapStats().estimatedMarkingTime() && !Platform::current()->currentThread()->scheduler()->canExceedIdleDeadlineIfRequired()) {
         // If marking is estimated to take longer than the deadline and we can't
         // exceed the deadline, then reschedule for the next idle period.
         scheduleIdleGC();
         return;
     }
 
     Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep, BlinkGC::IdleGC);
 }
 
 void ThreadState::performIdleLazySweep(double deadlineSeconds)
@@ skipping 12 matching lines @@
         return;
 
     TRACE_EVENT1("blink_gc,devtools.timeline", "ThreadState::performIdleLazySweep", "idleDeltaInSeconds", deadlineSeconds - monotonicallyIncreasingTime());
 
     bool sweepCompleted = true;
     SweepForbiddenScope scope(this);
     {
         double startTime = WTF::currentTimeMS();
         ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
-        for (int i = 0; i < BlinkGC::NumberOfHeaps; i++) {
+        for (int i = 0; i < BlinkGC::NumberOfArenas; i++) {
             // lazySweepWithDeadline() won't check the deadline until it sweeps
             // 10 pages. So we give a small slack for safety.
             double slack = 0.001;
             double remainingBudget = deadlineSeconds - slack - monotonicallyIncreasingTime();
-            if (remainingBudget <= 0 || !m_heaps[i]->lazySweepWithDeadline(deadlineSeconds)) {
+            if (remainingBudget <= 0 || !m_arenas[i]->lazySweepWithDeadline(deadlineSeconds)) {
                 // We couldn't finish the sweeping within the deadline.
                 // We request another idle task for the remaining sweeping.
                 scheduleIdleLazySweep();
                 sweepCompleted = false;
                 break;
             }
         }
 
         accumulateSweepingTime(WTF::currentTimeMS() - startTime);
     }
@@ skipping 143 matching lines @@
         // Idle time GC will be scheduled by Blink Scheduler.
         break;
     default:
         break;
     }
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded()
 {
     if (m_shouldFlushHeapDoesNotContainCache) {
-        Heap::flushHeapDoesNotContainCache();
+        m_heap->flushHeapDoesNotContainCache();
         m_shouldFlushHeapDoesNotContainCache = false;
     }
 }
 
 void ThreadState::makeConsistentForGC()
 {
     ASSERT(isInGC());
     TRACE_EVENT0("blink_gc", "ThreadState::makeConsistentForGC");
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->makeConsistentForGC();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->makeConsistentForGC();
 }
 
 void ThreadState::makeConsistentForMutator()
 {
     ASSERT(isInGC());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->makeConsistentForMutator();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->makeConsistentForMutator();
 }
 
 void ThreadState::preGC()
 {
     ASSERT(!isInGC());
     setGCState(GCRunning);
     makeConsistentForGC();
     flushHeapDoesNotContainCacheIfNeeded();
     clearHeapAges();
 }
 
 void ThreadState::postGC(BlinkGC::GCType gcType)
 {
     ASSERT(isInGC());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
-        m_heaps[i]->prepareForSweep();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
+        m_arenas[i]->prepareForSweep();
 
     if (gcType == BlinkGC::GCWithSweep) {
         setGCState(EagerSweepScheduled);
     } else if (gcType == BlinkGC::GCWithoutSweep) {
         setGCState(LazySweepScheduled);
     } else {
         takeSnapshot(SnapshotType::HeapSnapshot);
 
         // This unmarks all marked objects and marks all unmarked objects dead.
         makeConsistentForMutator();
@@ skipping 44 matching lines @@
 }
 
 #if defined(ADDRESS_SANITIZER)
 void ThreadState::poisonAllHeaps()
 {
     // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
     // Unpoison the live objects remaining in the eager heaps..
     poisonEagerHeap(BlinkGC::ClearPoison);
     // ..along with poisoning all unmarked objects in the other heaps.
-    for (int i = 1; i < BlinkGC::NumberOfHeaps; i++)
-        m_heaps[i]->poisonHeap(BlinkGC::UnmarkedOnly, BlinkGC::SetPoison);
+    for (int i = 1; i < BlinkGC::NumberOfArenas; i++)
+        m_arenas[i]->poisonHeap(BlinkGC::UnmarkedOnly, BlinkGC::SetPoison);
 #endif
 }
 
 void ThreadState::poisonEagerHeap(BlinkGC::Poisoning poisoning)
 {
     // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
-    m_heaps[BlinkGC::EagerSweepHeapIndex]->poisonHeap(BlinkGC::MarkedAndUnmarked, poisoning);
+    m_arenas[BlinkGC::EagerSweepArenaIndex]->poisonHeap(BlinkGC::MarkedAndUnmarked, poisoning);
 #endif
 }
 #endif
 
 void ThreadState::eagerSweep()
 {
     ASSERT(checkThread());
     // Some objects need to be finalized promptly and cannot be handled
     // by lazy sweeping. Keep those in a designated heap and sweep it
     // eagerly.
     ASSERT(isSweepingInProgress());
 
     // Mirroring the completeSweep() condition; see its comment.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
     double startTime = WTF::currentTimeMS();
-    m_heaps[BlinkGC::EagerSweepHeapIndex]->completeSweep();
+    m_arenas[BlinkGC::EagerSweepArenaIndex]->completeSweep();
     accumulateSweepingTime(WTF::currentTimeMS() - startTime);
 }
 
 void ThreadState::completeSweep()
 {
     ASSERT(checkThread());
     // If we are not in a sweeping phase, there is nothing to do here.
     if (!isSweepingInProgress())
         return;
 
     // completeSweep() can be called recursively if finalizers can allocate
     // memory and the allocation triggers completeSweep(). This check prevents
     // the sweeping from being executed recursively.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     {
         ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
         TRACE_EVENT0("blink_gc,devtools.timeline", "ThreadState::completeSweep");
         double startTime = WTF::currentTimeMS();
 
-        static_assert(BlinkGC::EagerSweepHeapIndex == 0, "Eagerly swept heaps must be processed first.");
-        for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
-            m_heaps[i]->completeSweep();
+        static_assert(BlinkGC::EagerSweepArenaIndex == 0, "Eagerly swept heaps must be processed first.");
+        for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
+            m_arenas[i]->completeSweep();
 
         double timeForCompleteSweep = WTF::currentTimeMS() - startTime;
         accumulateSweepingTime(timeForCompleteSweep);
 
         if (isMainThread()) {
             DEFINE_STATIC_LOCAL(CustomCountHistogram, completeSweepHistogram, ("BlinkGC.CompleteSweep", 1, 10 * 1000, 50));
             completeSweepHistogram.count(timeForCompleteSweep);
         }
     }
 
     postSweep();
 }
 
 void ThreadState::postSweep()
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
     if (isMainThread()) {
         double collectionRate = 0;
-        if (Heap::objectSizeAtLastGC() > 0)
-            collectionRate = 1 - 1.0 * Heap::markedObjectSize() / Heap::objectSizeAtLastGC();
+        if (m_heap->heapStats().objectSizeAtLastGC() > 0)
+            collectionRate = 1 - 1.0 * m_heap->heapStats().markedObjectSize() / m_heap->heapStats().objectSizeAtLastGC();
         TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "ThreadState::collectionRate", static_cast<int>(100 * collectionRate));
 
 #if PRINT_HEAP_STATS
         dataLogF("ThreadState::postSweep (collectionRate=%d%%)\n", static_cast<int>(100 * collectionRate));
 #endif
 
         // Heap::markedObjectSize() may be underestimated here if any other
         // thread has not yet finished lazy sweeping.
-        Heap::setMarkedObjectSizeAtLastCompleteSweep(Heap::markedObjectSize());
+        m_heap->heapStats().setMarkedObjectSizeAtLastCompleteSweep(m_heap->heapStats().markedObjectSize());
 
         DEFINE_STATIC_LOCAL(CustomCountHistogram, objectSizeBeforeGCHistogram, ("BlinkGC.ObjectSizeBeforeGC", 1, 4 * 1024 * 1024, 50));
-        objectSizeBeforeGCHistogram.count(Heap::objectSizeAtLastGC() / 1024);
+        objectSizeBeforeGCHistogram.count(m_heap->heapStats().objectSizeAtLastGC() / 1024);
         DEFINE_STATIC_LOCAL(CustomCountHistogram, objectSizeAfterGCHistogram, ("BlinkGC.ObjectSizeAfterGC", 1, 4 * 1024 * 1024, 50));
-        objectSizeAfterGCHistogram.count(Heap::markedObjectSize() / 1024);
+        objectSizeAfterGCHistogram.count(m_heap->heapStats().markedObjectSize() / 1024);
         DEFINE_STATIC_LOCAL(CustomCountHistogram, collectionRateHistogram, ("BlinkGC.CollectionRate", 1, 100, 20));
         collectionRateHistogram.count(static_cast<int>(100 * collectionRate));
         DEFINE_STATIC_LOCAL(CustomCountHistogram, timeForSweepHistogram, ("BlinkGC.TimeForSweepingAllObjects", 1, 10 * 1000, 50));
         timeForSweepHistogram.count(m_accumulatedSweepingTime);
     }
 
     switch (gcState()) {
     case Sweeping:
         setGCState(NoGCScheduled);
         break;
     case SweepingAndPreciseGCScheduled:
         setGCState(PreciseGCScheduled);
         break;
     case SweepingAndIdleGCScheduled:
         setGCState(NoGCScheduled);
         scheduleIdleGC();
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 void ThreadState::prepareForThreadStateTermination()
 {
     ASSERT(checkThread());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->prepareHeapForTermination();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->prepareHeapForTermination();
 }
 
 #if ENABLE(ASSERT)
 BasePage* ThreadState::findPageFromAddress(Address address)
 {
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i) {
-        if (BasePage* page = m_heaps[i]->findPageFromAddress(address))
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i) {
+        if (BasePage* page = m_arenas[i]->findPageFromAddress(address))
             return page;
     }
     return nullptr;
 }
 #endif
 
 size_t ThreadState::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        objectPayloadSize += m_heaps[i]->objectPayloadSizeForTesting();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        objectPayloadSize += m_arenas[i]->objectPayloadSizeForTesting();
     return objectPayloadSize;
 }
 
-bool ThreadState::stopThreads()
-{
-    return s_safePointBarrier->parkOthers();
-}
-
-void ThreadState::resumeThreads()
-{
-    s_safePointBarrier->resumeOthers();
-}
-
 void ThreadState::safePoint(BlinkGC::StackState stackState)
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
     runScheduledGC(stackState);
     ASSERT(!m_atSafePoint);
     m_stackState = stackState;
     m_atSafePoint = true;
-    s_safePointBarrier->checkAndPark(this);
+    m_heap->checkAndPark(this, nullptr);
     m_atSafePoint = false;
     m_stackState = BlinkGC::HeapPointersOnStack;
     preSweep();
 }
 
 #ifdef ADDRESS_SANITIZER
 // When we are running under AddressSanitizer with detect_stack_use_after_return=1
 // then stack marker obtained from SafePointScope will point into a fake stack.
 // Detect this case by checking if it falls in between current stack frame
 // and stack start and use an arbitrary high enough value for it.
@@ skipping 23 matching lines @@
 #ifdef ADDRESS_SANITIZER
     if (stackState == BlinkGC::HeapPointersOnStack)
         scopeMarker = adjustScopeMarkerForAdressSanitizer(scopeMarker);
 #endif
     ASSERT(stackState == BlinkGC::NoHeapPointersOnStack || scopeMarker);
     runScheduledGC(stackState);
     ASSERT(!m_atSafePoint);
     m_atSafePoint = true;
     m_stackState = stackState;
     m_safePointScopeMarker = scopeMarker;
-    s_safePointBarrier->enterSafePoint(this);
+    m_heap->enterSafePoint(this);
 }
 
 void ThreadState::leaveSafePoint(SafePointAwareMutexLocker* locker)
 {
     ASSERT(checkThread());
     ASSERT(m_atSafePoint);
-    s_safePointBarrier->leaveSafePoint(this, locker);
+    m_heap->leaveSafePoint(this, locker);
     m_atSafePoint = false;
     m_stackState = BlinkGC::HeapPointersOnStack;
     clearSafePointScopeMarker();
     preSweep();
 }
 
 void ThreadState::reportMemoryToV8()
 {
     if (!m_isolate)
         return;
 
     size_t currentHeapSize = m_allocatedObjectSize + m_markedObjectSize;
     int64_t diff = static_cast<int64_t>(currentHeapSize) - static_cast<int64_t>(m_reportedMemoryToV8);
     m_isolate->AdjustAmountOfExternalAllocatedMemory(diff);
     m_reportedMemoryToV8 = currentHeapSize;
 }
 
 void ThreadState::resetHeapCounters()
 {
     m_allocatedObjectSize = 0;
     m_markedObjectSize = 0;
 }
 
 void ThreadState::increaseAllocatedObjectSize(size_t delta)
 {
     m_allocatedObjectSize += delta;
-    Heap::increaseAllocatedObjectSize(delta);
+    m_heap->heapStats().increaseAllocatedObjectSize(delta);
 }
 
 void ThreadState::decreaseAllocatedObjectSize(size_t delta)
 {
     m_allocatedObjectSize -= delta;
-    Heap::decreaseAllocatedObjectSize(delta);
+    m_heap->heapStats().decreaseAllocatedObjectSize(delta);
 }
 
 void ThreadState::increaseMarkedObjectSize(size_t delta)
 {
     m_markedObjectSize += delta;
-    Heap::increaseMarkedObjectSize(delta);
+    m_heap->heapStats().increaseMarkedObjectSize(delta);
 }
 
 void ThreadState::copyStackUntilSafePointScope()
 {
     if (!m_safePointScopeMarker || m_stackState == BlinkGC::NoHeapPointersOnStack)
         return;
 
     Address* to = reinterpret_cast<Address*>(m_safePointScopeMarker);
     Address* from = reinterpret_cast<Address*>(m_endOfStack);
     RELEASE_ASSERT(from < to);
@@ skipping 13 matching lines @@
     for (size_t i = 0; i < slotCount; ++i) {
         m_safePointStackCopy[i] = from[i];
     }
 }
 
 void ThreadState::addInterruptor(PassOwnPtr<BlinkGCInterruptor> interruptor)
 {
     ASSERT(checkThread());
     SafePointScope scope(BlinkGC::HeapPointersOnStack);
     {
-        MutexLocker locker(threadAttachMutex());
+        MutexLocker locker(m_heap->threadAttachMutex());
         m_interruptors.append(interruptor);
     }
 }
 
 void ThreadState::removeInterruptor(BlinkGCInterruptor* interruptor)
 {
     ASSERT(checkThread());
     SafePointScope scope(BlinkGC::HeapPointersOnStack);
     {
-        MutexLocker locker(threadAttachMutex());
+        MutexLocker locker(m_heap->threadAttachMutex());
         size_t index = m_interruptors.find(interruptor);
         RELEASE_ASSERT(index != kNotFound);
         m_interruptors.remove(index);
     }
 }
 
 #if defined(LEAK_SANITIZER)
 void ThreadState::registerStaticPersistentNode(PersistentNode* node)
 {
     if (m_disabledStaticPersistentsRegistration)
@@ skipping 16 matching lines @@
     m_disabledStaticPersistentsRegistration++;
 }
 
 void ThreadState::leaveStaticReferenceRegistrationDisabledScope()
 {
     ASSERT(m_disabledStaticPersistentsRegistration);
     m_disabledStaticPersistentsRegistration--;
 }
 #endif
 
-ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
-{
-    DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
-    return threads;
-}
-
-void ThreadState::lockThreadAttachMutex()
-{
-    threadAttachMutex().lock();
-}
-
-void ThreadState::unlockThreadAttachMutex()
-{
-    threadAttachMutex().unlock();
-}
-
 void ThreadState::invokePreFinalizers()
 {
     ASSERT(checkThread());
     ASSERT(!sweepForbidden());
     TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
     double startTime = WTF::currentTimeMS();
     if (!m_orderedPreFinalizers.isEmpty()) {
         SweepForbiddenScope sweepForbidden(this);
         ScriptForbiddenIfMainThreadScope scriptForbidden;
@@ skipping 17 matching lines @@
     }
     if (isMainThread()) {
         double timeForInvokingPreFinalizers = WTF::currentTimeMS() - startTime;
         DEFINE_STATIC_LOCAL(CustomCountHistogram, preFinalizersHistogram, ("BlinkGC.TimeForInvokingPreFinalizers", 1, 10 * 1000, 50));
         preFinalizersHistogram.count(timeForInvokingPreFinalizers);
     }
 }
 
 void ThreadState::clearHeapAges()
 {
-    memset(m_heapAges, 0, sizeof(size_t) * BlinkGC::NumberOfHeaps);
+    memset(m_arenaAges, 0, sizeof(size_t) * BlinkGC::NumberOfArenas);
     memset(m_likelyToBePromptlyFreed.get(), 0, sizeof(int) * likelyToBePromptlyFreedArraySize);
     m_currentHeapAges = 0;
 }
 
-int ThreadState::heapIndexOfVectorHeapLeastRecentlyExpanded(int beginHeapIndex, int endHeapIndex)
+int ThreadState::arenaIndexOfVectorHeapLeastRecentlyExpanded(int beginArenaIndex, int endArenaIndex)
 {
-    size_t minHeapAge = m_heapAges[beginHeapIndex];
-    int heapIndexWithMinHeapAge = beginHeapIndex;
-    for (int heapIndex = beginHeapIndex + 1; heapIndex <= endHeapIndex; heapIndex++) {
-        if (m_heapAges[heapIndex] < minHeapAge) {
-            minHeapAge = m_heapAges[heapIndex];
-            heapIndexWithMinHeapAge = heapIndex;
+    size_t minHeapAge = m_arenaAges[beginArenaIndex];
+    int arenaIndexWithMinHeapAge = beginArenaIndex;
+    for (int arenaIndex = beginArenaIndex + 1; arenaIndex <= endArenaIndex; arenaIndex++) {
+        if (m_arenaAges[arenaIndex] < minHeapAge) {
+            minHeapAge = m_arenaAges[arenaIndex];
+            arenaIndexWithMinHeapAge = arenaIndex;
         }
     }
-    ASSERT(isVectorHeapIndex(heapIndexWithMinHeapAge));
-    return heapIndexWithMinHeapAge;
+    ASSERT(isVectorArenaIndex(arenaIndexWithMinHeapAge));
+    return arenaIndexWithMinHeapAge;
 }
 
-BaseHeap* ThreadState::expandedVectorBackingHeap(size_t gcInfoIndex)
+BaseArena* ThreadState::expandedVectorBackingArena(size_t gcInfoIndex)
 {
     ASSERT(checkThread());
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
     --m_likelyToBePromptlyFreed[entryIndex];
-    int heapIndex = m_vectorBackingHeapIndex;
-    m_heapAges[heapIndex] = ++m_currentHeapAges;
-    m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
-    return m_heaps[heapIndex];
+    int arenaIndex = m_vectorBackingArenaIndex;
+    m_arenaAges[arenaIndex] = ++m_currentHeapAges;
+    m_vectorBackingArenaIndex = arenaIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
+    return m_arenas[arenaIndex];
 }
 
-void ThreadState::allocationPointAdjusted(int heapIndex)
+void ThreadState::allocationPointAdjusted(int arenaIndex)
 {
-    m_heapAges[heapIndex] = ++m_currentHeapAges;
-    if (m_vectorBackingHeapIndex == heapIndex)
-        m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
+    m_arenaAges[arenaIndex] = ++m_currentHeapAges;
+    if (m_vectorBackingArenaIndex == arenaIndex)
+        m_vectorBackingArenaIndex = arenaIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
 }
 
 void ThreadState::promptlyFreed(size_t gcInfoIndex)
 {
     ASSERT(checkThread());
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
-    // See the comment in vectorBackingHeap() for why this is +3.
+    // See the comment in vectorBackingArena() for why this is +3.
     m_likelyToBePromptlyFreed[entryIndex] += 3;
 }
 
 void ThreadState::takeSnapshot(SnapshotType type)
 {
     ASSERT(isInGC());
 
     // 0 is used as index for freelist entries. Objects are indexed 1 to
     // gcInfoIndex.
     GCSnapshotInfo info(GCInfoTable::gcInfoIndex() + 1);
     String threadDumpName = String::format("blink_gc/thread_%lu", static_cast<unsigned long>(m_thread));
     const String heapsDumpName = threadDumpName + "/heaps";
     const String classesDumpName = threadDumpName + "/classes";
 
     int numberOfHeapsReported = 0;
 #define SNAPSHOT_HEAP(HeapType)                                                                \
     {                                                                                          \
         numberOfHeapsReported++;                                                               \
         switch (type) {                                                                        \
         case SnapshotType::HeapSnapshot:                                                       \
-            m_heaps[BlinkGC::HeapType##HeapIndex]->takeSnapshot(heapsDumpName + "/" #HeapType, info);   \
+            m_arenas[BlinkGC::HeapType##ArenaIndex]->takeSnapshot(heapsDumpName + "/" #HeapType, info);   \
             break;                                                                             \
         case SnapshotType::FreelistSnapshot:                                                   \
-            m_heaps[BlinkGC::HeapType##HeapIndex]->takeFreelistSnapshot(heapsDumpName + "/" #HeapType); \
+            m_arenas[BlinkGC::HeapType##ArenaIndex]->takeFreelistSnapshot(heapsDumpName + "/" #HeapType); \
             break;                                                                             \
         default:                                                                               \
             ASSERT_NOT_REACHED();                                                              \
         }                                                                                      \
     }
 
     SNAPSHOT_HEAP(NormalPage1);
     SNAPSHOT_HEAP(NormalPage2);
     SNAPSHOT_HEAP(NormalPage3);
     SNAPSHOT_HEAP(NormalPage4);
     SNAPSHOT_HEAP(EagerSweep);
     SNAPSHOT_HEAP(Vector1);
     SNAPSHOT_HEAP(Vector2);
     SNAPSHOT_HEAP(Vector3);
     SNAPSHOT_HEAP(Vector4);
     SNAPSHOT_HEAP(InlineVector);
     SNAPSHOT_HEAP(HashTable);
     SNAPSHOT_HEAP(LargeObject);
     FOR_EACH_TYPED_HEAP(SNAPSHOT_HEAP);
 
-    ASSERT(numberOfHeapsReported == BlinkGC::NumberOfHeaps);
+    ASSERT(numberOfHeapsReported == BlinkGC::NumberOfArenas);
 
 #undef SNAPSHOT_HEAP
 
     if (type == SnapshotType::FreelistSnapshot)
         return;
 
     size_t totalLiveCount = 0;
     size_t totalDeadCount = 0;
     size_t totalLiveSize = 0;
     size_t totalDeadSize = 0;
     for (size_t gcInfoIndex = 1; gcInfoIndex <= GCInfoTable::gcInfoIndex(); ++gcInfoIndex) {
         totalLiveCount += info.liveCount[gcInfoIndex];
         totalDeadCount += info.deadCount[gcInfoIndex];
         totalLiveSize += info.liveSize[gcInfoIndex];
         totalDeadSize += info.deadSize[gcInfoIndex];
     }
 
     WebMemoryAllocatorDump* threadDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(threadDumpName);
     threadDump->addScalar("live_count", "objects", totalLiveCount);
     threadDump->addScalar("dead_count", "objects", totalDeadCount);
     threadDump->addScalar("live_size", "bytes", totalLiveSize);
     threadDump->addScalar("dead_size", "bytes", totalDeadSize);
 
     WebMemoryAllocatorDump* heapsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(heapsDumpName);
     WebMemoryAllocatorDump* classesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
     BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->addOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 } // namespace blink