{"id":106261,"date":"2022-02-16T07:00:00","date_gmt":"2022-02-16T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=106261"},"modified":"2022-02-16T07:07:21","modified_gmt":"2022-02-16T15:07:21","slug":"20220216-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20220216-00\/?p=106261","title":{"rendered":"COM asynchronous interfaces, part 3: Abandoning the operation after a timeout"},"content":{"rendered":"

Last time, we learned how to abandon an asynchronous operation<\/a>. But maybe we don’t want to fire and forget so much as wait for a while before finally giving up.<\/p>\n

You can check on the completion state of the asynchronous call by using the ISynchronize<\/code> interface on the call object. Today, we’re going to use the Wait<\/code> method to wait for the call to complete, with a timeout.<\/p>\n

Let’s make these changes to our program.<\/p>\n

int main(int, char**)\r\n{\r\n  winrt::init_apartment(winrt::apartment_type::multi_threaded);\r\n\r\n  auto pipe = CreateSlowPipeOnOtherThread();\r\n\r\n  winrt::com_ptr<::AsyncIPipeByte> call;\r\n  auto factory = pipe.as<ICallFactory>();\r\n  winrt::check_hresult(factory->CreateCall(\r\n    __uuidof(::AsyncIPipeByte), nullptr,\r\n    __uuidof(::AsyncIPipeByte),\r\n    reinterpret_cast<::IUnknown**>(call.put())));\r\n\r\n  printf(\"Beginning the Push\\n\");\r\n  BYTE buffer[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\r\n                      11, 12, 13, 14, 15 };\r\n  winrt::check_hresult(call->Begin_Push(buffer, 15));\r\n\r\n  printf(\"Waiting up to 250ms...\\n\");\r\n  auto sync = call.as<::ISynchronize>();\r\n  if (sync->Wait(COWAIT_DEFAULT, 250) == S_OK) {<\/span>\r\n    auto hr = call->Finish_Push();\r\n    printf(\"Pushed, result is %08x\\n\", hr);\r\n  } else {\r\n    printf(\"Took too long!\\n\");\r\n    \/\/ abandon the operation\r\n  }<\/span>\r\n\r\n  Sleep(2000); \/\/ so we can see the other thread finish<\/span>\r\n  return 0;\r\n}\r\n<\/pre>\n
This time, instead of abandoning the operation immediately, we ask ISynchronize::Wait<\/code> to wait up to 250ms for the call to complete. If it does, then we call Finish_Push<\/code> to get the result of the Push()<\/code> call. If it doesn’t, then we just abandon the operation.<\/p>\n
This works, but it could be better. Observe that even though we abandoned the operation, the SlowPipe<\/code> still goes through with the Push<\/code>. Instead of abandoning the operation, we can cancel it, to tell the server that it should stop doing any further work on this operation. The server can call CoTestCancel()<\/code> periodically to see if the operation has been cancelled, and if so, stop and return RPC_E_CALL_CANCELED<\/code>.<\/p>\n
struct SlowPipe :\r\n    winrt::implements<SlowPipe, ::IPipeByte, winrt::non_agile>\r\n{\r\n  \/\/ exit the STA thread when we destruct\r\n  ~SlowPipe() {  PostQuitMessage(0); }\r\n\r\n  STDMETHODIMP Pull(BYTE* buffer, ULONG size, ULONG* written)\r\n  {\r\n    HRESULT hr = S_OK;<\/span>\r\n    printf(\"Pulling %lu bytes...\\n\", size);\r\n    ULONG index;\r\n    for (index = 0; index < size \/ 2; index++) {\r\n      if (CoTestCancel() == RPC_E_CALL_CANCELED) {\r\n          hr = RPC_E_CALL_CANCELED;\r\n          break;\r\n      }<\/span>\r\n      Sleep(100);\r\n      buffer[index] = 42;\r\n      printf(\"Pulled byte %lu of %lu\\n\", index, size);\r\n    }\r\n    *written = index;\r\n    printf(\"Finished pulling %lu% of %lu bytes, hr = %08x<\/span>\\n\",\r\n            index, size, hr<\/span>);\r\n    return hr<\/span>;\r\n  }\r\n\r\n  STDMETHODIMP Push(BYTE* buffer, ULONG size)\r\n  {\r\n    HRESULT hr = S_OK;<\/span>\r\n    printf(\"Pushing %lu bytes...\\n\", size);\r\n    ULONG index;\r\n    for (index = 0; index < size; index++) {\r\n      if (CoTestCancel() == RPC_E_CALL_CANCELED) {\r\n          hr = RPC_E_CALL_CANCELED;\r\n          break;\r\n      }<\/span>\r\n      Sleep(100);\r\n      printf(\"Pushed byte %08x\\n\", buffer[index]);\r\n    }\r\n    printf(\"Finished pushing %lu bytes, hr = %08x<\/span>\\n\",\r\n           size, hr<\/span>);\r\n    return hr<\/span>;\r\n  }\r\n};\r\n<\/pre>\n
Our server now periodically checks whether the call was cancelled, and if so, it abandons the remainder of the operation. The Pull<\/code> still reports the partial result, in case the caller cares.<\/p>\n
Now we can issue a cancellation from the main thread and see how it alters the behavior of the server.<\/p>\n
int main(int, char**)\r\n{\r\n  winrt::init_apartment(winrt::apartment_type::multi_threaded);\r\n\r\n  auto pipe = CreateSlowPipeOnOtherThread();\r\n\r\n  winrt::com_ptr<::AsyncIPipeByte> call;\r\n  auto factory = pipe.as<ICallFactory>();\r\n  winrt::check_hresult(factory->CreateCall(\r\n    __uuidof(::AsyncIPipeByte), nullptr,\r\n    __uuidof(::AsyncIPipeByte),\r\n    reinterpret_cast<::IUnknown**>(call.put())));\r\n\r\n  printf(\"Beginning the Push\\n\");\r\n  BYTE buffer[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\r\n                      11, 12, 13, 14, 15 };\r\n  winrt::check_hresult(call->Begin_Push(buffer, 15));\r\n\r\n  printf(\"Waiting up to 250ms...\\n\");\r\n  auto sync = call.as<::ISynchronize>();\r\n  if (sync->Wait(COWAIT_DEFAULT, 250) == S_OK) {\r\n    auto hr = call->Finish_Push();\r\n    printf(\"Pushed, result is %08x\\n\", hr);\r\n  } else {\r\n    printf(\"Took too long!\\n\");\r\n    call.as<::ICancelMethodCalls>()->Cancel(0);<\/span>\r\n  }\r\n\r\n  Sleep(2000); \/\/ so we can see the other thread finish\r\n  return 0;\r\n}\r\n<\/pre>\n
This time, instead of abandoning the operation, we ask ICancel\u00adMethod\u00adCalls::Cancel<\/code> to cancel it with a timeout of zero, which means “immediately.” If you run this version of the program, you’ll see that the slow pipe responds to the cancellation by abandoning the operation partway through.<\/p>\n
At this point, we realize that we didn’t need ISynchronize<\/code> at all. We could just have gone straight to ICancel\u00adMethod\u00adCalls::Cancel<\/code>, assuming we are willing to accept the fact that the ICancel\u00adMethod\u00adCalls::Cancel<\/code> method takes the timeout in seconds rather than milliseconds.<\/p>\n
int main(int, char**)\r\n{\r\n  winrt::init_apartment(winrt::apartment_type::multi_threaded);\r\n\r\n  auto pipe = CreateSlowPipeOnOtherThread();\r\n\r\n  winrt::com_ptr<::AsyncIPipeByte> call;\r\n  auto factory = pipe.as<ICallFactory>();\r\n  winrt::check_hresult(factory->CreateCall(\r\n    __uuidof(::AsyncIPipeByte), nullptr,\r\n    __uuidof(::AsyncIPipeByte),\r\n    reinterpret_cast<::IUnknown**>(call.put())));\r\n\r\n  printf(\"Beginning the Push\\n\");\r\n  BYTE buffer[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\r\n                      11, 12, 13, 14, 15 };\r\n  winrt::check_hresult(call->Begin_Push(buffer, 15));\r\n\r\n  printf(\"Waiting up to 1 second...\\n\");\r\n  call.as<::ICancelMethodCalls>()->Cancel(1);\r\n\r\n  auto hr = call->Finish_Push();\r\n  printf(\"Pushed, result is %08x\\n\", hr);<\/span>\r\n\r\n  Sleep(2000); \/\/ so we can see the other thread finish\r\n  return 0;\r\n}\r\n<\/pre>\n
The Cancel()<\/code> method waits for the timeout, in case the operation completes in time. If not, then it issues a cancellation and returns immediately. It doesn’t wait for the server to acknowledge the cancellation; it just issues the cancellation and marks the operation locally as having been cancelled, so that calling the Finish_<\/code> method will return RPC_E_CALL_CANCELED<\/code> immediately.<\/p>\n
You can run the program again, but with a 2-second timeout to see the operation run to completion before the timeout elapses.<\/p>\n
So far, we’ve just been sitting around doing nothing while waiting for the operation to complete. Next time, we’ll try doing work in parallel.<\/p>\n","protected":false},"excerpt":{"rendered":"
Waiting a little while, but not forever.<\/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-106261","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Waiting a little while, but not forever.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/106261","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=106261"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/106261\/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=106261"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=106261"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=106261"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}