refactor dump_callstack

Author: netcan

include/asyncio/callstack.h

@@ -14,12 +14,7 @@ struct CallStackAwaiter {
     constexpr void await_resume() const noexcept {}
     template<typename Promise>
     bool await_suspend(std::coroutine_handle<Promise> caller) const noexcept {
-        size_t i = 0;
-        for (Handle* handle = &caller.promise();
-            handle != nullptr;
-            handle = handle->get_continuation(), ++i) {
-            fmt::print("[{}] {}\n", i, handle->name());
-        }
+        caller.promise().dump_backtrace();
         return false;
     }
 };

include/asyncio/concept/awaitable.h

@@ -12,13 +12,13 @@ template<typename A>
 struct GetAwaiter: std::type_identity<A> { };
 
 template<typename A>
-requires requires(A a) { a.operator co_await(); }
+requires requires(A&& a) { std::forward<A>(a).operator co_await(); }
 struct GetAwaiter<A>: std::type_identity<decltype(std::declval<A>().operator co_await())> { };
 
 template<typename A>
-requires requires(A a) {
-    operator co_await(a);
-    requires ! (requires { a.operator co_await(); });
+requires requires(A&& a) {
+    operator co_await(std::forward<A>(a));
+    requires ! (requires { std::forward<A>(a).operator co_await(); });
 }
 struct GetAwaiter<A>: std::type_identity<decltype(operator co_await(std::declval<A>()))> { };
 

include/asyncio/gather.h

@@ -13,7 +13,7 @@ ASYNCIO_NS_BEGIN
 namespace detail {
 
 template<typename... Rs>
-class GatherAwaiter {
+class GatherAwaiter: NonCopyable {
     using ResultTypes = std::tuple<GetTypeIfVoid_t<Rs>...>;
 public:
     constexpr bool await_ready() noexcept { return is_finished(); }
@@ -71,16 +71,31 @@ template<concepts::Awaitable... Futs> // C++17 deduction guide
 GatherAwaiter(Futs&&...) -> GatherAwaiter<AwaitResult<Futs>...>;
 
 template<concepts::Awaitable... Futs>
-auto gather(NoWaitAtInitialSuspend, Futs&&... futs) // need NoWaitAtInitialSuspend to lift futures lifetime early
--> Task<std::tuple<GetTypeIfVoid_t<AwaitResult<Futs>>...>> {
-    // futures(tuple) to lift Future's lifetime
+struct GatherAwaiterRepositry {
+    explicit GatherAwaiterRepositry(Futs&&... futs)
+    : futs_(std::forward<Futs>(futs)...) { }
+
+    auto operator co_await() && {
+        return std::apply([]<concepts::Awaitable... F>(F&&... f) {
+            return GatherAwaiter { std::forward<F>(f)... };
+        }, std::move(futs_));
+    }
+
+private:
+    // futs_ to lift Future's lifetime
     // 1. if Future is rvalue(Fut&&), then move it to tuple(Fut)
     // 2. if Future is xvalue(Fut&&), then move it to tuple(Fut)
     // 3. if Future is lvalue(Fut&), then store as lvalue-ref(Fut&)
-    std::tuple<Futs...> futures{ std::forward<Futs>(futs)... };
-    co_return co_await std::apply([]<concepts::Awaitable... Fs>(Fs&&... fs) {
-        return GatherAwaiter{ std::forward<Fs>(fs)... };
-    }, std::move(futures));
+    std::tuple<Futs...> futs_;
+};
+
+template<concepts::Awaitable... Futs> // need deduction guide to deduce future type
+GatherAwaiterRepositry(Futs&&...) -> GatherAwaiterRepositry<Futs...>;
+
+template<concepts::Awaitable... Futs>
+auto gather(NoWaitAtInitialSuspend, Futs&&... futs) // need NoWaitAtInitialSuspend to lift futures lifetime early
+-> Task<std::tuple<GetTypeIfVoid_t<AwaitResult<Futs>>...>> {
+    co_return co_await detail::GatherAwaiterRepositry{ std::forward<Futs>(futs)... };
 }
 }
 

include/asyncio/handle.h

@@ -15,30 +15,21 @@ enum class PromiseState: uint8_t {
     PENDING,
 };
 
-struct HandleFrameInfo {
-    uint32_t line{0};
-    std::string_view file_name;
-    std::string_view func_name;
-    constexpr HandleFrameInfo() = default;
-    constexpr HandleFrameInfo(std::source_location loc):
-        line(loc.line()),
-        file_name(loc.file_name()),
-        func_name(loc.function_name()) {}
-};
-
 struct Handle {
     virtual void run() = 0;
-    std::string name() {
+    std::string frame_name() const {
         const auto& frame_info = get_frame_info();
-//        return fmt::format("{} at {}:{}", frame_info.func_name,
-//                           frame_info.file_name, frame_info.line);
-        return fmt::format("{} at {}", frame_info.func_name, frame_info.file_name);
+        return fmt::format("{} at {}:{}", frame_info.function_name(),
+                           frame_info.file_name(), frame_info.line());
     }
-    virtual Handle* get_continuation() { return nullptr; }
+    virtual void dump_backtrace(size_t depth = 0) const {};
     virtual void set_state(PromiseState state) {}
     virtual ~Handle() = default;
 private:
-    virtual const HandleFrameInfo& get_frame_info() = 0;
+    virtual const std::source_location& get_frame_info() const {
+        static std::source_location frame_info = std::source_location::current();
+        return frame_info;
+    }
 };
 
 ASYNCIO_NS_END

include/asyncio/noncopyable.h

@@ -10,7 +10,11 @@ ASYNCIO_NS_BEGIN
 struct NonCopyable {
 protected:
     NonCopyable() = default;
+    ~NonCopyable() = default;
+    NonCopyable(NonCopyable&&) = default;
+    NonCopyable& operator=(NonCopyable&&) = default;
     NonCopyable(const NonCopyable&) = delete;
+    NonCopyable& operator=(const NonCopyable&) = delete;
 };
 ASYNCIO_NS_END
 

include/asyncio/task.h

@@ -65,8 +65,7 @@ struct Task: private NonCopyable {
     }
 
     struct promise_type: Handle, Result<R> {
-        promise_type(std::source_location loc = std::source_location::current()):
-        frame_info_(loc) { }
+        promise_type() = default;
 
         template<typename... Args> // from free function
         promise_type(NoWaitAtInitialSuspend, Args&&...): wait_at_initial_suspend_{false} { }
@@ -99,25 +98,35 @@ struct Task: private NonCopyable {
         Task get_return_object() noexcept {
             return Task{coro_handle::from_promise(*this)};
         }
+        template<concepts::Awaitable A>
+        decltype(auto) await_transform(A&& awaiter, // for save source_location info
+                                       std::source_location loc = std::source_location::current()) {
+            frame_info_ = loc;
+            return std::forward<A>(awaiter);
+        }
 
         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
-        void run() override {
+        void run() final {
             assert(state_ == PromiseState::PENDING);
             auto handle = coro_handle::from_promise(*this);
             // set to unschedule in advance, because 'resume' may change state
             state_ = PromiseState::UNSCHEDULED;
             handle.resume();
         }
-        void set_state(PromiseState state) override { state_ = state; }
-        const HandleFrameInfo& get_frame_info() override { return frame_info_; }
-        Handle* get_continuation() override { return continuation_; }
+        void set_state(PromiseState state) final { state_ = state; }
+        const std::source_location& get_frame_info() const final { return frame_info_; }
+        void dump_backtrace(size_t depth = 0) const final {
+            fmt::print("[{}] {}\n", depth, frame_name());
+            if (continuation_) { continuation_->dump_backtrace(depth + 1); }
+            else { fmt::print("\n"); }
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
         // to auto delete by final awaiter
         PromiseState state_ {PromiseState::UNSCHEDULED};
         const bool wait_at_initial_suspend_ {true};
         Handle* continuation_ {};
-        HandleFrameInfo frame_info_{};
+        std::source_location frame_info_{};
     };
 
     bool valid() const { return handle_ != nullptr; }

include/asyncio/wait_for.h

@@ -14,7 +14,7 @@
 ASYNCIO_NS_BEGIN
 namespace detail {
 template<typename R, typename Duration>
-struct WaitForAwaiter {
+struct WaitForAwaiter: NonCopyable {
     constexpr bool await_ready() noexcept { return false; }
     constexpr decltype(auto) await_resume() {
         return result_.result();
@@ -60,16 +60,12 @@ struct WaitForAwaiter {
             EventLoop& loop{get_event_loop()};
             loop.call_later(timeout, *this);
         }
-        void run() override { // timeout!
+        void run() final { // timeout!
             EventLoop& loop{get_event_loop()};
             loop.cancel_handle(current_task_);
             awaiter_.result_.set_exception(std::make_exception_ptr(TimeoutError{}));
             loop.call_soon(*awaiter_.continuation_);
         }
-        const HandleFrameInfo& get_frame_info() override {
-            static HandleFrameInfo frame_info;
-            return frame_info;
-        }
 
         WaitForAwaiter& awaiter_;
         Handle& current_task_;
@@ -79,11 +75,27 @@ struct WaitForAwaiter {
 template<concepts::Awaitable Fut, typename Duration>
 WaitForAwaiter(Fut&&, Duration) -> WaitForAwaiter<AwaitResult<Fut>, Duration>;
 
+template<concepts::Awaitable Fut, typename Duration>
+struct WaitForAwaiterRegistry {
+    WaitForAwaiterRegistry(Fut&& fut, Duration duration)
+    : fut_(std::forward<Fut>(fut)), duration_(duration) { }
+
+    auto operator co_await () && {
+        return WaitForAwaiter{std::move(fut_), duration_};
+    }
+private:
+    Fut fut_; // lift Future's lifetime
+    Duration duration_;
+};
+
+template<concepts::Awaitable Fut, typename Duration>
+WaitForAwaiterRegistry(Fut&& fut, Duration duration)
+-> WaitForAwaiterRegistry<Fut, Duration>;
+
 template<concepts::Awaitable Fut, typename Rep, typename Period>
 auto wait_for(NoWaitAtInitialSuspend, Fut&& fut, std::chrono::duration<Rep, Period> timeout)
 -> Task<AwaitResult<Fut>> {
-    Fut future = std::forward<Fut>(fut); // lift fut lifetime
-    co_return co_await WaitForAwaiter { std::forward<Fut>(future), timeout };
+    co_return co_await WaitForAwaiterRegistry { std::forward<Fut>(fut), timeout };
 }
 }
 

test/ut/task_test.cpp

@@ -4,6 +4,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>
 #include <asyncio/event_loop.h>
+#include <asyncio/callstack.h>
 #include <asyncio/task.h>
 #include <asyncio/gather.h>
 #include <asyncio/exception.h>
@@ -79,7 +80,7 @@ SCENARIO("test Task await result value") {
     GIVEN("fibonacci") {
         std::function<auto(size_t) -> Task<size_t>> fibo =
             [&](size_t n) -> Task<size_t> {
-                if (n <= 1) co_return n;
+                if (n <= 1) { co_return n; }
                 co_return co_await fibo(n - 1) +
                           co_await fibo(n - 2);
             };