Na poziomie abstrakcyjnym, Coroutines oddzieliły ideę posiadania stanu wykonania od idei posiadania wątku wykonania.
SIMD (pojedyncza instrukcja wiele danych) ma wiele „wątków wykonania”, ale tylko jeden stan wykonania (działa tylko na wielu danych). Prawdopodobnie algorytmy równoległe są trochę podobne do tego, że jeden „program” działa na różnych danych.
Wątkowanie ma wiele „wątków wykonywania” i wiele stanów wykonywania. Masz więcej niż jeden program i więcej niż jeden wątek wykonania.
Coroutines ma wiele stanów wykonania, ale nie jest właścicielem wątku wykonania. Masz program, który ma stan, ale nie ma wątku wykonywania.
Najłatwiejszym przykładem coroutines są generatory lub wyliczenia z innych języków.
W pseudokodzie:
function Generator() {
for (i = 0 to 100)
produce i
}
GeneratorNazywa, a po raz pierwszy nazywa go zwraca 0. Jego stan jest zapamiętywany (jak bardzo zmienia się stan w zależności od implementacji programów) i następnym razem, gdy go nazwiesz, będzie kontynuowany od miejsca, w którym został przerwany. Więc następnym razem zwraca 1. Następnie 2.
W końcu dociera do końca pętli i spada z końca funkcji; program jest zakończony. (To, co się tutaj dzieje, różni się w zależności od języka, o którym mówimy; w Pythonie zgłasza wyjątek).
Korekty wprowadzają tę możliwość do C ++.
Istnieją dwa rodzaje programów; stos i bez stosu.
Program bez stosu przechowuje tylko zmienne lokalne w swoim stanie i lokalizacji wykonania.
Sterty coroutine przechowuje cały stos (jak nić).
Korekty bez stosu mogą być niezwykle lekkie. Ostatnia propozycja, którą przeczytałem, polegała w zasadzie na przepisaniu twojej funkcji na coś podobnego do lambdy; wszystkie zmienne lokalne przechodzą do stanu obiektu, a etykiety służą do przeskakiwania do / z lokalizacji, w której program „generuje” wyniki pośrednie.
Proces tworzenia wartości nazywany jest „wydajnością”, ponieważ procedury są nieco podobne do wielowątkowości kooperatywnej; oddajesz punkt wykonania z powrotem dzwoniącemu.
Boost ma implementację stosowych procedur; pozwala wywołać funkcję, która da ci wynik. Układane w stosy programy są mocniejsze, ale także droższe.
Korekty to coś więcej niż prosty generator. Możesz poczekać na coroutine w coroutine, co pozwoli ci komponować coroutines w użyteczny sposób.
Korekty, takie jak if, pętle i wywołania funkcji, to inny rodzaj „strukturalnego goto”, który pozwala wyrazić pewne użyteczne wzorce (takie jak maszyny stanu) w bardziej naturalny sposób.
Specyficzna implementacja Coroutines w C ++ jest nieco interesująca.
Na najbardziej podstawowym poziomie dodaje kilka słów kluczowych do C ++: co_return co_await co_yieldwraz z pewnymi typami bibliotek, które z nimi współpracują.
Funkcja staje się rutyną, mając jedną z tych funkcji w swoim ciele. Tak więc z ich deklaracji nie da się ich odróżnić od funkcji.
Kiedy jedno z tych trzech słów kluczowych jest używane w treści funkcji, zachodzi pewne standardowe nakazane badanie typu zwracanego i argumentów, a funkcja jest przekształcana w procedurę. To badanie mówi kompilatorowi, gdzie przechowywać stan funkcji, gdy funkcja jest zawieszona.
Najprostszym programem jest generator:
generator<int> get_integers( int start=0, int step=1 ) {
for (int current=start; true; current+= step)
co_yield current;
}
co_yieldzawiesza wykonywanie funkcji, zapisuje ten stan w generator<int>, a następnie zwraca wartość currentpoprzez generator<int>.
Możesz zapętlić zwrócone liczby całkowite.
co_awaitw międzyczasie pozwala łączyć jeden program z drugim. Jeśli jesteś w jednym programie i potrzebujesz wyników czegoś nieoczekiwanego (często programu), zanim przejdziesz co_awaitdalej. Jeśli są gotowe, kontynuujesz natychmiast; jeśli nie, zawieszasz, aż to, na co czekasz, będzie gotowe.
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_datajest programem, który generuje a, std::futuregdy nazwany zasób jest otwierany i udaje nam się przeanalizować do punktu, w którym znaleźliśmy żądane dane.
open_resourcea read_lines to prawdopodobnie procedury asynchroniczne, które otwierają plik i odczytują z niego wiersze. Stan co_awaitwstrzymania i gotowości łączy z load_dataich postępem.
Korekty języka C ++ są znacznie bardziej elastyczne, ponieważ zostały zaimplementowane jako minimalny zestaw funkcji językowych na szczycie typów przestrzeni użytkownika. Typy przestrzeni użytkownika skutecznie definiują, co co_return co_awaiti co_yield znaczą - widziałem, jak ludzie używają go do implementacji monadycznych wyrażeń opcjonalnych, tak że a co_awaitna pustym opcjonalnym automatycznie propaguje stan pusty do zewnętrznego opcjonalnego:
modified_optional<int> add( modified_optional<int> a, modified_optional<int> b ) {
return (co_await a) + (co_await b);
}
zamiast
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;
}
