[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();
         ASSERT(!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();
-        ASSERT(!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();
+            ASSERT(!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 3029 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 415 matching lines @@
 TEST(HeapTest, DestructorsCalledOnMapClear)
 {
     HeapHashMap<SimpleClassWithDestructor*, OwnPtr<SimpleClassWithDestructor> > map;
     SimpleClassWithDestructor* hasDestructor = new SimpleClassWithDestructor();
     map.add(hasDestructor, adoptPtr(hasDestructor));
     SimpleClassWithDestructor::s_wasDestructed = false;
     map.clear();
     ASSERT(SimpleClassWithDestructor::s_wasDestructed);
 }
 
+
+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) {
+            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