Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/Source/platform/heap/HeapTest.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 496 matching lines @@
     using GlobalIntWrapperPersistent = CrossThreadPersistent<IntWrapper>;
 
     PassOwnPtr<GlobalIntWrapperPersistent> createGlobalPersistent(int value)
     {
         return adoptPtr(new GlobalIntWrapperPersistent(IntWrapper::create(value)));
     }
 
     void runThread() override
     {
         OwnPtr<GlobalIntWrapperPersistent> longLivingPersistent;
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         longLivingPersistent = createGlobalPersistent(0x2a2a2a2a);
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
                 OwnPtr<GlobalIntWrapperPersistent> globalPersistent = createGlobalPersistent(0x0ed0cabb);
 
@@ skipping 38 matching lines @@
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
     void runThread() override
     {
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>> weakMap = new HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>;
                 PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     weakMap->add(static_cast<unsigned>(i), IntWrapper::create(0));
@@ skipping 73 matching lines @@
         explicit PersistentChain(int count)
         {
             m_refCountedChain = adoptRef(RefCountedChain::create(count));
         }
 
         RefPtr<RefCountedChain> m_refCountedChain;
     };
 
     void runThread() override
     {
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         PersistentChain::create(100);
 
         // Upon thread detach, GCs will run until all persistents have been
         // released. We verify that the draining of persistents proceeds
         // as expected by dropping one Persistent<> per GC until there
         // are none left.
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
@@ skipping 1083 matching lines @@
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
     {
         size_t slack = 0;
 
         // When the test starts there may already have been leaked some memory
         // on the heap, so we establish a base line.
         size_t baseLevel = initialObjectPayloadSize;
         bool testPagesAllocated = !baseLevel;
         if (testPagesAllocated)
-            EXPECT_EQ(Heap::allocatedSpace(), 0ul);
+            EXPECT_EQ(ThreadState::current()->allocatedSpace(), 0ul);
 
         // This allocates objects on the general heap which should add a page of memory.
         DynamicallySizedObject* alloc32 = DynamicallySizedObject::create(32);
         slack += 4;
         memset(alloc32, 40, 32);
         DynamicallySizedObject* alloc64 = DynamicallySizedObject::create(64);
         slack += 4;
         memset(alloc64, 27, 64);
 
         size_t total = 96;
 
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(Heap::allocatedSpace(), blinkPageSize * 2);
+            EXPECT_EQ(ThreadState::current()->allocatedSpace(), blinkPageSize * 2);
 
         EXPECT_EQ(alloc32->get(0), 40);
         EXPECT_EQ(alloc32->get(31), 40);
         EXPECT_EQ(alloc64->get(0), 27);
         EXPECT_EQ(alloc64->get(63), 27);
 
         conservativelyCollectGarbage();
 
         EXPECT_EQ(alloc32->get(0), 40);
         EXPECT_EQ(alloc32->get(31), 40);
         EXPECT_EQ(alloc64->get(0), 27);
         EXPECT_EQ(alloc64->get(63), 27);
     }
 
     clearOutOldGarbage();
     size_t total = 0;
     size_t slack = 0;
     size_t baseLevel = Heap::objectPayloadSizeForTesting();
     bool testPagesAllocated = !baseLevel;
     if (testPagesAllocated)
-        EXPECT_EQ(Heap::allocatedSpace(), 0ul);
+        EXPECT_EQ(ThreadState::current()->allocatedSpace(), 0ul);
 
     size_t big = 1008;
     Persistent<DynamicallySizedObject> bigArea = DynamicallySizedObject::create(big);
     total += big;
     slack += 4;
 
     size_t persistentCount = 0;
     const size_t numPersistents = 100000;
     Persistent<DynamicallySizedObject>* persistents[numPersistents];
 
     for (int i = 0; i < 1000; i++) {
         size_t size = 128 + i * 8;
         total += size;
         persistents[persistentCount++] = new Persistent<DynamicallySizedObject>(DynamicallySizedObject::create(size));
         slack += 4;
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, ThreadState::current()->allocatedSpace() & (blinkPageSize - 1));
     }
 
     {
         DynamicallySizedObject* alloc32b(DynamicallySizedObject::create(32));
         slack += 4;
         memset(alloc32b, 40, 32);
         DynamicallySizedObject* alloc64b(DynamicallySizedObject::create(64));
         slack += 4;
         memset(alloc64b, 27, 64);
         EXPECT_TRUE(alloc32b != alloc64b);
 
         total += 96;
         CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
         if (testPagesAllocated)
-            EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+            EXPECT_EQ(0ul, ThreadState::current()->allocatedSpace() & (blinkPageSize - 1));
     }
 
     clearOutOldGarbage();
     total -= 96;
     slack -= 8;
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, ThreadState::current()->allocatedSpace() & (blinkPageSize - 1));
 
     // Clear the persistent, so that the big area will be garbage collected.
     bigArea.release();
     clearOutOldGarbage();
 
     total -= big;
     slack -= 4;
     CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, ThreadState::current()->allocatedSpace() & (blinkPageSize - 1));
 
     CheckWithSlack(baseLevel + total, Heap::objectPayloadSizeForTesting(), slack);
     if (testPagesAllocated)
