{"id":105009,"date":"2021-03-26T07:00:00","date_gmt":"2021-03-26T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=105009"},"modified":"2021-03-26T08:03:08","modified_gmt":"2021-03-26T15:03:08","slug":"20210326-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20210326-00\/?p=105009","title":{"rendered":"Creating a task completion source for a C++ coroutine: Failing to produce a result"},"content":{"rendered":"

So far, we’ve been working on building a result_holder<\/code> that can hold any type of result. But what about errors? <\/a><\/p>\n

Because maybe you have code that’s waiting for a result, and the code that’s supposed to produce the result realizes that it messed up and wants to say, “Sorry, no result today.”<\/p>\n

We can do that by storing a std::exception_ptr<\/code> as a possible result. This means that our result is no longer merely an optional value, but rather it’s a variant, since it could be empty, or it could have a value, or it could have an exception. It also means that ready<\/code> needs to become a discriminant.<\/p>\n

template<typename T>\r\nstruct result_holder_state :\r\n    async_helpers::awaitable_state<result_holder_state<T>>\r\n{\r\n    enum class result_kind {\r\n        unset,\r\n        value,\r\n        exception,\r\n    };\r\n\r\n    std::atomic<result_kind> kind{ result_kind::unset };<\/span>\r\n\r\n    struct wrapper\r\n    {\r\n        T value;\r\n    };\r\n\r\n    union variant\r\n    {\r\n        variant() {}\r\n        ~variant() {}\r\n\r\n        wrapper wrap;\r\n        std::exception_ptr ex;\r\n    } result;<\/span>\r\n\r\n    result_holder_state() {}\r\n    result_holder_state(result_holder_state const&) = delete;\r\n    void operator=(result_holder_state const&) = delete;\r\n\r\n    ~result_holder_state()\r\n    {\r\n        switch (kind.load(std::memory_order_relaxed)) {\r\n        case result_kind::value:\r\n            result.wrap.~wrapper();\r\n            break;\r\n        case result_kind::exception:\r\n            result.ex.~exception_ptr();\r\n            break;\r\n        }<\/span>\r\n    }\r\n\r\n    using typename result_holder_state::extra_await_data;\r\n    using typename result_holder_state::node_list;\r\n\r\n    bool fast_claim(extra_await_data const&) noexcept\r\n    {\r\n        return kind.load(std::memory_order_acquire)\r\n            != result_kind::unset<\/span>;\r\n    }\r\n\r\n    bool claim(extra_await_data const&) noexcept\r\n    {\r\n        return kind.load(std::memory_order_relaxed)\r\n            != result_kind::unset<\/span>;\r\n    }\r\n\r\n    void set_result(node_list& list, T v)\r\n    {\r\n        if (kind.load(std::memory_order_relaxed)\r\n            == result_kind::unset<\/span>) {\r\n            new (std::addressof(result.wrap))\r\n                wrapper{ std::forward<T>(v) };\r\n            kind.store(result_kind::value<\/span>,\r\n                std::memory_order_release);\r\n            this->resume_all(list);\r\n        }\r\n    }\r\n\r\n    void set_exception(\r\n        node_list& list, std::exception_ptr ex)\r\n    {\r\n        if (kind.load(std::memory_order_relaxed)\r\n            == result_kind::unset) {\r\n            new (std::addressof(result.ex))\r\n                std::exception_ptr{ std::move(ex) };\r\n            kind.store(result_kind::exception,\r\n                std::memory_order_release);\r\n            this->resume_all(list);\r\n        }\r\n    }<\/span>\r\n\r\n    T get_result()\r\n    {\r\n        switch (kind.load(std::memory_order_relaxed)) {\r\n        case result_kind::value:\r\n            return result.wrap.value;\r\n        case result_kind::exception:\r\n            std::rethrow_exception(result.ex);\r\n        }\r\n        std::terminate(); \/\/ shouldn't get here<\/span>\r\n    }\r\n};\r\n<\/pre>\n
There isn’t much exciting going on here. It’s just changing the things that need to be changed: Instead of a simple bool<\/code> tracking what is in the result<\/code>, we use a discriminant which starts out unset<\/code>. Cleaning up our variant requires us to call the appropriate destructor for the contents of the result<\/code>, and setting the result requires us to update the discriminant.<\/p>\n
Setting an exception is the same as setting a value, except that we put the result in to the ex<\/code> member instead of the wrap<\/code> wrapper.<\/p>\n
When it comes time to fetch the result, we check what we have. If we have a value, we return it. If we have an exception, we rethrow it. (Otherwise, something went wrong and we terminate.)<\/p>\n
The result_holder<\/code> itself is basically the same, just with an extra method for storing the exception.<\/p>\n
template<typename T>\r\nstruct result_holder\r\n    : async_helpers::awaitable_sync_object<\r\n        result_holder_state<T>>\r\n{\r\n    using typename result_holder::state;\r\n\r\n    void set_result(T result) const noexcept\r\n    {\r\n        this->action_impl(&state::set_result,\r\n            std::move(result));\r\n    }\r\n\r\n    void set_exception(std::exception_ptr ex) const noexcept\r\n    {\r\n        this->action_impl(&state::set_exception,\r\n            std::move(ex));\r\n    }<\/span>\r\n};\r\n<\/pre>\n
The Windows Runtime IAsync\u00adOperation<\/code> can be awaited only once, but you can use this result_holder<\/code> to make it possible to await multiple times.<\/p>\n
template<typename T>\r\nresult_holder<T> MakeMultiAwaitable(IAsyncOperation<T> async)\r\n{\r\n    result_holder<T> holder;\r\n    async.Completed([holder, async](auto, auto status) {\r\n        try {\r\n            switch (status) {\r\n            case AsyncStatus::Completed:\r\n                holder.set_result(async.GetResults());\r\n                break;\r\n            case AsyncStatus::Canceled:\r\n                throw hresult_canceled();\r\n            case AsyncStatus::Error:\r\n                throw_hresult(async.ErrorCode());\r\n            }\r\n        } catch (...) {\r\n            holder.set_exception(std::current_exception());\r\n        }\r\n    });\r\n    return holder;\r\n}\r\n<\/pre>\n
You would use it something like this:<\/p>\n
class MyClass\r\n{\r\n    result_holder<Widget> widget_result;\r\n\r\n    MyClass()\r\n    {\r\n        \/\/ Kick off initialization but don't wait for it.\r\n        widget_result = MakeMultiAwaitable(InitializeAsync());\r\n    }\r\n\r\n    IAsyncOperation<Widget> InitializeAsync();\r\n\r\n    IAsyncAction DoSomethingAsync()\r\n    {\r\n        \/\/ Wait for the widget that InitializeAsync produced.\r\n        \/\/ rethrow any exception that occurred during initialization.\r\n        auto widget = co_await widget_result;\r\n        ... do something interesting ...\r\n    }\r\n};\r\n<\/pre>\n
More generally, you would do something like this:<\/p>\n
void CalculateResult(result_holder<Widget>& holder)\r\n{\r\n    try\r\n    {\r\n        \/* do a bunch of calculations *\/\r\n        widget = \/* the answer *\/;\r\n        holder.set_result(widget);\r\n    } catch (...) {\r\n        holder.set_exception(std::current_exception());\r\n    }\r\n}\r\n<\/pre>\n
You know what this looks like?<\/p>\n
A coroutine!<\/p>\n
result_holder<Widget> CalculateResult()\r\n{\r\n    \/* do a bunch of calculations *\/\r\n    widget = \/* the answer *\/;\r\n    co_return widget;\r\n\r\n    \/* exception is captured into the result_holder *\/\r\n}\r\n<\/pre>\n
So I guess it’s time to learn how to create our own coroutines. The dive into the deep end begins next time.<\/p>\n","protected":false},"excerpt":{"rendered":"
Stowing an exception.<\/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-105009","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Stowing an exception.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/105009","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=105009"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/105009\/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=105009"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=105009"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=105009"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}