{"id":6099,"date":"2021-03-04T11:54:31","date_gmt":"2021-03-04T11:54:31","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/lazy-futures-with-coroutines-in-c-20\/"},"modified":"2023-09-28T06:56:42","modified_gmt":"2023-09-28T06:56:42","slug":"lazy-futures-with-coroutines-in-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/lazy-futures-with-coroutines-in-c-20\/","title":{"rendered":"Lazy Futures with Coroutines"},"content":{"rendered":"

Based on the coroutines-based implementation of a simple future in my last post “Implementing Simple Futures with Coroutines<\/a>“, I want to go today one giant step further. I analyze the workflow of the simple future and make it lazy.<\/p>\n

<\/p>\n

\"\"<\/p>\n

Before I create future variations, you should understand its control flow. I assume you know my previous post: “Implementing Simple Futures with Coroutines<\/a>. In this post, comments help me make the coroutine’s control flow transparent. Additionally, I added a link to an online compiler to each presented program so that you directly use and experiment with the programs.<\/p>\n

The Transparent Control Flow<\/h2>\n

<\/p>\n

\n
\/\/ eagerFutureWithComments.cpp<\/span>\n\n#include <coroutine><\/span>\n#include <iostream><\/span>\n#include <memory><\/span>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\nstruct<\/span> MyFuture {\n    std::<\/span>shared_ptr<<\/span>T><\/span> value\n    MyFuture(std::<\/span>shared_ptr<<\/span>T><\/span> p):<\/span> value(p) {                         \/\/ (3)<\/span>\n        std::<\/span>cout <<<\/span> \"    MyFuture::MyFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n    ~<\/span>MyFuture() { \n        std::<\/span>cout <<<\/span> \"    MyFuture::~MyFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n    T get() {\n        std::<\/span>cout <<<\/span> \"    MyFuture::get\"<\/span> <<<\/span> '\\n'<\/span>;\n        return<\/span> *<\/span>value;\n    }\n\n    struct<\/span> promise_type {                                              \/\/ (4)<\/span>\n        std::<\/span>shared_ptr<<\/span>T><\/span> ptr =<\/span> std::<\/span>make_shared<<\/span>T><\/span>();                \/\/ (11)<\/span>\n        promise_type() {\n            std::<\/span>cout <<<\/span> \"        promise_type::promise_type\"<\/span> <<<\/span> '\\n'<\/span>;\n        }\n        ~<\/span>promise_type() { \n            std::<\/span>cout <<<\/span> \"        promise_type::~promise_type\"<\/span> <<<\/span> '\\n'<\/span>;\n        }\n        MyFuture<<\/span>T><\/span> get_return_object() {\n            std::<\/span>cout <<<\/span> \"        promise_type::get_return_object\"<\/span> <<<\/span> '\\n'<\/span>;\n            return<\/span> ptr;\n        }\n        void<\/span> return_value(T v) {\n            std::<\/span>cout <<<\/span> \"        promise_type::return_value\"<\/span> <<<\/span> '\\n'<\/span>;\n            *<\/span>ptr =<\/span> v;\n        }\n        std::<\/span>suspend_never initial_suspend() {                         \/\/ (6)<\/span>\n            std::<\/span>cout <<<\/span> \"        promise_type::initial_suspend\"<\/span> <<<\/span> '\\n'<\/span>;\n            return<\/span> {};\n        }\n        std::<\/span>suspend_never final_suspend() noexcept {                 \/\/ (7)<\/span>\n            std::<\/span>cout <<<\/span> \"        promise_type::final_suspend\"<\/span> <<<\/span> '\\n'<\/span>;\n            return<\/span> {};\n        }\n        void<\/span> return_void() {}\n        void<\/span> unhandled_exception() {\n            std::<\/span>exit(1<\/span>);\n        }\n    };                                                                 \/\/ (5)<\/span>\n};\n\nMyFuture<<\/span>int<\/span>><\/span> createFuture() {                                         \/\/ (2)<\/span>\n    std::<\/span>cout <<<\/span> \"createFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n    co_return 2021<\/span>;\n}\n\nint<\/span> main() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    auto<\/span> fut =<\/span> createFuture();                                         \/\/ (1)<\/span>\n    auto<\/span> res =<\/span> fut.get();                                              \/\/ (8)<\/span>\n    std::<\/span>cout <<<\/span> \"res: \"<\/span> <<<\/span> res <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}                                                                     \/\/ (12)<\/span>\n<\/pre>\n<\/div>\n
The call createFuture<\/code> (line 1) causes the creation of the instance of MyFuture<\/code> (line 2). Before MyFuture<\/code> ‘s constructor call (line 3) is completed, the promise promise_type<\/code> is created, executed, and destroyed (lines 4 – 5). The promise uses the awaitable (lines 6 and 7) in each step of its control flow and, hence, never suspends. It has to be allocated to save the result of the promise for the later call (line 8). Furthermore, the used std::shared_ptr'<\/code>s ensure (lines 3 and 10) that the program does not cause a memory leak. As a local, fut <\/code>goes out of scope in line 12, and the C++ run time calls its destructor.<\/p>\n
You can try out the program on Compiler Explorer<\/a>.<\/p>\n
\"eagerFutureWithComments\"<\/p>\n
The presented coroutine runs immediately and is, therefore, eager. Furthermore, the coroutine runs in the thread of the caller.<\/p>\n
Let’s make the future lazy.<\/p>\n
A Lazy Future<\/h2>\n
A lazy future is a future that runs only if asked for the value. Let’s see what I must change in the previous coroutine to make the future lazy.<\/p>\n
<\/p>\n
\n
\/\/ lazyFuture.cpp<\/span>\n\n#include <coroutine><\/span>\n#include <iostream><\/span>\n#include <memory><\/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 \n    handle_type coro;                                               \/\/ (5)<\/span>\n\n    MyFuture(handle_type h):<\/span> coro(h) {\n        std::<\/span>cout <<<\/span> \"    MyFuture::MyFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n    ~<\/span>MyFuture() { \n        std::<\/span>cout <<<\/span> \"    MyFuture::~MyFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n        if<\/span> ( coro ) coro.destroy();                                 \/\/ (8)<\/span>\n    }\n\n    T get() {\n        std::<\/span>cout <<<\/span> \"    MyFuture::get\"<\/span> <<<\/span> '\\n'<\/span>;\n        coro.resume();                                              \/\/ (6)<\/span>\n        return<\/span> coro.promise().result;\n    }\n\n    struct<\/span> promise_type {\n\t\tT result;\n        promise_type() {\n           std::<\/span>cout <<<\/span> \"        promise_type::promise_type\"<\/span> <<<\/span> '\\n'<\/span>;\n        }\n        ~<\/span>promise_type() { \n            std::<\/span>cout <<<\/span> \"        promise_type::~promise_type\"<\/span> <<<\/span> '\\n'<\/span>;\n        }\n        auto<\/span> get_return_object() {                                  \/\/ (3)<\/span>\n            std::<\/span>cout <<<\/span> \"        promise_type::get_return_object\"<\/span> <<<\/span> '\\n'<\/span>;\n            return<\/span> MyFuture{handle_type::<\/span>from_promise(*<\/span>this<\/span>)};\n        }\n        void<\/span> return_value(T v) {\n            std::<\/span>cout <<<\/span> \"        promise_type::return_value\"<\/span> <<<\/span> '\\n'<\/span>;\n            result =<\/span> v;\n        }\n        std::<\/span>suspend_always initial_suspend() {                    \/\/ (1)<\/span>\n            std::<\/span>cout <<<\/span> \"        promise_type::initial_suspend\"<\/span> <<<\/span> '\\n'<\/span>;\n            return<\/span> {};\n        }\n        std::<\/span>suspend_always final_suspend() noexcept {            \/\/ (2)<\/span>\n            std::<\/span>cout <<<\/span> \"        promise_type::final_suspend\"<\/span> <<<\/span> '\\n'<\/span>;\n            return<\/span> {};\n        }\n        void<\/span> return_void() {}\n        void<\/span> unhandled_exception() {\n            std::<\/span>exit(1<\/span>);\n        }\n    };\n};\n\nMyFuture<<\/span>int<\/span>><\/span> createFuture() {\n    std::<\/span>cout <<<\/span> \"createFuture\"<\/span> <<<\/span> '\\n'<\/span>;\n    co_return 2021<\/span>;\n}\n\nint<\/span> main() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    auto<\/span> fut =<\/span> createFuture();                                        \/\/ (4)<\/span>\n    auto<\/span> res =<\/span> fut.get();                                             \/\/ (7)<\/span>\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
Let’s first study the promise. The promise always suspends at the beginning (line 1) and the end (line 2). Furthermore, the member function get_return_object<\/code> (line 3) creates the return object that is returned to the caller of the coroutine createFuture<\/code> (line 4). The future MyFuture<\/code> is more interesting. It has a handle coro<\/code> (line 5) to the promise. MyFuture<\/code> uses the handle to manage its promise. It resumes the promise (line 6), asks for the promise for the result (line 7), and finally destroys it (line 8). The resumption of the coroutine is necessary because it never runs automatically (line 1). When the client invokes fut.get()<\/code> (line 7) to ask for the result of the future, it implicitly resumes the promise (line 6).<\/p>\n
You can try out the program on Compiler Explorer<\/a>.<\/p>\n
\"lazyFuture\"<\/p>\n
What happens if the client is not interested in the result of the future and, hence, does not resume the coroutine? Let’s try it out.<\/p>\n
<\/p>\n
\n
int<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    auto<\/span> fut =<\/span> createFuture();\n    \/\/ auto res = fut.get();<\/span>\n    \/\/ std::cout << \"res: \" << res << '\\n';<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\n
As you may guess, the promise never runs, and the member functions return_value<\/code> and final_suspend<\/code> are not executed.<\/p>\n
\"lazyFutureWithoutGet\"<\/p>\n
Before I end this post, I want to write about the lifetime challenges of coroutines.<\/p>\n
Lifetime Challenges of Coroutines<\/h2>\n
One of the challenges of dealing with coroutines is handling the lifetime of the coroutine.<\/p>\n
In the first program eagerFutureWithComments.cpp<\/code>, I stored the coroutine result in a std::shared_ptr<\/code>. This is critical because the coroutine is eagerly executed.<\/p>\n
In the program lazyFuture.cpp<\/code>, the call final_suspend<\/code> always suspends (line 2): std::suspend_always final_suspend()<\/code>. Consequently, the promise outlives the client, and a std::shared_ptr<\/code> is not necessary anymore. Returning std::suspend_never<\/code> from the function final_suspend<\/code> would cause, in this case, undefined behavior because the client would outlive the promise. Hence, the lifetime of the result<\/code> ends before the client asks for it.<\/p>\n
What’s next?<\/h2>\n
My final step in the variation of the future is still missing. In the next post, <\/a>I will resume the coroutine on a separate thread.<\/p>\n","protected":false},"excerpt":{"rendered":"
Based on the coroutines-based implementation of a simple future in my last post “Implementing Simple Futures with Coroutines“, I want to go today one giant step further. I analyze the workflow of the simple future and make it lazy.<\/p>\n","protected":false},"author":21,"featured_media":8406,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[445,446],"class_list":["post-6099","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-coroutines","tag-tasks"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6099","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=6099"}],"version-history":[{"count":2,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6099\/revisions"}],"predecessor-version":[{"id":8409,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6099\/revisions\/8409"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8406"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6099"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6099"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6099"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}