En un nivel abstracto, Coroutines separó la idea de tener un estado de ejecución de la idea de tener un hilo de ejecución.
SIMD (instrucción única de múltiples datos) tiene múltiples "subprocesos de ejecución" pero solo un estado de ejecución (solo funciona con múltiples datos). Podría decirse que los algoritmos paralelos son un poco así, en el sentido de que tiene un "programa" que se ejecuta en diferentes datos.
El subproceso tiene varios "subprocesos de ejecución" y varios estados de ejecución. Tiene más de un programa y más de un hilo de ejecución.
Coroutines tiene varios estados de ejecución, pero no posee un hilo de ejecución. Tiene un programa y el programa tiene estado, pero no tiene hilo de ejecución.
El ejemplo más sencillo de corrutinas son los generadores o enumerables de otros lenguajes.
En pseudocódigo:
function Generator() {
for (i = 0 to 100)
produce i
}
Se Generatorllama y la primera vez que se llama vuelve 0. Se recuerda su estado (cuánto varía el estado con la implementación de las corrutinas) y la próxima vez que lo llame continúa donde lo dejó. Entonces devuelve 1 la próxima vez. Entonces 2.
Finalmente llega al final del ciclo y cae al final de la función; la corrutina está terminada. (Lo que sucede aquí varía según el lenguaje del que estamos hablando; en Python, arroja una excepción).
Las corrutinas llevan esta capacidad a C ++.
Hay dos tipos de corrutinas; apilables y sin apilar.
Una corrutina sin pila solo almacena variables locales en su estado y ubicación de ejecución.
Una corrutina apilada almacena una pila completa (como un hilo).
Las corrutinas sin apilamiento pueden ser extremadamente ligeras. La última propuesta que leí involucraba básicamente reescribir su función en algo un poco como una lambda; todas las variables locales pasan al estado de un objeto, y las etiquetas se utilizan para saltar hacia / desde la ubicación donde la corrutina "produce" resultados intermedios.
El proceso de producir un valor se llama "rendimiento", ya que las corrutinas son un poco como multiproceso cooperativo; está cediendo el punto de ejecución a la persona que llama.
Boost tiene una implementación de corrutinas apiladas; le permite llamar a una función para ceder por usted. Las corrutinas apiladas son más potentes, pero también más caras.
Las corrutinas son más que un simple generador. Puede esperar una corrutina en una corrutina, lo que le permite componer corrutinas de una manera útil.
Las corrutinas, como if, bucles y llamadas a funciones, son otro tipo de "goto estructurado" que le permite expresar ciertos patrones útiles (como máquinas de estado) de una manera más natural.
La implementación específica de Coroutines en C ++ es un poco interesante.
En su nivel más básico, agrega algunas palabras clave a C ++:, co_return co_await co_yieldjunto con algunos tipos de bibliotecas que funcionan con ellas.
Una función se convierte en una corrutina al tener una de esas en su cuerpo. Entonces, de su declaración, son indistinguibles de las funciones.
Cuando se utiliza una de esas tres palabras clave en el cuerpo de una función, se produce un examen obligatorio estándar del tipo de retorno y los argumentos y la función se transforma en una corrutina. Este examen le dice al compilador dónde almacenar el estado de la función cuando la función está suspendida.
La corrutina más simple es un generador:
generator<int> get_integers( int start=0, int step=1 ) {
for (int current=start; true; current+= step)
co_yield current;
}
co_yieldsuspende la ejecución de funciones, almacena ese estado en generator<int>, luego devuelve el valor de a currenttravés de generator<int>.
Puede recorrer los enteros devueltos.
co_awaitmientras tanto, le permite unir una corrutina con otra. Si está en una corrutina y necesita los resultados de algo que se espera (a menudo una corrutina) antes de progresar, hágalo co_await. Si están listos, proceda de inmediato; si no, suspendes hasta que esté listo el awaitable que estás esperando.
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_dataes una corrutina que genera un std::futurecuando se abre el recurso nombrado y logramos analizar hasta el punto donde encontramos los datos solicitados.
open_resourcey read_lines son probablemente corrutinas asincrónicas que abren un archivo y leen líneas de él. El co_awaitconecta el estado de suspensión y listo de load_datacon su progreso.
Las corrutinas de C ++ son mucho más flexibles que esto, ya que se implementaron como un conjunto mínimo de características de lenguaje además de los tipos de espacio de usuario. Los tipos de espacio de usuario definen efectivamente qué co_return co_awaity co_yield significan : he visto a personas usarlo para implementar expresiones opcionales monádicas, de modo que un co_awaiten un opcional vacío automáticamente propaga el estado vacío al opcional externo:
modified_optional<int> add( modified_optional<int> a, modified_optional<int> b ) {
return (co_await a) + (co_await b);
}
en vez 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;
}
