[oilpan] Rename PauseScope to SafePointScope

Source/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 41 matching lines @@
 typedef void (*PushAllRegistersCallback)(SafePointBarrier*, ThreadState*, intptr_t*);
 extern "C" void pushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback);
 
 static Mutex& threadAttachMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
 
 static void parkAfterPushRegisters(SafePointBarrier*, ThreadState*, intptr_t* stackEnd);
-static void notifyPausedAfterPushRegisters(SafePointBarrier*, ThreadState*, intptr_t* stackEnd);
+static void enterSafePointAfterPushRegisters(SafePointBarrier*, ThreadState*, intptr_t* stackEnd);
 
 class SafePointBarrier {
 public:
     SafePointBarrier()
     {
         NoBarrier_Store(&m_unparkedThreadCount, 0);
         Release_Store(&m_canResume, 1);
     }
 
     ~SafePointBarrier()
     {
     }
 
-    // Request other attached and non-paused threads to park themselves on safepoints.
+    // Request other attached and not-in-safe-point threads to park themselves on safepoints.
     void parkOthers(ThreadState::StackState stackState)
     {
-        // Mark current thread as paused before attempting to lock the threadAttachMutex(). This will
+        // Enter safe point before attempting to lock the threadAttachMutex(). This will
         // allow to avoid dead-lock if two threads arrive into parkOthers() simultaneously.
-        ThreadState::Current()->paused(stackState);
+        ThreadState::Current()->enterSafePoint(stackState);
 
         // Lock threadAttachMutex() to prevent threads from attaching.
         threadAttachMutex().lock();
 
         ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
 
         MutexLocker locker(m_mutex);
         NoBarrier_AtomicIncrement(&m_unparkedThreadCount, threads.size());
         Release_Store(&m_canResume, 0);
 
         for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
             if ((*it)->interruptor())
                 (*it)->interruptor()->requestInterrupt();
         }
 
         while (NoBarrier_Load(&m_unparkedThreadCount) > 0)
             m_parked.wait(m_mutex);
     }
 
     void resumeOthers()
     {
         ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
         NoBarrier_AtomicIncrement(&m_unparkedThreadCount, -threads.size());
         Release_Store(&m_canResume, 1);
         {
-            // FIXME(oilpan) resumed threads will all contend for
+            // FIXME(oilpan): Resumed threads will all contend for
             // m_mutex just to unlock it later which is a waste of
             // resources.
             MutexLocker locker(m_mutex);
             m_resume.broadcast();
         }
 
         for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
             if ((*it)->interruptor())
                 (*it)->interruptor()->clearInterrupt();
         }
 
         threadAttachMutex().unlock();
-        ThreadState::Current()->resumed();
+        ThreadState::Current()->leaveSafePoint();
     }
 
     void doPark(ThreadState* state, intptr_t* stackEnd)
     {
         state->recordStackEnd(stackEnd);
         MutexLocker locker(m_mutex);
         if (!NoBarrier_AtomicIncrement(&m_unparkedThreadCount, -1))
             m_parked.signal();
         while (!NoBarrier_Load(&m_canResume))
             m_resume.wait(m_mutex);
         NoBarrier_AtomicIncrement(&m_unparkedThreadCount, 1);
     }
 
     void checkAndPark(ThreadState* state)
     {
         ASSERT(!state->isSweepInProgress());
         if (!Acquire_Load(&m_canResume)) {
             pushAllRegisters(this, state, parkAfterPushRegisters);
             state->executePendingAction();
         }
     }
 
-    void doNotifyPaused(ThreadState* state, intptr_t* stackEnd)
+    void doEnterSafePoint(ThreadState* state, intptr_t* stackEnd)
     {
         state->recordStackEnd(stackEnd);
         if (!NoBarrier_AtomicIncrement(&m_unparkedThreadCount, -1)) {
             MutexLocker locker(m_mutex);
             m_parked.signal(); // Safe point reached.
         }
     }
 
-    void notifyPaused(ThreadState* state)
+    void enterSafePoint(ThreadState* state)
     {
         ASSERT(!state->isSweepInProgress());
-        pushAllRegisters(this, state, notifyPausedAfterPushRegisters);
+        pushAllRegisters(this, state, enterSafePointAfterPushRegisters);
     }
 
-    void notifyResumed(ThreadState* state)
+    void leaveSafePoint(ThreadState* state)
     {
         if (NoBarrier_AtomicIncrement(&m_unparkedThreadCount, 1) > 0)
             checkAndPark(state);
         state->executePendingAction();
     }
 
 private:
     volatile Atomic32 m_canResume;
     volatile Atomic32 m_unparkedThreadCount;
     Mutex m_mutex;
@@ skipping 35 matching lines @@
 {
     MutexLocker locker(threadAttachMutex());
     ThreadState* state = new ThreadState();
     state->create(startOfStack);
     attachedThreads().add(state);
 }
 
 void ThreadState::detach()
 {
     ThreadState* current = Current();
-    // Mark current thread as paused before trying to acquire threadAttachMutex
+    // Enter safe point before trying to acquire threadAttachMutex
     // to avoid dead lock if another thread is preparing for GC, has acquired
     // threadAttachMutex and waiting for other threads to pause or reach a
     // safepoint.
-    if (!current->isPaused())
-        current->paused(NoHeapPointersOnStack);
+    if (!current->isInSafePoint())
+        current->enterSafePoint(NoHeapPointersOnStack);
     MutexLocker locker(threadAttachMutex());
-    current->resumed();
+    current->leaveSafePoint();
     current->destroy();
     attachedThreads().remove(current);
     delete current;
 }
 
 void ThreadState::create(intptr_t* startOfStack)
 {
     ASSERT(!**s_threadSpecific);
     m_thread = currentThread();
     **s_threadSpecific = this;
@@ skipping 28 matching lines @@
     checkThread();
     delete m_heaps[GeneralHeap];
     for (int i = GeneralHeap + 1; i < NumberOfHeaps; i++)
         delete m_heaps[i];
     delete m_persistents;
     m_persistents = 0;
     delete m_interruptor;
     m_interruptor = 0;
 }
 
-void ThreadState::paused(StackState stackState)
+void ThreadState::enterSafePoint(StackState stackState)
 {
     if (stackState == NoHeapPointersOnStack && gcRequested())
         Heap::collectGarbage(NoHeapPointersOnStack);
     checkThread();
-    ASSERT(!m_isPaused);
-    m_isPaused = true;
+    ASSERT(!m_inSafePoint);
+    m_inSafePoint = true;
     m_stackState = stackState;
-    s_safePointBarrier->notifyPaused(this);
+    s_safePointBarrier->enterSafePoint(this);
 }
 
-void ThreadState::resumed()
+void ThreadState::leaveSafePoint()
 {
     checkThread();
-    ASSERT(m_isPaused);
-    m_isPaused = false;
+    ASSERT(m_inSafePoint);
+    m_inSafePoint = false;
     m_stackState = HeapPointersOnStack;
-    s_safePointBarrier->notifyResumed(this);
+    s_safePointBarrier->leaveSafePoint(this);
 }
 
 void ThreadState::visitRoots(Visitor* visitor)
 {
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->trace(visitor);
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
@@ skipping 142 matching lines @@
     return Acquire_Load(&m_gcRequested);
 }
 
 void ThreadState::setGCRequested(bool gcRequested)
 {
     Release_Store(&m_gcRequested, gcRequested);
 }
 
 void ThreadState::setInterruptor(Interruptor* interruptor)
 {
-    bool wasPaused = false;
-    if (!isPaused()) {
-        paused(HeapPointersOnStack);
-        wasPaused = true;
+    bool wasInSafePoint = false;
+    if (!isInSafePoint()) {
+        enterSafePoint(HeapPointersOnStack);
+        wasInSafePoint = true;
     }
 
     {
         MutexLocker locker(threadAttachMutex());
         delete m_interruptor;
         m_interruptor = interruptor;
     }
 
-    if (wasPaused)
-        resumed();
+    if (wasInSafePoint)
+        leaveSafePoint();
 }
 
 bool ThreadState::inFinalizeAll()
 {
     for (int i = 0; i < NumberOfHeaps; i++) {
         if (m_heaps[i]->inFinalizeAll())
             return true;
     }
     return false;
 }
@@ skipping 20 matching lines @@
         m_sweepInProgress = false;
         setGCRequested(false);
         setSweepRequested(false);
     }
 }
 
 void ThreadState::Interruptor::onInterrupted()
 {
     ThreadState* state = ThreadState::Current();
     ASSERT(state);
-    ASSERT(!state->isPaused());
+    ASSERT(!state->isInSafePoint());
     state->safePoint();
 }
 
 // Trigger on a 50% increase in size, but not for less than 2 pages.
 static bool increasedEnough(size_t newSize, size_t oldSize)
 {
     if (newSize < 2 * writablePageSize())
         return false;
     return newSize > oldSize + (oldSize >> 1);
 }
@@ skipping 24 matching lines @@
 {
     return m_totalAllocatedSpace == other.m_totalAllocatedSpace
         && m_totalObjectSpace == other.m_totalObjectSpace;
 }
 
 static void parkAfterPushRegisters(SafePointBarrier* barrier, ThreadState* state, intptr_t* stackEnd)
 {
     barrier->doPark(state, stackEnd);
 }
 
-static void notifyPausedAfterPushRegisters(SafePointBarrier* barrier, ThreadState* state, intptr_t* stackEnd)
+static void enterSafePointAfterPushRegisters(SafePointBarrier* barrier, ThreadState* state, intptr_t* stackEnd)
 {
-    barrier->doNotifyPaused(state, stackEnd);
+    barrier->doEnterSafePoint(state, stackEnd);
 }
 
 
 }