major fix

Author: denisichh

runtime-light/coroutine/async-stack-methods.h

@@ -0,0 +1,104 @@
+// Compiler for PHP (aka KPHP)
+// Copyright (c) 2025 LLC «V Kontakte»
+// Distributed under the GPL v3 License, see LICENSE.notice.txt
+
+#pragma once
+
+/**
+ * This header defines the data structures used to represent a coroutine asynchronous stack.
+ *
+ * Overview:
+ * The asynchronous stack is used to manage the execution state of coroutines, allowing for
+ * efficient context switching and stack management.
+ *
+ * Diagram: Normal and Asynchronous Stacks
+ *
+ *  Base Pointer (%rbp)              async_stack_root
+ *         |                                 |
+ *         V                                 V
+ *    stack_frame                    async_stack_frame
+ *         |                                 |
+ *         V                                 V
+ *    stack_frame                    async_stack_frame
+ *        ...                               ...
+ *         |                                 |
+ *         V                                 V
+ *    stack_frame                    async_stack_frame
+ *         |                                 |
+ *         V                                 V
+ *
+ * In the diagram above, the left side represents a typical call stack with stack frames linked by
+ * the base pointer (%rbp). The right side illustrates an asynchronous stack where `async_stack_frame`
+ * structures are linked by `async_stack_root`.
+ *
+ * Diagram: Backtrace Mechanism
+ *
+ *  Base Pointer (%rbp)
+ *         |
+ *         V
+ *    stack_frame
+ *         |
+ *         V
+ *    stack_frame (stop_sync_frame)  <- async_stack_root
+ *                                             |
+ *                                             V
+ *                                     async_stack_frame (top_async_frame)
+ *                                             |
+ *                                             V
+ *                                     async_stack_frame
+ *                                            ...
+ *                                             |
+ *                                             V
+ *                                     async_stack_frame
+ *
+ * The backtrace mechanism involves traversing the stack frames to capture the call stack.
+ * The `stop_sync_frame` serves as a marker where the transition to the asynchronous stack occurs,
+ * allowing the backtrace to continue through the `async_stack_frame` structures.
+ */
+
+#define STACK_RETURN_ADDRESS __builtin_return_address(0)
+
+#define STACK_FRAME_ADDRESS __builtin_frame_address(0)
+
+namespace kphp::coro {
+
+
+
+struct stack_frame {
+  stack_frame* caller_stack_frame{};
+  void* return_address{};
+};
+
+struct async_stack_root;
+
+struct async_stack_frame {
+  async_stack_frame* caller_async_stack_frame{};
+  async_stack_root* async_stack_root{};
+  void* return_address{};
+};
+
+struct async_stack_root {
+  async_stack_frame* top_async_stack_frame{};
+  stack_frame* stop_sync_stack_frame{};
+  async_stack_root* next_async_stack_root{};
+};
+
+/**
+ * The async_stack_element class facilitates working with asynchronous traces in templated code.
+ * This allows for uniform handling of any coroutines in places where async frames are pushed or popped.
+ */
+struct async_stack_element {
+  async_stack_frame& get_async_stack_frame() noexcept {
+    return m_async_stack_frame;
+  }
+
+private:
+  async_stack_frame m_async_stack_frame;
+};
+
+/**
+ * The async_stack_element class facilitates working with asynchronous traces in templated code.
+ * This allows for uniform handling of any coroutines in places where async frames are pushed or popped.
+ */
+
+} // namespace kphp::coro

runtime-light/coroutine/async-stack-structs.h

@@ -4,94 +4,47 @@
 
 #pragma once
 
-/**
- * This header defines the data structures used to represent a coroutine asynchronous stack.
- *
- * Overview:
- * The asynchronous stack is used to manage the execution state of coroutines, allowing for
- * efficient context switching and stack management.
- *
- * Diagram: Normal and Asynchronous Stacks
- *
- *  Base Pointer (%rbp)              async_stack_root
- *         |                                 |
- *         V                                 V
- *    stack_frame                    async_stack_frame
- *         |                                 |
- *         V                                 V
- *    stack_frame                    async_stack_frame
- *        ...                               ...
- *         |                                 |
- *         V                                 V
- *    stack_frame                    async_stack_frame
- *         |                                 |
- *         V                                 V
- *
- * In the diagram above, the left side represents a typical call stack with stack frames linked by
- * the base pointer (%rbp). The right side illustrates an asynchronous stack where `async_stack_frame`
- * structures are linked by `async_stack_root`.
- *
- * Diagram: Backtrace Mechanism
- *
- *  Base Pointer (%rbp)
- *         |
- *         V
- *    stack_frame
- *         |
- *         V
- *    stack_frame (stop_sync_frame)  <- async_stack_root
- *                                             |
- *                                             V
- *                                     async_stack_frame (top_async_frame)
- *                                             |
- *                                             V
- *                                     async_stack_frame
- *                                            ...
- *                                             |
- *                                             V
- *                                     async_stack_frame
- *
- * The backtrace mechanism involves traversing the stack frames to capture the call stack.
- * The `stop_sync_frame` serves as a marker where the transition to the asynchronous stack occurs,
- * allowing the backtrace to continue through the `async_stack_frame` structures.
- */
+#include "runtime-light/coroutine/async-stack-structs.h"
 
