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

Source/platform/heap/Heap.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 283 matching lines @@
 
     MemoryRegion m_reserved;
     MemoryRegion m_writable;
 };
 
 class GCScope {
 public:
     explicit GCScope(ThreadState::StackState stackState)
         : m_state(ThreadState::current())
         , m_safePointScope(stackState)
+        , m_parkedAllThreads(false)
     {
         TRACE_EVENT0("Blink", "Heap::GCScope");
         const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
         if (m_state->isMainThread())
             TRACE_EVENT_SET_SAMPLING_STATE("Blink", "BlinkGCWaiting");
 
         m_state->checkThread();
 
         // FIXME: in an unlikely coincidence that two threads decide
         // to collect garbage at the same time, avoid doing two GCs in
         // a row.
         RELEASE_ASSERT(!m_state->isInGC());
         RELEASE_ASSERT(!m_state->isSweepInProgress());
-        ThreadState::stopThreads();
-        m_state->enterGC();
-
+        if (LIKELY(ThreadState::stopThreads())) {
+            m_parkedAllThreads = true;
+            m_state->enterGC();
+        }
         if (m_state->isMainThread())
             TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
     }
 
+    bool allThreadsParked() { return m_parkedAllThreads; }
+
     ~GCScope()
     {
-        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
 };
 
 NO_SANITIZE_ADDRESS
 bool HeapObjectHeader::isMarked() const
 {
     checkHeader();
     return m_size & markBitMask;
 }
 
 NO_SANITIZE_ADDRESS
@@ skipping 1249 matching lines @@
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->prepareForGC();
 }
 
 void Heap::collectGarbage(ThreadState::StackState stackState)
 {
     ThreadState* state = ThreadState::current();
     state->clearGCRequested();
 
     GCScope gcScope(stackState);
-
+    // Check if we successfully parked the other threads. If not we bail out of the GC.
+    if (!gcScope.allThreadsParked()) {
+        ThreadState::current()->setGCRequested();
+        return;
+    }
     TRACE_EVENT0("Blink", "Heap::collectGarbage");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BlinkGC");
-
 #if ENABLE(GC_TRACING)
     static_cast<MarkingVisitor*>(s_markingVisitor)->objectGraph().clear();
 #endif
 
     // Disallow allocation during garbage collection (but not
     // during the finalization that happens when the gcScope is
     // torn down).
     NoAllocationScope<AnyThread> noAllocationScope;
 
     prepareForGC();
@@ skipping 67 matching lines @@
 template class HeapPage<FinalizedHeapObjectHeader>;
 template class HeapPage<HeapObjectHeader>;
 template class ThreadHeap<FinalizedHeapObjectHeader>;
 template class ThreadHeap<HeapObjectHeader>;
 
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 bool Heap::s_shutdownCalled = false;
 }