[oilpan]: Don't enter safepoint in SafePointAwareMutexLocker if sweeping.

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 599 matching lines @@
 // leaveSafePoint method cannot complete without blocking, see
 // SafePointBarrier::checkAndPark.
 class SafePointAwareMutexLocker {
     WTF_MAKE_NONCOPYABLE(SafePointAwareMutexLocker);
 public:
     explicit SafePointAwareMutexLocker(Mutex& mutex) : m_mutex(mutex), m_locked(false)
     {
         ThreadState* state = ThreadState::current();
         do {
             bool leaveSafePoint = false;
-            if (!state->isAtSafePoint()) {
+            // We cannot enter a safepoint if we are currently sweeping. In that
+            // case we just try to acquire the lock without being at a safepoint.
+            // If another thread tries to do a GC at that time it might time out
+            // due to this thread not being at a safepoint and waiting on the lock.

[haraken, 2014/07/01 10:35:10]

Would you elaborate on why this doesn't cause dead lock?

(1) Thread 1 is sweeping.
(2) Thread 2 calls SafePointAwareMutexLocker. It acquires the mutex.
(3) Thread 2 triggers a GC.
(4) Thread 1 calls SafePointAwareMutexLocker. It tries to acquire the mutex.
(5) Dead lock?

Actually I don't fully understand why we cannot enter a safe point while
sweeping. It seems we can just enter a safe point, and if a GC is triggered we
can just clear the mark bits and restart the GC. I'd be happy if you could just
help me understand :)

+            if (!state->isSweepInProgress() && !state->isAtSafePoint()) {
                 state->enterSafePoint(ThreadState::HeapPointersOnStack, this);
                 leaveSafePoint = true;
             }
             m_mutex.lock();
             m_locked = true;
             if (leaveSafePoint) {
                 // When leaving the safepoint we might end up release the mutex
                 // if another thread is requesting a GC, see
                 // SafePointBarrier::checkAndPark. This is the case where we
                 // loop around to reacquire the lock.
@@ skipping 18 matching lines @@
         m_locked = false;
     }
 
     Mutex& m_mutex;
     bool m_locked;
 };
 
 }
 
 #endif // ThreadState_h