-#define STACK_RETURN_ADDRESS __builtin_return_address(0)
+#include <coroutine>
+#include <utility>
 
-#define STACK_FRAME_ADDRESS __builtin_frame_address(0)
+#include "runtime-light/coroutine/coroutine-state.h"
+#include "runtime-light/stdlib/diagnostics/logs.h"
 
 namespace kphp::coro {
 
-struct stack_frame {
-  stack_frame* caller_stack_frame{};
-  void* return_address{};
+struct async_stack_root_wrapper {
+  async_stack_root root;
+  async_stack_root_wrapper() = default;
+  async_stack_root_wrapper(const async_stack_root_wrapper& other) = default;
+  async_stack_root_wrapper& operator=(const async_stack_root_wrapper& other) = default;
+  ~async_stack_root_wrapper() {
+    CoroutineInstanceState::get().current_async_stack_root = root.next_async_stack_root;
+  }
 };
 
-struct async_stack_root;
-
-struct async_stack_frame {
-  async_stack_frame* caller_async_stack_frame{};
-  async_stack_root* async_stack_root{};
-  void* return_address{};
-};
-
-struct async_stack_root {
-  async_stack_frame* top_async_stack_frame{};
-  stack_frame* stop_sync_stack_frame{};
-  async_stack_root* next_async_stack_root{};
-};
+inline void preparation_for_resume(kphp::coro::async_stack_root* root, void* stack_frame_addr,
+                                   CoroutineInstanceState& coroutine_state = CoroutineInstanceState::get()) {
+  root->stop_sync_stack_frame = reinterpret_cast<stack_frame*>(stack_frame_addr);
+  coroutine_state.current_async_stack_root = root;
+}
 
 /**
- * The async_stack_element class facilitates working with asynchronous traces in templated code.
- * This allows for uniform handling of any coroutines in places where async frames are pushed or popped.
+ * The `resume_with_new_root` function is responsible for storing the current synchronous stack frame
+ * in async_stack_root::stop_sync_frame before resuming the coroutine. This allows
+ * capturing one of the stack frames in the synchronous stack trace and jump between parts of the async_stack.
  */
-struct async_stack_element {
-  async_stack_frame& get_async_stack_frame() noexcept {
-    return m_async_stack_frame;
-  }
-
-private:
-  async_stack_frame m_async_stack_frame;
-};
-
+[[clang::noinline]] inline void resume_with_new_root(std::coroutine_handle<> handle, async_stack_root* new_async_stack_root) noexcept {
+  kphp::log::assertion(new_async_stack_root != nullptr);
+  auto& coroutine_st{CoroutineInstanceState::get()};
+  // auto* previous_stack_root{coroutine_st.current_async_stack_root};
+
+  new_async_stack_root->next_async_stack_root = coroutine_st.current_async_stack_root;
+  new_async_stack_root->stop_sync_stack_frame = reinterpret_cast<stack_frame*>(STACK_FRAME_ADDRESS);
+
+  coroutine_st.current_async_stack_root = new_async_stack_root;
+  handle.resume();
+  new_async_stack_root->stop_sync_stack_frame = nullptr;
+}
 } // namespace kphp::coro

runtime-light/coroutine/async-stack.h

@@ -40,7 +40,7 @@ class await_set {
   template<typename awaitable_type>
   requires kphp::coro::concepts::awaitable<awaitable_type> && std::is_same_v<typename awaitable_traits<awaitable_type>::awaiter_return_type, return_type>
   void push(awaitable_type awaitable) noexcept {
-    m_await_broker->start_task(detail::await_set::make_await_set_task(std::move(awaitable)), STACK_RETURN_ADDRESS);
+    m_await_broker->start_task(detail::await_set::make_await_set_task(std::move(awaitable)));
   }
 
   auto next() noexcept {

runtime-light/coroutine/await-set.h

@@ -6,7 +6,7 @@
 
 #include "common/mixin/not_copyable.h"
 
-#include "runtime-light/coroutine/async-stack.h"
+#include "runtime-light/coroutine/async-stack-structs.h"
 
 struct CoroutineInstanceState final : private vk::not_copyable {
 

runtime-light/coroutine/coroutine-state.h

@@ -12,7 +12,6 @@
 
 #include "runtime-common/core/allocator/script-malloc-interface.h"
 #include "runtime-common/core/std/containers.h"
-#include "runtime-light/coroutine/async-stack-methods.h"
 #include "runtime-light/coroutine/async-stack.h"
 #include "runtime-light/coroutine/type-traits.h"
 #include "runtime-light/coroutine/void-value.h"
@@ -66,9 +65,9 @@ class await_broker {
     kphp::memory::script::free(ptr);
   }
 
-  void start_task(await_set_task<return_type>&& task, void* return_address) noexcept {
+  void start_task(await_set_task<return_type>&& task) noexcept {
     auto task_iterator{m_tasks_storage.insert(m_tasks_storage.begin(), std::move(task))};
-    task_iterator->start(*this, task_iterator, return_address);
+    task_iterator->start(*this, task_iterator);
   }
 
   void push_ready_task(await_set_ready_task_element<return_type>& ready_task) noexcept {
@@ -158,6 +157,7 @@ class await_set_task_promise_base : public kphp::coro::async_stack_element {
   std::optional<std::reference_wrapper<await_broker<return_type>>> m_await_broker{};
   await_set_ready_task_element<return_type> m_ready_task_element{};
 
+  kphp::coro::async_stack_root_wrapper root_wrapper_{};
 public:
   await_set_task_promise_base() noexcept = default;
 
@@ -197,8 +197,8 @@ class await_set_task_promise_base : public kphp::coro::async_stack_element {
     kphp::log::error("internal unhandled exception");
   }
 
-  auto start(detail::await_set::await_broker<return_type>& await_broker,
-             kphp::stl::list<await_set_task<return_type>, kphp::memory::script_allocator>::iterator storage_location, void* return_address) noexcept {
+  [[clang::noinline]] auto start(detail::await_set::await_broker<return_type>& await_broker,
+             kphp::stl::list<await_set_task<return_type>, kphp::memory::script_allocator>::iterator storage_location) noexcept {
     m_await_broker = await_broker;
     m_ready_task_element.m_storage_location = storage_location;
 
@@ -207,15 +207,14 @@ class await_set_task_promise_base : public kphp::coro::async_stack_element {
      * await_set_task is the top of the stack for calls from it.
      * Therefore, it doesn't store caller_frame, but it save `await_set::push()` return address
      * */
-    kphp::coro::async_stack_root root{};
     auto& async_stack_frame{get_async_stack_frame()};
     async_stack_frame.caller_async_stack_frame = nullptr;
-    async_stack_frame.async_stack_root = std::addressof(root);
-    async_stack_frame.return_address = return_address;
+    async_stack_frame.async_stack_root = std::addressof(root_wrapper_.root);
+    async_stack_frame.return_address = STACK_RETURN_ADDRESS; // this is necessary to prevent double printing of a coroutine
     async_stack_frame.async_stack_root->top_async_stack_frame = std::addressof(async_stack_frame);
 
     decltype(auto) handle = std::coroutine_handle<promise_type>::from_promise(*static_cast<promise_type*>(this));
-    kphp::coro::resume_with_new_root(handle, std::addressof(root));
+    kphp::coro::resume_with_new_root(handle, std::addressof(root_wrapper_.root));
   }
 };
 
@@ -271,8 +270,8 @@ class await_set_task {
   };
 
   auto start(detail::await_set::await_broker<return_type>& await_broker,
-             kphp::stl::list<await_set_task<return_type>, kphp::memory::script_allocator>::iterator storage_location, void* return_address) noexcept {
-    m_coroutine.promise().start(await_broker, storage_location, return_address);
+             kphp::stl::list<await_set_task<return_type>, kphp::memory::script_allocator>::iterator storage_location) noexcept {
+    m_coroutine.promise().start(await_broker, storage_location);
   }
 
 public: