139 #include "../version.h"
141 #ifdef VLINK_ENABLE_CXX_STD_20
142 #if defined(__cpp_impl_coroutine) && __has_include(<coroutine>)
145 #if defined(__cpp_lib_coroutine)
146 #ifndef VLINK_ENABLE_COROUTINE
147 #define VLINK_ENABLE_COROUTINE
152 #ifdef VLINK_ENABLE_COROUTINE
164 #include <type_traits>
186 namespace Coroutine {
188 template <
typename TypeT =
void>
202 template <
typename TypeT>
220 VLINK_EXPORT void deallocate_frame(
void* ptr,
size_t size) noexcept;
231 struct FinalAwaiter final {
238 bool await_ready() const noexcept;
248 template <typename PromiseT>
249 std::coroutine_handle<> await_suspend(std::coroutine_handle<PromiseT> handle) noexcept;
255 void await_resume() const noexcept;
268 template <typename TypeT>
269 struct TaskPromiseBase {
270 std::coroutine_handle<> continuation;
271 std::exception_ptr exception;
278 std::suspend_always initial_suspend() noexcept;
285 FinalAwaiter final_suspend() noexcept;
290 void unhandled_exception() noexcept;
303 template <typename TypeT>
304 struct TaskPromise final : TaskPromiseBase<TypeT> {
305 std::optional<TypeT> result;
313 static void*
operator new(
size_t size);
321 static void operator delete(
void* ptr,
size_t size) noexcept;
328 Task<TypeT> get_return_object() noexcept;
336 template <typename UpT>
337 void return_value(UpT&& v) noexcept(std::is_nothrow_constructible_v<TypeT, UpT&&>);
349 struct TaskPromise<
void> final : TaskPromiseBase<
void> {
356 static void*
operator new(
size_t size);
364 static void operator delete(
void* ptr,
size_t size) noexcept;
371 Task<void> get_return_object() noexcept;
376 void return_void() noexcept;
407 static void*
operator new(
size_t size);
415 static void operator delete(
void* ptr,
size_t size) noexcept;
422 DetachedTask get_return_object() noexcept;
429 std::suspend_always initial_suspend() noexcept;
436 std::suspend_never final_suspend() noexcept;
441 void return_void() noexcept;
450 void unhandled_exception() noexcept;
453 using Handle = std::coroutine_handle<promise_type>;
458 DetachedTask() noexcept;
477 explicit DetachedTask(Handle h) noexcept;
484 DetachedTask(DetachedTask&& other) noexcept;
496 DetachedTask& operator=(DetachedTask&& other) noexcept;
509 VLINK_EXPORT DetachedTask co_spawn_void_impl(Task<
void> task);
520 template <typename TypeT, typename CallbackT>
521 DetachedTask co_spawn_value_impl(Task<TypeT> task, CallbackT on_complete);
531 template <typename CallbackT>
532 DetachedTask co_spawn_void_with_cb_impl(Task<
void> task, CallbackT on_complete);
543 enum class ResumePostResult : uint8_t {
549 struct AwaiterResumeState;
560 inline constexpr uint32_t kMaxResumePostRetry = 30000U;
583 VLINK_EXPORT ResumePostResult post_callback_if_alive(MessageLoop* loop,
584 const std::shared_ptr<MessageLoop::AliveState>& alive_state,
585 MoveFunction<
void()>&& resume_callback,
586 MoveFunction<
void()>&& drop_callback, uint16_t priority = 0);
600 VLINK_EXPORT void co_spawn_detached_handle(MessageLoop& loop, DetachedTask::Handle handle, uint16_t priority = 0);
612 VLINK_EXPORT void register_future_wait(MoveFunction<
bool()>&& poll);
620 [[nodiscard]]
VLINK_EXPORT bool run_deferred_future(MoveFunction<
void()>&& callback);
636 template <
typename TypeT>
639 using promise_type = detail::TaskPromise<TypeT>;
640 using Handle = std::coroutine_handle<promise_type>;
645 Task() noexcept = default;
652 explicit Task(Handle handle) noexcept;
659 Task(Task&& other) noexcept;
667 Task& operator=(Task&& other) noexcept;
679 [[nodiscard]]
bool valid() const noexcept;
686 [[nodiscard]]
bool done() const noexcept;
693 bool await_ready() const noexcept;
701 std::coroutine_handle<> await_suspend(std::coroutine_handle<> awaiter) noexcept;
712 TypeT await_resume();
719 Handle release() noexcept;
726 [[nodiscard]] Handle native_handle() const noexcept;
754 ScheduleAwaiter() noexcept;
764 ScheduleAwaiter(MessageLoop* loop, std::shared_ptr<MessageLoop::AliveState> alive_state,
765 std::shared_ptr<detail::AwaiterResumeState> state, uint16_t priority) noexcept;
770 ScheduleAwaiter(ScheduleAwaiter&&) noexcept;
775 ScheduleAwaiter& operator=(ScheduleAwaiter&&) noexcept;
777 MessageLoop* loop{
nullptr};
778 std::shared_ptr<MessageLoop::AliveState> alive_state;
779 std::shared_ptr<detail::AwaiterResumeState> state;
780 uint16_t priority{0};
788 static bool await_ready() noexcept;
806 bool await_suspend(std::coroutine_handle<> handle);
835 YieldAwaiter() noexcept;
845 YieldAwaiter(MessageLoop* loop, std::shared_ptr<MessageLoop::AliveState> alive_state,
846 std::shared_ptr<detail::AwaiterResumeState> state, uint16_t priority) noexcept;
851 YieldAwaiter(YieldAwaiter&&) noexcept;
856 YieldAwaiter& operator=(YieldAwaiter&&) noexcept;
858 MessageLoop* loop{
nullptr};
859 std::shared_ptr<MessageLoop::AliveState> alive_state;
860 std::shared_ptr<detail::AwaiterResumeState> state;
861 uint16_t priority{0};
869 static bool await_ready() noexcept;
882 bool await_suspend(std::coroutine_handle<> handle);
913 DelayAwaiter() noexcept;
924 DelayAwaiter(MessageLoop* loop, std::shared_ptr<MessageLoop::AliveState> alive_state,
925 std::shared_ptr<detail::AwaiterResumeState> state, uint32_t ms, uint16_t priority) noexcept;
930 DelayAwaiter(DelayAwaiter&&) noexcept;
935 DelayAwaiter& operator=(DelayAwaiter&&) noexcept;
937 MessageLoop* loop{
nullptr};
938 std::shared_ptr<MessageLoop::AliveState> alive_state;
939 std::shared_ptr<detail::AwaiterResumeState> state;
941 uint16_t priority{0};
949 static bool await_ready() noexcept;
962 bool await_suspend(std::coroutine_handle<> handle);
1000 template <typename TypeT>
1001 class FutureAwaiter final {
1009 FutureAwaiter(MessageLoop* loop, std::future<TypeT> fut) noexcept;
1014 FutureAwaiter(FutureAwaiter&&) noexcept = default;
1019 FutureAwaiter& operator=(FutureAwaiter&&) noexcept = default;
1031 bool await_ready() const noexcept;
1039 void await_suspend(std::coroutine_handle<> handle);
1048 TypeT await_resume();
1053 MessageLoop* loop_{
nullptr};
1054 std::shared_ptr<State> state_;
1085 GraphAwaiter(MessageLoop* loop,
GraphTaskPtr graph) noexcept;
1090 GraphAwaiter(GraphAwaiter&&) noexcept;
1095 GraphAwaiter& operator=(GraphAwaiter&&) noexcept;
1107 [[nodiscard]]
bool await_ready() const noexcept;
1114 void await_suspend(std::coroutine_handle<> handle);
1121 void await_resume() const;
1126 MessageLoop* loop_{
nullptr};
1128 std::shared_ptr<State> state_;
1170 VLINK_EXPORT DelayAwaiter delay_ms(MessageLoop& loop, uint32_t ms,
1181 template <
typename TypeT>
1182 FutureAwaiter<TypeT> await_future(MessageLoop& loop, std::future<TypeT> fut) noexcept;
1211 VLINK_EXPORT void co_spawn(MessageLoop& loop, Task<void>&& task);
1220 VLINK_EXPORT void co_spawn_with_priority(MessageLoop& loop, Task<void>&& task, uint16_t priority);
1257 template <
typename TypeT,
typename CallbackT,
1259 typename = std::enable_if_t<!std::is_integral_v<std::remove_reference_t<CallbackT>>>>
1260 void co_spawn(MessageLoop& loop, Task<TypeT>&& task, CallbackT&& on_complete);
1272 template <
typename TypeT,
typename CallbackT,
1274 typename = std::enable_if_t<!std::is_integral_v<std::remove_reference_t<CallbackT>>>>
1275 void co_spawn_with_priority(MessageLoop& loop, Task<TypeT>&& task, CallbackT&& on_complete, uint16_t priority);
1306 template <
typename CallbackT>
1307 Task<void> exec(MessageLoop& loop, Schedule::Config config, CallbackT callback);
1329 template <
typename TypeT>
1330 Task<std::vector<TypeT>> when_all(MessageLoop& loop, std::vector<Task<TypeT>> tasks);
1345 VLINK_EXPORT Task<void> when_all(MessageLoop& loop, std::vector<Task<void>> tasks);
1368 template <
typename TypeT>
1369 Task<std::pair<size_t, TypeT>> when_any(MessageLoop& loop, std::vector<Task<TypeT>> tasks);
1389 VLINK_EXPORT Task<size_t> when_any(MessageLoop& loop, std::vector<Task<void>> tasks);
1407 VLINK_EXPORT Task<void> sequence(MessageLoop& loop, std::vector<Task<void>> tasks);
1416 inline bool FinalAwaiter::await_ready() const noexcept {
return false; }
1418 template <
typename PromiseT>
1419 inline std::coroutine_handle<> FinalAwaiter::await_suspend(std::coroutine_handle<PromiseT> handle) noexcept {
1420 auto next = handle.promise().continuation;
1421 return next ? next : std::noop_coroutine();
1425 inline void FinalAwaiter::await_resume() const noexcept {}
1427 template <
typename TypeT>
1428 inline std::suspend_always TaskPromiseBase<TypeT>::initial_suspend() noexcept {
1432 template <
typename TypeT>
1433 inline FinalAwaiter TaskPromiseBase<TypeT>::final_suspend() noexcept {
1437 template <
typename TypeT>
1438 inline void TaskPromiseBase<TypeT>::unhandled_exception() noexcept {
1439 exception = std::current_exception();
1442 template <
typename TypeT>
1443 inline void* TaskPromise<TypeT>::operator
new(
size_t size) {
1444 return detail::allocate_frame(size);
1447 template <
typename TypeT>
1448 inline void TaskPromise<TypeT>::operator
delete(
void* ptr,
size_t size) noexcept {
1449 detail::deallocate_frame(ptr, size);
1452 template <
typename TypeT>
1453 inline Task<TypeT> TaskPromise<TypeT>::get_return_object() noexcept {
1454 return Task<TypeT>{std::coroutine_handle<TaskPromise<TypeT>>::from_promise(*
this)};
1457 template <
typename TypeT>
1458 template <
typename UpT>
1459 inline void TaskPromise<TypeT>::return_value(UpT&& v) noexcept(std::is_nothrow_constructible_v<TypeT, UpT&&>) {
1460 result.emplace(std::forward<UpT>(v));
1463 inline void* TaskPromise<void>::operator
new(
size_t size) {
return detail::allocate_frame(size); }
1465 inline void TaskPromise<void>::operator
delete(
void* ptr,
size_t size) noexcept { detail::deallocate_frame(ptr, size); }
1467 inline Task<void> TaskPromise<void>::get_return_object() noexcept {
1468 return Task<void>{std::coroutine_handle<TaskPromise<void>>::from_promise(*
this)};
1471 inline void TaskPromise<void>::return_void() noexcept {}
1473 template <
typename TypeT,
typename CallbackT>
1474 inline DetachedTask co_spawn_value_impl(Task<TypeT> task, CallbackT on_complete) {
1475 on_complete(co_await std::move(task));
1478 template <
typename CallbackT>
1479 inline DetachedTask co_spawn_void_with_cb_impl(Task<void> task, CallbackT on_complete) {
1480 co_await std::move(task);
1486 template <
typename TypeT>
1487 inline Task<TypeT>::Task(Handle handle) noexcept : handle_(handle) {}
1489 template <
typename TypeT>
1490 inline Task<TypeT>::Task(Task&& other) noexcept : handle_(std::exchange(other.handle_, {})) {}
1492 template <
typename TypeT>
1493 inline Task<TypeT>& Task<TypeT>::operator=(Task&& other) noexcept {
1498 handle_ = std::exchange(other.handle_, {});
1504 template <
typename TypeT>
1505 inline Task<TypeT>::~Task() {
1511 template <
typename TypeT>
1512 inline bool Task<TypeT>::valid() const noexcept {
1513 return handle_ !=
nullptr;
1516 template <
typename TypeT>
1517 inline bool Task<TypeT>::done() const noexcept {
1518 return handle_ && handle_.done();
1521 template <
typename TypeT>
1522 inline bool Task<TypeT>::await_ready() const noexcept {
1527 return handle_.done();
1530 template <
typename TypeT>
1531 inline std::coroutine_handle<> Task<TypeT>::await_suspend(std::coroutine_handle<> awaiter) noexcept {
1532 handle_.promise().continuation = awaiter;
1536 template <
typename TypeT>
1537 inline TypeT Task<TypeT>::await_resume() {
1539 throw std::logic_error(
"vlink::Coroutine::Task::await_resume on invalid Task (moved-from or default-constructed)");
1542 if VUNLIKELY (handle_.promise().exception) {
1543 std::rethrow_exception(handle_.promise().exception);
1546 if constexpr (!std::is_void_v<TypeT>) {
1547 return std::move(*handle_.promise().result);
1551 template <
typename TypeT>
1552 inline typename Task<TypeT>::Handle Task<TypeT>::release() noexcept {
1553 return std::exchange(handle_, {});
1556 template <
typename TypeT>
1557 inline typename Task<TypeT>::Handle Task<TypeT>::native_handle() const noexcept {
1561 template <
typename TypeT>
1562 struct FutureAwaiter<TypeT>::State final {
1563 explicit State(std::future<TypeT> future) noexcept : fut(std::move(future)) {}
1565 void set_handle(std::coroutine_handle<> h) {
1566 std::lock_guard lock(mtx);
1568 if (!abandoned.load(std::memory_order_acquire)) {
1573 std::coroutine_handle<> take_handle() {
1574 std::lock_guard lock(mtx);
1575 return std::exchange(handle, {});
1578 void clear_handle() {
1579 std::lock_guard lock(mtx);
1583 void resume_ready() {
1584 auto h = take_handle();
1591 void cancel_and_resume() {
1592 target_closed.store(
true, std::memory_order_release);
1593 auto h = take_handle();
1600 std::future<TypeT> fut;
1602 std::coroutine_handle<> handle;
1603 std::atomic_bool abandoned{
false};
1604 std::atomic_bool target_closed{
false};
1607 template <
typename TypeT>
1608 inline FutureAwaiter<TypeT>::FutureAwaiter(MessageLoop* loop, std::future<TypeT> fut) noexcept
1609 : loop_(loop), state_(MemoryResource::make_shared<State>(std::move(fut))) {}
1611 template <
typename TypeT>
1612 inline FutureAwaiter<TypeT>::~FutureAwaiter() {
1614 state_->abandoned.store(
true, std::memory_order_release);
1615 state_->clear_handle();
1619 template <
typename TypeT>
1620 inline bool FutureAwaiter<TypeT>::await_ready() const noexcept {
1621 return !state_->fut.valid() || state_->fut.wait_for(std::chrono::nanoseconds::zero()) == std::future_status::ready;
1624 template <
typename TypeT>
1625 inline void FutureAwaiter<TypeT>::await_suspend(std::coroutine_handle<> handle) {
1626 auto* loop_ptr = loop_;
1627 auto loop_alive = loop_ptr->get_alive_state();
1628 auto state = state_;
1629 state->set_handle(handle);
1631 const bool deferred = state->fut.wait_for(std::chrono::nanoseconds::zero()) == std::future_status::deferred;
1633 auto poll = MoveFunction<bool()>([loop_ptr, loop_alive, state = std::move(state),
1634 retry_count = 0U]()
mutable ->
bool {
1635 if VUNLIKELY (state->abandoned.load(std::memory_order_acquire)) {
1639 if (state->fut.valid() && state->fut.wait_for(std::chrono::nanoseconds::zero()) != std::future_status::ready) {
1643 const auto result = detail::post_callback_if_alive(
1644 loop_ptr, loop_alive, MoveFunction<
void()>([state]() { state->resume_ready(); }),
1645 MoveFunction<
void()>([state]() {
1646 detail::register_future_wait(MoveFunction<
bool()>([state]() {
1647 if (!state->abandoned.load(std::memory_order_acquire)) {
1648 state->cancel_and_resume();
1655 if (result == detail::ResumePostResult::kPosted) {
1659 if (result == detail::ResumePostResult::kRetry) {
1660 if (++retry_count >= detail::kMaxResumePostRetry) {
1661 detail::register_future_wait(MoveFunction<
bool()>([state]() {
1662 if (!state->abandoned.load(std::memory_order_acquire)) {
1663 state->cancel_and_resume();
1677 if VUNLIKELY (!detail::run_deferred_future([state = state_, poll = std::move(poll)]()
mutable {
1679 detail::register_future_wait(std::move(poll));
1681 throw std::runtime_error(
"Coroutine::await_future: deferred task post failed");
1684 detail::register_future_wait(std::move(poll));
1688 template <
typename TypeT>
1689 inline TypeT FutureAwaiter<TypeT>::await_resume() {
1690 state_->abandoned.store(
true, std::memory_order_release);
1691 state_->clear_handle();
1693 if VUNLIKELY (state_->target_closed.load(std::memory_order_acquire)) {
1694 throw Exception::OperationCancelled{};
1698 throw Exception::InvalidArgument{
"await_future: the future has no shared state"};
1701 if constexpr (std::is_void_v<TypeT>) {
1704 return state_->fut.get();
1708 template <
typename TypeT>
1709 inline FutureAwaiter<TypeT> await_future(MessageLoop& loop, std::future<TypeT> fut) noexcept {
1710 return FutureAwaiter<TypeT>{&loop, std::move(fut)};
1713 template <
typename TypeT,
typename CallbackT,
typename>
1714 inline void co_spawn(MessageLoop& loop, Task<TypeT>&& task, CallbackT&& on_complete) {
1715 co_spawn_with_priority<TypeT, CallbackT>(loop, std::move(task), std::forward<CallbackT>(on_complete), 0);
1718 template <
typename TypeT,
typename CallbackT,
typename>
1719 inline void co_spawn_with_priority(MessageLoop& loop, Task<TypeT>&& task, CallbackT&& on_complete, uint16_t priority) {
1720 if constexpr (std::is_void_v<TypeT>) {
1721 auto detached = detail::co_spawn_void_with_cb_impl<std::decay_t<CallbackT>>(std::move(task),
1722 std::forward<CallbackT>(on_complete));
1723 auto handle = detached.handle;
1724 detached.handle = {};
1725 detail::co_spawn_detached_handle(loop, handle, priority);
1727 auto detached = detail::co_spawn_value_impl<TypeT, std::decay_t<CallbackT>>(std::move(task),
1728 std::forward<CallbackT>(on_complete));
1729 auto handle = detached.handle;
1730 detached.handle = {};
1731 detail::co_spawn_detached_handle(loop, handle, priority);
1735 template <
typename CallbackT>
1736 inline Task<void> exec(MessageLoop& loop, Schedule::Config config, CallbackT callback) {
1737 std::future<void> fut;
1740 auto promise_ptr = MemoryResource::make_shared<std::promise<void>>();
1741 fut = promise_ptr->get_future();
1743 auto status = loop.exec_task(config, [cb = std::move(callback), promise_ptr]()
mutable {
1746 promise_ptr->set_value();
1748 promise_ptr->set_exception(std::current_exception());
1752 if (config.schedule_timeout_ms > 0) {
1753 status.on_schedule_timeout([promise_ptr]() {
1754 promise_ptr->set_exception(std::make_exception_ptr(std::runtime_error(
"Coroutine::exec: schedule timeout")));
1759 promise_ptr->set_exception(std::make_exception_ptr(std::runtime_error(
"Coroutine::exec: exec_task post failed")));
1763 co_await await_future(loop, std::move(fut));
1770 template <
typename TypeT>
1771 struct WhenAllState final {
1772 std::vector<TypeT> results;
1773 std::atomic<size_t> remaining{0};
1775 std::exception_ptr first_exc;
1776 std::promise<void> promise;
1779 template <
typename TypeT>
1780 struct WhenAllGuard final {
1781 std::shared_ptr<WhenAllState<TypeT>> state;
1782 bool completed_normally{
false};
1784 explicit WhenAllGuard(std::shared_ptr<WhenAllState<TypeT>> s) noexcept : state(std::move(s)) {}
1786 WhenAllGuard(WhenAllGuard&& other) noexcept
1787 : state(std::move(other.state)), completed_normally(other.completed_normally) {}
1789 WhenAllGuard(
const WhenAllGuard&) =
delete;
1791 WhenAllGuard& operator=(
const WhenAllGuard&) =
delete;
1793 WhenAllGuard& operator=(WhenAllGuard&&) =
delete;
1800 if (!completed_normally) {
1802 std::lock_guard lock(state->exc_mtx);
1804 if (!state->first_exc) {
1805 state->first_exc = std::make_exception_ptr(
1806 std::runtime_error(
"vlink::Coroutine::when_all: sub-task aborted before completion"));
1811 if (state->remaining.fetch_sub(1, std::memory_order_acq_rel) == 1) {
1812 if (state->first_exc) {
1813 state->promise.set_exception(state->first_exc);
1815 state->promise.set_value();
1821 template <
typename TypeT>
1822 inline Task<void> when_all_runner(Task<TypeT> task,
size_t i, WhenAllGuard<TypeT> guard) {
1824 auto value = co_await std::move(task);
1825 if constexpr (std::is_same_v<TypeT, bool>) {
1826 std::lock_guard lock(guard.state->exc_mtx);
1827 guard.state->results[i] = value;
1829 guard.state->results[i] = std::move(value);
1832 std::lock_guard lock(guard.state->exc_mtx);
1834 if (!guard.state->first_exc) {
1835 guard.state->first_exc = std::current_exception();
1839 guard.completed_normally =
true;
1842 template <
typename TypeT>
1843 struct WhenAnyState final {
1844 std::atomic_bool fired{
false};
1845 std::atomic<size_t> remaining{0};
1847 std::exception_ptr first_exc;
1848 std::optional<std::pair<size_t, TypeT>> winner;
1849 std::promise<std::pair<size_t, TypeT>> promise;
1852 template <
typename TypeT>
1853 struct WhenAnyGuard final {
1854 std::shared_ptr<WhenAnyState<TypeT>> state;
1855 bool completed_normally{
false};
1857 explicit WhenAnyGuard(std::shared_ptr<WhenAnyState<TypeT>> s) noexcept : state(std::move(s)) {}
1859 WhenAnyGuard(WhenAnyGuard&& other) noexcept
1860 : state(std::move(other.state)), completed_normally(other.completed_normally) {}
1862 WhenAnyGuard(
const WhenAnyGuard&) =
delete;
1864 WhenAnyGuard& operator=(
const WhenAnyGuard&) =
delete;
1866 WhenAnyGuard& operator=(WhenAnyGuard&&) =
delete;
1873 if (!completed_normally) {
1875 std::lock_guard lock(state->exc_mtx);
1877 if (!state->first_exc) {
1878 state->first_exc = std::make_exception_ptr(
1879 std::runtime_error(
"vlink::Coroutine::when_any: sub-task aborted before completion"));
1884 if (state->remaining.fetch_sub(1, std::memory_order_acq_rel) == 1) {
1885 if (state->winner) {
1886 state->promise.set_value(std::move(*state->winner));
1888 state->promise.set_exception(state->first_exc);
1894 template <
typename TypeT>
1895 inline Task<void> when_any_runner(Task<TypeT> task,
size_t i, WhenAnyGuard<TypeT> guard) {
1897 auto value = co_await std::move(task);
1898 bool expected =
false;
1900 if (guard.state->fired.compare_exchange_strong(expected,
true, std::memory_order_acq_rel,
1901 std::memory_order_relaxed)) {
1902 guard.state->winner.emplace(i, std::move(value));
1905 std::lock_guard lock(guard.state->exc_mtx);
1907 if (!guard.state->first_exc) {
1908 guard.state->first_exc = std::current_exception();
1912 guard.completed_normally =
true;
1917 template <
typename TypeT>
1918 inline Task<std::vector<TypeT>> when_all(MessageLoop& loop, std::vector<Task<TypeT>> tasks) {
1919 static_assert(std::is_default_constructible_v<TypeT>,
1920 "Co::when_all<T>: T must be default-constructible (results vector pre-sized).");
1923 co_return std::vector<TypeT>{};
1926 const size_t count = tasks.size();
1927 auto state = MemoryResource::make_shared<detail::WhenAllState<TypeT>>();
1928 state->results.resize(count);
1929 state->remaining.store(count, std::memory_order_relaxed);
1930 auto fut = state->promise.get_future();
1932 for (
size_t i = 0; i < count; ++i) {
1933 co_spawn(loop, detail::when_all_runner<TypeT>(std::move(tasks[i]), i, detail::WhenAllGuard<TypeT>{state}));
1936 co_await await_future(loop, std::move(fut));
1938 co_return std::move(state->results);
1941 template <
typename TypeT>
1942 inline Task<std::pair<size_t, TypeT>> when_any(MessageLoop& loop, std::vector<Task<TypeT>> tasks) {
1944 throw std::invalid_argument(
"vlink::Coroutine::when_any: tasks must not be empty");
1947 auto state = MemoryResource::make_shared<detail::WhenAnyState<TypeT>>();
1948 state->remaining.store(tasks.size(), std::memory_order_relaxed);
1949 auto fut = state->promise.get_future();
1951 for (
size_t i = 0; i < tasks.size(); ++i) {
1952 co_spawn(loop, detail::when_any_runner<TypeT>(std::move(tasks[i]), i, detail::WhenAnyGuard<TypeT>{state}));
1955 co_return co_await await_future(loop, std::move(fut));
1968 namespace Co = Coroutine;
@ kNoPriority
FIFO sentinel.
Definition: message_loop.h:167
Thin final wrappers around the standard exception hierarchy used by VLink.
Pool-backed type-erased callables: copyable vlink::Function and move-only vlink::MoveFunction.
Directed acyclic task graph with condition branching, cycle guard and DOT export.
Cross-platform macros for visibility, branch hints, copy prevention, singletons and string helpers.
#define VUNLIKELY(...)
Short alias for VLINK_UNLIKELY.
Definition: macros.h:292
#define VLINK_EXPORT
Definition: macros.h:81
#define VLIKELY(...)
Short alias for VLINK_LIKELY.
Definition: macros.h:284
#define VLINK_DISALLOW_COPY_AND_ASSIGN(classname)
Deletes the copy constructor and copy-assignment operator of classname.
Definition: macros.h:174
PMR adapter that lets standard pmr-aware containers allocate through vlink::MemoryPool.
Single-threaded task dispatcher with three queue backends, timers and scheduling envelopes.
std::shared_ptr< GraphTask > GraphTaskPtr
Convenience alias for the canonical shared_ptr<GraphTask> handle.
Definition: graph_task.h:534
Fluent task-scheduling wrapper used by MessageLoop::exec_task() and family.