Más acerca de Coroutines en C ++

¿Qué son las corutinas?

• Corutinas apiladas
• Pila de corutinas
• Corrientes verdes
• Fibras
• Gorutins

void foo(){
     return; //     
}	
foo(); //   / 

def generate_nums():
     num = 0
     while True:
          yield num
          num = num + 1	

nums = generate_nums()
	
for x in nums:
     print(x)
	
     if x > 9:
          break

Coroutines como una biblioteca

Pila de corutinas

• Tienen su propia pila,
• La vida útil de las fibras no depende del código que las llama (generalmente tienen un planificador definido por el usuario),
• Las fibras se pueden separar de un hilo y unir a otro,
• Planificación cooperativa (la fibra debe decidir cambiar a otra fibra / programador),
• No se puede trabajar simultáneamente en el mismo hilo.

• El usuario debe cambiar el contexto de las fibras y no el sistema operativo (además, el sistema operativo puede liberar la fibra y liberar el hilo en el que funciona).
• No hay una carrera real de datos entre las dos fibras, ya que en un momento dado solo una de ellas puede estar activa,
• El diseñador de fibra debe poder elegir el lugar y la hora correctos, dónde y cuándo es apropiado devolver la potencia informática a un posible programador o llamante.
• Las operaciones de entrada / salida en la fibra deben ser asíncronas, para que otras fibras puedan realizar sus tareas sin bloquearse entre sí.

1. Una llamada de función regular dentro de un hilo. La memoria se asigna en la pila.
2. . . , . . , .
3. .
4. . .
5. .
6. .
7. . , , , .
8. .
9. .
10. – , .
11. , .
12. . .
13. . : , . , ( ) .
14. , .
15. .
16. . . . , .
17. .
18. , , .

#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
	
#include <boost/intrusive_ptr.hpp>
	
#include <boost/fiber/all.hpp>
	
inline
void fn( std::string const& str, int n) {
     for ( int i = 0; i < n; ++i) {
          std::cout << i << ": " << str << std::endl;
               boost::this_fiber::yield();
     }
}
	
int main() {
     try {
          boost::fibers::fiber f1( fn, "abc", 5);
          std::cerr << "f1 : " << f1.get_id() << std::endl;
          f1.join();
          std::cout << "done." << std::endl;
	
          return EXIT_SUCCESS;
     } catch ( std::exception const& e) {
          std::cerr << "exception: " << e.what() << std::endl;
     } catch (...) {
          std::cerr << "unhandled exception" << std::endl;
     }
     return EXIT_FAILURE;
}

Corutinas apiladas

• Corutin está estrechamente relacionada con su interlocutor: cuando se llama a una rutina, la ejecución se transfiere a ella, y el resultado de la rutina se transfiere nuevamente a la persona que llama.
• La vida útil de una pila de corutina es igual a la vida de su pila. La vida útil de una corutina sin pila es igual a la vida de su objeto.

1. Una llamada a función regular cuyo marco está almacenado en la pila
2. La función crea una corutina . Es decir, asigna un marco de activación para él en algún lugar del montón.
3. Llamada de función normal.
4. Llama a Corutin . El cuerpo de Corutin se destaca en una pila regular. El programa se ejecuta de la misma manera que en el caso de una función regular.
5. Una llamada de función regular desde la rutina. Una vez más, todo sigue sucediendo en la pila [Nota: no puede pausar la rutina desde este punto, ya que esta no es la función más importante en la rutina]
6. [: .]
7. – , , .
9. – , + .
10. 5.
11. 6.
12. . .

Uso práctico de la corutina.

• generadores
• código de entrada / salida asíncrono
• computación perezosa
• aplicaciones conducidas por eventos

Resumen

• por qué en C ++ necesitas implementar corutinas como una característica de lenguaje dedicada
• ¿Cuál es la diferencia entre corutinas apiladas y apiladas?
• por qué se necesitan corutinas