Introduce WTF::releaseStore and WTF::acquireLoad.

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 97 matching lines @@
     {
         ASSERT(ThreadState::current()->isAtSafePoint());
 
         // Lock threadAttachMutex() to prevent threads from attaching.
         threadAttachMutex().lock();
 
         ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
 
         MutexLocker locker(m_mutex);
         atomicAdd(&m_unparkedThreadCount, threads.size());
-        atomicSetOneToZero(&m_canResume);
+        releaseStore(&m_canResume, 0);
 
         ThreadState* current = ThreadState::current();
         for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
             if (*it == current)
                 continue;
 
             const Vector<ThreadState::Interruptor*>& interruptors = (*it)->interruptors();
             for (size_t i = 0; i < interruptors.size(); i++)
                 interruptors[i]->requestInterrupt();
         }
 
-        while (m_unparkedThreadCount > 0)
+        while (acquireLoad(&m_unparkedThreadCount) > 0)
             m_parked.wait(m_mutex);
     }
 
     void resumeOthers()
     {
         ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
         atomicSubtract(&m_unparkedThreadCount, threads.size());
-        atomicTestAndSetToOne(&m_canResume);
+        releaseStore(&m_canResume, 1);
         {
             // FIXME: 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();
         }
 
         ThreadState* current = ThreadState::current();
         for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
             if (*it == current)
                 continue;
 
             const Vector<ThreadState::Interruptor*>& interruptors = (*it)->interruptors();
             for (size_t i = 0; i < interruptors.size(); i++)
                 interruptors[i]->clearInterrupt();
         }
 
         threadAttachMutex().unlock();
         ASSERT(ThreadState::current()->isAtSafePoint());
     }
 
     void doPark(ThreadState* state, intptr_t* stackEnd)
     {
         state->recordStackEnd(stackEnd);
         MutexLocker locker(m_mutex);
         if (!atomicDecrement(&m_unparkedThreadCount))
             m_parked.signal();
-        while (!m_canResume)
+        while (!acquireLoad(&m_canResume))
             m_resume.wait(m_mutex);
         atomicIncrement(&m_unparkedThreadCount);
     }
 
     void checkAndPark(ThreadState* state)
     {
         ASSERT(!state->isSweepInProgress());
-        if (!m_canResume) {
+        if (!acquireLoad(&m_canResume)) {
             pushAllRegisters(this, state, parkAfterPushRegisters);
             state->performPendingSweep();
         }
     }
 
     void doEnterSafePoint(ThreadState* state, intptr_t* stackEnd)
     {
         state->recordStackEnd(stackEnd);
         // m_unparkedThreadCount tracks amount of unparked threads. It is
         // positive if and only if we have requested other threads to park
@@ skipping 528 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }