[oilpan]: Make parking threads for GC timeout in the case parking exceeds 100 MS

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 18 matching lines @@
  */
 
 #include "config.h"
 
 #include "platform/heap/Handle.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/HeapLinkedStack.h"
 #include "platform/heap/HeapTerminatedArrayBuilder.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
+#include "public/platform/Platform.h"
 #include "wtf/HashTraits.h"
 #include "wtf/LinkedHashSet.h"
 
 #include <gtest/gtest.h>
 
 namespace WebCore {
 
 class ThreadMarker {
 public:
     ThreadMarker() : m_creatingThread(reinterpret_cast<ThreadState*>(0)), m_num(0) { }
@@ skipping 43 matching lines @@
 
 }
 
 namespace WebCore {
 
 class TestGCScope {
 public:
     explicit TestGCScope(ThreadState::StackState state)
         : m_state(ThreadState::current())
         , m_safePointScope(state)
+        , m_parkedAllThreads(false)
     {
         m_state->checkThread();
         EXPECT_FALSE(m_state->isInGC());
-        ThreadState::stopThreads();
-        m_state->enterGC();
+        if (LIKELY(ThreadState::stopThreads())) {
+            m_state->enterGC();
+            m_parkedAllThreads = true;
+        }
     }
 
+    bool allThreadsParked() { return m_parkedAllThreads; }
+
     ~TestGCScope()
     {
-        m_state->leaveGC();
-        EXPECT_FALSE(m_state->isInGC());
-        ThreadState::resumeThreads();
+        // Only cleanup if we parked all threads in which case the GC happened
+        // and we need to resume the other threads.
+        if (LIKELY(m_parkedAllThreads)) {
+            m_state->leaveGC();
+            EXPECT_FALSE(m_state->isInGC());
+            ThreadState::resumeThreads();
+        }
     }
 
 private:
     ThreadState* m_state;
     ThreadState::SafePointScope m_safePointScope;
+    bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
 static void getHeapStats(HeapStats* stats)
 {
     TestGCScope scope(ThreadState::NoHeapPointersOnStack);
+    EXPECT_TRUE(scope.allThreadsParked());
     Heap::getStats(stats);
 }
 
 #define DEFINE_VISITOR_METHODS(Type)                                       \
     virtual void mark(const Type* object, TraceCallback callback) OVERRIDE \
     {                                                                      \
         if (object)                                                        \
             m_count++;                                                     \
     }                                                                      \
     virtual bool isMarked(const Type*) OVERRIDE { return false; }
@@ skipping 209 matching lines @@
 int IntWrapper::s_destructorCalls = 0;
 int OffHeapInt::s_destructorCalls = 0;
 
 class ThreadedTesterBase {
 protected:
     static void test(ThreadedTesterBase* tester)
     {
         for (int i = 0; i < numberOfThreads; i++)
             createThread(&threadFunc, tester, "testing thread");
         while (tester->m_threadsToFinish) {
-            ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
+            ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             yield();
         }
         delete tester;
     }
 
     virtual void runThread() = 0;
 
 protected:
     static const int numberOfThreads = 10;
     static const int gcPerThread = 5;
@@ skipping 37 matching lines @@
             {
                 Persistent<IntWrapper> wrapper;
 
                 typedef Persistent<IntWrapper, GlobalPersistents> GlobalIntWrapperPersistent;
                 OwnPtr<GlobalIntWrapperPersistent> globalPersistent = adoptPtr(new GlobalIntWrapperPersistent(IntWrapper::create(0x0ed0cabb)));
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     wrapper = IntWrapper::create(0x0bbac0de);
                     if (!(i % 10)) {
                         globalPersistent = adoptPtr(new GlobalIntWrapperPersistent(IntWrapper::create(0x0ed0cabb)));
-                        ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
                     }
+                    ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
                     yield();
                 }
 
                 if (gcCount < gcPerThread) {
                     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
                     gcCount++;
                     atomicIncrement(&m_gcCount);
                 }
 
                 Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
                 EXPECT_EQ(wrapper->value(), 0x0bbac0de);
                 EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
             }
+            ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             yield();
         }
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
     virtual void runThread() OVERRIDE
     {
         ThreadState::attach();
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(ThreadState::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));
                     weakMap2.add(static_cast<unsigned>(i), IntWrapper::create(0));
-                    if (!(i % 10)) {
-                        ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
-                    }
+                    ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
                     yield();
                 }
 
                 if (gcCount < gcPerThread) {
                     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
                     gcCount++;
                     atomicIncrement(&m_gcCount);
                 }
 
                 Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
                 EXPECT_TRUE(weakMap->isEmpty());
                 EXPECT_TRUE(weakMap2.isEmpty());
             }
+            ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             yield();
         }
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 // The accounting for memory includes the memory used by rounding up object
 // sizes. This is done in a different way on 32 bit and 64 bit, so we have to
 // have some slack in the tests.
@@ skipping 2785 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(ThreadState::HeapPointersOnStack);
+        EXPECT_TRUE(scope.allThreadsParked()); // Fail the test if we could not park all threads.
         Heap::makeConsistentForGC();
         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(&initialHeapStats);
     {
         TestGCScope scope(ThreadState::HeapPointersOnStack);
+        EXPECT_TRUE(scope.allThreadsParked());
         Heap::makeConsistentForGC();
         for (size_t i = 0; i < objectAddresses.size(); i++) {
             EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, objectAddresses[i]));
             EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, endAddresses[i]));
         }
         EXPECT_EQ(0ul, visitor.count());
         EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, largeObjectAddress));
         EXPECT_FALSE(Heap::checkAndMarkPointer(&visitor, largeObjectEndAddress));
         EXPECT_EQ(0ul, visitor.count());
     }
@@ skipping 569 matching lines @@
     }
     {
         Persistent<MixinB> b = obj;
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(0, IntWrapper::s_destructorCalls);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(3, IntWrapper::s_destructorCalls);
 }
 
+class GCParkingThreadTester {
+public:
+    static void test()
+    {
+        createThread(&sleeperMainFunc, 0, "SleepingThread");
+
+        // Wait for the sleeper to run.
+        while (!s_sleeperRunning) {
+            yield();
+        }
+
+        {
+            // Expect the first attempt to park the sleeping thread to fail
+            TestGCScope scope(ThreadState::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(ThreadState::NoHeapPointersOnStack);
+            yield();
+        }
+        {
+            // Since the sleeper thread has detached this is the only thread.
+            TestGCScope scope(ThreadState::NoHeapPointersOnStack);
+            EXPECT_TRUE(scope.allThreadsParked());
+        }
+    }
+
+private:
+    static void sleeperMainFunc(void* data)
+    {
+        ThreadState::attach();
+        s_sleeperRunning = true;
+
+        // Simulate a long running op that is not entering a safepoint.
+        while (!s_sleeperDone) {
+            yield();
+        }
+
+        ThreadState::detach();
+        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();
+}
+
 } // WebCore namespace