try to fix aarch64 memory order (#448)

Author: RainMark

async_simple/FutureState.h

@@ -140,7 +140,7 @@ class FutureState {
     }
 
     AS_INLINE void attachOne() {
-        _attached.fetch_add(1, std::memory_order_relaxed);
+        _attached.fetch_add(1, std::memory_order_acq_rel);
     }
     AS_INLINE void detachOne() {
         auto old = _attached.fetch_sub(1, std::memory_order_acq_rel);
@@ -150,7 +150,7 @@ class FutureState {
         }
     }
     AS_INLINE void attachPromise() {
-        _promiseRef.fetch_add(1, std::memory_order_relaxed);
+        _promiseRef.fetch_add(1, std::memory_order_acq_rel);
         attachOne();
     }
     AS_INLINE void detachPromise() {
@@ -204,17 +204,18 @@ class FutureState {
         auto state = _state.load(std::memory_order_acquire);
         switch (state) {
             case detail::State::START:
-                if (_state.compare_exchange_strong(state,
-                                                   detail::State::ONLY_RESULT,
-                                                   std::memory_order_release)) {
+                if (_state.compare_exchange_strong(
+                        state, detail::State::ONLY_RESULT,
+                        std::memory_order_acq_rel, std::memory_order_acquire)) {
                     return;
                 }
                 // state has already transfered, fallthrough
                 assert(_state.load(std::memory_order_relaxed) ==
                        detail::State::ONLY_CONTINUATION);
             case detail::State::ONLY_CONTINUATION:
                 if (_state.compare_exchange_strong(state, detail::State::DONE,
-                                                   std::memory_order_release)) {
+                                                   std::memory_order_acq_rel,
+                                                   std::memory_order_acquire)) {
                     scheduleContinuation(false);
                     return;
                 }
@@ -237,15 +238,16 @@ class FutureState {
             case detail::State::START:
                 if (_state.compare_exchange_strong(
                         state, detail::State::ONLY_CONTINUATION,
-                        std::memory_order_release)) {
+                        std::memory_order_acq_rel, std::memory_order_acquire)) {
                     return;
                 }
                 // state has already transferred, fallthrough
                 assert(_state.load(std::memory_order_relaxed) ==
                        detail::State::ONLY_RESULT);
             case detail::State::ONLY_RESULT:
                 if (_state.compare_exchange_strong(state, detail::State::DONE,
-                                                   std::memory_order_release)) {
+                                                   std::memory_order_acq_rel,
+                                                   std::memory_order_acquire)) {
                     scheduleContinuation(true);
                     return;
                 }
@@ -308,10 +310,10 @@ class FutureState {
     }
 
     void refContinuation() {
-        _continuationRef.fetch_add(1, std::memory_order_relaxed);
+        _continuationRef.fetch_add(1, std::memory_order_acq_rel);
     }
     void derefContinuation() {
-        auto old = _continuationRef.fetch_sub(1, std::memory_order_relaxed);
+        auto old = _continuationRef.fetch_sub(1, std::memory_order_acq_rel);
         assert(old >= 1);
         if (old == 1) {
             _continuation.~Continuation();

async_simple/Signal.h

@@ -80,7 +80,8 @@ class Signal : public std::enable_shared_from_this<Signal> {
             validSignal = (expected | type) ^ expected;
         } while (validSignal &&
                  !state.compare_exchange_weak(expected, expected | type,
-                                              std::memory_order_release));
+                                              std::memory_order_acq_rel,
+                                              std::memory_order_acquire));
         // high 32 bits signal is always valid, they can be trigger multiple
         // times. low 32 bits signal only trigger once.
         return static_cast<SignalType>(validSignal |

async_simple/coro/ConditionVariable.h

@@ -67,8 +67,8 @@ class ConditionVariableAwaiter {
         do {
             _next = awaitings;
         } while (!_cv->_awaiters.compare_exchange_weak(
-            awaitings, this, std::memory_order_acquire,
-            std::memory_order_relaxed));
+            awaitings, this, std::memory_order_release,
+            std::memory_order_acquire));
     }
     void await_resume() const noexcept {}
 
@@ -94,23 +94,23 @@ inline Lazy<> ConditionVariable<Lock>::wait(Lock& lock, Pred&& pred) noexcept {
 
 template <class Lock>
 inline void ConditionVariable<Lock>::notifyAll() noexcept {
-    auto awaitings = _awaiters.load(std::memory_order_relaxed);
+    auto awaitings = _awaiters.load(std::memory_order_acquire);
     while (!_awaiters.compare_exchange_weak(awaitings, nullptr,
-                                            std::memory_order_release,
-                                            std::memory_order_relaxed))
+                                            std::memory_order_acq_rel,
+                                            std::memory_order_acquire))
         ;
     resumeWaiters(awaitings);
 }
 
 template <class Lock>
 inline void ConditionVariable<Lock>::notifyOne() noexcept {
-    auto awaitings = _awaiters.load(std::memory_order_relaxed);
+    auto awaitings = _awaiters.load(std::memory_order_acquire);
     if (!awaitings) {
         return;
     }
     while (!_awaiters.compare_exchange_weak(awaitings, awaitings->_next,
-                                            std::memory_order_release,
-                                            std::memory_order_relaxed))
+                                            std::memory_order_acq_rel,
+                                            std::memory_order_acquire))
         ;
     awaitings->_next = nullptr;
     resumeWaiters(awaitings);