async_lock_lf

Author: esufaev

include/pot/coroutines/task.h

@@ -7,78 +7,11 @@
 #include <type_traits>
 #include <utility>
 #include <variant>
-#include <memory>
 
 #include "pot/memory/coro_memory.h"
 
-namespace pot::coroutines
-{
-    template<typename T>
-    class task;
-
-    template<typename T>
-    class lazy_task;
-}
-
-namespace std
-{
-
-template <typename T, typename... Args>
-struct coroutine_traits<pot::coroutines::lazy_task<T>, Args...>
-{
-    using promise_type = typename pot::coroutines::lazy_task<T>::promise_type;
-};
-} // namespace std
-
-namespace pot::traits
-{
-template <typename T> struct is_lazy_task : std::false_type
-{
-};
-template <typename U> struct is_lazy_task<pot::coroutines::lazy_task<U>> : std::true_type
-{
-};
-template <typename T> inline constexpr bool is_lazy_task_v = is_lazy_task<T>::value;
-
-template <typename T> struct awaitable_value
-{
-    using type = T;
-};
-template <typename U> struct awaitable_value<coroutines::lazy_task<U>>
-{
-    using type = U;
-};
-template <typename T> using awaitable_value_t = typename awaitable_value<T>::type;
-template <typename T> struct is_task : std::false_type
-{
-};
-template <typename U> struct is_task<pot::coroutines::task<U>> : std::true_type
-{
-};
-template <typename T> inline constexpr bool is_task_v = is_task<T>::value;
-
-template <typename U> struct awaitable_value<coroutines::task<U>>
-{
-    using type = U;
-};
-} // namespace pot::traits
-
-
-namespace pot::coroutines
-{
-    struct task_meta 
-    {
-        std::atomic<size_t> run_count{0};
-        
-        // ~task_meta() {
-        //     std::printf("Task finished with run_count = %zu\n", run_count.load());
-        // }
-    };
-}
-
 namespace pot::coroutines::detail
 {
-
 template <typename T> struct basic_promise_type
 {
     using value_type = T;
@@ -172,7 +105,6 @@ template <typename T> struct basic_promise_type
     std::atomic<bool> m_ready{false};
     std::atomic<void *> m_awaiter{nullptr};
     variant_type m_data{std::monostate{}};
-    std::shared_ptr<pot::coroutines::task_meta> m_meta{std::make_shared<pot::coroutines::task_meta>()};
 };
 } // namespace pot::coroutines::detail
 
@@ -291,17 +223,6 @@ template <typename T> class task
         }
     }
 
-    std::shared_ptr<pot::coroutines::task_meta> meta() const 
-    {
-        if (m_handle) return m_handle.promise().m_meta;
-        return nullptr;
-    }
-
-    void set_meta(std::shared_ptr<pot::coroutines::task_meta> meta) 
-    {
-        if (m_handle) m_handle.promise().m_meta = std::move(meta);
-    }
-
     ~task()
     {
         if (m_handle)
@@ -412,18 +333,6 @@ template <typename T> class lazy_task
         }
     }
 
-    std::shared_ptr<pot::coroutines::task_meta> meta() const 
-    {
-        if (m_handle) return m_handle.promise().m_meta;
-        return nullptr;
-    }
-
-    void set_meta(std::shared_ptr<pot::coroutines::task_meta> meta) 
-    {
-        if (m_handle) m_handle.promise().m_meta = std::move(meta);
-    }
-
-
     ~lazy_task()
     {
         if (m_handle)
@@ -507,3 +416,46 @@ template <> struct lazy_task_promise_type_impl<void> final : detail::basic_promi
 };
 
 } // namespace pot::coroutines
+
+namespace std
+{
+
+template <typename T, typename... Args>
+struct coroutine_traits<pot::coroutines::lazy_task<T>, Args...>
+{
+    using promise_type = typename pot::coroutines::lazy_task<T>::promise_type;
+};
+} // namespace std
+
+namespace pot::traits
+{
+template <typename T> struct is_lazy_task : std::false_type
+{
+};
+template <typename U> struct is_lazy_task<pot::coroutines::lazy_task<U>> : std::true_type
+{
+};
+template <typename T> inline constexpr bool is_lazy_task_v = is_lazy_task<T>::value;
+
+template <typename T> struct awaitable_value
+{
+    using type = T;
+};
+template <typename U> struct awaitable_value<coroutines::lazy_task<U>>
+{
+    using type = U;
+};
+template <typename T> using awaitable_value_t = typename awaitable_value<T>::type;
+template <typename T> struct is_task : std::false_type
+{
+};
+template <typename U> struct is_task<pot::coroutines::task<U>> : std::true_type
+{
+};
+template <typename T> inline constexpr bool is_task_v = is_task<T>::value;
+
+template <typename U> struct awaitable_value<coroutines::task<U>>
+{
+    using type = U;
+};
+} // namespace pot::traits

include/pot/executors/executor.h

@@ -12,8 +12,7 @@ class executor
   protected:
     std::string m_name;
 
-    virtual void derived_execute(std::function<void()> &&func, 
-                                 std::shared_ptr<pot::coroutines::task_meta> meta = nullptr) = 0;
+    virtual void derived_execute(std::function<void()> &&func) = 0;
 
   public:
     explicit executor(std::string name) : m_name(std::move(name)) {}
@@ -27,19 +26,13 @@ class executor
 
     [[nodiscard]] std::string name() const { return m_name; }
 
-    void schedule_task(std::function<void()> func, std::shared_ptr<pot::coroutines::task_meta> meta)
-    {
-        derived_execute(std::move(func), std::move(meta));
-    }
-
     template <typename Func, typename... Args>
         requires std::is_invocable_v<Func, Args...>
     void run_detached(Func &&func, Args &&...args)
     {
-        auto meta = std::make_shared<pot::coroutines::task_meta>();
         derived_execute([f = std::decay_t<Func>(std::forward<Func>(func)),
                          ... captured_args = std::decay_t<Args>(std::forward<Args>(args))]() mutable
-                        { std::invoke(f, std::move(captured_args)...); }, std::move(meta));
+                        { std::invoke(f, std::move(captured_args)...); });
     }
 
     template <typename Func, typename... Args>
@@ -73,17 +66,14 @@ class executor
         using ReturnTaskType =
             std::conditional_t<Lazy, pot::coroutines::lazy_task<Val>, pot::coroutines::task<Val>>;
 
-        using PromiseType = typename ReturnTaskType::promise_type;
-
         struct schedule_awaiter
         {
             executor *exec;
             bool await_ready() const noexcept { return false; }
 
-            void await_suspend(std::coroutine_handle<PromiseType> h)
+            void await_suspend(std::coroutine_handle<> h)
             {
-                std::shared_ptr<pot::coroutines::task_meta> meta = h.promise().m_meta;
-                exec->derived_execute([h]() mutable { h.resume(); }, std::move(meta));
+                exec->derived_execute([h]() mutable { h.resume(); });
             }
 
             void await_resume() const noexcept {}