add example obtaining current scheduler from within alien coroutine (#61)

Author: m-fila

examples/CMakeLists.txt

@@ -36,6 +36,8 @@ add_executable(alien_counting_scope alien_counting_scope.cpp)
 target_link_libraries(alien_counting_scope PRIVATE CoroutineTests)
 add_executable(alien_schedule_on alien_schedule_on.cpp)
 target_link_libraries(alien_schedule_on PRIVATE CoroutineTests)
+add_executable(alien_get_scheduler alien_get_scheduler.cpp)
+target_link_libraries(alien_get_scheduler PRIVATE CoroutineTests)
 
 if(BUILD_STDEXEC)
   add_executable(exec_task_stdexec exec_task.cpp)

examples/README.md

@@ -150,6 +150,12 @@ Link: [alien_schedule_on.cpp](alien_schedule_on.cpp)
 
 This example demonstrates changing scheduler used by part of a chain of coroutines following the semantics from ["Alien" example](#alien). The `schedule_on` algorithm can be used to adapt a coroutine to use a different scheduler than its parent. Starting the coroutine suspends its parent and reschedule work on the new scheduler, finishing the coroutine reschedules continuation of its parent using parent's scheduler.
 
+## Alien get_scheduler
+
+Link: [alien_get_scheduler.cpp](alien_get_scheduler.cpp)
+
+This example shows how the contents of promise type can be extracted from within a coroutine. The `GetScheduler` awaitable when co_awaited accessed the promise type and returns the currently used coroutine. The example uses then `schedule_on` algorithm from ["alien schedule_on" example](#alien-schedule_on) to alternate between used schedulers in each nested coroutine.
+
 ## Capy task
 
 Link: [capy_task.cpp](capy_task.cpp)

examples/alien_get_scheduler.cpp

@@ -0,0 +1,58 @@
+#include <format>
+#include <string_view>
+
+#include "CoroutineTests/alien/get_scheduler.hpp"
+#include "CoroutineTests/alien/schedule_on.hpp"
+#include "CoroutineTests/alien/sync_wait.hpp"
+#include "CoroutineTests/alien/tool.hpp"
+#include "CoroutineTests/threadpool.hpp"
+#include "logging_utils.hpp"
+
+using namespace CoroutineTests::alien;
+using scheduler_t = std::function<void(std::coroutine_handle<>)>;
+tool::Task<void> innermost_task(std::string_view parent) {
+    const auto self = format_name(parent, "innermost_task");
+    log(self) << "Running innermost task" << std::endl;
+    co_return;
+}
+
+tool::Task<void> inner_task(scheduler_t innermost_scheduler,
+                            std::string_view parent) {
+    const auto self = format_name(parent, "inner_task");
+    log(self) << "Running inner task, scheduling innermost task on innermost "
+                 "scheduler"
+              << std::endl;
+    co_await schedule_on(innermost_scheduler, innermost_task(self));
+    log(self) << "Innermost task completed, resuming inner task" << std::endl;
+    co_return;
+}
+
+tool::Task<void> outer_task(scheduler_t inner_scheduler,
+                            std::string_view parent) {
+    const auto self = format_name(parent, "outer_task");
+    log(self) << "Running outer task" << std::endl;
+    auto current_scheduler = co_await GetScheduler{};
+    log(self) << "Got current scheduler in outer task, scheduling inner task "
+                 "on inner scheduler"
+              << std::endl;
+    co_await schedule_on(inner_scheduler, inner_task(current_scheduler, self));
+    log(self) << "Inner task completed, resuming outer task" << std::endl;
+    co_return;
+}
+
+int main() {
+    log() << "Starting main, launching task..." << std::endl;
+    auto threadpool_A = CoroutineTests::Threadpool(1);
+    auto scheduler_A = [&](std::coroutine_handle<> h) {
+        threadpool_A.enqueue_task(h);
+    };
+
+    auto threadpool_B = CoroutineTests::Threadpool(1);
+    auto scheduler_B = [&](std::coroutine_handle<> h) {
+        threadpool_B.enqueue_task(h);
+    };
+
+    sync_wait(scheduler_A, outer_task(scheduler_B, "main"));
+    log() << "Finished waiting for task" << std::endl;
+    return 0;
+}

include/CoroutineTests/alien/get_scheduler.hpp

@@ -0,0 +1,27 @@
+#include <coroutine>
+#include <functional>
+
+namespace CoroutineTests::alien {
+
+class GetScheduler {
+    public:
+    // Don't skip suspension, we need to get the scheduler from the promise.
+    bool await_ready() const noexcept { return false; }
+
+    // On suspend, capture the handle to the current coroutine and get the
+    // scheduler from the promise. Then resume the coroutine immediately.
+    template <typename PromiseType>
+    std::coroutine_handle<> await_suspend(
+        std::coroutine_handle<PromiseType> h) noexcept {
+        m_scheduler = h.promise().get_scheduler();
+        return h;
+    }
+    // On resume, return the captured scheduler.
+    auto await_resume() const noexcept { return m_scheduler; }
+
+    private:
+    // Storage for the captured scheduler.
+    std::function<void(std::coroutine_handle<>)> m_scheduler;
+};
+
+}  // namespace CoroutineTests::alien