-        EXPECT_EQ(0ul, Heap::allocatedSpace() & (blinkPageSize - 1));
+        EXPECT_EQ(0ul, ThreadState::current()->allocatedSpace() & (blinkPageSize - 1));
 
     for (size_t i = 0; i < persistentCount; i++) {
         delete persistents[i];
         persistents[i] = 0;
     }
 
     uint8_t* address = reinterpret_cast<uint8_t*>(Heap::allocate<DynamicallySizedObject>(100));
     for (int i = 0; i < 100; i++)
         address[i] = i;
     address = reinterpret_cast<uint8_t*>(Heap::reallocate<DynamicallySizedObject>(address, 100000));
@@ skipping 442 matching lines @@
     }
     clearOutOldGarbage();
     size_t afterFree = Heap::objectPayloadSizeForTesting();
     EXPECT_TRUE(initialObjectPayloadSize == afterFree);
 }
 
 TEST(HeapTest, LargeHeapObjects)
 {
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
-    size_t initialAllocatedSpace = Heap::allocatedSpace();
+    size_t initialAllocatedSpace = ThreadState::current()->allocatedSpace();
     IntWrapper::s_destructorCalls = 0;
     LargeHeapObject::s_destructorCalls = 0;
     {
         int slack = 8; // LargeHeapObject points to an IntWrapper that is also allocated.
         Persistent<LargeHeapObject> object = LargeHeapObject::create();
         ASSERT(ThreadState::current()->findPageFromAddress(object));
         ASSERT(ThreadState::current()->findPageFromAddress(reinterpret_cast<char*>(object.get()) + sizeof(LargeHeapObject) - 1));
         clearOutOldGarbage();
-        size_t afterAllocation = Heap::allocatedSpace();
+        size_t afterAllocation = ThreadState::current()->allocatedSpace();
         {
             object->set(0, 'a');
             EXPECT_EQ('a', object->get(0));
             object->set(object->length() - 1, 'b');
             EXPECT_EQ('b', object->get(object->length() - 1));
             size_t expectedLargeHeapObjectPayloadSize = Heap::allocationSizeFromSize(sizeof(LargeHeapObject));
             size_t expectedObjectPayloadSize = expectedLargeHeapObjectPayloadSize + sizeof(IntWrapper);
             size_t actualObjectPayloadSize = Heap::objectPayloadSizeForTesting() - initialObjectPayloadSize;
             CheckWithSlack(expectedObjectPayloadSize, actualObjectPayloadSize, slack);
             // There is probably space for the IntWrapper in a heap page without
             // allocating extra pages. However, the IntWrapper allocation might cause
             // the addition of a heap page.
             size_t largeObjectAllocationSize = sizeof(LargeObjectPage) + expectedLargeHeapObjectPayloadSize;
             size_t allocatedSpaceLowerBound = initialAllocatedSpace + largeObjectAllocationSize;
             size_t allocatedSpaceUpperBound = allocatedSpaceLowerBound + slack + blinkPageSize;
             EXPECT_LE(allocatedSpaceLowerBound, afterAllocation);
             EXPECT_LE(afterAllocation, allocatedSpaceUpperBound);
             EXPECT_EQ(0, IntWrapper::s_destructorCalls);
             EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
             for (int i = 0; i < 10; i++)
                 object = LargeHeapObject::create();
         }
         clearOutOldGarbage();
-        EXPECT_TRUE(Heap::allocatedSpace() == afterAllocation);
+        EXPECT_TRUE(ThreadState::current()->allocatedSpace() == afterAllocation);
         EXPECT_EQ(10, IntWrapper::s_destructorCalls);
         EXPECT_EQ(10, LargeHeapObject::s_destructorCalls);
     }
     clearOutOldGarbage();
     EXPECT_TRUE(initialObjectPayloadSize == Heap::objectPayloadSizeForTesting());
-    EXPECT_TRUE(initialAllocatedSpace == Heap::allocatedSpace());
+    EXPECT_TRUE(initialAllocatedSpace == ThreadState::current()->allocatedSpace());
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeHeapObject::s_destructorCalls);
     preciselyCollectGarbage();
 }
 
 typedef std::pair<Member<IntWrapper>, int> PairWrappedUnwrapped;
 typedef std::pair<int, Member<IntWrapper>> PairUnwrappedWrapped;
 typedef std::pair<WeakMember<IntWrapper>, Member<IntWrapper>> PairWeakStrong;
 typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper>> PairStrongWeak;
 typedef std::pair<WeakMember<IntWrapper>, int> PairWeakUnwrapped;
