Prepare for incremental sweep by making the FreeList independent of the ThreadHeap

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 630 matching lines @@
 template<typename Header>
 ThreadHeap<Header>::ThreadHeap(ThreadState* state, int index)
     : m_currentAllocationPoint(0)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_firstPage(0)
     , m_firstLargeHeapObject(0)
     , m_firstPageAllocatedDuringSweeping(0)
     , m_lastPageAllocatedDuringSweeping(0)
     , m_mergePoint(0)
-    , m_biggestFreeListIndex(0)
     , m_threadState(state)
     , m_index(index)
     , m_numberOfNormalPages(0)
     , m_promptlyFreedCount(0)
 {
     clearFreeLists();
 }
 
 template<typename Header>
+FreeList<Header>::FreeList()
+    : m_biggestFreeListIndex(0)
+{
+}
+
+template<typename Header>
 ThreadHeap<Header>::~ThreadHeap()
 {
     ASSERT(!m_firstPage);
     ASSERT(!m_firstLargeHeapObject);
 }
 
 template<typename Header>
 void ThreadHeap<Header>::cleanupPages()
 {
     clearFreeLists();
@@ skipping 27 matching lines @@
         return allocateLargeObject(allocationSize, gcInfo);
 
     updateRemainingAllocationSize();
     if (threadState()->shouldGC()) {
         if (threadState()->shouldForceConservativeGC())
             Heap::collectGarbage(ThreadState::HeapPointersOnStack);
         else
             threadState()->setGCRequested();
     }
     if (remainingAllocationSize() > 0) {
-        addToFreeList(currentAllocationPoint(), remainingAllocationSize());
+        m_freeList.addToFreeList(currentAllocationPoint(), remainingAllocationSize());
         setAllocationPoint(0, 0);
     }
     ensureCurrentAllocation(allocationSize, gcInfo);
     return allocate(size, gcInfo);
 }
 
 template<typename Header>
 bool ThreadHeap<Header>::allocateFromFreeList(size_t minSize)
 {
-    size_t bucketSize = 1 << m_biggestFreeListIndex;
-    int i = m_biggestFreeListIndex;
+    size_t bucketSize = 1 << m_freeList.m_biggestFreeListIndex;
+    int i = m_freeList.m_biggestFreeListIndex;
     for (; i > 0; i--, bucketSize >>= 1) {
         if (bucketSize < minSize)
             break;
-        FreeListEntry* entry = m_freeLists[i];
+        FreeListEntry* entry = m_freeList.m_freeLists[i];
         if (entry) {
-            m_biggestFreeListIndex = i;
-            entry->unlink(&m_freeLists[i]);
+            m_freeList.m_biggestFreeListIndex = i;
+            entry->unlink(&m_freeList.m_freeLists[i]);
             setAllocationPoint(entry->address(), entry->size());
             ASSERT(currentAllocationPoint() && remainingAllocationSize() >= minSize);
             return true;
         }
     }
-    m_biggestFreeListIndex = i;
+    m_freeList.m_biggestFreeListIndex = i;
     return false;
 }
 
 template<typename Header>
 void ThreadHeap<Header>::ensureCurrentAllocation(size_t minSize, const GCInfo* gcInfo)
 {
     ASSERT(minSize >= allocationGranularity);
     if (allocateFromFreeList(minSize))
         return;
     if (coalesce(minSize) && allocateFromFreeList(minSize))
@@ skipping 63 matching lines @@
         current->snapshot(json, info);
         json->endDictionary();
     }
     json->endArray();
 
     json->setInteger("pageCount", info->pageCount - previousPageCount);
 }
 #endif
 
 template<typename Header>
-void ThreadHeap<Header>::addToFreeList(Address address, size_t size)
+void FreeList<Header>::addToFreeList(Address address, size_t size)
 {
-    ASSERT(heapPageFromAddress(address));
-    ASSERT(heapPageFromAddress(address + size - 1));
     ASSERT(size < blinkPagePayloadSize());
     // The free list entries are only pointer aligned (but when we allocate
     // from them we are 8 byte aligned due to the header size).
     ASSERT(!((reinterpret_cast<uintptr_t>(address) + sizeof(Header)) & allocationMask));
     ASSERT(!(size & allocationMask));
     ASAN_POISON_MEMORY_REGION(address, size);
     FreeListEntry* entry;
     if (size < sizeof(*entry)) {
         // Create a dummy header with only a size and freelist bit set.
         ASSERT(size >= sizeof(BasicObjectHeader));
@@ skipping 49 matching lines @@
 {
     if (m_threadState->isSweepInProgress())
         return false;
 
     if (m_promptlyFreedCount < 256)
         return false;
 
     // The smallest bucket able to satisfy an allocation request for minSize is
     // the bucket where all free-list entries are guarantied to be larger than
     // minSize. That bucket is one larger than the bucket minSize would go into.
-    size_t neededBucketIndex = bucketIndexForSize(minSize) + 1;
+    size_t neededBucketIndex = FreeList<Header>::bucketIndexForSize(minSize) + 1;
     size_t neededFreeEntrySize = 1 << neededBucketIndex;
     size_t neededPromptlyFreedSize = neededFreeEntrySize * 3;
     size_t foundFreeEntrySize = 0;
 
     // Bailout early on large requests because it is unlikely we will find a free-list entry.
     if (neededPromptlyFreedSize >= blinkPageSize)
         return false;
 
     TRACE_EVENT_BEGIN2("blink_gc", "ThreadHeap::coalesce" , "requestedSize", (unsigned)minSize , "neededSize", (unsigned)neededFreeEntrySize);
 
@@ skipping 523 matching lines @@
 }
 
 #if ENABLE(ASSERT)
 template<typename Header>
 bool ThreadHeap<Header>::isConsistentForSweeping()
 {
     // A thread heap is consistent for sweeping if none of the pages to
     // be swept contain a freelist block or the current allocation
     // point.
     for (size_t i = 0; i < blinkPageSizeLog2; i++) {
-        for (FreeListEntry* freeListEntry = m_freeLists[i]; freeListEntry; freeListEntry = freeListEntry->next()) {
+        for (FreeListEntry* freeListEntry = m_freeList.m_freeLists[i]; freeListEntry; freeListEntry = freeListEntry->next()) {
             if (pagesToBeSweptContains(freeListEntry->address())) {
                 return false;
             }
             ASSERT(pagesAllocatedDuringSweepingContains(freeListEntry->address()));
         }
     }
     if (ownsNonEmptyAllocationArea()) {
         ASSERT(pagesToBeSweptContains(currentAllocationPoint())
             || pagesAllocatedDuringSweepingContains(currentAllocationPoint()));
         return !pagesToBeSweptContains(currentAllocationPoint());
@@ skipping 22 matching lines @@
             current->unmark();
         else
             current->setDeadMark();
     }
 }
 
 template<typename Header>
 void ThreadHeap<Header>::clearFreeLists()
 {
     m_promptlyFreedCount = 0;
+    m_freeList.clear();
+}
+
+template<typename Header>
+void FreeList<Header>::clear()
+{
+    m_biggestFreeListIndex = 0;
     for (size_t i = 0; i < blinkPageSizeLog2; i++) {
         m_freeLists[i] = 0;
         m_lastFreeListEntries[i] = 0;
     }
 }
 
-int BaseHeap::bucketIndexForSize(size_t size)
+template<typename Header>
+int FreeList<Header>::bucketIndexForSize(size_t size)
 {
     ASSERT(size > 0);
     int index = -1;
     while (size) {
         size >>= 1;
         index++;
     }
     return index;
 }
 
@@ skipping 1243 matching lines @@
     // nothing on the freelists.
     ASSERT(splitOff->m_mergePoint || splitOff->m_numberOfNormalPages == 0);
     if (splitOff->m_mergePoint) {
         // Link the split off pages into the beginning of the list again.
         splitOff->m_mergePoint->m_next = m_firstPage;
         m_firstPage = splitOff->m_firstPage;
         m_numberOfNormalPages += splitOff->m_numberOfNormalPages;
         splitOff->m_firstPage = 0;
         // Merge free lists.
         for (size_t i = 0; i < blinkPageSizeLog2; i++) {
-            if (!m_freeLists[i]) {
-                m_freeLists[i] = splitOff->m_freeLists[i];
-            } else if (splitOff->m_freeLists[i]) {
-                m_lastFreeListEntries[i]->append(splitOff->m_freeLists[i]);
-                m_lastFreeListEntries[i] = splitOff->m_lastFreeListEntries[i];
+            if (!m_freeList.m_freeLists[i]) {
+                m_freeList.m_freeLists[i] = splitOff->m_freeList.m_freeLists[i];
+            } else if (splitOff->m_freeList.m_freeLists[i]) {
+                m_freeList.m_lastFreeListEntries[i]->append(splitOff->m_freeList.m_freeLists[i]);
+                m_freeList.m_lastFreeListEntries[i] = splitOff->m_freeList.m_lastFreeListEntries[i];
             }
         }
     }
 }
 
 void Heap::getHeapSpaceSize(uint64_t* objectSpaceSize, uint64_t* allocatedSpaceSize)
 {
     *objectSpaceSize = 0;
     *allocatedSpaceSize = 0;
     ASSERT(ThreadState::isAnyThreadInGC());
@@ skipping 183 matching lines @@
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = 0;
 
 }