Re: [Async] Review of proposed Boost.Async begins

From: Andrzej Krzemienski (akrzemi1_at_[hidden])
Date: 2023-08-12 17:52:56

wt., 8 sie 2023 o 07:33 Niall Douglas via Boost <boost_at_[hidden]>
napisał(a):

> Dear Boost,
>
> It is my great pleasure to announce the beginning of the peer review of
> proposed Boost.Async, which is hoped to become the most popular way of
> programming C++ coroutines in future C++. The peer review shall run
> between Tuesday 8th August and Friday 18th August.
>
> Like many of you have found, until now there has been no good standard
> and easy way of writing C++ coroutine code which works easily with
> multiple third party codebases and foreign asynchronous design patterns.
> ASIO’s current coroutine support is tightly coupled to ASIO, and it
> rejects foreign awaitables. Libunifex is dense to master and non-obvious
> to make work well with foreign asynchronous design patterns, not helped
> by a lack of documentation, a problem which also afflicts stdexec which
> also has a steep and dense learning curve. CppCoro is probably currently
> the best in class solution to the space of easy to use fire and forget
> C++ coroutine programming, but it isn’t particularly portable and was
> designed long before C++ coroutine standardisation was completed.
>
> Klemens very kindly stepped up and created for us an open source
> ground-up reimplementation of the best ideas of hitherto proprietary
> commercial C++ coroutine libraries, taking in experience and feedback
> from multiple domain experts in the area to create an easy to use C++
> coroutine support library with excellent support for foreign
> asynchronous design patterns. For example, if you want your coroutine to
> suspend while a stackful fiber runs and then resume when that fiber has
> done something – AND that fiber implementation is unknown to Boost.Async
> – this is made as easy as possible. If your C++ coroutine code wants to
> await on unknown foreign awaitables, that generally “just works” with no
> added effort. This makes tying together multiple third party
> dependencies into a solution based on C++ coroutines much easier than
> until now.
>
> The industry standard executor is ASIO, so Boost.Async uses Boost.ASIO
> as its base executor. To keep things simple and high performance,
> Boost.Async requires each pool of things it works with to execute on a
> single kernel thread at a time – though there can be a pool of things
> per kernel thread, or an ASIO strand can ensure execution never occurs
> on multiple kernel threads. The basic concurrency primitives of promise,
> generator and task are provided, with the fundamental operations of
> select, join and gather. Some more complex async support is supplied:
> Go-type channels, and async teardown. Performance is superior to both
> stackful coroutines and ASIO’s own C++ coroutine support, and sometimes
> far superior.
>
> You can read the documentation at https://klemens.dev/async/ and study
> or try out the code at https://github.com/klemens-morgenstern/async.
>

Is there a single-header version of this library? One that could be tested
in Compiler Explorer?

Regards,
&rzej;

>
> Anyone with experience using C++ coroutines is welcome to contribute a
> review at the Boost mailing list
> (https://lists.boost.org/mailman/listinfo.cgi/boost), here at this
> Reddit page, via email to me personally, or any other mechanism where I
> the review manager will see it. In your review please state at the end
> whether you recommend acceptance, acceptance with conditions, or
> rejection. Please state your experience with C++ coroutines and ASIO in
> your review, and how many hours you spent on the review.
>
> Thanks in advance for your time and reviews!
>
> Niall
>
> _______________________________________________
> Unsubscribe & other changes:
> http://lists.boost.org/mailman/listinfo.cgi/boost
>