Stack overflow threadid (#224)

* draft of using the thread ID for the stack overflow management

* use thread::id for stackoverflow management

Author: dietmarkuehl

Makefile

@@ -59,9 +59,14 @@ ifeq (${hostSystemName},Darwin)
 
   ifeq ($(origin CXX),default)
     $(info CXX is using the built-in default: $(CXX))
-    export CXX=g++-15
-    CXXLIB=libstdc++
-    export CXXFLAGS=-stdlib=$(CXXLIB)
+    ifeq ($(shell uname -m),arm64)
+        export CXX=clang++
+        CXXLIB=libc++
+    else
+        export CXX=g++-15
+        CXXLIB=libstdc++
+    endif
+    export CXX_FLAGS=-stdlib=$(CXXLIB)
   endif
   export GCOV="gcov"
 else ifeq (${hostSystemName},Linux)
@@ -120,6 +125,7 @@ doc:
 # NOTE: cmake configure to only test without modules! CK
 # ==========================================================
 build build-interface:
+	@echo CXX=$(CXX) CXX_FLAGS=$(CXX_FLAGS)
 	cmake -G Ninja -S $(SOURCEDIR) -B $(BUILD) $(TOOLCHAIN) $(SYSROOT) \
 	  -D CMAKE_EXPORT_COMPILE_COMMANDS=ON \
 	  -D CMAKE_SKIP_INSTALL_RULES=ON \
@@ -130,7 +136,8 @@ build build-interface:
 	  -D BEMAN_USE_STD_MODULE=OFF \
 	  -D CMAKE_BUILD_TYPE=Release \
 	  -D CMAKE_SKIP_TEST_ALL_DEPENDENCY=OFF \
-	  -D CMAKE_CXX_COMPILER=$(CXX) --log-level=VERBOSE --fresh
+	  -D CMAKE_CXX_COMPILER=$(CXX) --log-level=VERBOSE --fresh \
+	  -D CMAKE_CXX_FLAGS="$(CXX_FLAGS) $(SAN_FLAGS)"
 	# XXX -D CMAKE_CXX_FLAGS="$(CXX_FLAGS) $(SAN_FLAGS)"
 	cmake --build $(BUILD) --target all_verify_interface_header_sets
 	cmake --build $(BUILD) --target all

include/beman/execution/detail/sender_awaitable.hpp

@@ -12,6 +12,7 @@ import std;
 #include <concepts>
 #include <coroutine>
 #include <exception>
+#include <thread>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -53,13 +54,15 @@ class sender_awaitable {
         ::beman::execution::detail::single_sender_value_type<Sndr, ::beman::execution::env_of_t<Promise>>;
     using result_type  = ::std::conditional_t<::std::is_void_v<value_type>, unit, value_type>;
     using variant_type = ::std::variant<::std::monostate, result_type, ::std::exception_ptr>;
-    using data_type    = ::std::tuple<variant_type, ::std::atomic<bool>, ::std::coroutine_handle<Promise>>;
+    using data_type = ::std::tuple<variant_type, ::std::atomic<::std::thread::id>, ::std::coroutine_handle<Promise>>;
 
     struct awaitable_receiver {
         using receiver_concept = ::beman::execution::receiver_t;
 
         void resume() {
-            if (::std::get<1>(*result_ptr_).exchange(true, std::memory_order_acq_rel)) {
+            std::thread::id id(::std::this_thread::get_id());
+            if (not ::std::get<1>(*result_ptr_)
+                        .compare_exchange_strong(id, ::std::thread::id{}, std::memory_order_acq_rel)) {
                 ::std::get<2>(*result_ptr_).resume();
             }
         }
@@ -82,7 +85,9 @@ class sender_awaitable {
         }
 
         void set_stopped() && noexcept {
-            if (::std::get<1>(*result_ptr_).exchange(true, ::std::memory_order_acq_rel)) {
+            std::thread::id id(::std::this_thread::get_id());
+            if (not ::std::get<1>(*result_ptr_)
+                        .compare_exchange_strong(id, ::std::thread::id{}, ::std::memory_order_acq_rel)) {
                 static_cast<::std::coroutine_handle<>>(::std::get<2>(*result_ptr_).promise().unhandled_stopped())
                     .resume();
             }
@@ -102,14 +107,16 @@ class sender_awaitable {
 
   public:
     sender_awaitable(Sndr&& sndr, Promise& p)
-        : result{::std::monostate{}, false, ::std::coroutine_handle<Promise>::from_promise(p)},
+        : result{::std::monostate{}, ::std::this_thread::get_id(), ::std::coroutine_handle<Promise>::from_promise(p)},
           state{::beman::execution::connect(::std::forward<Sndr>(sndr),
                                             sender_awaitable::awaitable_receiver{::std::addressof(result)})} {}
 
     static constexpr bool     await_ready() noexcept { return false; }
     ::std::coroutine_handle<> await_suspend(::std::coroutine_handle<Promise> handle) noexcept {
         ::beman::execution::start(state);
-        if (::std::get<1>(this->result).exchange(true, std::memory_order_acq_rel)) {
+        ::std::thread::id id(::std::this_thread::get_id());
+        if (not ::std::get<1>(this->result)
+                    .compare_exchange_strong(id, ::std::thread::id{}, ::std::memory_order_acq_rel)) {
             if (::std::holds_alternative<::std::monostate>(::std::get<0>(this->result))) {
                 return ::std::get<2>(this->result).promise().unhandled_stopped();
             }