我可以在await_suspend期间调用coroutine_handle :: resume吗？

Question

Consider the following code:

coroutine_handle<> g_handle;
atomic<int> g_ready;

void worker_thread() {
  if (++g_ready == 2) g_handle.resume();
}

struct Awaitable {
  bool await_ready() const { return false; }
  bool await_suspend(coroutine_handle<> h) {
    g_handle = h;
    if (++g_ready == 2) return false;
    // worker_thread can call h.resume() at this point
    return true;
  }
  void await_resume() {}
};

Future coroutine() {
  Awaitable a;
  std::thread(worker_thread).detach();
  co_await a; // compiles as:
              // if (a.await_suspend(h)) {
              //   // worker_thread can call h.resume() at this point
              //   return;
              // }
}

Here the worker_thread can call h.resume(); when the coroutine is still executing await_suspend or between await_suspend() and return in the coroutine.

The Coroutines TS says that resume can be called only when a coroutine is suspended.

Is it considered suspended during the execution of await_suspend ?

Answer 1

Yes, the text of the linked Coroutines TS states, 5.3.8 paragraph 3-5. Emphasis mine:

5 The await-expression evaluates the await-ready expression, then: —

(5.1) If the result is false , the coroutine is considered suspended. Then, the await-suspend expression is evaluated. If that expression has type bool and evaluates to false , the coroutine is resumed. If that expression exits via an exception, the exception is caught, the coroutine is resumed, and the exception is immediately re-thrown (15.1). Otherwise, control flow returns to the current caller or resumer (8.4.4) without exiting any scopes (6.6). —

So you may resume the coroutine from another thread, as long as you guarantee that exiting await-suspend does not cause a double resume, or destruction of the coroutine