[oilpan]: Add SafePointAwareMutexLocker to allow GC when waiting for lock.

Source/platform/heap/ThreadState.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 86 matching lines @@
 bool ThreadState::s_inGC = false;
 
 static Mutex& threadAttachMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
 
 static double lockingTimeout()
 {
-    // Wait time for parking all threads is at most 500 MS.
+    // Wait time for parking all threads is at most 100 MS.
     return 0.100;
 }
 
 
 typedef void (*PushAllRegistersCallback)(SafePointBarrier*, ThreadState*, intptr_t*);
 extern "C" void pushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback);
 
 class SafePointBarrier {
 public:
     SafePointBarrier() : m_canResume(1), m_unparkedThreadCount(0) { }
@@ skipping 61 matching lines @@
 
             const Vector<ThreadState::Interruptor*>& interruptors = (*it)->interruptors();
             for (size_t i = 0; i < interruptors.size(); i++)
                 interruptors[i]->clearInterrupt();
         }
 
         threadAttachMutex().unlock();
         ASSERT(ThreadState::current()->isAtSafePoint());
     }
 
-    void checkAndPark(ThreadState* state)
+    void checkAndPark(ThreadState* state, SafePointAwareMutexLocker* locker = 0)
     {
         ASSERT(!state->isSweepInProgress());
         if (!acquireLoad(&m_canResume)) {
+            // If we are leaving the safepoint from a SafePointAwareMutexLocker
+            // call out to release the lock before going to sleep. This enables the
+            // lock to be acquired in the sweep phase, e.g. during weak processing
+            // or finalization. The SafePointAwareLocker will reenter the safepoint
+            // and reacquire the lock after leaving this safepoint.
+            if (locker)
+                locker->reset();
             pushAllRegisters(this, state, parkAfterPushRegisters);
             state->performPendingSweep();
         }
     }
 
     void enterSafePoint(ThreadState* state)
     {
         ASSERT(!state->isSweepInProgress());
         pushAllRegisters(this, state, enterSafePointAfterPushRegisters);
     }
 
-    void leaveSafePoint(ThreadState* state)
+    void leaveSafePoint(ThreadState* state, SafePointAwareMutexLocker* locker = 0)
     {
         if (atomicIncrement(&m_unparkedThreadCount) > 0)
-            checkAndPark(state);
+            checkAndPark(state, locker);
     }
 
 private:
     void doPark(ThreadState* state, intptr_t* stackEnd)
     {
         state->recordStackEnd(stackEnd);
         MutexLocker locker(m_mutex);
         if (!atomicDecrement(&m_unparkedThreadCount))
             m_parked.signal();
         while (!acquireLoad(&m_canResume))
@@ skipping 520 matching lines @@
 
 void ThreadState::resumeThreads()
 {
     s_safePointBarrier->resumeOthers();
 }
 
 void ThreadState::safePoint(StackState stackState)
 {
     checkThread();
     performPendingGC(stackState);
+    ASSERT(!m_atSafePoint);
     m_stackState = stackState;
+    m_atSafePoint = true;
     s_safePointBarrier->checkAndPark(this);
+    m_atSafePoint = false;
     m_stackState = HeapPointersOnStack;
 }
 
 #ifdef ADDRESS_SANITIZER
 // When we are running under AddressSanitizer with detect_stack_use_after_return=1
 // then stack marker obtained from SafePointScope will point into a fake stack.
 // Detect this case by checking if it falls in between current stack frame
 // and stack start and use an arbitrary high enough value for it.
 // Don't adjust stack marker in any other case to match behavior of code running
 // without AddressSanitizer.
@@ skipping 24 matching lines @@
     ASSERT(stackState == NoHeapPointersOnStack || scopeMarker);
     performPendingGC(stackState);
     checkThread();
     ASSERT(!m_atSafePoint);
     m_atSafePoint = true;
     m_stackState = stackState;
     m_safePointScopeMarker = scopeMarker;
     s_safePointBarrier->enterSafePoint(this);
 }
 
-void ThreadState::leaveSafePoint()
+void ThreadState::leaveSafePoint(SafePointAwareMutexLocker* locker)
 {
     checkThread();
     ASSERT(m_atSafePoint);
-    s_safePointBarrier->leaveSafePoint(this);
+    s_safePointBarrier->leaveSafePoint(this, locker);
     m_atSafePoint = false;
     m_stackState = HeapPointersOnStack;
     clearSafePointScopeMarker();
     performPendingSweep();
 }
 
 void ThreadState::copyStackUntilSafePointScope()
 {
     if (!m_safePointScopeMarker || m_stackState == NoHeapPointersOnStack)
         return;
@@ skipping 96 matching lines @@
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 }