@@ skipping 1406 matching lines @@
     // This is a low-level test where we call checkAndMarkPointer. This method
     // causes the object start bitmap to be computed which requires the heap
     // to be in a consistent state (e.g. the free allocation area must be put
     // into a free list header). However when we call makeConsistentForGC it
     // also clears out the freelists so we have to rebuild those before trying
     // to allocate anything again. We do this by forcing a GC after doing the
     // checkAndMarkPointer tests.
     {
         TestGCScope scope(BlinkGC::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked()); // Fail the test if we could not park all threads.
-        Heap::flushHeapDoesNotContainCache();
+        ThreadState::current()->flushHeapDoesNotContainCache();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, objectAddresses[i]));
             EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, endAddresses[i]));
         }
         EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
         visitor.reset();
         EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectAddress));
         EXPECT_TRUE(Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress));
         EXPECT_EQ(2ul, visitor.count());
         visitor.reset();
     }
     // This forces a GC without stack scanning which results in the objects
     // being collected. This will also rebuild the above mentioned freelists,
     // however we don't rely on that below since we don't have any allocations.
     clearOutOldGarbage();
     {
         TestGCScope scope(BlinkGC::HeapPointersOnStack);
         EXPECT_TRUE(scope.allThreadsParked());
-        Heap::flushHeapDoesNotContainCache();
+        ThreadState::current()->flushHeapDoesNotContainCache();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             // We would like to assert that checkAndMarkPointer returned false
             // here because the pointers no longer point into a valid object
             // (it's been freed by the GCs. But checkAndMarkPointer will return
             // true for any pointer that points into a heap page, regardless of
             // whether it points at a valid object (this ensures the
             // correctness of the page-based on-heap address caches), so we
             // can't make that assert.
             Heap::checkAndMarkPointer(&visitor, objectAddresses[i]);
             Heap::checkAndMarkPointer(&visitor, endAddresses[i]);
@@ skipping 905 matching lines @@
         {
             // Since the sleeper thread has detached this is the only thread.
             TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
             EXPECT_TRUE(scope.allThreadsParked());
         }
     }
 
 private:
     static void sleeperMainFunc()
     {
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
         s_sleeperRunning = true;
 
         // Simulate a long running op that is not entering a safepoint.
         while (!s_sleeperDone) {
             Platform::current()->yieldCurrentThread();
         }
 
         ThreadState::detach();
         s_sleeperRunning = false;
     }
@@ skipping 669 matching lines @@
         // shutdown.
         wakeWorkerThread();
     }
 
 private:
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         {
             // Create a worker object that is not kept alive except the
             // main thread will keep it as an integer value on its stack.
             IntWrapper* workerObject = IntWrapper::create(42);
             s_workerObjectPointer = reinterpret_cast<uintptr_t>(workerObject);
         }
 
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
@@ skipping 100 matching lines @@
             parkWorkerThread();
         }
 
         return weakCollection;
     }
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         {
             Persistent<WeakCollectionType> collection = allocateCollection();
             {
                 // Prevent weak processing with an iterator and GC.
                 WeakCollectionType::iterator it = collection->begin();
                 conservativelyCollectGarbage();
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
@@ skipping 140 matching lines @@
         // can acquire it and do its sweep of its heaps. Just wait for the worker
         // to complete its sweep and check the result.
         parkMainThread();
         EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
     }
 
 private:
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         DestructorLockingObject* dlo = DestructorLockingObject::create();
         ASSERT_UNUSED(dlo, dlo);
 
         // Wake up the main thread which is waiting for the worker to do its
         // allocation.
         wakeMainThread();
 
         // Wait for the main thread to get the global lock to ensure it has
         // it before the worker tries to acquire it. We want the worker to
@@ skipping 47 matching lines @@
 private:
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
         // Start up a worker thread and have it detach after the main thread has.
         // Do this to verify that CrossThreadPersistent<>s referring to objects
         // on one of the main thread's heaps does not upset the CTP invalidation
         // pass that ThreadState::detach() performs.
-        ThreadState::attach();
+        ThreadState::attach(ThreadState::PerThreadHeapDisabled);
 
         CrossThreadPersistent<IntWrapper> persistent(IntWrapper::create(43));
 
         // Wait for the main thread to detach.
         wakeMainThread();
         parkWorkerThread();
 
         ThreadState::detach();
         wakeMainThread();
     }
@@ skipping 645 matching lines @@
     preciselyCollectGarbage();
     EXPECT_FALSE(holder->object());
 }
 
 namespace {
 
 void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject** object)
 {
     // Step 2: Create an object and store the pointer.
     MutexLocker locker(workerThreadMutex());
-    ThreadState::attach();
+    ThreadState::attach(ThreadState::PerThreadHeapDisabled);
     *object = DestructorLockingObject::create();
     wakeMainThread();
     parkWorkerThread();
 
     // Step 4: Run a GC.
     Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     wakeMainThread();
     parkWorkerThread();
 
     // Step 6: Finish.
@@ skipping 69 matching lines @@
     EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
     EXPECT_EQ(16u, vector1.capacity());
     EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 } // namespace blink