A livello astratto, Coroutines ha separato l'idea di avere uno stato di esecuzione dall'idea di avere un filo di esecuzione.
SIMD (singola istruzione più dati) ha più "thread di esecuzione" ma solo uno stato di esecuzione (funziona solo su più dati). Probabilmente gli algoritmi paralleli sono un po 'così, in quanto hai un "programma" eseguito su dati diversi.
Il threading ha più "thread di esecuzione" e più stati di esecuzione. Hai più di un programma e più di un thread di esecuzione.
Coroutines ha più stati di esecuzione, ma non possiede un thread di esecuzione. Hai un programma e il programma ha uno stato, ma non ha thread di esecuzione.
L'esempio più semplice di coroutine sono generatori o enumerabili da altre lingue.
In pseudo codice:
function Generator() {
for (i = 0 to 100)
produce i
}
La Generatorsi chiama, e la prima volta che viene chiamato lo restituisce 0. Il suo stato viene ricordato (quanto lo stato varia con l'implementazione delle coroutine) e la volta successiva che lo chiami continua da dove era stato interrotto. Quindi restituisce 1 la volta successiva. Quindi 2.
Infine raggiunge la fine del ciclo e cade dalla fine della funzione; la coroutine è finita. (Quello che succede qui varia in base al linguaggio di cui stiamo parlando; in Python, genera un'eccezione).
Le coroutine portano questa capacità in C ++.
Esistono due tipi di coroutine; impilabile e impilabile.
Una coroutine stackless memorizza solo le variabili locali nel suo stato e nella sua posizione di esecuzione.
Una coroutine impilata memorizza un intero stack (come un thread).
Le coroutine impilabili possono essere estremamente leggere. L'ultima proposta che ho letto riguardava fondamentalmente la riscrittura della tua funzione in qualcosa di simile a un lambda; tutte le variabili locali entrano nello stato di un oggetto e le etichette vengono utilizzate per saltare alla / dalla posizione in cui la coroutine "produce" risultati intermedi.
Il processo di produzione di un valore è chiamato "rendimento", poiché le coroutine sono un po 'come il multithreading cooperativo; stai restituendo il punto di esecuzione al chiamante.
Boost ha un'implementazione di coroutine impilate; ti consente di chiamare una funzione da restituire. Le coroutine impilate sono più potenti, ma anche più costose.
C'è di più nelle coroutine di un semplice generatore. Puoi aspettare una coroutine in una coroutine, che ti consente di comporre coroutine in modo utile.
Le coroutine, come if, i loop e le chiamate di funzione, sono un altro tipo di "goto strutturato" che ti permette di esprimere certi pattern utili (come le macchine a stati) in modo più naturale.
L'implementazione specifica di Coroutines in C ++ è un po 'interessante.
Al suo livello più elementare, aggiunge alcune parole chiave a C ++:, co_return co_await co_yieldinsieme ad alcuni tipi di libreria che funzionano con loro.
Una funzione diventa una coroutine avendo una di quelle nel suo corpo. Quindi dalla loro dichiarazione sono indistinguibili dalle funzioni.
Quando una di queste tre parole chiave viene utilizzata nel corpo di una funzione, si verifica un esame obbligatorio standard del tipo e degli argomenti restituiti e la funzione viene trasformata in una coroutine. Questo esame indica al compilatore dove memorizzare lo stato della funzione quando la funzione è sospesa.
La coroutine più semplice è un generatore:
generator<int> get_integers( int start=0, int step=1 ) {
for (int current=start; true; current+= step)
co_yield current;
}
co_yieldsospende l'esecuzione delle funzioni, memorizza tale stato in generator<int>, quindi restituisce il valore di currenttramite generator<int>.
È possibile eseguire il ciclo sugli interi restituiti.
co_awaitnel frattempo ti permette di unire una coroutine all'altra. Se sei in una coroutine e hai bisogno dei risultati di una cosa attendibile (spesso una coroutine) prima di progredire, tu co_awaitsu di essa. Se sono pronti, procedi immediatamente; in caso contrario, sospendi fino a quando l'atteso che stai aspettando non è 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è una coroutine che genera un std::futurequando la risorsa nominata viene aperta e riusciamo ad analizzare fino al punto in cui abbiamo trovato i dati richiesti.
open_resourcee read_lines sono probabilmente coroutine asincrone che aprono un file e leggere le linee da esso. Il co_awaitcollega lo stato di sospensione e di pronto load_dataal loro progresso.
Le coroutine C ++ sono molto più flessibili di così, poiché sono state implementate come un set minimo di funzionalità del linguaggio in cima ai tipi di spazio utente. I tipi di spazio utente definiscono efficacemente cosa co_return co_awaite co_yield significano : ho visto persone usarlo per implementare espressioni opzionali monadiche in modo tale che un co_awaitsu un opzionale vuoto proponga automaticamente lo stato vuoto all'opzionale esterno:
modified_optional<int> add( modified_optional<int> a, modified_optional<int> b ) {
return (co_await a) + (co_await b);
}
invece di
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;
}
