{"id":103201,"date":"2019-12-11T07:00:00","date_gmt":"2019-12-11T15:00:00","guid":{"rendered":"http:\/\/devblogs.microsoft.com\/oldnewthing\/?p=103201"},"modified":"2019-12-10T21:25:44","modified_gmt":"2019-12-11T05:25:44","slug":"20191211-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20191211-00\/?p=103201","title":{"rendered":"C++ coroutines: Framework interop"},"content":{"rendered":"

So far<\/a>, we’ve been looking at the basics of awaitable objects. Even though we barely know anything beyond await_<\/code>suspend<\/code>, we already know enough to allow us to start diving deeper.<\/p>\n

It is frequently the case that you need your awaiter to interact with something outside the C++ standard library. To make it easier to integrate coroutines with existing frameworks, the coroutine_handle<\/code> can be converted to a void*<\/code> by calling its address()<\/code> method, and the resulting void*<\/code> can be converted back to an equivalent coroutine_handle<\/code> by calling from_<\/code>address()<\/code>.\u00b9<\/p>\n

Most frameworks let you pass a pointer-sized piece of data around to help remember state, and being able to convert a handle into a pointer (and back) lets you pass the coroutine handle through such state parameters. Otherwise, you’d have to copy the coroutine_handle<\/code> to the heap and pass the address of the heap block, and then keep track of when to free the heap block.<\/p>\n

Let’s demonstrate this by reimplementing resume_<\/code>new_<\/code>thread<\/code> in terms of Win32 functions instead of the std::<\/code>thread<\/code> standard library class.<\/p>\n

struct resume_new_thread : std::experimental::suspend_always\r\n{\r\n  void await_suspend(\r\n      std::experimental::coroutine_handle<> handle)\r\n  {\r\n    HANDLE thread = CreateThread(nullptr, 0, callback,\r\n                        handle.address(), 0, &threadId);\r\n    if (!thread) throw some_kind_of_error();\r\n    CloseHandle(thread);\r\n  }\r\n\r\n  DWORD CALLBACK callback(void* parameter)\r\n  {\r\n    auto handle = std::experimental::coroutine_handle<>::\r\n                    from_address(parameter);\r\n    handle();\r\n    return 0;\r\n  }\r\n};\r\n<\/pre>\n
The basic idea is the same as last time: When the coroutine suspends, schedule the continuation on a newly-created thread.<\/p>\n
The Create\u00adThread<\/code> function allows you to pass a single pointer-sized piece of data, so we convert our handle to a void*<\/code> by calling the address<\/code> method, and pass that pointer as the reference data to the thread procedure. The thread procedure converts the pointer back into a coroutine handle by calling from_<\/code>address<\/code>, and then invokes the coroutine to resume execution.<\/p>\n
If terseness is your game, you could inline the thread procedure as a stateless lambda, taking advantage of  the implicit conversion from a stateless lambda to a function pointer<\/a>.<\/p>\n
struct resume_new_thread : std::experimental::suspend_always\r\n{\r\n  void await_suspend(\r\n      std::experimental::coroutine_handle<> handle)\r\n  {\r\n    HANDLE thread = CreateThread(nullptr, 0,\r\n      [](void* parameter) -> DWORD\r\n      {\r\n        std::experimental::coroutine_handle<>::\r\n                    from_address(parameter)();\r\n        return 0;\r\n      }, handle.address(), 0, &threadId);\r\n    if (!thread) throw some_kind_of_error();\r\n    CloseHandle(thread);\r\n  }\r\n};\r\n<\/pre>\n
Next time, we’ll use what we’ve learned about awaiters to develop a way to override C++\/WinRT coroutine threading defaults.<\/p>\n
\u00b9 The method names address<\/code> and from_<\/code>address<\/code> give a strong clue as to what the void*<\/code> represents: it’s the address of runtime-managed coroutine state, known in the language specification as a coroutine frame<\/i>.<\/p>\n","protected":false},"excerpt":{"rendered":"
Plays well with others.<\/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-103201","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Plays well with others.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/103201","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=103201"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/103201\/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=103201"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=103201"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=103201"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}