[oilpan]: Don't sweep while in safepoint.

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 180 matching lines @@
         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();
+            state->setSweepRequested();

[haraken, 2014/06/26 13:52:11]

Do we need to call this?

I guess setSweepRequested is alerady called for all attached threads by the
GCing thread (see Heap::prepareForGC()).

[Mads Ager (chromium), 2014/06/26 13:52:40]

I don't think we need to actually set sweep requested here that should have been
already done otherwise the performPendingSweep call would do nothing here.

So it seem you can just remove performPendingSweep from here and call it after
checkAndPark.

[wibling-chromium, 2014/06/27 10:07:48]

No, that is actually wrong. We risk sweeping when no marking has been done. Will
remove.

[wibling-chromium, 2014/06/27 10:07:48]

Done.

         }
     }
 
     void enterSafePoint(ThreadState* state)
     {
         ASSERT(!state->isSweepInProgress());
         pushAllRegisters(this, state, enterSafePointAfterPushRegisters);
     }
 
     void leaveSafePoint(ThreadState* state, SafePointAwareMutexLocker* locker = 0)
@@ skipping 539 matching lines @@
 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;
+    performPendingSweep();
 }
 
 #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.
 NO_SANITIZE_ADDRESS static void* adjustScopeMarkerForAdressSanitizer(void* scopeMarker)
@@ skipping 144 matching lines @@
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 }