CKTIS / C++
Corrotinas
Uma corrotina pode suspender a execução e retomá-la mais tarde, preservando o estado de que necessita. As palavras-chave co_await, co_yield e co_return cooperam com um tipo promise e um handle de corrotina; não iniciam automaticamente uma thread ou um escalonador.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
co_await expression; co_yield expression; co_return [expression];Uma corrotina é uma função cujo corpo contém co_await, co_yield ou co_return. Quando suspende a execução, preserva o estado necessário para continuar. O controlo pode regressar a quem a chamou ou retomou, mas, se await_suspend() do awaiter devolver um handle para outra corrotina, o controlo passa diretamente para essa corrotina. Isto não implica execução paralela automática: uma corrotina, por si só, não cria uma thread nem um escalonador.
co_await utiliza o protocolo awaiter: await_ready() verifica se o resultado está pronto, await_suspend() trata da suspensão e await_resume() fornece o resultado. Nem todos os usos de co_await deixam efetivamente a corrotina suspensa. co_yield value aguarda o resultado de promise.yield_value(value) sem aplicar await_transform do objeto promise. Em contrapartida, ao escrever explicitamente co_await promise.yield_value(value), é utilizado await_transform se o tipo promise o disponibilizar. A substituição pode, portanto, alterar o comportamento ou provocar um erro de compilação. co_return termina o corpo da corrotina, em vez de passar um valor diretamente a quem a chamou.
O tipo promise, normalmente disponível como promise_type do tipo de retorno, controla, entre outras coisas, o objeto de resultado, a suspensão inicial e final, a conclusão e o tratamento de exceções. <coroutine> fornece std::coroutine_handle e std::suspend_always. Um handle não gere, por si só, o tempo de vida do estado: a responsabilidade pela sua destruição tem de ser explícita.
No exemplo, Task é um proprietário que não pode ser copiado nem movido. initial_suspend() adia a execução do corpo e final_suspend() conserva o estado para ser destruído pelo destrutor. O std::suspend_always utilizado no exemplo não transfere o controlo diretamente para outra corrotina. Duas retomas imprimem 1 e 2; a terceira não faz nada devido a done(). Retomar uma corrotina terminada ou não suspensa causa comportamento indefinido. Depois de destruído o estado da corrotina, tentar retomá-la através de um handle para esse estado também causa comportamento indefinido. Já repor esse handle atribuindo-lhe nullptr é uma operação bem definida. Os objetos referenciados têm de permanecer vivos durante tempo suficiente.
Esta entrada destina-se a C++23; a opção do compilador no repositório não atesta o suporte no ambiente de execução de produção. O documento fornecido é um rascunho de trabalho em evolução, não uma edição definitiva de C++23. O exemplo requer verificação local e chama deliberadamente std::terminate() se ocorrer uma exceção não tratada.
Exemplos
#include <coroutine>
#include <exception>
#include <iostream>
class Task {
public:
struct promise_type {
Task get_return_object() {
return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() noexcept { std::terminate(); }
};
using Handle = std::coroutine_handle<promise_type>;
explicit Task(Handle handle) noexcept : handle_(handle) {}
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
~Task() { handle_.destroy(); }
void resume() {
if (!handle_.done()) {
handle_.resume();
}
}
private:
Handle handle_;
};
Task steps() {
std::cout << "1\n";
co_await std::suspend_always{};
std::cout << "2\n";
co_return;
}
int main() {
auto task = steps();
task.resume();
task.resume();
task.resume();
}
Resultado
1 2
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.