Em um nível abstrato, as co-rotinas dividem a ideia de ter um estado de execução da ideia de ter um thread de execução.
SIMD (instrução única, dados múltiplos) tem vários "threads de execução", mas apenas um estado de execução (funciona apenas em vários dados). Algoritmos indiscutivelmente paralelos são um pouco assim, em que você tem um "programa" rodando em dados diferentes.
Threading tem vários "threads de execução" e vários estados de execução. Você tem mais de um programa e mais de um thread de execução.
As corrotinas têm vários estados de execução, mas não possuem um thread de execução. Você tem um programa e o programa tem estado, mas não tem thread de execução.
O exemplo mais fácil de co-rotinas são geradores ou enumeráveis de outras linguagens.
Em pseudocódigo:
function Generator() {
for (i = 0 to 100)
produce i
}
O Generatoré chamado e, na primeira vez, ele retorna 0. Seu estado é lembrado (o quanto o estado varia com a implementação de co-rotinas) e, da próxima vez que você chamá-lo, ele continuará de onde parou. Portanto, ele retorna 1 na próxima vez. Em seguida, 2.
Finalmente, ele atinge o final do loop e sai do final da função; a co-rotina está concluída. (O que acontece aqui varia de acordo com a linguagem da qual estamos falando; em python, isso gera uma exceção).
As corrotinas trazem esse recurso para C ++.
Existem dois tipos de corrotinas; empilhados e sem pilha.
Uma co-rotina sem pilha armazena apenas variáveis locais em seu estado e seu local de execução.
Uma co-rotina empilhável armazena uma pilha inteira (como um thread).
As co-rotinas sem pilha podem ser extremamente leves. A última proposta que li envolvia basicamente reescrever sua função em algo um pouco como lambda; todas as variáveis locais vão para o estado de um objeto, e rótulos são usados para pular de / para o local onde a co-rotina "produz" resultados intermediários.
O processo de produção de um valor é chamado de "rendimento", pois as co-rotinas são quase como multithreading cooperativo; você está devolvendo o ponto de execução ao chamador.
Boost tem uma implementação de corrotinas empilháveis; ele permite que você chame uma função para produzir para você. Corrotinas empilháveis são mais poderosas, mas também mais caras.
As co-rotinas são mais do que um simples gerador. Você pode esperar uma co-rotina em uma co-rotina, o que permite compor co-rotinas de uma maneira útil.
Corrotinas, como if, loops e chamadas de função, são outro tipo de "goto estruturado" que permite expressar certos padrões úteis (como máquinas de estado) de uma maneira mais natural.
A implementação específica de corrotinas em C ++ é um pouco interessante.
Em seu nível mais básico, ele adiciona algumas palavras-chave ao C ++:, co_return co_await co_yieldjunto com alguns tipos de biblioteca que funcionam com elas.
Uma função se torna uma co-rotina por ter uma delas em seu corpo. Portanto, de acordo com sua declaração, eles são indistinguíveis de funções.
Quando uma dessas três palavras-chave é usada em um corpo de função, ocorre algum exame obrigatório padrão do tipo de retorno e dos argumentos e a função é transformada em uma co-rotina. Esse exame informa ao compilador onde armazenar o estado da função quando a função está suspensa.
A co-rotina mais simples é um gerador:
generator<int> get_integers( int start=0, int step=1 ) {
for (int current=start; true; current+= step)
co_yield current;
}
co_yieldsuspende a execução das funções, armazena esse estado em generator<int>e retorna o valor de currentpor meio de generator<int>.
Você pode fazer um loop sobre os inteiros retornados.
co_awaitentretanto, permite emendar uma co-rotina em outra. Se você está em uma co-rotina e precisa dos resultados de uma coisa esperada (geralmente uma co-rotina) antes de progredir, você está co_awaitnela. Se eles estiverem prontos, você prossegue imediatamente; caso contrário, você suspende até que o aguardado que você está esperando esteja pronto.
std::future<std::expected<std::string>> load_data( std::string resource )
{
auto handle = co_await open_resouce(resource);
while( auto line = co_await read_line(handle)) {
if (std::optional<std::string> r = parse_data_from_line( line ))
co_return *r;
}
co_return std::unexpected( resource_lacks_data(resource) );
}
load_dataé uma co-rotina que gera um std::futurequando o recurso nomeado é aberto e conseguimos analisar até o ponto onde encontramos os dados solicitados.
open_resourcee read_lines são provavelmente corrotinas assíncronas que abrem um arquivo e leem linhas dele. O co_awaitconecta o estado de suspensão e pronto de load_dataao seu progresso.
As co-rotinas C ++ são muito mais flexíveis do que isso, pois foram implementadas como um conjunto mínimo de recursos de linguagem além dos tipos de espaço do usuário. Os tipos de espaço do usuário definem efetivamente o que co_return co_awaite o co_yield significado - tenho visto pessoas usá-los para implementar expressões opcionais monádicas, de modo que um co_awaitopcional vazio propaga automaticamente o estado vazio para o opcional externo:
modified_optional<int> add( modified_optional<int> a, modified_optional<int> b ) {
return (co_await a) + (co_await b);
}
ao invés de
std::optional<int> add( std::optional<int> a, std::optional<int> b ) {
if (!a) return std::nullopt;
if (!b) return std::nullopt;
return *a + *b;
}
