Auf einer abstrakten Ebene trennte Coroutines die Idee eines Ausführungszustands von der Idee eines Ausführungsthreads.
SIMD (Single Instruction Multiple Data) hat mehrere "Ausführungsthreads", aber nur einen Ausführungsstatus (es funktioniert nur mit mehreren Daten). Vermutlich sind parallele Algorithmen insofern ein bisschen so, als Sie ein "Programm" mit unterschiedlichen Daten ausführen lassen.
Threading hat mehrere "Ausführungsthreads" und mehrere Ausführungszustände. Sie haben mehr als ein Programm und mehr als einen Ausführungsthread.
Coroutines hat mehrere Ausführungszustände, besitzt jedoch keinen Ausführungsthread. Sie haben ein Programm und das Programm hat den Status, aber keinen Ausführungsthread.
Das einfachste Beispiel für Coroutinen sind Generatoren oder Aufzählungen aus anderen Sprachen.
Im Pseudocode:
function Generator() {
for (i = 0 to 100)
produce i
}
Das Generator wird aufgerufen und beim ersten Aufruf wird es zurückgegeben0 . Der Status wird gespeichert (wie stark der Status mit der Implementierung von Coroutinen variiert), und wenn Sie ihn das nächste Mal aufrufen, wird er dort fortgesetzt, wo er aufgehört hat. So wird beim nächsten Mal 1 zurückgegeben. Dann 2.
Schließlich erreicht es das Ende der Schleife und fällt vom Ende der Funktion ab; Die Coroutine ist fertig. (Was hier passiert, hängt von der Sprache ab, über die wir sprechen. In Python wird eine Ausnahme ausgelöst.)
Coroutinen bringen diese Funktion in C ++.
Es gibt zwei Arten von Coroutinen; stapelbar und stapellos.
Eine stapellose Coroutine speichert nur lokale Variablen in ihrem Status und ihrem Ausführungsort.
Eine stapelbare Coroutine speichert einen gesamten Stapel (wie einen Thread).
Stapellose Coroutinen können extrem leicht sein. Der letzte Vorschlag, den ich gelesen habe, bestand darin, Ihre Funktion in etwas wie ein Lambda umzuschreiben. Alle lokalen Variablen werden in den Status eines Objekts versetzt, und Beschriftungen werden verwendet, um zu / von der Stelle zu springen, an der die Coroutine Zwischenergebnisse "erzeugt".
Der Prozess der Wertgenerierung wird als "Ertrag" bezeichnet, da Coroutinen ein bisschen wie kooperatives Multithreading sind. Sie geben den Ausführungspunkt an den Anrufer zurück.
Boost hat eine Implementierung von stapelbaren Coroutinen; Sie können eine Funktion aufrufen, die für Sie nachgibt. Stapelbare Coroutinen sind leistungsfähiger, aber auch teurer.
Coroutinen sind mehr als ein einfacher Generator. Sie können eine Coroutine in einer Coroutine abwarten, mit der Sie Coroutinen auf nützliche Weise zusammenstellen können.
Coroutinen wie if, Schleifen und Funktionsaufrufe sind eine andere Art von "strukturiertem goto", mit dem Sie bestimmte nützliche Muster (wie Zustandsmaschinen) auf natürlichere Weise ausdrücken können.
Die spezifische Implementierung von Coroutines in C ++ ist etwas interessant.
Auf der einfachsten Ebene werden C ++: einige Schlüsselwörter hinzugefügt co_return co_await co_yield, zusammen mit einigen Bibliothekstypen, die mit ihnen arbeiten.
Eine Funktion wird zu einer Coroutine, indem sie eine davon in ihrem Körper hat. Von ihrer Deklaration sind sie also nicht von Funktionen zu unterscheiden.
Wenn eines dieser drei Schlüsselwörter in einem Funktionskörper verwendet wird, erfolgt eine standardmäßige Prüfung des Rückgabetyps und der Argumente, und die Funktion wird in eine Coroutine umgewandelt. Diese Prüfung teilt dem Compiler mit, wo der Funktionsstatus gespeichert werden soll, wenn die Funktion angehalten wird.
Die einfachste Coroutine ist ein Generator:
generator<int> get_integers( int start=0, int step=1 ) {
for (int current=start; true; current+= step)
co_yield current;
}
co_yieldUnterbricht die Funktionsausführung, speichert diesen Status in der generator<int>und gibt dann den Wert von currentdurch zurück generator<int>.
Sie können die zurückgegebenen Ganzzahlen durchlaufen.
co_awaitIn der Zwischenzeit können Sie eine Coroutine auf eine andere spleißen. Wenn Sie sich in einer Coroutine befinden und die Ergebnisse einer erwarteten Sache (häufig einer Coroutine) benötigen, bevor Sie fortfahren, können Sie co_awaitdiese durchführen. Wenn sie bereit sind, fahren Sie sofort fort. Wenn nicht, setzen Sie aus, bis die Wartezeit, auf die Sie warten, bereit ist.
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_dataist eine Coroutine, die std::futurebeim Öffnen der genannten Ressource eine generiert und es uns gelingt, bis zu dem Punkt zu analysieren, an dem wir die angeforderten Daten gefunden haben.
open_resourceund read_lines sind wahrscheinlich asynchrone Coroutinen, die eine Datei öffnen und Zeilen daraus lesen. Das co_awaitverbindet den Suspendierungs- und Bereitschaftszustand load_datamit ihrem Fortschritt.
C ++ - Coroutinen sind viel flexibler als diese, da sie als minimaler Satz von Sprachfunktionen zusätzlich zu den User-Space-Typen implementiert wurden. Die User-Space-Typen definieren effektiv, was co_return co_awaitund was co_yield bedeutet. Ich habe gesehen, dass Leute damit monadische optionale Ausdrücke implementieren, sodass co_awaitein leeres optionales automatisch den leeren Status auf das äußere optionale überträgt:
modified_optional<int> add( modified_optional<int> a, modified_optional<int> b ) {
return (co_await a) + (co_await b);
}
anstatt
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;
}
