{"id":100715,"date":"2019-01-16T07:00:00","date_gmt":"2019-01-16T22:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/?p=100715"},"modified":"2019-03-13T00:07:37","modified_gmt":"2019-03-13T07:07:37","slug":"20190116-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20190116-00\/?p=100715","title":{"rendered":"How do I get the effect of C#’s async void<\/CODE> in a C++ coroutine? Part 1: Why does the obvious solution crash?"},"content":{"rendered":"

The co_await<\/code> C++ language keyword makes it a lot easier to write coroutines. The compiler does the grunt work of transforming your function into a state machine, similar in spirit to the coroutine transformations performed by C#<\/a> and JavaScript<\/a>. <\/p>\n

C# and JavaScript have an additional feature that C++ doesn’t: They let you take a coroutine and treat it like a plain function which returns when the coroutine yields for the first time. With C#, this is done by declaring the function as async void<\/code>. With JavaScript, you get this automatically because JavaScript is dynamically-typed. <\/p>\n

But you don’t get any built-in help in C++. <\/p>\n

\ntypedef void (*EventHandler_t)(int a, int b);\n\nvoid MyEventHandler(int a, int b)\n{\n  GetReady(a);\n  co_await GetSetAsync(b); \/\/ oops - this doesn't compile<\/font>\n  Go(a, b);\n}\n\nextern void SetEventHandler(EventHandler_t eventHandler);\n\nvoid RegisterTheEventHandler()\n{\n   SetEventHandler(MyEventHandler);\n}\n<\/pre>\n
In order to use co_await<\/code>, your function must return a future<\/code> or task<\/code> or some other representation of a coroutine. <\/p>\n
Okay, so let’s do that. <\/p>\n
\ntypedef void (*EventHandler_t)(int a, int b);\n\nConcurrency::task<void> MyEventHandler(int a, int b)\n{\n  GetReady(a);\n  co_await GetSetAsync(b); \/\/ all right, now this compiles!\n  Go(a, b);\n}\n\nextern void SetEventHandler(EventHandler_t eventHandler);\n\nvoid RegisterTheEventHandler()\n{\n   SetEventHandler(MyEventHandler); \/\/ but this doesn't<\/font>\n}\n<\/pre>\n
So now what? <\/p>\n
If you’re lucky, your event handler takes a std::function<\/code>, which is more generous about function return types, and the problem goes away. <\/p>\n
But suppose you’re not that lucky. <\/p>\n
Gor Nishanov, one of the brains behind co_await<\/code>, had two suggestions<\/a>. The first is to create a wrapper. <\/p>\n
\nConcurrency::task<void> MyEventHandlerAsync(int a, int b)\n{\n  GetReady(a);\n  co_await GetSetAsync(b);\n  Go(a, b);\n}\n\nvoid MyEventHandler(int a, int b)\n{\n  MyEventHandlerAsync(); \/\/ throw away the task\n}<\/font>\n\nextern void SetEventHandler(EventHandler_t eventHandler);\n\nvoid RegisterTheEventHandler()\n{\n   SetEventHandler(MyEventHandler);\n}\n<\/pre>\n
The other is to roll up your sleeves and write a specialization of coroutine_<\/code>traits<\/code> to support returning void<\/code>. I’m not going to reproduce it here because it assumes you understand the low-level machinery that makes co_await<\/code> work,¹ and it ties you to a specific asynchronous framework (since it’s going to be used for all functions returning void<\/code>). <\/p>\n
I thought I discovered a third way: <\/p>\n
\n\/\/ Code in italics is wrong.\nvoid MyEventHandler(int a, int b)\n{\n  [=]() -> Concurrency::task<void><\/i>\n  {<\/font>\n    GetReady(a);\n    co_await GetSetAsync(b);\n    Go(a, b);\n  }();<\/font>\n}\n\nextern void SetEventHandler(EventHandler_t eventHandler);\n\nvoid RegisterTheEventHandler()\n{\n   SetEventHandler(MyEventHandler);\n}\n<\/pre>\n
We create a lambda that returns a coroutine, and that lambda can now use co_await<\/code>. And then we invoke the lambda immediately and throw the result away. <\/p>\n
This does cost you a level of indentation, but it beats writing another function entirely. <\/p>\n
Basically, I just took Gor’s first suggestion and inlined the function as a lambda. <\/p>\n
Unfortunately, it also doesn’t work. <\/p>\n
To see why, let’s write out the lambda in its expanded form. <\/p>\n
\nvoid MyEventHandler(int a, int b)\n{\n  struct Lambda {\n   Lambda(int a, int b) : a_(a), b_(b) { }\n   Concurrency::task<void> operator() {\n    GetReady(a_);\n    co_await GetSetAsync(b_);\n    Go(a_, b_);\n   }\n  private:\n   int a_, b_;\n  } lambda(a, b);\n\n  lambda();<\/i>\n}\n<\/pre>\n
To make things even more explicit, let’s expand out the task, too. <\/p>\n
\nvoid MyEventHandler(int a, int b)\n{\n  struct LambdaFrame {\n   LambdaFrame(Lambda* lambda) : lambda_(lambda) { }\n\n   Concurrency::task<void> Run() {\n    if (state_ == 0) {\n     GetReady(lambda_->a_);\n     auto innerTask = GetSetAsync(lambda_->b_);\n     state_ = 1;\n     return magic_create_task_from_frame(this);\n    } else if (state_ == 1) {\n     Go(lambda_->a_, lambda_->b_);\n     state_ = 2;\n     return magic_completed_task();\n    }\n   }\n  private:\n   Lambda* lambda_;\n   int state_ = 0;\n  };\n\n  struct Lambda {\n   Lambda(int a, int b) : a_(a), b_(b) { }\n   Concurrency::task<void> operator() {\n    return magic_create_task_from_frame\n            <LambdaFrame>(__this, a_, b_);\n   }\n  private:\n   int a_, b_;\n  } lambda(a, b);\n\n  lambda();<\/i>\n}\n<\/pre>\n
I’m glossing over a bunch of magic_<\/code> stuff which is part of the behind-the-scenes coroutine infrastructure. The important thing is that the task<\/code> keeps the Lambda­Frame<\/code> alive for as long as the task needs it. <\/p>\n
But there is no magic that keeps the lambda<\/code> alive! <\/p>\n
What we did was invoke the lambda and then destruct it when the function returns. But the task is still running, and that task is going to try to use the a_<\/code> and b_<\/code> members of the lambda. Which no longer exists. <\/p>\n
In other words, we have a case of using an object after it has destructed. <\/p>\n
But wait, all is not lost. We can fix this by using a non-capturing lambda. <\/p>\n
\nvoid MyEventHandler(int a, int b)\n{\n  [](int a, int b) -> Concurrency::task<void>\n  {\n   GetReady(a);\n   co_await GetSetAsync(b);\n   Go(a, b);\n  }(a, b);\n}\n<\/pre>\n
We cannot capture state in the lambda because the lambda is going to be destructed as soon as the task reaches a suspension point. Instead, we capture the state in the explicit lambda parameters (which are part of the frame, not the lambda). <\/p>\n
If My­Event­Handler<\/code> is a member function, you’ll also have to capture this<\/code> explicitly. Furthermore, you need to make sure the instance doesn’t get destructed while the task is running. This might be implicit in the way you use the task, or it could be explicit by maintaining a strong reference to the enclosing object. <\/p>\n
\nvoid MyClass::MyEventHandler(int a, int b)\n{\n  [](std::shared_ptr<MyClass> self, int a, int b)\n   -> Concurrency::task<void>\n  {\n   self->GetReady(a);\n   co_await self->GetSetAsync(b);\n   self->Go(a, b);\n  }(this->shared_from_this(), a, b);\n}\n<\/pre>\n
Unfortunately, having to type self-><\/code> each time you access a member makes this rather cumbersome. To solve this, you can make the lambda body a separate method. But now you’ve come full circle back to Gor’s original suggestion. <\/p>\n
So is this hopeless? Not quite. We’ll pick up the story next time. <\/p>\n
¹ If you want to learn the low-level machinery that makes co_await<\/code> work, you can read this series of articles by Lewis Baker<\/a>: <\/p>\n