Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/PagePool.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/PagePool.h"
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/PageMemory.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 FreePagePool::~FreePagePool()
 {
-    for (int index = 0; index < BlinkGC::NumberOfHeaps; ++index) {
+    for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
         while (PoolEntry* entry = m_pool[index]) {
             m_pool[index] = entry->next;
             PageMemory* memory = entry->data;
             ASSERT(memory);
             delete memory;
             delete entry;
         }
     }
 }
 
@@ skipping 20 matching lines @@
             return memory;
 
         // We got some memory, but failed to commit it, try again.
         delete memory;
     }
     return nullptr;
 }
 
 OrphanedPagePool::~OrphanedPagePool()
 {
-    for (int index = 0; index < BlinkGC::NumberOfHeaps; ++index) {
+    for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
         while (PoolEntry* entry = m_pool[index]) {
             m_pool[index] = entry->next;
             BasePage* page = entry->data;
             delete entry;
             PageMemory* memory = page->storage();
             ASSERT(memory);
             page->~BasePage();
             delete memory;
         }
     }
 }
 
 void OrphanedPagePool::addOrphanedPage(int index, BasePage* page)
 {
     page->markOrphaned();
     PoolEntry* entry = new PoolEntry(page, m_pool[index]);
     m_pool[index] = entry;
 }
 
 NO_SANITIZE_ADDRESS
 void OrphanedPagePool::decommitOrphanedPages()
 {
     ASSERT(ThreadState::current()->isInGC());

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

Add ASSERT(ThreadState::current() == ThreadState::mainThreadState()).

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

Turned out decommitOrphanedPages() was called from non main thread. Changed
mainThreadState() to currentThread() below.

 
 #if ENABLE(ASSERT)
     // No locking needed as all threads are at safepoints at this point in time.
-    for (ThreadState* state : ThreadState::attachedThreads())
-        ASSERT(state->isAtSafePoint());
+    ASSERT(ThreadState::mainThreadState()->heap().isAtSafePoint());
 #endif
 
-    for (int index = 0; index < BlinkGC::NumberOfHeaps; ++index) {
+    for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
         PoolEntry* entry = m_pool[index];
         PoolEntry** prevNext = &m_pool[index];
         while (entry) {
             BasePage* page = entry->data;
             // Check if we should reuse the memory or just free it.
             // Large object memory is not reused but freed, normal blink heap
             // pages are reused.
             // NOTE: We call the destructor before freeing or adding to the
             // free page pool.
             PageMemory* memory = page->storage();
             if (page->isLargeObjectPage()) {
                 page->~BasePage();
                 delete memory;
             } else {
                 page->~BasePage();
                 clearMemory(memory);
-                Heap::freePagePool()->addFreePage(index, memory);
+                ThreadState::current()->heap().freePagePool()->addFreePage(index, memory);

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

ThreadState::current() => ThreadState::mainThreadState()).

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

Done.

             }
 
             PoolEntry* deadEntry = entry;
             entry = entry->next;
             *prevNext = entry;
             delete deadEntry;
         }
     }
 }
 
@@ skipping 17 matching lines @@
 }
 
 void OrphanedPagePool::clearMemory(PageMemory* memory)
 {
     asanDisabledMemset(memory->writableStart(), 0, blinkPagePayloadSize());
 }
 
 #if ENABLE(ASSERT)
 bool OrphanedPagePool::contains(void* object)
 {
-    for (int index = 0; index < BlinkGC::NumberOfHeaps; ++index) {
+    for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
         for (PoolEntry* entry = m_pool[index]; entry; entry = entry->next) {
             BasePage* page = entry->data;
             if (page->contains(reinterpret_cast<Address>(object)))
                 return true;
         }
     }
     return false;
 }
 #endif
 
 } // namespace blink