{"id":106602,"date":"2022-05-06T07:00:00","date_gmt":"2022-05-06T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=106602"},"modified":"2022-05-06T10:53:38","modified_gmt":"2022-05-06T17:53:38","slug":"20220506-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20220506-00\/?p=106602","title":{"rendered":"On awaiting a task with a timeout in C++\/WinRT"},"content":{"rendered":"

Last time, we studied ways of awaiting a task with a timeout in C#<\/a>. Now we’ll apply what we learned to C++\/WinRT.<\/p>\n

C++\/WinRT already has a when_any<\/code> function which completes as soon as any of the provided coroutines completes, so we can follow a similar pattern. An added wrinkle is that winrt::resume_after<\/code> does not return an IAsyncAction<\/code> so we’ll have to adapt it. This isn’t too much an extra wrinkle, since we ended up having to adapt Task.Delay<\/code> in C# anyway, so it’s work that gets done sooner or later. It’s just that in C++\/WinRT, it’s done sooner.<\/p>\n

co_await winrt::when_any(\r\n    DoSomethingAsync(),\r\n    [] -> IAsyncAction { co_await winrt::resume_after(1s); });\r\n<\/pre>\n
The C++\/WinRT when_any<\/code> doesn’t tell you who the winner was. It just completes with the result of the task that completed first. This means that we don’t know whether the when_any<\/code> finished due to normal completion or timeout.<\/p>\n
We could infer which one completed first by having the timeout set a flag.<\/p>\n
auto timed_out = make_shared(false);\r\n\r\nco_await winrt::when_any(\r\n    DoSomethingAsync(),\r\n    [](auto flag) -> IAsyncAction\r\n        { co_await winrt::resume_after(1s); *flag = true; }(timed_out));\r\nif (timed_out) { ... }\r\n<\/pre>\n
For IAsync\u00adOperation<\/code>, we need our timer to return some fallback value:<\/p>\n
template<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<std::is_same_v<Result, void>, int> = 0>\r\nAsync delayed_async_result(\r\n    TimeSpan delay)\r\n{\r\n    co_await winrt::resume_after(delay);\r\n}\r\n\r\ntemplate<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<!std::is_same_v<Result, void>, int> = 0>\r\nAsync delayed_async_result(\r\n    TimeSpan delay,\r\n    Result fallback = winrt_empty_value<Result>())\r\n{\r\n    co_await winrt::resume_after(delay);\r\n    co_return fallback;\r\n}\r\n<\/pre>\n
The delayed_async_result<\/code> is cumbersome for multiple reasons.<\/p>\n
First, there’s the need to identify the result of the Async<\/code> so we can generate a default fallback value if necessary. To do that, we infer it from the value returned by GetResults()<\/code>. This covers IAsync\u00adAction<\/code>, IAsync\u00adAction\u00adWith\u00adProgress<\/code>, IAsync\u00adOperation<\/code>, and IAsync\u00adOperation\u00adWith\u00adProgress<\/code>.<\/p>\n
If that result is void<\/code>, then we need to remove the extra Result<\/code> parameter.<\/p>\n
If that result is not void<\/code>, we need to come up with the default fallback value. This is tricky for the case of Windows Runtime classes, but we dealt with that a little while ago when we wrote the winrt_empty_value<\/code> function.<\/p>\n
Or maybe we want to raise a timeout exception if the operation times out:<\/p>\n
template<typename Async>\r\nAsync delayed_timeout_exception(TimeSpan delay)\r\n{\r\n    co_await winrt::resume_after(delay);\r\n    throw winrt::hresult_error(HRESULT_FROM_WIN32(ERROR_TIMEOUT));\r\n}\r\n<\/pre>\n
We can use these in conjunction with when_any<\/code> to await a Windows Runtime asynchronous activity with a timeout.<\/p>\n
It could be an IAsync\u00adAction<\/code> or IAsync\u00adAction\u00adWith\u00adProgress<\/code>, in which case the co_await<\/code> simple returns early.<\/p>\n
auto somethingTask = DoSomethingAsync();\r\nco_await winrt::when_any(\r\n    somethingTask,\r\n    delayed_async_result<decltype(somethingTask)>(1s));\r\n<\/pre>\n
Or it could be an IAsync\u00adOperation<\/code> or IAsync\u00adOperation\u00adWith\u00adProgress<\/code>, in which case the co_await<\/code> produces the result or the fallback value:<\/p>\n
auto somethingTask = GetSomethingAsync();\r\nauto result = co_await winrt::when_any(\r\n    somethingTask,\r\n    delayed_async_result<decltype(somethingTask)>(1s));\r\n<\/pre>\n
Or you can ask for an exception to be raised if the operation takes too long:<\/p>\n
auto somethingTask = GetSomethingAsync();\r\nauto result = co_await winrt::when_any(\r\n    somethingTask,\r\n    delayed_timeout_exception<decltype(somethingTask)>(1s));\r\n<\/pre>\n
Having to pass a delayed result or delayed exception with a matching type as the thing you’re waiting for calls for a helper function to save you the typing:<\/p>\n
template<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<std::is_same_v<Result, void>, int> = 0>\r\nAsync when_complete_or_timeout(Async async, TimeSpan delay)\r\n{\r\n    return co_await winrt::when_any(async,\r\n        delayed_async_result<Async>(delay));\r\n}\r\n\r\ntemplate<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<!std::is_same_v<Result, void>, int> = 0>\r\nAsync when_complete_or_timeout(\r\n    Async async,\r\n    TimeSpan delay,\r\n    Result fallback = winrt_empty_value<Result>())\r\n{\r\n    return co_await winrt::when_any(async,\r\n        delayed_async_result<Async>(delay, fallback));\r\n}\r\n\r\ntemplate<typename Async>\r\nAsync when_complete_or_timeout_exception(\r\n    Async async,\r\n    TimeSpan delay)\r\n{\r\n    return co_await winrt::when_any(async,\r\n        delayed_timeout_exception<Async>(delay));\r\n}\r\n<\/pre>\n
In the discussion of the C# version of these helpers, I noted that if the operation times out, it nevertheless continues to run. Windows Runtime asynchronous activities support the Cancel()<\/code> method, so you can tell them to abandon whatever they were doing. We can add that feature to our helper function, so that all the incomplete activities are cancelled.<\/p>\n
Note that we had been leaving our delayed_...<\/code> tasks uncancelled, so the timers nevertheless continue to run and either complete with nobody listening, or raise an exception that nobody is listening to. If you’re doing a lot of timeouts, these extra threadpool timers will eventually drain, but you may not want them to accumulate in the first place.<\/p>\n
So let’s cancel everything before we finish.<\/p>\n
template<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<std::is_same_v<Result, void>, int> = 0>\r\nAsync delayed_async_result(\r\n    TimeSpan delay)\r\n{\r\n    (co_await winrt::get_cancellation_token()).enable_propagation();\r\n    co_await winrt::resume_after(delay);\r\n}\r\n\r\ntemplate<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<!std::is_same_v<Result, void>, int> = 0>\r\nAsync delayed_async_result(\r\n    TimeSpan delay,\r\n    Result fallback = winrt_empty_value<Result>())\r\n{\r\n    (co_await winrt::get_cancellation_token()).enable_propagation();\r\n    co_await winrt::resume_after(delay);\r\n    co_return fallback;\r\n}\r\n\r\ntemplate<typename Async>\r\nAsync delayed_timeout_exception(TimeSpan delay)\r\n{\r\n    (co_await winrt::get_cancellation_token()).enable_propagation();\r\n    co_await winrt::resume_after(delay);\r\n    throw winrt::hresult_error(HRESULT_FROM_WIN32(ERROR_TIMEOUT));\r\n}\r\n<\/pre>\n
To prevent timers from lingering, we enable cancellation propagation in our delayed result\/exception coroutines. That way, when they are cancelled, they cancel the timer immediately rather than leaving the timer running, only for it to have nothing to do when it expires.<\/p>\n
template<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<std::is_same_v<Result, void>, int> = 0>\r\nAsync when_complete_or_timeout(Async async, TimeSpan delay)\r\n{\r\n    auto timeout = delayed_async_result<Async>(delay);\r\n\r\n    auto cancel_async = wil::scope_exit([&] { async.Cancel(); });\r\n    auto cancel_timeout = wil::scope_exit([&] { timeout.Cancel(); });\r\n\r\n    return co_await winrt::when_any(async, timeout);\r\n}\r\n\r\ntemplate<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<!std::is_same_v<Result, void>, int> = 0>\r\nAsync when_complete_or_timeout(\r\n    Async async,\r\n    TimeSpan delay,\r\n    Result fallback = winrt_empty_value<Result>())\r\n{\r\n    auto timeout = delayed_async_result<Async>(delay, fallback);\r\n\r\n    auto cancel_async = wil::scope_exit([&] { async.Cancel(); });\r\n    auto cancel_timeout = wil::scope_exit([&] { timeout.Cancel(); });\r\n\r\n    return co_await winrt::when_any(async, timeout);\r\n}\r\n\r\ntemplate<typename Async>\r\nAsync when_complete_or_timeout_exception(\r\n    Async async,\r\n    TimeSpan delay)\r\n{\r\n    auto timeout = delayed_timeout_exception<Async>(delay);\r\n\r\n    auto cancel_async = wil::scope_exit([&] { async.Cancel(); });\r\n    auto cancel_timeout = wil::scope_exit([&] { timeout.Cancel(); });\r\n\r\n    return co_await winrt::when_any(async, timeout);\r\n}\r\n<\/pre>\n
After accepting the Async<\/code> and creating our matching timeout, we use an RAII type to ensure that both are cancelled when the coroutine completes, even if it completes with an exception. Cancelling an already-completed Windows Runtime asynchronous activity has no effect, so we don’t have to keep track of which activity completed and which is being abandoned. We just cancel them all and let somebody else figure it out.<\/p>\n
There’s a lot of repetition in the version up above, so let’s try to shorten it up a bit.<\/p>\n
template<typename First, typename...Rest>\r\nFirst when_any_cancel_others(First first, Rest...rest)\r\n{\r\n    auto cleanup = std::make_tuple(\r\n        wil::scope_exit([&] { first.Cancel(); }),\r\n        wil::scope_exit([&] { rest.Cancel(); })...);\r\n\r\n    return co_await winrt::when_any(first, rest...);\r\n}\r\n\r\ntemplate<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<std::is_same_v<Result, void>, int> = 0>\r\nAsync when_complete_or_timeout(Async async, TimeSpan delay)\r\n{\r\n    return when_any_cancel_others(async,\r\n        [](TimeSpan delay) -> Async {\r\n            (co_await winrt::get_cancellation_token()).enable_propagation();\r\n            co_await winrt::resume_after(delay);\r\n        }(delay));\r\n}\r\n\r\ntemplate<\r\n    typename Async,\r\n    typename Result = decltype(std::declval<Async>().GetResults()),\r\n    typename std::enable_if_t<!std::is_same_v<Result, void>, int> = 0>\r\nAsync when_complete_or_timeout(\r\n    Async async,\r\n    TimeSpan delay,\r\n    Result fallback = winrt_empty_value<Result>())\r\n{\r\n    return when_any_cancel_others(async,\r\n        [](TimeSpan delay, Result fallback) -> Async {\r\n            (co_await winrt::get_cancellation_token()).enable_propagation();\r\n            co_await winrt::resume_after(delay);\r\n            co_return fallback;\r\n        }(delay, std::move(fallback)));\r\n}\r\n\r\ntemplate<typename Async>\r\nAsync when_complete_or_timeout_exception(\r\n    Async async,\r\n    TimeSpan delay)\r\n{\r\n    return when_any_cancel_others(async,\r\n        [](TimeSpan delay) -> Async {\r\n            (co_await winrt::get_cancellation_token()).enable_propagation();\r\n            co_await winrt::resume_after(delay);\r\n            throw winrt::hresult_error(HRESULT_FROM_WIN32(ERROR_TIMEOUT));\r\n        }(delay));\r\n}\r\n<\/pre>\n
Exercise<\/b>: Why can’t we simplify when_any_cancel_others<\/code> to this?<\/p>\n
template<typename...Args>\r\nauto when_any_cancel_others(Args...args)\r\n{\r\n    auto cleanup = std::make_tuple(\r\n        wil::scope_exit([&] { args.Cancel(); })...);\r\n\r\n    return winrt::when_any(args...);\r\n}\r\n<\/pre>\n
Exercise 2<\/b>: Why not use perfect forwarding to avoid the extra AddRef<\/code> and Release<\/code>?<\/p>\n
template<typename First, typename...Rest>\r\nstd::decay_t<First>\r\nwhen_any_cancel_others(First&& first, Rest&...rest)\r\n{\r\n    auto cleanup = std::make_tuple(\r\n        wil::scope_exit([&] { first.Cancel(); }),\r\n        wil::scope_exit([&] { rest.Cancel(); })...);\r\n\r\n    return co_await winrt::when_any(\r\n        std::forward<First>(first),\r\n        std::forward<Rest>(rest)...);\r\n}\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Doing the same thing, just in another language.<\/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-106602","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Doing the same thing, just in another language.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/106602","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=106602"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/106602\/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=106602"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=106602"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=106602"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}