C++20 Coroutines的栈管理与Continuation机制：深入理解co_await与co_yield的编译器转换
大家好，今天我们深入探讨C++20协程的栈管理和Continuation机制。协程是C++20引入的一项强大的特性，它允许我们在函数执行过程中暂停和恢复，而无需依赖操作系统线程。理解其内部工作原理对于编写高效、可维护的协程代码至关重要。
1. 协程的基本概念
协程本质上是一个可以暂停和恢复执行的函数。 它的关键在于 co_await 和 co_yield 这两个关键字，它们分别用于挂起和恢复协程的执行，以及产生一个值给调用者。
一个简单的协程示例：
#include <iostream>
#include <coroutine>
struct Task {
struct promise_type {
Task get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
};
Task my_coroutine() {
std::cout << "Coroutine startedn";
co_await std::suspend_always{};
std::cout << "Coroutine resumedn";
}
int main() {
my_coroutine();
std::cout << "Main function finishedn";
return 0;
}在这个例子中，my_coroutine 是一个协程。 co_await std::suspend_always{} 会立即挂起协程，但由于main函数没有等待协程，因此程序直接执行完毕。
2. 协程的栈管理
与传统函数不同，协程在暂停时不需要将整个调用栈保存到堆上。 C++20 协程采用了一种叫做 堆分配协程帧 (Heap-allocated coroutine frame) 的策略。
协程帧是一个在堆上分配的内存块，用于存储协程的状态，包括：
- 局部变量
- 参数
- 返回地址
promise_type对象- Continuation句柄
当协程挂起时，只有协程帧被保留。 调用栈可以被释放，从而节省内存。 协程帧的存在使得协程可以在稍后的某个时间点恢复执行，而不需要重新创建整个调用栈。
考虑以下代码：
#include <iostream>
#include <coroutine>
struct ReturnObject {
struct promise_type {
ReturnObject get_return_object() { return ReturnObject{std::coroutine_handle<promise_type>::from_promise(*this)}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
std::coroutine_handle<promise_type> h_;
};
ReturnObject my_coroutine() {
std::cout << "Coroutine startedn";
co_await std::suspend_always{};
std::cout << "Coroutine resumedn";
}
int main() {
ReturnObject coro = my_coroutine();
coro.h_.resume();
std::cout << "Main function finishedn";
return 0;
}在这个例子中，ReturnObject 持有一个 std::coroutine_handle，它是指向协程帧的指针。 通过调用 coro.h_.resume()，我们可以恢复协程的执行。
3. Continuation机制
Continuation 是协程的核心概念。 它代表了协程在某个特定点的执行状态。 当协程挂起时，会创建一个 Continuation 对象，其中包含了恢复执行所需的所有信息。
co_await 表达式负责创建 Continuation 并将控制权转移到awaiter对象。awaiter对象可以决定何时以及如何恢复协程的执行。
co_yield 表达式则更为复杂，它不仅创建了 Continuation，还向调用者返回一个值。
4. co_await 的编译器转换
co_await 表达式的编译器转换是一个复杂的过程，涉及到多个步骤。 简单来说，以下是 co_await 表达式的典型转换流程：
- 获取awaiter对象： 从操作数中获取awaiter对象。 例如，
co_await expression会调用expression.operator co_await()(如果存在) 或者直接使用expression本身。 - 检查awaiter是否已经完成： 调用
awaiter.await_ready()。 如果返回true，则awaiter已经完成，不需要挂起协程，直接执行后续代码。 - 挂起协程 (如果awaiter未完成)：
- 调用
awaiter.await_suspend(handle)，其中handle是一个std::coroutine_handle，指向当前协程的协程帧。 await_suspend函数负责决定如何恢复协程。 它可以立即恢复协程，也可以将协程的句柄传递给其他任务，以便在稍后的某个时间点恢复。await_suspend返回void、bool或者coroutine_handle。- 如果返回
void，则awaiter负责恢复协程。 - 如果返回
bool，返回false会立即恢复协程，返回true则不恢复（awaiter负责）。 - 如果返回
coroutine_handle，则恢复该句柄对应的协程。
- 如果返回
- 调用
- 获取结果： 当协程恢复执行时，调用
awaiter.await_resume()来获取co_await表达式的结果。
可以用表格来更清晰的表示这个过程：
| 步骤 | 操作 | 方法调用 | 返回值 |
|---|---|---|---|
| 1 | 获取awaiter对象 | expression.operator co_await() 或 expression 本身 |
awaiter对象 |
| 2 | 检查awaiter是否已经完成 | awaiter.await_ready() |
true (已完成) / false (未完成) |
| 3 | 挂起协程 (如果awaiter未完成) | awaiter.await_suspend(handle) |
void (awaiter负责恢复), bool (false: 立即恢复, true:awaiter负责), coroutine_handle (恢复该协程) |
| 4 | 获取结果 (当协程恢复执行时) | awaiter.await_resume() |
co_await 表达式的结果 |
一个简单的例子：
#include <iostream>
#include <coroutine>
struct MyAwaitable {
bool await_ready() {
std::cout << "await_ready calledn";
return false; // 始终挂起
}
void await_suspend(std::coroutine_handle<> handle) {
std::cout << "await_suspend calledn";
// 在这里可以做一些异步操作，并在完成后恢复协程
handle.resume(); // 立即恢复协程
}
int await_resume() {
std::cout << "await_resume calledn";
return 42;
}
};
struct Task {
struct promise_type {
Task get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
};
Task my_coroutine() {
std::cout << "Coroutine startedn";
int result = co_await MyAwaitable{};
std::cout << "Coroutine resumed, result = " << result << "n";
}
int main() {
my_coroutine();
std::cout << "Main function finishedn";
return 0;
}输出将会是:
Coroutine started
await_ready called
await_suspend called
await_resume called
Coroutine resumed, result = 42
Main function finished5. co_yield 的编译器转换
co_yield 表达式用于产生一个值给调用者。 它的编译器转换比 co_await 更复杂一些，因为它涉及到与调用者的交互。
以下是 co_yield 表达式的典型转换流程：
- 调用
promise.yield_value(value)： 将要产生的值传递给promise_type的yield_value函数。 - 挂起协程：
yield_value函数通常会挂起协程，并将控制权返回给调用者。 - 恢复协程 (可选)： 调用者可以在稍后的某个时间点恢复协程的执行，以产生下一个值。
考虑以下生成器协程的例子：
#include <iostream>
#include <coroutine>
template <typename T>
struct Generator {
struct promise_type {
T value_;
std::exception_ptr exception_;
Generator get_return_object() {
return Generator(std::coroutine_handle<promise_type>::from_promise(*this));
}
std::suspend_never initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void unhandled_exception() { exception_ = std::current_exception(); }
std::suspend_always yield_value(T value) {
value_ = value;
return {};
}
void return_void() {}
};
Generator(std::coroutine_handle<promise_type> h) : handle(h) {}
~Generator() { if (handle) handle.destroy(); }
struct iterator {
std::coroutine_handle<promise_type> handle;
T operator*() const { return handle.promise().value_; }
iterator& operator++() {
handle.resume();
return *this;
}
bool operator!=(const iterator& other) const {
return !handle || handle.done();
}
};
iterator begin() { return {handle}; }
iterator end() { return {nullptr}; }
private:
std::coroutine_handle<promise_type> handle;
};
Generator<int> my_generator() {
co_yield 1;
co_yield 2;
co_yield 3;
}
int main() {
for (int i : my_generator()) {
std::cout << i << std::endl;
}
return 0;
}在这个例子中，my_generator 是一个生成器协程。 每次调用 co_yield，都会将一个值传递给 promise_type 的 yield_value 函数，并将协程挂起。 调用者可以通过迭代器来获取产生的值。
更详细的表格来描述 co_yield 的过程:
| 步骤 | 操作 | 方法调用 | 返回值 |
|---|---|---|---|
| 1 | 将要产生的值传递给 promise_type |
promise.yield_value(value) |
std::suspend_always 或 std::suspend_never, 通常挂起协程 |
| 2 | (可选) 挂起协程并返回调用者 | 控制权返回给调用者 | |
| 3 | (可选) 调用者恢复协程的执行 | handle.resume() |
继续执行，产生下一个值或完成 |
6. 异常处理
协程中的异常处理需要特别注意。 如果协程中抛出了未处理的异常，它会被传递到 promise_type 的 unhandled_exception() 函数。 这个函数可以记录异常，或者以其他方式处理它。 重要的是，异常不会自动传播到调用者，而是需要在 promise_type 中显式处理。
#include <iostream>
#include <coroutine>
#include <exception>
struct Task {
struct promise_type {
Task get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {
try {
throw; // Rethrow the exception
} catch (const std::exception& e) {
std::cerr << "Exception caught in coroutine: " << e.what() << std::endl;
}
}
};
};
Task my_coroutine() {
std::cout << "Coroutine startedn";
throw std::runtime_error("Something went wrong");
co_await std::suspend_always{};
std::cout << "Coroutine resumedn";
}
int main() {
my_coroutine();
std::cout << "Main function finishedn";
return 0;
}在这个例子中，当 my_coroutine 抛出异常时，promise_type 的 unhandled_exception() 函数会被调用，并打印错误信息。
7. 深入理解 Promise Type
promise_type 是协程中一个非常重要的概念。它定义了协程的行为，包括如何创建返回对象，如何处理挂起和恢复，以及如何处理异常。
以下是一些常用的 promise_type 方法：
get_return_object(): 创建并返回协程的返回对象。initial_suspend(): 决定协程是否在开始时挂起。final_suspend(): 决定协程在完成时是否挂起。return_void(): 在协程完成时调用 (如果返回类型是void)。return_value(T value): 在协程完成时调用 (如果返回类型是T)。yield_value(T value): 在co_yield表达式中调用。unhandled_exception(): 在协程中抛出未处理的异常时调用。
自定义 promise_type 可以实现各种各样的协程行为，例如：
- Lazy evaluation
- Asynchronous operations
- Generators
- State machines
8. 优化协程性能
协程的性能取决于多种因素，包括栈管理、Continuation机制和编译器优化。
以下是一些优化协程性能的技巧：
- 避免不必要的堆分配： 尽量使用栈分配的局部变量，减少堆分配的次数。
- 使用轻量级的awaiter： awaiter 对象应该尽可能的小，避免复杂的计算。
- 利用编译器优化： 编译器可以对协程代码进行优化，例如内联函数和消除冗余操作。
- 选择合适的挂起策略： 根据实际情况选择
std::suspend_always或std::suspend_never。 - 避免深层协程调用链： 深层调用链可能导致栈溢出。
简要总结：协程的关键要素
协程的栈管理基于堆分配的协程帧，Continuation机制通过co_await和co_yield实现挂起和恢复，而promise_type则定义了协程的行为和生命周期。深入理解这些概念对于编写高效、可维护的协程代码至关重要。
更多IT精英技术系列讲座，到智猿学院