co_await似乎不是最理想的？

Question

我有一个异步函数

void async_foo(A& a, B& b, C&c, function<void(X&, Y&)> callback); 

我想在一个无堆栈协程使用它，所以我写

auto coro_foo(A& a, B& b, C& c, X& x) /* -> Y */ { 
    struct Awaitable { 
    bool await_ready() const noexcept { return false; } 
    bool await_suspend(coroutine_handle<> h) { 
     async_foo(*a_, *b_, *c_, [this, h](X& x, Y& y){ 
     *x_ = std::move(x); 
     y_ = std::move(y); 
     h.resume(); 
     }); 
    } 
    Y await_resume() { 
     return std::move(y); 
    } 
    A* a_; B* b_; C* c_; X* x_; Y y_; 
    }; 
    return Awaitable{&a, &b, &c, &x}; 
} 

那么我就可以这样使用它：

Y y = co_await coro_foo(a, b, c, x); 

和编译器将其改写为：

auto e = coro_foo(a, b, c, x); 
    if (!e.await_ready()) { 
    <suspend> 
    if (e.await_suspend(h)) return; 
resume-point: 
    <resume> 
    } 
    Y y = e.await_resume(); 

在此情况下，协程在暂停时将保留a_，b_和c_，此时它只需要保留它们，直到获得coroutine_handle的await_suspend(h)。
（顺便说一句，我不知道如果我能保持到参数参考这里）。

这将是更有效的，如果包装函数可直接获得coroutine_handle作为参数。

这可能是一个隐含参数：

Promise f(coroutine_handle<> h); 
co_await f(); 

或者它可能是一个特殊的关键字参数：

Promise f(coroutine_handle<> h); 
f(co_await); 

我在这里失去了一些东西？ （其它的是，额外开销并不大。）

Answer 1

当前的设计有一个重要的未来，co_await采取一般表达式而不是调用表达式。

这使得我们可以这样写代码：

auto f = coro_1(); 
co_await coro_2(); 
co_await f; 

我们可以运行在平行的两个或多个异步任务，然后等待他们两个。

因此，coro_1的实施应在其呼叫中开始其工作，而不是在await_suspend中开始其工作。

这也意味着应该有一个预先分配的内存，其中coro_1将其结果，以及它将需要coroutine_handle。

我们可以使用不可复制的Awaitable，并保证复制省略。
async_foo将从构造函数调用的Awaitable：

auto coro_foo(A& a, B& b, C& c, X& x) /* -> Y */ { 
    struct Awaitable { 
    Awaitable(A& a, B& b, C& c, X& x) : x_(x) { 
     async_foo(a, b, c, [this](X& x, Y& y){ 
     *x_ = std::move(x); 
     y_ = &y; 
     if (done_.exchange(true)) { 
      h.resume(); // Coroutine resumes inside of resume() 
     } 
     }); 
    } 
    bool await_ready() const noexcept { 
     return done_; 
    } 
    bool await_suspend(coroutine_handle<> h) { 
     h_ = h; 
     return !done_.exchange(true); 
    } 
    Y await_resume() { 
     return std::move(*y_); 
    } 
    atomic<bool> done_; 
    coroutine_handle<> h_; 
    X* x_; 
    Y* y_; 
    }; 
    return Awaitable(a, b, c, &x); 
} 

Answer 2

由协程TS中定义的“协程”系统被设计为处理异步函数其中：

1. 返回一个未来状物体（一个对象，表示延迟的返回值）。
2. 类似将来的对象有能力与延续功能相关联。

async_foo不符合这些要求。它不会返回一个类似未来的对象;它通过延续功能“返回”一个值。而这个延续是作为参数传递的，而不是你用对象的返回类型做的事情。

到co_await发生的时候，产生未来的潜在异步过程预计已经开始。或者至少，co_await机器使其可能已启动。

您的建议版本在await_ready功能上失效，这允许co_await处理潜在的异步进程。在未来生成时间和await_ready被调用时，该过程可能已经完成。如果有，则不需要安排恢复协程。因此，它应该发生在这里，在这个线程。

如果轻微堆栈效率低下，那么您将不得不按照Coroutine TS要求的方式执行操作。

处理此问题的一般方法是，coro_foo将直接执行async_foo，并返回一个类似将来的对象，其机制类似于.then。你的问题是，async_foo本身不具有.then样的机制，所以你必须创建一个。

这意味着coro_foo必须通过async_foo函子存储coroutine_handle<>，一个可以由未来的继续机制更新。当然，你还需要同步原语。如果在仿函数执行时句柄已经初始化，那么仿函数调用它，恢复协程。如果函子完成而没有恢复协程，仿函数将设置一个变量让等待机器知道该值已准备就绪。

由于手柄，该变量是的await机械和函子之间的共享，你需要确保两个之间的同步。这是一件相当复杂的事情，但无论它是什么风格的机器都需要。

或者你可以只住了轻微低效率。

Answer 3

async_foo可以直接从coro_foo如果我们用一个未来般类调用。
这将花费我们一个分配和原子变量：

static char done = 0; 

template<typename T> 
struct Future { 
    T t_; 
    std::atomic<void*> addr_; 

    template<typename X> 
    void SetResult(X&& r) { 
    t_ = std::move(r); 
    void* h = addr_.exchange(&done); 
    if (h) std::experimental::coroutine_handle<>::from_address(h).resume(); 
    } 

    bool await_ready() const noexcept { return false; } 
    bool await_suspend(std::experimental::coroutine_handle<> h) noexcept { 
    return addr_.exchange(h.address()) != &done; 
    } 
    auto await_resume() noexcept { 
    auto t = std::move(t_); 
    delete this; // unsafe, will be leaked on h.destroy() 
    return t; 
    } 
}; 

Future<Y>& coro_foo(A& a, B& b, C& c, X& x) { 
    auto* p = new Future<Y>; 
    async_foo(a, b, c, [p, &x](X& x_, Y& y_) { 
     x = std::move(x_); 
     p->SetResult(y_); 
    }); 
    return *p; 
} 

它看起来并不十分昂贵，
但它并不显著改善问题的代码。
（它也伤害了我的眼睛）