support for asio::yield_context

.github/workflows/ci.yml

@@ -97,8 +97,10 @@ jobs:
           cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
           git submodule update --init tools/boostdep
           python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          
           git submodule update --init libs/test
-          # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
           
@@ -165,6 +167,8 @@ jobs:
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
           git submodule update --init libs/test
           # temporary workaround, 
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
           cmd /c bootstrap
@@ -221,6 +225,8 @@ jobs:
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
           git submodule update --init libs/test
           # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
 
@@ -277,6 +283,8 @@ jobs:
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
           git submodule update --init libs/test
           # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
 
@@ -350,6 +358,8 @@ jobs:
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
           git submodule update --init libs/test
           # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
 
@@ -403,6 +413,8 @@ jobs:
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
           git submodule update --init libs/test
           # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
 
@@ -458,6 +470,8 @@ jobs:
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
           git submodule update --init libs/test
           # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
 
@@ -531,8 +545,10 @@ jobs:
           xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
           git submodule update --init tools/boostdep
           python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+          
           git submodule update --init libs/test
-          # Temporary workaround
+          git submodule update --init libs/callable_traits
+          git submodule update --init libs/context
           git submodule update --init libs/chrono
           git submodule update --init libs/ratio
 

CMakeLists.txt

@@ -47,6 +47,7 @@ if (NOT BOOST_COBALT_IS_ROOT)
     target_link_libraries(boost_cobalt
             PUBLIC
             Boost::asio
+            Boost::callable_traits
             Boost::circular_buffer
             Boost::config
             Boost::container

doc/index.adoc

@@ -78,6 +78,9 @@ include::reference/error.adoc[]
 include::reference/config.adoc[]
 include::reference/leaf.adoc[]
 
+include::reference/experimental/context.adoc[]
+
+
 = In-Depth
 
 include::background/custom_executors.adoc[]

doc/reference/experimental/context.adoc

@@ -0,0 +1,69 @@
+[#context]
+== cobalt/experimental/context.hpp
+
+WARNING: This is (most likely) undefined behaviour, since the violates a precondition in the standard. A paper to address this can be found here (https://isocpp.org/files/papers/P3203R0.html).
+
+This header provides `experimental` support for using `boost.fiber` based stackful coroutines
+as if they were C++20 coroutines. That is, they can use `awaitables` by being able to be put into a `coroutine_handle`.
+Likewise the implementation uses a C++20 coroutine promise and runs is as if it was a C++20 coroutine.
+
+[source,cpp]
+----
+//
+void delay(experimental::context<promise<void>> h, std::chrono::milliseconds ms)
+{
+  asio::steady_timer tim{co_await cobalt::this_coro::executor, ms};
+  h.await(tim.async_wait(cobalt::use_op)); // instead of co_await.
+}
+
+cobalt::main co_main(int argc, char *argv[])
+{
+  cobalt::promise<void> dl = cobalt::experimental::make_context(&delay, 50);
+  co_await dl;
+  co_return 0;
+}
+----
+
+=== Reference
+
+[source,cpp]
+----
+// The internal coroutine context.
+/// Args are the function arguments after the handle.
+template<typename Return, typename ... Args>
+struct context
+{
+  // Get a handle to the promise
+        promise_type & promise();
+  const promise_type & promise() const;
+
+  // Convert it to any context if the underlying promise is the same
+  template<typename Return_, typename ... Args_>
+  constexpr operator context<Return_, Args_...>() const;
+
+  // Await something. Uses await_transform automatically.
+  template<typename Awaitable>
+  auto await(Awaitable && aw);
+  // Yield a value, if supported by the promise.
+  template<typename Yield>
+  auto yield(Yield && value);
+};
+
+
+// Create a fiber with a custom stack allocator (see boost.fiber for details) and explicit result (e.g. `promise<void>`)
+template<typename Return, typename ... Args, std::invocable<context<Return, Args...>, Args...> Func, typename StackAlloc>
+auto make_context(Func && func, std::allocator_arg_t, StackAlloc  && salloc, Args && ... args);
+
+// Create a fiber with the default allocator and explicit result (e.g. `promise<void>`)
+template<typename Return, typename ... Args, std::invocable<context<Return, Args...>, Args...> Func>
+auto make_context(Func && func, Args && ... args);
+
+// Create a fiber with a custom stack allocator and implicit result (deduced from the first argument to func).
+template<typename ... Args, typename Func, typename StackAlloc>
+auto make_context(Func && func, std::allocator_arg_t, StackAlloc  && salloc, Args && ... args);
+
+// Create a fiber with the default stack allocator and implicit result (deduced from the first argument to func).
+template<typename ... Args, typename Func>
+auto make_context(Func && func, Args && ... args);
+----
+

include/boost/cobalt/detail/fork.hpp

@@ -108,9 +108,7 @@ struct fork
       return st.resource.allocate(size);
     }
 
-    template<typename ... Rest>
-    void operator delete(void * raw, const std::size_t size, Rest && ...) noexcept;
-    void operator delete(void *, const std::size_t) noexcept {}
+    void operator delete(void *) noexcept {}
 
     template<typename ... Rest>
     promise_type(shared_state & st, Rest & ...)

include/boost/cobalt/experimental/context.hpp

@@ -2,18 +2,18 @@
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_COBALT_CONTEXT_HPP
-#define BOOST_COBALT_CONTEXT_HPP
+#ifndef BOOST_COBALT_EXPERIMENTAL_CONTEXT_HPP
+#define BOOST_COBALT_EXPERIMENTAL_CONTEXT_HPP
 
 #include <boost/callable_traits/args.hpp>
 #include <boost/context/fiber.hpp>
 #include <boost/context/fixedsize_stack.hpp>
 
 #include <boost/cobalt/concepts.hpp>
+#include <boost/cobalt/experimental/frame.hpp>
 #include <boost/cobalt/config.hpp>
 #include <coroutine>
 #include <new>
-// this is all UB according to the standard. BUT it shouldn't be!
 
 namespace boost::cobalt::experimental
 {
@@ -25,25 +25,20 @@ namespace detail
 {
 
 template<typename Promise>
-struct fiber_frame
+struct context_frame : frame<context_frame<Promise>,  Promise>
 {
-  void (*resume_) (fiber_frame *) = +[](fiber_frame * ff) { ff->resume();};
-  void (*destroy_)(fiber_frame *) = +[](fiber_frame * ff) { ff->destroy();};
-
-  Promise promise;
-
   boost::context::fiber caller, callee;
 
-  void (*after_resume)(fiber_frame *, void *) = nullptr;
+  void (*after_resume)(context_frame *, void *) = nullptr;
   void * after_resume_p;
 
   template<typename ... Args>
     requires std::constructible_from<Promise, Args...>
-  fiber_frame(Args && ... args) : promise(args...) {}
+  context_frame(Args && ... args) : frame<context_frame, Promise>(args...) {}
 
   template<typename ... Args>
     requires (!std::constructible_from<Promise, Args...> && std::is_default_constructible_v<Promise>)
-  fiber_frame(Args && ...) {}
+  context_frame(Args && ...) {}
 
   void resume()
   {
@@ -54,32 +49,53 @@ struct fiber_frame
   void destroy()
   {
     auto c = std::exchange(callee, {});
-    this->~fiber_frame();
+    this->~context_frame();
+  }
+
+  template<typename Awaitable>
+  auto do_resume(void * )
+  {
+    return +[](context_frame * this_, void * p)
+    {
+      auto aw_ = static_cast<Awaitable*>(p);
+      auto h = std::coroutine_handle<Promise>::from_address(this_) ;
+      aw_->await_suspend(h);
+    };
   }
 
+  template<typename Awaitable>
+  auto do_resume(bool * )
+  {
+    return +[](context_frame * this_, void * p)
+    {
+      auto aw_ = static_cast<Awaitable*>(p);
+      auto h = std::coroutine_handle<Promise>::from_address(this_) ;
+      if (!aw_->await_suspend(h))
+        h.resume();
+    };
+  }
+
+  template<typename Awaitable, typename Promise_>
+  auto do_resume(std::coroutine_handle<Promise_> * )
+  {
+    return +[](context_frame * this_, void * p)
+    {
+      auto aw_ = static_cast<Awaitable*>(p);
+      auto h = std::coroutine_handle<Promise>::from_address(this_) ;
+      aw_->await_suspend(h).resume();
+    };
+  }
+
+
   template<typename Awaitable>
   auto do_await(Awaitable aw)
   {
     if (!aw.await_ready())
     {
       after_resume_p = & aw;
-      after_resume =
-            +[](fiber_frame * this_, void * p)
-            {
-              auto aw_ = static_cast<Awaitable*>(p);
-              auto h = std::coroutine_handle<Promise>::from_address(this_) ;
-              if constexpr (requires {{aw_->await_suspend(h)} -> std::same_as<void>;})
-                aw_->await_suspend(h);
-              else if constexpr (requires {{aw_->await_suspend(h)} -> std::same_as<bool>;})
-              {
-                if (!aw_->await_suspend(h))
-                  h.resume();
-              }
-              else if constexpr (requires {{aw_->await_suspend(h)} -> std::convertible_to<std::coroutine_handle<void>>;})
-                aw_->await_suspend(h).resume();
-              else
-                static_assert(std::is_void_v<Awaitable>, "Invalid return from await_suspend()");
-            };
+      after_resume = do_resume<Awaitable>(
+          static_cast<decltype(aw.await_suspend(std::declval<std::coroutine_handle<Promise>>()))*>(nullptr)
+          );
       caller = std::move(caller).resume();
     }
     return aw.await_resume();
@@ -162,6 +178,20 @@ struct await_transform_impl : await_transform_base, T
 template<typename T>
 concept has_await_transform = ! requires (await_transform_impl<T> & p) {p.await_transform(await_transform_base::dummy{});};
 
+template<typename Promise, typename Context, typename Func, typename ... Args>
+void do_return(std::true_type /* is_void */, Promise& promise, Context ctx, Func && func, Args && ... args)
+{
+  std::forward<Func>(func)(ctx, std::forward<Args>(args)...);
+  promise.return_void();
+}
+
+template<typename Promise, typename Context, typename Func, typename ... Args>
+void do_return(std::false_type /* is_void */, Promise& promise, Context ctx, Func && func, Args && ... args)
+{
+  promise.return_value(std::forward<Func>(func)(ctx, std::forward<Args>(args)...));
+}
+
+
 }
 
 template<typename Return, typename ... Args>
@@ -242,14 +272,14 @@ struct context
 
  private:
 
-  context(detail::fiber_frame<promise_type> * frame) : frame_(frame) {}
+  context(detail::context_frame<promise_type> * frame) : frame_(frame) {}
   template<typename, typename ...>
   friend struct context;
 
   //template<typename >
-  friend struct detail::fiber_frame<promise_type>;
+  friend struct detail::context_frame<promise_type>;
 
-  detail::fiber_frame<promise_type> * frame_;
+  detail::context_frame<promise_type> * frame_;
 };
 
 template<typename Return, typename ... Args, std::invocable<context<Return, Args...>, Args...> Func, typename StackAlloc>
@@ -258,17 +288,17 @@ auto make_context(Func && func, std::allocator_arg_t, StackAlloc  && salloc, Arg
   auto sctx_ = salloc.allocate();
 
   using promise_type = typename std::coroutine_traits<Return, Args...>::promise_type;
-  void * p = static_cast<char*>(sctx_.sp) - sizeof(detail::fiber_frame<promise_type>);
-  auto sz = sctx_.size - sizeof(detail::fiber_frame<promise_type>);
+  void * p = static_cast<char*>(sctx_.sp) - sizeof(detail::context_frame<promise_type>);
+  auto sz = sctx_.size - sizeof(detail::context_frame<promise_type>);
 
-  if (auto diff = reinterpret_cast<std::uintptr_t>(p) % alignof(detail::fiber_frame<promise_type>); diff != 0u)
+  if (auto diff = reinterpret_cast<std::uintptr_t>(p) % alignof(detail::context_frame<promise_type>); diff != 0u)
   {
     p = static_cast<char*>(p) - diff;
     sz -= diff;
   }
 
   boost::context::preallocated psc{p, sz, sctx_};
-  auto f = new (p) detail::fiber_frame<promise_type>(args...);
+  auto f = new (p) detail::context_frame<promise_type>(args...);
 
   auto res = f->promise.get_return_object();
 
@@ -278,11 +308,11 @@ auto make_context(Func && func, std::allocator_arg_t, StackAlloc  && salloc, Arg
 
   struct invoker
   {
-    detail::fiber_frame<promise_type> * frame;
+    detail::context_frame<promise_type> * frame;
     mutable Func func;
     mutable std::tuple<Args...> args;
 
-    invoker(detail::fiber_frame<promise_type> * frame, Func && func, Args && ...  args)
+    invoker(detail::context_frame<promise_type> * frame, Func && func, Args && ...  args)
         : frame(frame), func(std::forward<Func>(func)), args(std::forward<Args>(args)...)
     {
     }
@@ -303,15 +333,8 @@ auto make_context(Func && func, std::allocator_arg_t, StackAlloc  && salloc, Arg
               auto ctx = frame->template get_context<Return, Args...>();
               using return_type = decltype(std::forward<Func>(func)(ctx, std::forward<Args>(args_)...));
 
-              if constexpr (std::is_void_v<return_type>)
-              {
-                std::forward<Func>(func)(ctx, std::forward<Args>(args_)...);
-                frame->promise.return_void();
-              }
-              else
-                frame->promise.return_value(std::forward<Func>(func)(ctx, std::forward<Args>(args_)...));
-
-
+              detail::do_return(std::is_void<return_type>{}, frame->promise, ctx,
+                                std::forward<Func>(func), std::forward<Args>(args_)...);
             },
             std::move(args));
       }
@@ -364,4 +387,4 @@ auto make_context(Func && func, Args && ... args)
 
 }
 
-#endif //BOOST_COBALT_CONTEXT_HPP
+#endif //BOOST_COBALT_EXPERIMENTAL_CONTEXT_HPP