![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/02\/TimelineCpp20Coroutines.png\")
<\/p>\nThis post concludes my posts about co_return in C++20. I started with an eager future, and continued with a lazy future. Today, I execute the future in a separate thread using coroutines as an implementation detail.<\/p>\n
<\/p>\n
<\/p>\n
Before I continue, I want to emphasize this. The reason for this mini-series about coroutines in C++20 is simple: I want to help you to build an intuition about the complicated workflow of coroutines. This is what has happened so far in this mini-series. Each post is based on the previous ones.<\/p>\n
Now,\u00a0 I want to execute the coroutine on a separate thread.<\/p>\n The coroutine in the previous example, “Lazy Futures with Coroutines in C++20<\/a>”\u00a0 was fully suspended before entering the coroutine body of <\/p>\n The reason was that the function <\/p>\n I added a few comments to the program that show the id of the running thread. The program You can try out the program on the\u00a0Wandbox<\/a> online compiler.<\/p>\n I want to add a few additional remarks about the member function <\/p>\n When I join the thread <\/p>\n In this case, the client likely gets its result before the promise prepares it using the member function <\/p>\n <\/p>\n In particular, I don’t like the last solution because it may take you a few seconds to recognize that I just called the constructor of Now, it is the right time to add more theories about coroutines.<\/p>\n You may wonder that the coroutine, such as Here is another trap I fall into on Windows.<\/p>\n The promise needs either the member function Falling off the end of a void-returning coroutine without a After I discussed the new keyword co_return<\/code>:<\/p>\n\n
Execution on Another Thread<\/h2>\n
createFuture<\/code>.<\/p>\n\nMyFuture<<\/span>int<\/span>><\/span> createFuture() {\n std::<\/span>cout <<<\/span> \"createFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n co_return 2021<\/span>;\n}\n<\/pre>\n<\/div>\n initial_suspend<\/code> of the promise returns std::suspend_always<\/code>. This means that the coroutine is at first suspended and can, hence,\u00a0 be executed on a separate thread<\/p>\n\n\/\/ lazyFutureOnOtherThread.cpp<\/span>\n\n#include <coroutine><\/span>\n#include <iostream><\/span>\n#include <memory><\/span>\n#include <thread><\/span>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\nstruct<\/span> MyFuture {\n struct<\/span> promise_type;\n using<\/span> handle_type =<\/span> std::<\/span>coroutine_handle<<\/span>promise_type><\/span>; \n handle_type coro;\n\n MyFuture(handle_type h):<\/span> coro(h) {}\n ~<\/span>MyFuture() {\n if<\/span> ( coro ) coro.destroy();\n }\n\n T get() { \/\/ (1)<\/span>\n std::<\/span>cout <<<\/span> \" MyFuture::get: \"<\/span> \n <<<\/span> \"std::this_thread::get_id(): \"<\/span> \n <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> '\\n'<\/span>;\n \n std::<\/span>thread<\/span> t([this<\/span>] { coro.resume(); }); \/\/ (2)<\/span>\n t.join();\n return<\/span> coro.promise().result;\n }\n\n struct<\/span> promise_type {\n promise_type(){ \n std::<\/span>cout <<<\/span> \" promise_type::promise_type: \"<\/span> \n <<<\/span> \"std::this_thread::get_id(): \"<\/span> \n <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> '\\n'<\/span>;\n }\n ~<\/span>promise_type(){ \n std::<\/span>cout <<<\/span> \" promise_type::~promise_type: \"<\/span> \n <<<\/span> \"std::this_thread::get_id(): \"<\/span> \n <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> '\\n'<\/span>;\n }\n\n T result;\n auto<\/span> get_return_object<\/span>() {\n return<\/span> MyFuture{handle_type::<\/span>from_promise(*<\/span>this<\/span>)};\n }\n void<\/span> return_value<\/span>(T v) {\n std::<\/span>cout <<<\/span> \" promise_type::return_value: \"<\/span> \n <<<\/span> \"std::this_thread::get_id(): \"<\/span> \n <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> '\\n'<\/span>;\n std::<\/span>cout <<<\/span> v <<<\/span> std::<\/span>endl;\n result =<\/span> v;\n }\n std::<\/span>suspend_always initial_suspend() {\n return<\/span> {};\n }\n std::<\/span>suspend_always final_suspend() noexcept {\n std::<\/span>cout <<<\/span> \" promise_type::final_suspend: \"<\/span> \n <<<\/span> \"std::this_thread::get_id(): \"<\/span> \n <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> '\\n'<\/span>;\n return<\/span> {};\n }\n void<\/span> unhandled_exception() {\n std::<\/span>exit(1<\/span>);\n }\n };\n};\n\nMyFuture<<\/span>int<\/span>><\/span> createFuture() {\n co_return 2021<\/span>;\n}\n\nint<\/span> main() {\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n std::<\/span>cout <<<\/span> \"main: \"<\/span> \n <<<\/span> \"std::this_thread::get_id(): \"<\/span> \n <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> '\\n'<\/span>;\n\n auto<\/span> fut =<\/span> createFuture();\n auto<\/span> res =<\/span> fut.get();\n std::<\/span>cout <<<\/span> \"res: \"<\/span> <<<\/span> res <<<\/span> '\\n'<\/span>;\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\n lazyFutureOnOtherThread.cpp<\/code> is quite similar to the previous program lazyFuture.cpp<\/code> in the post “Lazy Futures with Coroutines in C++20<\/a>“. The client calls get<\/code> (line 1) for the next value. The call std::thread t([this] { coro.resume(); });<\/code> (line 2) resumes the coroutine on another thread.<\/p>\n![\"lazyFutureOnOtherThread\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/03\/lazyFutureOnOtherThread.png\")
<\/p>\nget<\/code>. It is crucial that the promise is resumed in a separate thread, and finishes before it returns coro.promise().result;<\/code> .<\/p>\n\nT get<\/span>() {\n std::<\/span>thread<\/span> t([this<\/span>] { coro.resume(); });\n t.join();\n return<\/span> coro.promise().result;\n}\n<\/pre>\n<\/div>\n t<\/code> after the call return coro.promise().result<\/code>, the program would have undefined behavior. In the following implementation of the function get<\/code>I use a std::jthread<\/code>. Here is my post about std::jthread in C++20: “An Improved Thread with C++20<\/a>“. Since std::jthread<\/code> automatically joins when it goes out of scope. This is too late.<\/p>\n\nT get<\/span>() { \n std::<\/span>jthread t([this<\/span>] { coro.resume(); });\n return<\/span> coro.promise().result;\n}\n<\/pre>\n<\/div>\n return_value<\/code>. Now, result<\/code> has an arbitrary value, and therefore so does res<\/code>.<\/p>\n![\"lazyFutureOnOtherThreadLateJoin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/03\/lazyFutureOnOtherThreadLateJoin.png\")
<\/p>\n<\/div>\nOther possibilities exist to ensure the thread is done before the return call.<\/div>\n<\/div>\n\n
std::jthread<\/code> has its scope<\/li>\n<\/ul>\n<\/div>\n\nT get<\/span>() {\n {\n std::<\/span>jthread t([this<\/span>] { coro.resume(); });\n }\n return<\/span> coro.promise().result;\n}\n<\/pre>\n<\/div>\n\n
std::jthread<\/code> a temporary object<\/li>\n<\/ul>\n\nT get<\/span>() {\n std::<\/span>jthread([this<\/span>] { coro.resume(); });\n return<\/span> coro.promise().result;\n}<\/pre>\n<\/div>\nstd::jthread<\/code>.<\/p>\npromise_type<\/code><\/h2>\nMyFuture<\/code> always has inner type promise_type<\/code>. This name is required. Alternatively, you can specialize std::coroutines_traits<\/a>\u00a0<\/code>on MyFuture <\/code>and define a public promise_type<\/code> in it. I mentioned this point explicitly because I know a few people, including me who already fall into this trap.<\/p>\nreturn_void<\/code> and return_value<\/code><\/h2>\n return_void<\/code> or return_value.<\/code><\/p>\n\n
return_void<\/code> member function if\n\n
co_return<\/code> statement.<\/li>\nco_return<\/code> statement without argument.<\/li>\nco_return expression<\/code>\u00a0a statement where the expression has type void.<\/code><\/li>\n<\/ul>\n<\/li>\nreturn_value<\/code> member function if it returns co_return<\/code> expression statement where expression must not have the type void<\/code><\/li>\n<\/ul>\nreturn_void<\/code>\u00a0a member function is an undefined behavior. Interestingly, Microsoft, but not the GCC compiler, requires a member function return_void<\/code> if the coroutine is always suspended at its final suspension point and, therefore, does not fail at the end: std::<\/span>suspend_always final_suspend() noexcept; <\/code>From my perspective, the C++20 standard is not clear, and I always add a member function void return_void() {}<\/code> to my promise type.<\/p>\nWhat’s next?<\/h2>\n
co_return<\/code>, I want to continue with co_yield<\/code>. co_yield<\/code> enables you to create infinite data streams. I will show in my next post<\/a>, how.<\/p>\n","protected":false},"excerpt":{"rendered":"