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

Source/platform/heap/ThreadState.cpp

Index: Source/platform/heap/ThreadState.cpp
diff --git a/Source/platform/heap/ThreadState.cpp b/Source/platform/heap/ThreadState.cpp
index 75a6c81ed865246377001d1202159aba14d2abff..1b28e26edaac27933a5485dace518ad79f7c5550 100644
--- a/Source/platform/heap/ThreadState.cpp
+++ b/Source/platform/heap/ThreadState.cpp
@@ -104,7 +104,7 @@ static Mutex& threadAttachMutex()
 
 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;
 }
 
@@ -186,10 +186,17 @@ public:
         ASSERT(ThreadState::current()->isAtSafePoint());
     }
 
-    void checkAndPark(ThreadState* state)
+    void checkAndPark(ThreadState* state, SafePointAwareMutexLocker* locker = 0)

[haraken, 2014/06/17 12:25:41]

Does the |locker| need to be an optional parameter?

[wibling-chromium, 2014/06/17 12:38:21]

I prefer it that way to avoid having to pass in 0 from the normal call sites. It
is a style preference, both would work.

     {
         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
+            // lock to be acquired in the sweep phase, e.g. during weak processing

[Mads Ager (chromium), 2014/06/17 11:57:19]

lock to be -> the lock to be

[wibling-chromium, 2014/06/17 12:06:40]

Done.

+            // 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();
         }
@@ -201,10 +208,10 @@ public:
         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:
@@ -745,8 +752,11 @@ void ThreadState::safePoint(StackState stackState)
 {
     checkThread();
     performPendingGC(stackState);
+    ASSERT(!m_atSafePoint);

[haraken, 2014/06/17 12:25:41]

Just to confirm: The SafePointAwareLocker is reentrant, but the SafePoint itself
is not reentrant. In other words, the SafePointAwareLocker is implemented in a
way that it doesn't nest SafePoints used by the SafePointAwareLocker. Right?

[wibling-chromium, 2014/06/17 12:38:21]

The SafePointAwareLocker is only entering the safepoint when trying to acquire
the lock, ie. only during the constructor. This means that we are not in a
safepoint after leaving the SafePointAwareMutexLocker's constructor.
In that sense you can argue the SafePointAwareMutexLocker is reentrant, but it
is more that it is only in the safepoint while waiting on the acquisition of the
lock.

As you have noticed we also only try to enter the safepoint in the
SafePointAwareMutexLocker's constructor if we are not already in a safepoint.
This avoids us hitting the above assert. 

Basically we don't support entering a safepoint while in a safepoint, but we do
support using the SafePointAwareMutexLocker while in a safepoint.

[haraken, 2014/06/17 14:25:36]

Thanks, makes a lot of sense!

     m_stackState = stackState;
+    m_atSafePoint = true;
     s_safePointBarrier->checkAndPark(this);
+    m_atSafePoint = false;

[haraken, 2014/06/17 12:25:41]

Nice catch. We should have had these lines...

     m_stackState = HeapPointersOnStack;
 }
 
@@ -791,11 +801,11 @@ void ThreadState::enterSafePoint(StackState stackState, void* 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();