{"id":108398,"date":"2023-07-06T07:00:00","date_gmt":"2023-07-06T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108398"},"modified":"2023-06-19T07:31:08","modified_gmt":"2023-06-19T14:31:08","slug":"20230706-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230706-00\/?p=108398\/","title":{"rendered":"How to wait for multiple C++ coroutines to complete before propagating failure, wrapping the awaitable"},"content":{"rendered":"

So far, we’ve been trying to intercept exceptions that propagate from the awaitable by wrapping it in a coroutine that catches exceptions. This seems like a reasonable approach, but we got bogged down dealing with the edge case where the wrapper coroutine itself throws a memory allocation exception<\/a> while creating the coroutine frame.<\/p>\n

But there’s another way to intercept the exception that doesn’t involve creating a new coroutine at all. Instead of wrapping the awaitable in a coroutine, we can wrap the awaitable inside another awaitable.<\/p>\n

Consider the simple case of an awaitable that is its own awaiter. (No operator co_await<\/code>.) You can wrap the awaitable inside another awaitable that catches the exception. We’ll start with a wrapper that does nothing.<\/p>\n

template<typename Inner>\r\nstruct wrapped_awaitable\r\n{\r\n    wrapped_awaitable(Inner& inner) : m_inner(inner) {}\r\n\r\n    Inner& m_inner;\r\n\r\n    bool await_ready()\r\n    { return m_inner.await_ready(); }\r\n\r\n    template<typename Handle>\r\n    auto await_suspend(Handle handle) {\r\n        return m_inner.await_suspend(handle);\r\n    }\r\n\r\n    auto await_resume()\r\n    { return m_inner.await_resume(); }\r\n};\r\n<\/pre>\n
This wrapper doesn’t do anything. It just forwards all of the awaiter methods to the wrapped object.<\/p>\n
But now that we have a framework, we can start adding features to it.<\/p>\n
template<typename Inner>\r\nstruct wrapped_awaitable\r\n{\r\n    wrapped_awaitable(Inner& inner) : m_inner(inner) {}\r\n\r\n    Inner& m_inner;\r\n\r\n    bool await_ready()\r\n    { return m_inner.await_ready(); }\r\n\r\n    template<typename Handle>\r\n    auto await_suspend(Handle handle) {\r\n        return m_inner.await_suspend(handle);\r\n    }\r\n\r\n    std::exception_ptr<\/span> await_resume() try<\/span> {\r\n        m_inner.await_resume();\r\n        return nullptr;\r\n    } catch (...) {                     <\/span>\r\n        return std::current_exception();<\/span>\r\n    }\r\n};\r\n<\/pre>\n
We change await_resume()<\/code> to return any exception that is thrown when inspecting the result of the co_await<\/code>. If no exception occurs, then we return nullptr<\/code>, indicating that no exception occurred.<\/p>\n
That’s the basic idea. The rest is filling in the gaps.<\/p>\n
For example, what happens if the awaiter throws an exception from one of the other two awaiter methods?<\/p>\n
Well, the await_ready<\/code> happens before the coroutine suspends, so any exception that is thrown from there just goes straight to the containing coroutine’s unhandled_exception<\/code>. Since our goal is to capture and return the exception rather than allowing it to be thrown, we have to include a try<\/code>\/catch<\/code> in our await_ready<\/code> wrapper, and if an exception occurs, we need to bypass the await_suspend<\/code> and go directly to await_resume<\/code>. Furthermore, the await_resume<\/code> should not call the wrapped awaiter; it should just produce the caught exception immediately.<\/p>\n
template<typename Inner>\r\nstruct wrapped_awaitable\r\n{\r\n    wrapped_awaitable(Inner& inner) : m_inner(inner) {}\r\n\r\n    Inner& m_inner;\r\n    std::exception_ptr m_eptr;<\/span>\r\n\r\n    bool await_ready() try<\/span>\r\n    { return m_inner.await_ready(); }\r\n    catch (...) {                         <\/span>\r\n        m_eptr = std::current_exception();<\/span>\r\n        return true;                      <\/span>\r\n    }                                     <\/span>\r\n\r\n    template<typename Handle>\r\n    auto await_suspend(Handle handle) {\r\n        return m_inner.await_suspend(handle);\r\n    }\r\n\r\n    std::exception_ptr await_resume() try {\r\n        if (m_eptr) return m_eptr;<\/span>\r\n        m_inner.await_resume();\r\n        return nullptr;\r\n    } catch (...) {\r\n        return std::current_exception();\r\n    }\r\n};\r\n<\/pre>\n
An exception in await_suspend<\/code> is the trickiest one. According to the language specification, if an exception is thrown by await_suspend<\/code>, the coroutine resumes but does not<\/i> call await_resume<\/code>. Instead, the exception thrown by await_suspend<\/code> is immediately rethrown.<\/p>\n
This means that if we catch an exception from await_suspend<\/code>, we should return it immediately from await_resume<\/code> without calling m_inner.await_resume()<\/code>.<\/p>\n
template<typename Inner>\r\nstruct wrapped_awaitable\r\n{\r\n    wrapped_awaitable(Inner& inner) : m_inner(inner) {}\r\n\r\n    Inner& m_inner;\r\n    std::exception_ptr m_eptr;\r\n\r\n    bool await_ready() try\r\n    { return m_inner.await_ready(); }\r\n    catch (...) {\r\n        m_eptr = std::current_exception();\r\n        return true;\r\n    }\r\n\r\n    template<typename Handle>\r\n    auto await_suspend(Handle handle) try<\/span> {\r\n        return m_inner.await_suspend(handle);\r\n    } catch (...) {                       <\/span>\r\n        m_eptr = std::current_exception();<\/span>\r\n        return \/* something *\/;           <\/span>\r\n    }                                     <\/span>\r\n\r\n    std::exception_ptr await_resume() try {\r\n        if (m_eptr) return m_eptr;\r\n        m_inner.await_resume();\r\n        return nullptr;\r\n    } catch (...) {\r\n        return std::current_exception();\r\n    }\r\n};\r\n<\/pre>\n
The next tricky part is the return \/* something *\/<\/code>. We want to return something that means “Don’t suspend this coroutine after all.” But it also has to be compatible with the return<\/code> statement inside the try<\/code> block.<\/p>\n
Fortunately, symmetric transfer is a superset of the other types of return values from await_suspend()<\/code>, so we can always return a coroutine handle and adapt the other return values accordingly.<\/p>\n
template<typename Inner>\r\nstruct wrapped_awaitable\r\n{\r\n    wrapped_awaitable(Inner& inner) : m_inner(inner) {}\r\n\r\n    Inner& m_inner;\r\n    std::exception_ptr m_eptr;\r\n\r\n    bool await_ready() try\r\n    { return m_inner.await_ready(); }\r\n    catch (...) {\r\n        m_eptr = std::current_exception();\r\n        return true;\r\n    }\r\n\r\n    template<typename Handle>\r\n    std::coroutine_handle<><\/span>\r\n    await_suspend(Handle handle) try {\r\n        using Ret = decltype(m_inner.await_suspend(handle));<\/span>\r\n        if constexpr (std::is_same_v<void, Ret>) {          <\/span>\r\n            m_inner.await_suspend(handle);                  <\/span>\r\n            return std::noop_coroutine();                   <\/span>\r\n        } else if constexpr (std::is_same_v<bool, Ret>) {   <\/span>\r\n            return m_inner.await_suspend(handle) ?          <\/span>\r\n                static_cast<std::coroutine_handle<>>(       <\/span>\r\n                    std::noop_coroutine()) :                <\/span>\r\n                handle;                                     <\/span>\r\n        } else {                                            <\/span>\r\n            return m_inner.await_suspend(handle);           <\/span>\r\n        }                                                   <\/span>\r\n    } catch (...) {\r\n        m_eptr = std::current_exception();\r\n        return handle;<\/span>\r\n    }\r\n\r\n    std::exception_ptr await_resume() try {\r\n        if (m_eptr) return m_eptr;\r\n        m_inner.await_resume();\r\n        return nullptr;\r\n    } catch (...) {\r\n        return std::current_exception();\r\n    }\r\n};\r\n<\/pre>\n
All right, we’ve wrapped an awaiter so that awaiting the wrapper reports any exception that may have resulted from awaiting the original awaiter.<\/p>\n
template<typename... T>\r\nIAsyncAction when_all_complete(T... asyncs)\r\n{\r\n    std::exception_ptr eptr;\r\n\r\n    auto accumulate = [&](std::exception_ptr e) {\r\n        if (eptr == nullptr) eptr = e;\r\n    };\r\n\r\n    (accumulate(co_await wrapped_awaitable(asyncs))<\/span>, ...);\r\n\r\n    if (eptr) std::rethrow_exception(eptr);\r\n}\r\n<\/pre>\n
Next time, we’ll deal with operator co_await<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"
Intercepting the exception on the front side.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-108398","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Intercepting the exception on the front side.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108398","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=108398"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108398\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=108398"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108398"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108398"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}