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

Source/platform/heap/ThreadState.h

 /*
  * 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 34 matching lines @@
 
 class BaseHeap;
 class BaseHeapPage;
 class FinalizedHeapObjectHeader;
 struct GCInfo;
 class HeapContainsCache;
 class HeapObjectHeader;
 class PersistentNode;
 class Visitor;
 class SafePointBarrier;
+class SafePointAwareMutexLocker;
 template<typename Header> class ThreadHeap;
 class CallbackStack;
 
 typedef uint8_t* Address;
 
 typedef void (*FinalizationCallback)(void*);
 typedef void (*VisitorCallback)(Visitor*, void* self);
 typedef VisitorCallback TraceCallback;
 typedef VisitorCallback WeakPointerCallback;
 
@@ skipping 297 matching lines @@
     static bool stopThreads();
     static void resumeThreads();
 
     // Check if GC is requested by another thread and pause this thread if this is the case.
     // Can only be called when current thread is in a consistent state.
     void safePoint(StackState);
 
     // Mark current thread as running inside safepoint.
     void enterSafePointWithoutPointers() { enterSafePoint(NoHeapPointersOnStack, 0); }
     void enterSafePointWithPointers(void* scopeMarker) { enterSafePoint(HeapPointersOnStack, scopeMarker); }
-    void leaveSafePoint();
+    void leaveSafePoint(SafePointAwareMutexLocker* = 0);
     bool isAtSafePoint() const { return m_atSafePoint; }
 
     class SafePointScope {
     public:
         enum ScopeNesting {
             NoNesting,
             AllowNesting
         };
 
         explicit SafePointScope(StackState stackState, ScopeNesting nesting = NoNesting)
@@ skipping 120 matching lines @@
 
     void getStats(HeapStats&);
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
 
 private:
     explicit ThreadState();
     ~ThreadState();
 
     friend class SafePointBarrier;
+    friend class SafePointAwareMutexLocker;
 
     void enterSafePoint(StackState, void*);
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
     {
         m_safePointStackCopy.clear();
         m_safePointScopeMarker = 0;
     }
 
     void performPendingGC(StackState);
@@ skipping 71 matching lines @@
         ASSERT(ThreadState::current()->isMainThread());
         return ThreadState::mainThreadState();
     }
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
+// The SafePointAwareMutexLocker is used to enter a safepoint while waiting for
+// mutex lock. It also ensures that the lock is not held while waiting for a GC
+// to complete in the leaveSafePoint method, by releasing the lock if the
+// leaveSafePoint method cannot complete without blocking, see
+// SafePointBarrier::checkAndPark.

[zerny-chromium, 2014/06/17 11:12:56]

Nits:
The SafePointAwareMutexLocker is -> SafePointAwareMutexLocker is
for mutex lock -> for a mutex lock.

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

Done.

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

... It also ensures that the lock is not held while waiting for the
leaveSafePoint() to complete a GC. This is realized by releasing the lock when
the leaveSafePoint() cannot complete without blocking. See a comment in
SafePointBarrier::checkAndPark.

+class SafePointAwareMutexLocker {
+    WTF_MAKE_NONCOPYABLE(SafePointAwareMutexLocker);
+public:
+    SafePointAwareMutexLocker(Mutex& mutex) : m_mutex(mutex), m_locked(false)

[zerny-chromium, 2014/06/17 11:12:56]

nit: explicit

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

Done.

+    {
+        ThreadState* state = ThreadState::current();
+        do {
+            bool leaveSafePoint = false;
+            if (!state->isAtSafePoint()) {
+                state->enterSafePoint(ThreadState::HeapPointersOnStack, this);
+                leaveSafePoint = true;
+            }
+            m_mutex.lock();
+            m_locked = true;
+            if (leaveSafePoint) {

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

Do we need |leaveSafePoint|? Probably we can use 'if (state->isAtSafePoint)'.

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

No, unfortunately not since we only want to leave the safepoint if we were the
one entering it.  Ie. we need to track that we explicitly called enterSafePoint
to make sure we don't release that was nesting the SafePointAwareMutexLocker.

+                state->leaveSafePoint(this);

[zerny-chromium, 2014/06/17 11:12:56]

Maybe add a comment here about "leaveSafePoint" possibly releasing the lock via
reset().

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

Done.

+            }
+        } while (!m_locked);
+    }
+
+    ~SafePointAwareMutexLocker()
+    {
+        ASSERT(m_locked);
+        m_mutex.unlock();
+    }
+
+private:
+    friend class SafePointBarrier;
+
+    void reset()
+    {
+        ASSERT(m_locked);
+        m_mutex.unlock();
+        m_locked = false;
+    }
+
+    Mutex& m_mutex;
+    bool m_locked;
+};
+
 }
 
 #endif // ThreadState_h