We created two very similiar promises for hot-start and cold-start coroutines. It turns out that we can unify them.<\/p>\n
The association between a promise and a task is not one-to-one, but rather one-to-many: A single promise can back multiple tasks. But how can you do that? After all, the task associated with a promise is the thing returned by the Well, not exactly.<\/p>\n The rule is that the thing returned by Therefore, you can associate multiple tasks with the promise if you arrange for The coroutine code generation goes like this:<\/p>\n In our case, we have two flavors of awaiters, one of which leaves the coroutine cold, and the other of which hot-starts the coroutine. The coroutine machinery itself can be left unaware of this detail and leave the mechanics to the task.<\/p>\n For Windows developers, two kinds of tasks that would be useful are one that awaits in a thread-unaware way (the version we have been writing so far), and another that awaits in a way that preserves the COM context.<\/p>\n But for today, I’ll show how a single promise can be used for both cold-start and hot-start tasks. Go back to our hot-start coroutine promise and make these changes:<\/p>\n The coroutine now starts out cold. The warm-start task will auto-start it, whereas the cold-start task will leave it cold until it is awaited.<\/p>\n We alter the A new explicit The coroutine now suspends at its initial suspend point instead of continuing to run. This makes the coroutine a cold-start coroutine by default.<\/p>\n These new functions are carried over from our previous conversion from hot-start to cold-start, but with different names so we can keep both versions.<\/p>\n Of course, we need to create an awaiter that uses these cold versions.<\/p>\n This is analogous to our We factor out the promise-management code and the “you’re holding it wrong” class into a common base class The We can also create a This is the same as our Finally, we teach the compiler how to create a coroutine that returns a There we have it, a single promise that supports multiple kinds of tasks. This is particularly handy when you have different kinds of tasks that differ only in how they await, since the awaiter isn’t even part of the promise at all.<\/p>\n Next time, we’ll look at how coroutines interact with the \u00b9 The language specification says merely that Using the special initialization rule for Using the special initialization rule for get_get_get_\n
get_\n
initial_get_ template<typename T>\r\n struct simple_promise_base\r\n {\r\n ...\r\n\r\n std::atomic<void*> m_waiting{ cold_ptr<\/span> };\r\n\r\n static constexpr void* cold_ptr = reinterpret_cast<void*>(3);\r\n<\/pre>\n auto get_return_object() noexcept\r\n {\r\n return as_promise();<\/span>\r\n }\r\n<\/pre>\nget_ void start()\r\n {\r\n m_waiting.store(running_ptr, std::memory_order_relaxed);\r\n as_handle().resume();\r\n }\r\n<\/pre>\nstart()<\/code> method kicks off the coroutine. The hot-start task will call this immediately, whereas the cold-start task will wait until the task is co_await<\/code>ed.<\/p>\n std::experimental::suspend_always<\/span> initial_suspend() noexcept\r\n {\r\n return {};\r\n }\r\n<\/pre>\n bool cold_client_await_ready()\r\n {\r\n return false;\r\n }\r\n\r\n auto cold_client_await_suspend(\r\n std::experimental::coroutine_handle<> handle)\r\n {\r\n start();\r\n return m_waiting.exchange(handle.address(),\r\n std::memory_order_acq_rel) == running_ptr;\r\n }\r\n<\/pre>\n template<typename T>\r\n struct cold_promise_awaiter\r\n {\r\n promise_ptr<T> self;\r\n\r\n bool await_ready()\r\n {\r\n return self->cold_client_await_ready();\r\n }\r\n\r\n auto await_suspend(std::experimental::coroutine_handle<> handle)\r\n {\r\n return self->cold_client_await_suspend(handle);\r\n }\r\n\r\n T await_resume()\r\n {\r\n return self->client_await_resume();\r\n }\r\n };\r\n<\/pre>\npromise_await_await_namespace async_helpers::details\r\n{\r\n template<typename T>\r\n struct simple_task_base\r\n {\r\n simple_task_base(simple_promise<T>*\r\n initial = nullptr) noexcept : promise(initial) { }\r\n\r\n struct cannot_await_lvalue_use_std_move {};\r\n cannot_await_lvalue_use_std_move operator co_await() & = delete;\r\n\r\n protected:\r\n promise_ptr<T> promise;\r\n };\r\n}\r\n\r\nnamespace async_helpers\r\n{\r\n template<typename T>\r\n struct simple_task : details::simple_task_base<T>\r\n {\r\n using base = details::simple_task_base<T>;\r\n simple_task() = default;\r\n simple_task(details::simple_promise<T>*\r\n initial) : base(initial)\r\n { this->promise->start(); }\r\n\r\n void swap(simple_task& other)\r\n {\r\n std::swap(this->promise, other.promise);\r\n }\r\n\r\n using base::operator co_await;\r\n\r\n auto operator co_await() &&\r\n {\r\n return details::promise_awaiter<T>\r\n { std::move(this->promise) };\r\n }\r\n };\r\n\r\n template<typename T>\r\n void swap(simple_task<T>& left, simple_task<T>& right)\r\n {\r\n left.swap(right);\r\n }\r\n}\r\n<\/pre>\nsimple_simple_start()<\/code> the promise in the case where we are being constructed as a result of a call to get_cold_namespace async_helpers\r\n{\r\n template<typename T>\r\n struct cold_simple_task : details::simple_task_base<T>\r\n {\r\n using base = details::simple_task_base<T>;\r\n cold_simple_task(details::simple_promise<T>*\r\n initial = nullptr) : base(initial) { }\r\n\r\n void swap(cold_simple_task& other)\r\n {\r\n std::swap(this->promise, other.promise);\r\n }\r\n\r\n using base::operator co_await;\r\n\r\n auto operator co_await() &&\r\n {\r\n return details::cold_promise_awaiter<T>\r\n { std::move(this->promise) };\r\n }\r\n };\r\n\r\n template<typename T>\r\n void swap(cold_simple_task<T>& left, cold_simple_task<T>& right)\r\n {\r\n left.swap(right);\r\n }\r\n}\r\n<\/pre>\nsimple_task<\/code> except that<\/p>\n\n
start()<\/code> the coroutine, leaving it cold.<\/li>\ncold_promise_cold_template <typename T, typename... Args>\r\nstruct std::experimental::coroutine_traits<\r\n async_helpers::cold_simple_task<T>, Args...>\r\n{\r\n using promise_type =\r\n async_helpers::details::simple_promise<T>;\r\n};\r\n<\/pre>\nnoexcept<\/code> keyword.<\/p>\nget_get_get_