update async_simple(6be48e7b3edde61a8a4e7ca432d25a8d9840153c) (qicosm…

…os#536)

cmake/develop.cmake

@@ -39,7 +39,11 @@ int main()
 endmacro()
 
 # Enable address sanitizer
-option(ENABLE_SANITIZER "Enable sanitizer(Debug+Gcc/Clang/AppleClang)" ON)
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    option(ENABLE_SANITIZER "Enable sanitizer(Debug+Gcc/Clang/AppleClang)" OFF)
+else()
+    option(ENABLE_SANITIZER "Enable sanitizer(Debug+Gcc/Clang/AppleClang)" ON)
+endif()
 if(ENABLE_SANITIZER AND NOT MSVC)
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         check_asan(HAS_ASAN)

include/async_simple/Common.h

@@ -44,6 +44,20 @@
 #endif  // __SANITIZE_ADDRESS__
 #endif  // __GNUC__
 
+#if defined(__alibaba_clang__) && \
+    __has_cpp_attribute(ACC::coro_only_destroy_when_complete)
+#define CORO_ONLY_DESTROY_WHEN_DONE [[ACC::coro_only_destroy_when_complete]]
+#else
+#define CORO_ONLY_DESTROY_WHEN_DONE
+#endif
+
+#if defined(__alibaba_clang__) && \
+    __has_cpp_attribute(ACC::elideable_after_await)
+#define ELIDEABLE_AFTER_AWAIT [[ACC::elideable_after_await]]
+#else
+#define ELIDEABLE_AFTER_AWAIT
+#endif
+
 namespace async_simple {
 // Different from assert, logicAssert is meaningful in
 // release mode. logicAssert should be used in case that

include/async_simple/Executor.h

@@ -20,7 +20,9 @@
 #include <functional>
 #include <string>
 #include <thread>
+#include "async_simple/MoveWrapper.h"
 #include "async_simple/experimental/coroutine.h"
+#include "async_simple/util/move_only_function.h"
 
 namespace async_simple {
 // Stat information for an executor.
@@ -86,6 +88,13 @@ class Executor {
     // func will not be executed. In case schedule return true, the executor
     // should guarantee that the func would be executed.
     virtual bool schedule(Func func) = 0;
+
+    // Schedule a move only functor
+    bool schedule_move_only(util::move_only_function<void()> func) {
+        MoveWrapper<decltype(func)> tmp(std::move(func));
+        return schedule([func = tmp]() { func.get()(); });
+    }
+
     // Return true if caller runs in the executor.
     virtual bool currentThreadInExecutor() const {
         throw std::logic_error("Not implemented");
@@ -143,10 +152,7 @@ class Executor::TimeAwaiter {
 
     template <typename PromiseType>
     void await_suspend(std::coroutine_handle<PromiseType> continuation) {
-        std::function<void()> func = [c = continuation]() mutable {
-            c.resume();
-        };
-        _ex->schedule(func, _dur);
+        _ex->schedule(std::move(continuation), _dur);
     }
     void await_resume() const noexcept {}
 

include/async_simple/Future.h

@@ -58,6 +58,7 @@ class Future {
 
 public:
     using value_type = T;
+
     Future(FutureState<inner_value_type>* fs) : _sharedState(fs) {
         if (_sharedState) {
             _sharedState->attachOne();
@@ -89,6 +90,8 @@ class Future {
         return *this;
     }
 
+    auto coAwait(Executor*) && noexcept { return std::move(*this); }
+
 public:
     bool valid() const {
         return _sharedState != nullptr || _localState.hasResult();
@@ -349,7 +352,9 @@ template <typename T>
 Future<T> makeReadyFuture(std::exception_ptr ex) {
     return Future<T>(Try<T>(ex));
 }
-inline Future<void> makeReadyFuture() { return Future<void>(Try<Unit>()); }
+inline Future<void> makeReadyFuture() {
+    return Future<void>(Try<Unit>(Unit()));
+}
 
 }  // namespace async_simple
 

include/async_simple/FutureState.h

@@ -27,8 +27,8 @@
 #include <thread>
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
-#include "async_simple/MoveWrapper.h"
 #include "async_simple/Try.h"
+#include "async_simple/util/move_only_function.h"
 
 namespace async_simple {
 
@@ -62,7 +62,7 @@ constexpr State operator&(State lhs, State rhs) {
 template <typename T>
 class FutureState {
 private:
-    using Continuation = std::function<void(Try<T>&& value)>;
+    using Continuation = util::move_only_function<void(Try<T>&& value)>;
 
 private:
     // A helper to help FutureState to count the references to guarantee
@@ -228,11 +228,10 @@ class FutureState {
     void setContinuation(F&& func) {
         logicAssert(!hasContinuation(),
                     "FutureState already has a continuation");
-        MoveWrapper<F> lambdaFunc(std::move(func));
-        new (&_continuation) Continuation([lambdaFunc](Try<T>&& v) mutable {
-            auto& lambda = lambdaFunc.get();
-            lambda(std::forward<Try<T>>(v));
-        });
+        new (&_continuation)
+            Continuation([func = std::move(func)](Try<T>&& v) mutable {
+                func(std::forward<Try<T>>(v));
+            });
 
         auto state = _state.load(std::memory_order_acquire);
         switch (state) {

include/async_simple/LocalState.h

@@ -27,7 +27,6 @@
 #include <utility>
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
-#include "async_simple/MoveWrapper.h"
 #include "async_simple/Try.h"
 
 namespace async_simple {

include/async_simple/MoveWrapper.h

@@ -18,6 +18,7 @@
 #define ASYNC_SIMPLE_MOVEWRAPPER_H
 
 #include <exception>
+
 #include "async_simple/Common.h"
 
 namespace async_simple {
@@ -26,23 +27,23 @@ namespace async_simple {
 // copy as move.
 template <typename T>
 class MoveWrapper {
-public:
-    MoveWrapper() = default;
-    MoveWrapper(T&& value) : _value(std::move(value)) {}
+ public:
+  MoveWrapper() = default;
+  MoveWrapper(T&& value) : _value(std::move(value)) {}
 
-    MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
-    MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
+  MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
+  MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
 
-    MoveWrapper& operator=(const MoveWrapper&) = delete;
-    MoveWrapper& operator=(MoveWrapper&&) = delete;
+  MoveWrapper& operator=(const MoveWrapper&) = delete;
+  MoveWrapper& operator=(MoveWrapper&&) = delete;
 
-    T& get() { return _value; }
-    const T& get() const { return _value; }
+  T& get() { return _value; }
+  const T& get() const { return _value; }
 
-    ~MoveWrapper() {}
+  ~MoveWrapper() {}
 
-private:
-    mutable T _value;
+ private:
+  mutable T _value;
 };
 
 }  // namespace async_simple

include/async_simple/Try.h

@@ -118,7 +118,7 @@ class Try {
     }
     std::exception_ptr getException() const {
         logicAssert(std::holds_alternative<std::exception_ptr>(_value),
-                    "Try object do not has on error");
+                    "Try object do not has an error");
         return std::get<std::exception_ptr>(_value);
     }