Is it wrong to expect renewable features to resume in the original thread?

Question

After watching an interview with Gor Nishanov in anticipation and coroutines, I decided to play a little with the renewable features of N4131 . Then I realized that the following code printed 'false' to my second question (tested with Visual Studio 2015 RC and online compiler (flag required: /await ))

 #include <future> #include <iostream> using namespace std; using namespace chrono; struct Foo { future<void> coro(thread::id ui_thread_id) { cout << "Q: awaiting result in UI thread? " << boolalpha << (this_thread::get_id() == ui_thread_id) << endl; auto intermediate_result = __await async([] { this_thread::sleep_for(250ms); return 42; }); cout << "Q: received result in UI thread? " << boolalpha << (this_thread::get_id() == ui_thread_id) << endl; result = intermediate_result; // race } int result = 0; }; int main() { const auto ui_thread_id = this_thread::get_id(); Foo f; auto c = f.coro(ui_thread_id); for (int i = 0; i < 7; ++i) { cout << " -- event loop: " << f.result << endl; this_thread::sleep_for(50ms); } c.wait(); } 

My expectation was the result of the assertion that “the fact that a function is implemented as a renewable function is not observable by the caller” ( N4131 , p.8, Renewable function, 4th paragraph).

This seems to be an important detail, and I could not find any expression in N4131 , which clarifies my question.

Is it wrong to expect renewable functions to actually resume their work in the original thread? If this is wrong, try to explain why?

Answer 1

To answer your question: yes, it is probably wrong to expect that the renewable functions will actually resume their work in the original thread, because the proposal is not indicated with respect to this behavior (maybe, specifically, maybe not).

I think your misconception is about which function is resumed in the example, and therefore which function is connected "by the fact that the function is implemented as a renewable function, unobservable by the caller."

From the sentence (my selection):

A function or lambda is called a renewable function or renewable lambda if the body of the function or lambda contains at least one pause / resume point . Pause / resume points are expressions with one or more pending statements, output statements, or pending statements

This means that lambda is not a renewable function, coro is that the await keyword is part of its body. The proposal indicates how the renewable function behaves with respect to its callers, and the example shows that in this case the caller does not detect, main() , if it was implemented as renewable or not ( main() also still on the UI when coro returns).

Now it can be argued that this may be an oversight in the sentence, so as not to indicate this, but I am sure that there was a good reason for this, but I could not find anything in the sentence regarding the actual renewal of the function.

Interaction with mutable parameters may also be discussed. For instance:

 future<void> coro(thread::id ui_thread_id, int* foo) { auto intermediate_result = __await async([] { this_thread::sleep_for(250ms); }); *foo = 42; } 

I would personally consider the fact that foo can be changed by another thread as "observable" from the caller, but then again, someone can argue differently (I'm not the best in standard ese).

And last but not least, I’m not sure what you think is extraordinarily racing in relation to the assignment. It runs the race with readings in main() , but you wrote the code specifically for this and there is only one purpose (the function body is suspended when await called and resumed after the return of the asynchronous lambda). Changing await to resume on the same thread would not have affected this situation at all (except in non-atomic read-write cases where you could read an object in an inconsistent state, which is another possibility for worms and probably is a real point) .

Please note that this feature is very young and is currently only experimentally implemented in the MSVC IIRC, so I expect it to make some changes before standardizing it (if ever). There is also a slight chance that this is actually a specification / implementation error.

At the same time, there is a good chance that the behavior during the resumption of renewable functions was hardly indicated in order to provide greater freedom in implementation.