From d2edd2dc394b72b02941d5a02922c1ee873c1305 Mon Sep 17 00:00:00 2001
From: Rain Mark <rain.by.zhou@gmail.com>
Date: Mon, 26 Jan 2026 15:11:28 +0800
Subject: [PATCH] try to fix aarch64 memory order

---
 async_simple/FutureState.h            | 22 ++++++++++++----------
 async_simple/Signal.h                 |  3 ++-
 async_simple/coro/ConditionVariable.h | 16 ++++++++--------
 3 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/async_simple/FutureState.h b/async_simple/FutureState.h
index c411a6d8..ba1dce84 100644
--- a/async_simple/FutureState.h
+++ b/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,9 +204,9 @@ 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
@@ -214,7 +214,8 @@ class FutureState {
                        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,7 +238,7 @@ 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
@@ -245,7 +246,8 @@ class FutureState {
                        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();
diff --git a/async_simple/Signal.h b/async_simple/Signal.h
index af467d1a..576878ce 100644
--- a/async_simple/Signal.h
+++ b/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 |
diff --git a/async_simple/coro/ConditionVariable.h b/async_simple/coro/ConditionVariable.h
index b65d4f80..bee0da8e 100644
--- a/async_simple/coro/ConditionVariable.h
+++ b/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);