Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/HeapPage.h

 /*
  * 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 107 matching lines @@
 #endif
 
 #if !ENABLE(ASSERT) && CPU(64BIT)
 #define USE_4BYTE_HEADER_PADDING 1
 #else
 #define USE_4BYTE_HEADER_PADDING 0
 #endif
 
 class CallbackStack;
 class FreePagePool;
-class NormalPageHeap;
+class NormalPageArena;
 class OrphanedPagePool;
 class PageMemory;
 class PageMemoryRegion;
 class WebMemoryAllocatorDump;
 
 // HeapObjectHeader is 4 byte (32 bit) that has the following layout:
 //
 // | gcInfoIndex (14 bit) | DOM mark bit (1 bit) | size (14 bit) | dead bit (1 bit) | freed bit (1 bit) | mark bit (1 bit) |
 //
 // - For non-large objects, 14 bit is enough for |size| because the blink
@@ skipping 206 matching lines @@
 //
 // - LargeObjectPage is a page that contains only one object. The object size
 //   is arbitrary. An object whose size is larger than |blinkPageSize| is stored
 //   as a single project in LargeObjectPage.
 //
 // Note: An object whose size is between |largeObjectSizeThreshold| and
 // |blinkPageSize| can go to either of NormalPage or LargeObjectPage.
 class BasePage {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
-    BasePage(PageMemory*, BaseHeap*);
+    BasePage(PageMemory*, BaseArena*);
     virtual ~BasePage() { }
 
     void link(BasePage** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
     }
     void unlink(BasePage** previousNext)
     {
         *previousNext = m_next;
@@ skipping 35 matching lines @@
 
     virtual void takeSnapshot(WebMemoryAllocatorDump*, ThreadState::GCSnapshotInfo&, HeapSnapshotInfo&) = 0;
 #if ENABLE(ASSERT)
     virtual bool contains(Address) = 0;
 #endif
     virtual size_t size() = 0;
     virtual bool isLargeObjectPage() { return false; }
 
     Address address() { return reinterpret_cast<Address>(this); }
     PageMemory* storage() const { return m_storage; }
-    BaseHeap* heap() const { return m_heap; }
-    bool orphaned() { return !m_heap; }
+    BaseArena* arena() const { return m_arena; }
+    bool orphaned() { return !m_arena; }
     bool terminating() { return m_terminating; }
     void setTerminating() { m_terminating = true; }
 
     // Returns true if this page has been swept by the ongoing lazy sweep.
     bool hasBeenSwept() const { return m_swept; }
 
     void markAsSwept()
     {
         ASSERT(!m_swept);
         m_swept = true;
     }
 
     void markAsUnswept()
     {
         ASSERT(m_swept);
         m_swept = false;
     }
 
 private:
     PageMemory* m_storage;
-    BaseHeap* m_heap;
+    BaseArena* m_arena;
     BasePage* m_next;
     // Whether the page is part of a terminating thread or not.
     bool m_terminating;
 
     // Track the sweeping state of a page. Set to true once
     // the lazy sweep completes has processed it.
     //
     // Set to false at the start of a sweep, true  upon completion
     // of lazy sweeping.
     bool m_swept;
-    friend class BaseHeap;
+    friend class BaseArena;
 };
 
 class NormalPage final : public BasePage {
 public:
-    NormalPage(PageMemory*, BaseHeap*);
+    NormalPage(PageMemory*, BaseArena*);
 
     Address payload()
     {
         return address() + pageHeaderSize();
     }
     size_t payloadSize()
     {
         return (blinkPagePayloadSize() - pageHeaderSize()) & ~allocationMask;
     }
     Address payloadEnd() { return payload() + payloadSize(); }
@@ skipping 25 matching lines @@
     size_t size() override { return blinkPageSize; }
     static size_t pageHeaderSize()
     {
         // Compute the amount of padding we have to add to a header to make
         // the size of the header plus the padding a multiple of 8 bytes.
         size_t paddingSize = (sizeof(NormalPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
         return sizeof(NormalPage) + paddingSize;
     }
 
 
-    NormalPageHeap* heapForNormalPage();
+    NormalPageArena* heapForNormalPage();
 
 private:
     HeapObjectHeader* findHeaderFromAddress(Address);
     void populateObjectStartBitMap();
 
     bool m_objectStartBitMapComputed;
     uint8_t m_objectStartBitMap[reservedForObjectBitMap];
 };
 
 // Large allocations are allocated as separate objects and linked in a list.
 //
 // In order to use the same memory allocation routines for everything allocated
 // in the heap, large objects are considered heap pages containing only one
 // object.
 class LargeObjectPage final : public BasePage {
 public:
-    LargeObjectPage(PageMemory*, BaseHeap*, size_t);
+    LargeObjectPage(PageMemory*, BaseArena*, size_t);
 
     Address payload() { return heapObjectHeader()->payload(); }
     size_t payloadSize() { return m_payloadSize; }
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address)
     {
         return payload() <= address && address < payloadEnd();
     }
 
     size_t objectPayloadSizeForTesting() override;
@@ skipping 116 matching lines @@
     static void zapFreedMemory(Address, size_t);
     static void checkFreedMemoryIsZapped(Address, size_t);
 #endif
 
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
-    friend class NormalPageHeap;
+    friend class NormalPageArena;
 };
 
 // Each thread has a number of thread heaps (e.g., Generic heaps,
 // typed heaps for Node, heaps for collection backings etc)
-// and BaseHeap represents each thread heap.
+// and BaseArena represents each thread heap.
 //
-// BaseHeap is a parent class of NormalPageHeap and LargeObjectHeap.
-// NormalPageHeap represents a heap that contains NormalPages
-// and LargeObjectHeap represents a heap that contains LargeObjectPages.
-class PLATFORM_EXPORT BaseHeap {
-    USING_FAST_MALLOC(BaseHeap);
+// BaseArena is a parent class of NormalPageArena and LargeObjectArena.
+// NormalPageArena represents a heap that contains NormalPages
+// and LargeObjectArena represents a heap that contains LargeObjectPages.
+class PLATFORM_EXPORT BaseArena {
+    USING_FAST_MALLOC(BaseArena);
 public:
-    BaseHeap(ThreadState*, int);
-    virtual ~BaseHeap();
+    BaseArena(ThreadState*, int);
+    virtual ~BaseArena();
     void cleanupPages();
 
     void takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo&);
 #if ENABLE(ASSERT)
     BasePage* findPageFromAddress(Address);
 #endif
     virtual void takeFreelistSnapshot(const String& dumpBaseName) { }
     virtual void clearFreeLists() { }
     void makeConsistentForGC();
     void makeConsistentForMutator();
 #if ENABLE(ASSERT)
     virtual bool isConsistentForGC() = 0;
 #endif
     size_t objectPayloadSizeForTesting();
     void prepareHeapForTermination();
     void prepareForSweep();
 #if defined(ADDRESS_SANITIZER)
     void poisonHeap(BlinkGC::ObjectsToPoison, BlinkGC::Poisoning);
 #endif
     Address lazySweep(size_t, size_t gcInfoIndex);
     void sweepUnsweptPage();
     // Returns true if we have swept all pages within the deadline.
     // Returns false otherwise.
     bool lazySweepWithDeadline(double deadlineSeconds);
     void completeSweep();
 
     ThreadState* threadState() { return m_threadState; }
-    int heapIndex() const { return m_index; }
+    int arenaIndex() const { return m_index; }
 
 protected:
     BasePage* m_firstPage;
     BasePage* m_firstUnsweptPage;
 
 private:
     virtual Address lazySweepPages(size_t, size_t gcInfoIndex) = 0;
 
     ThreadState* m_threadState;
 
     // Index into the page pools.  This is used to ensure that the pages of the
     // same type go into the correct page pool and thus avoid type confusion.
     int m_index;
 };
 
-class PLATFORM_EXPORT NormalPageHeap final : public BaseHeap {
+class PLATFORM_EXPORT NormalPageArena final : public BaseArena {
 public:
-    NormalPageHeap(ThreadState*, int);
+    NormalPageArena(ThreadState*, int);
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
     void clearFreeLists() override;
 #if ENABLE(ASSERT)
     bool isConsistentForGC() override;
     bool pagesToBeSweptContains(Address);
@@ skipping 32 matching lines @@
 
     FreeList m_freeList;
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
 };
 
-class LargeObjectHeap final : public BaseHeap {
+class LargeObjectArena final : public BaseArena {
 public:
-    LargeObjectHeap(ThreadState*, int);
+    LargeObjectArena(ThreadState*, int);
     Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
     bool isConsistentForGC() override { return true; }
 #endif
 private:
     Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
     Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 };
 
@@ skipping 90 matching lines @@
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::markDead()
 {
     ASSERT(checkHeader());
     ASSERT(!isMarked());
     m_encoded |= headerDeadBitMask;
 }
 
-inline Address NormalPageHeap::allocateObject(size_t allocationSize, size_t gcInfoIndex)
+inline Address NormalPageArena::allocateObject(size_t allocationSize, size_t gcInfoIndex)
 {
     if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
         Address headerAddress = m_currentAllocationPoint;
         m_currentAllocationPoint += allocationSize;
         m_remainingAllocationSize -= allocationSize;
         ASSERT(gcInfoIndex > 0);
         new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
         Address result = headerAddress + sizeof(HeapObjectHeader);
         ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
         SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 } // namespace blink
 
 #endif // HeapPage_h