Remove ThreadHeapMode

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 543 matching lines @@
     return WTF::wrapUnique(
         new GlobalIntWrapperPersistent(IntWrapper::create(value)));
   }
 
   void addGlobalPersistent() {
     MutexLocker lock(m_mutex);
     m_crossPersistents.push_back(createGlobalPersistent(0x2a2a2a2a));
   }
 
   void runThread() override {
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
+    ThreadState::attachCurrentThread();
 
     // Add a cross-thread persistent from this thread; the test object
     // verifies that it will have been cleared out after the threads
     // have all detached, running their termination GCs while doing so.
     addGlobalPersistent();
 
     int gcCount = 0;
     while (!done()) {
       ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
       {
@@ skipping 34 matching lines @@
     atomicDecrement(&m_threadsToFinish);
   }
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
  public:
   static void test() { ThreadedTesterBase::test(new ThreadedWeaknessTester); }
 
  private:
   void runThread() override {
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
+    ThreadState::attachCurrentThread();
 
     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++) {
@@ skipping 69 matching lines @@
 
    private:
     explicit PersistentChain(int count) {
       m_refCountedChain = adoptRef(RefCountedChain::create(count));
     }
 
     RefPtr<RefCountedChain> m_refCountedChain;
   };
 
   void runThread() override {
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
+    ThreadState::attachCurrentThread();
 
     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::detachCurrentThread();
     atomicDecrement(&m_threadsToFinish);
   }
@@ skipping 4053 matching lines @@
   }
   {
     Persistent<MixinInstanceWithoutTrace> b = obj;
     preciselyCollectGarbage();
     EXPECT_EQ(2, MixinA::s_traceCount);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(2, MixinA::s_traceCount);
 }
 
-class GCParkingThreadTester {
- public:
-  static void test() {
-    std::unique_ptr<WebThread> sleepingThread =
-        WTF::wrapUnique(Platform::current()->createThread("SleepingThread"));
-    sleepingThread->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(sleeperMainFunc));
-
-    // Wait for the sleeper to run.
-    while (!s_sleeperRunning) {
-      testing::yieldCurrentThread();
-    }
-
-    {
-      // Expect the first attempt to park the sleeping thread to fail
-      TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
-      EXPECT_FALSE(scope.allThreadsParked());
-    }
-
-    s_sleeperDone = true;
-
-    // Wait for the sleeper to finish.
-    while (s_sleeperRunning) {
-      // We enter the safepoint here since the sleeper thread will detach
-      // causing it to GC.
-      ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
-      testing::yieldCurrentThread();
-    }
-
-    {
-      // Since the sleeper thread has detached this is the only thread.
-      TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
-      EXPECT_TRUE(scope.allThreadsParked());
-    }
-  }
-
- private:
-  static void sleeperMainFunc() {
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
-    s_sleeperRunning = true;
-
-    // Simulate a long running op that is not entering a safepoint.
-    while (!s_sleeperDone) {
-      testing::yieldCurrentThread();
-    }
-
-    ThreadState::detachCurrentThread();
-    s_sleeperRunning = false;
-  }
-
-  static volatile bool s_sleeperRunning;
-  static volatile bool s_sleeperDone;
-};
-
-volatile bool GCParkingThreadTester::s_sleeperRunning = false;
-volatile bool GCParkingThreadTester::s_sleeperDone = false;
-
-TEST(HeapTest, GCParkingTimeout) {
-  GCParkingThreadTester::test();
-}
-
 TEST(HeapTest, NeedsAdjustAndMark) {
   // class Mixin : public GarbageCollectedMixin {};
   static_assert(NeedsAdjustAndMark<Mixin>::value,
                 "A Mixin pointer needs adjustment");
   static_assert(NeedsAdjustAndMark<Mixin>::value,
                 "A const Mixin pointer needs adjustment");
 
   // class SimpleObject : public GarbageCollected<SimpleObject> {};
   static_assert(!NeedsAdjustAndMark<SimpleObject>::value,
                 "A SimpleObject pointer does not need adjustment");
@@ skipping 608 matching lines @@
 
 static void parkWorkerThread() {
   workerThreadCondition().wait(workerThreadMutex());
 }
 
 static void wakeWorkerThread() {
   MutexLocker locker(workerThreadMutex());
   workerThreadCondition().signal();
 }
 
-class DeadBitTester {

[haraken, 2017/01/12 04:26:33]

Yeah, removing this test makes sense.

Sigbjorn: I begin to think that it's not possible to hit a Dead state in the
world of the per-thread heaps. A HeapObjectHeader is marked as Dead only when a
next GC is hit before the thread gets a chance to run preSweep(). It should not
happen with the per-thread heaps, right?

[sof, 2017/01/12 08:29:30]

I think that's correct also. completeSweep() will happen before the next GC goes
ahead, so "dead" object states shouldn't be observable during the next GC
marking pass.

- public:
-  static void test() {
-    IntWrapper::s_destructorCalls = 0;
-
-    MutexLocker locker(mainThreadMutex());
-    std::unique_ptr<WebThread> workerThread = WTF::wrapUnique(
-        Platform::current()->createThread("Test Worker Thread"));
-    workerThread->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(workerThreadMain));
-
-    // Wait for the worker thread to have done its initialization,
-    // IE. the worker allocates an object and then throw aways any
-    // pointers to it.
-    parkMainThread();
-
-    // Now do a GC. This will not find the worker threads object since it
-    // is not referred from any of the threads. Even a conservative
-    // GC will not find it.
-    // Also at this point the worker is waiting for the main thread
-    // to be parked and will not do any sweep of its heap.
-    preciselyCollectGarbage();
-
-    // Since the worker thread is not sweeping the worker object should
-    // not have been finalized.
-    EXPECT_EQ(0, IntWrapper::s_destructorCalls);
-
-    // Put the worker thread's object address on the stack and do a
-    // conservative GC. This should find the worker object, but since
-    // it was dead in the previous GC it should not be traced in this
-    // GC.
-    uintptr_t stackPtrValue = s_workerObjectPointer;
-    s_workerObjectPointer = 0;
-    DCHECK(stackPtrValue);
-    conservativelyCollectGarbage();
-
-    // Since the worker thread is not sweeping the worker object should
-    // not have been finalized.
-    EXPECT_EQ(0, IntWrapper::s_destructorCalls);
-
-    // Wake up the worker thread so it can continue with its sweeping.
-    // This should finalized the worker object which we test below.
-    // The worker thread will go back to sleep once sweeping to ensure
-    // we don't have thread local GCs until after validating the destructor
-    // was called.
-    wakeWorkerThread();
-
-    // Wait for the worker thread to sweep its heaps before checking.
-    parkMainThread();
-    EXPECT_EQ(1, IntWrapper::s_destructorCalls);
-
-    // Wake up the worker to allow it thread to continue with thread
-    // shutdown.
-    wakeWorkerThread();
-  }
-
- private:
-  static void workerThreadMain() {
-    MutexLocker locker(workerThreadMutex());
-
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
-
-    {
-      // 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();
-
-    {
-      // Wait for the main thread to do two GCs without sweeping this thread
-      // heap. The worker waits within a safepoint, but there is no sweeping
-      // until leaving the safepoint scope.
-      SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
-      parkWorkerThread();
-    }
-
-    // Wake up the main thread when done sweeping.
-    wakeMainThread();
-
-    // Wait with detach until the main thread says so. This is not strictly
-    // necessary, but it means the worker thread will not do its thread local
-    // GCs just yet, making it easier to reason about that no new GC has
-    // occurred and the above sweep was the one finalizing the worker object.
-    parkWorkerThread();
-
-    ThreadState::detachCurrentThread();
-  }
-
-  static volatile uintptr_t s_workerObjectPointer;
-};
-
-volatile uintptr_t DeadBitTester::s_workerObjectPointer = 0;
-
-TEST(HeapTest, ObjectDeadBit) {
-  DeadBitTester::test();
-}
-
 class ThreadedStrongificationTester {
  public:
   static void test() {
     IntWrapper::s_destructorCalls = 0;
 
     MutexLocker locker(mainThreadMutex());
     std::unique_ptr<WebThread> workerThread = WTF::wrapUnique(
         Platform::current()->createThread("Test Worker Thread"));
     workerThread->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE, crossThreadBind(workerThreadMain));
@@ skipping 58 matching lines @@
       SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       parkWorkerThread();
     }
 
     return weakCollection;
   }
 
   static void workerThreadMain() {
     MutexLocker locker(workerThreadMutex());
 
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
+    ThreadState::attachCurrentThread();
 
     {
       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 94 matching lines @@
 
   static int s_destructorCalls;
   DEFINE_INLINE_TRACE() {}
 
  private:
   DestructorLockingObject() {}
 };
 
 int DestructorLockingObject::s_destructorCalls = 0;
 
-class RecursiveLockingTester {
- public:
-  static void test() {
-    DestructorLockingObject::s_destructorCalls = 0;
-
-    MutexLocker locker(mainThreadMutex());
-    std::unique_ptr<WebThread> workerThread = WTF::wrapUnique(
-        Platform::current()->createThread("Test Worker Thread"));
-    workerThread->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(workerThreadMain));
-
-    // Park the main thread until the worker thread has initialized.
-    parkMainThread();
-
-    {
-      SafePointAwareMutexLocker recursiveLocker(recursiveMutex());
-
-      // Let the worker try to acquire the above mutex. It won't get it
-      // until the main thread has done its GC.
-      wakeWorkerThread();
-
-      preciselyCollectGarbage();
-
-      // The worker thread should not have swept yet since it is waiting
-      // to get the global mutex.
-      EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
-    }
-    // At this point the main thread releases the global lock and the worker
-    // can acquire it and do its sweep of its arenas. 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::attachCurrentThread(BlinkGC::MainThreadHeapMode);
-
-    DestructorLockingObject* dlo = DestructorLockingObject::create();
-    DCHECK(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
-    // block in the SafePointAwareMutexLocker until the main thread
-    // has done a GC. The GC will not mark the "dlo" object since the worker
-    // is entering the safepoint with NoHeapPointersOnStack. When the worker
-    // subsequently gets the global lock and leaves the safepoint it will
-    // sweep its heap and finalize "dlo". The destructor of "dlo" will try
-    // to acquire the same global lock that the thread just got and deadlock
-    // unless the global lock is recursive.
-    parkWorkerThread();
-    SafePointAwareMutexLocker recursiveLocker(recursiveMutex(),
-                                              BlinkGC::NoHeapPointersOnStack);
-
-    // We won't get here unless the lock is recursive since the sweep done
-    // in the constructor of SafePointAwareMutexLocker after
-    // getting the lock will not complete given the "dlo" destructor is
-    // waiting to get the same lock.
-    // Tell the main thread the worker has done its sweep.
-    wakeMainThread();
-
-    ThreadState::detachCurrentThread();
-  }
-
-  static volatile IntWrapper* s_workerObjectPointer;
-};
-
-TEST(HeapTest, RecursiveMutex) {
-  RecursiveLockingTester::test();
-}
-
 template <typename T>
 class TraceIfNeededTester
     : public GarbageCollectedFinalized<TraceIfNeededTester<T>> {
  public:
   static TraceIfNeededTester<T>* create() {
     return new TraceIfNeededTester<T>();
   }
   static TraceIfNeededTester<T>* create(const T& obj) {
     return new TraceIfNeededTester<T>(obj);
   }
@@ skipping 642 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::attachCurrentThread(BlinkGC::MainThreadHeapMode);
+  ThreadState::attachCurrentThread();
   *object = DestructorLockingObject::create();
   wakeMainThread();
   parkWorkerThread();
 
   // Step 4: Run a GC.
   ThreadState::current()->collectGarbage(
       BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
   wakeMainThread();
   parkWorkerThread();
 
@@ skipping 109 matching lines @@
   static void test() {
     IntWrapper::s_destructorCalls = 0;
     ThreadedTesterBase::test(new ThreadedClearOnShutdownTester);
     EXPECT_EQ(numberOfThreads, IntWrapper::s_destructorCalls);
   }
 
  private:
   void runWhileAttached();
 
   void runThread() override {
-    ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
+    ThreadState::attachCurrentThread();
     EXPECT_EQ(42, threadSpecificIntWrapper().value());
     runWhileAttached();
     ThreadState::detachCurrentThread();
     atomicDecrement(&m_threadsToFinish);
   }
 
   class HeapObject;
   friend class HeapObject;
 
   using WeakHeapObjectSet = PersistentHeapHashSet<WeakMember<HeapObject>>;
@@ skipping 160 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink