Mais sobre Coroutines em C ++

O que são corotinas?

• Corotinas sem pilha
• Corotinas de pilha
• Fluxos 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

Corotinas como uma biblioteca

Corotinas de pilha

• Eles têm sua própria pilha,
• O tempo de vida das fibras não depende do código que as chama (geralmente elas possuem um agendador definido pelo usuário),
• As fibras podem ser destacadas de uma linha e conectadas a outra,
• Planejamento cooperativo (a fibra deve decidir mudar para outra fibra / agendador),
• Não é possível trabalhar simultaneamente no mesmo segmento.

• a alternância do contexto das fibras deve ser realizada pelo usuário das fibras, e não o SO (além disso, o SO pode liberar a fibra, liberando o fio no qual trabalha),
• Não há dados reais entre as duas fibras, pois a qualquer momento, apenas uma delas pode estar ativa,
• O projetista de fibra deve poder escolher o local e a hora certos, onde e quando é apropriado devolver a energia da computação a um possível agendador ou chamador.
• As operações de entrada / saída na fibra devem ser assíncronas, para que outras fibras possam executar suas tarefas sem bloquear uma à outra.

1. Uma chamada de função regular dentro de um encadeamento. A memória está alocada na pilha.
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;
}

Corotinas sem pilha

• Corutin está intimamente ligada ao seu interlocutor: quando é chamada uma corotina, a execução é transferida para ela e o resultado da corotina é transferido de volta ao interlocutor.
• A vida útil de uma pilha corutin é igual à vida útil de sua pilha. A vida útil de uma rotina sem pilha é igual à vida do seu objeto.

1. Uma chamada de função regular cujo quadro está armazenado na pilha
2. A função cria uma corotina . Ou seja, ele aloca um quadro de ativação para ele em algum lugar na pilha.
3. Chamada de função normal.
4. Ligue para Corutin . O corpo de Corutin se destaca em uma pilha regular. O programa é executado da mesma maneira que no caso de uma função regular.
5. Uma chamada de função regular da corotina. Novamente, tudo ainda acontece na pilha [Nota: você não pode pausar a corotina a partir deste ponto, pois essa não é a função mais alta na corotina]
6. [: .]
7. – , , .
9. – , + .
10. 5.
11. 6.
12. . .

Uso prático de corutin

• geradores
• código de entrada / saída assíncrono
• computação preguiçosa
• aplicativos orientados a eventos

Sumário

• por que em C ++ você precisa implementar corotinas como um recurso de linguagem dedicado
• Qual é a diferença entre corotinas empilhadas e sem pilha?
• por que as corotinas são necessárias