En savoir plus sur Coroutines en C ++

Que sont les coroutines?

• Coroutines sans pile
• Empiler les coroutines
• Ruisseaux verts
• Les fibres
• 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 comme bibliothèque

Empiler les coroutines

• Ils ont leur propre pile,
• La durée de vie des fibres ne dépend pas du code qui les appelle (généralement elles ont un ordonnanceur défini par l'utilisateur),
• Les fibres peuvent être détachées d'un fil et attachées à un autre,
• Planification coopérative (la fibre doit décider de passer à une autre fibre / ordonnanceur),
• Ne peut pas fonctionner simultanément dans le même thread.

• le changement de contexte des fibres doit être effectué par l'utilisateur des fibres, et non par l'OS (en outre, l'OS peut libérer la fibre, libérant le fil dans lequel il fonctionne),
• Il n'y a pas de véritable course aux données entre les deux fibres, car à tout moment une seule d'entre elles peut être active,
• Le concepteur de fibres doit être en mesure de choisir le bon endroit et l'heure, où et quand il convient de restituer la puissance de calcul à un ordonnanceur ou à un appelant éventuel.
• Les opérations d'entrée / sortie dans la fibre doivent être asynchrones, afin que d'autres fibres puissent effectuer leurs tâches sans se bloquer.

1. Un appel de fonction régulier à l'intérieur d'un thread. La mémoire est allouée sur la pile.
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;
}

Coroutines sans pile

• Corutin est étroitement liée à son appelant: lorsqu'une coroutine est appelée, l'exécution lui est transférée et le résultat de la coroutine est retransféré à l'appelant.
• La durée de vie d'une pile de corutine est égale à la durée de vie de sa pile. La durée de vie d'une coroutine sans pile est égale à la durée de vie de son objet.

1. Un appel de fonction régulier dont la trame est stockée sur la pile
2. La fonction crée une coroutine . Autrement dit, il lui alloue une trame d'activation quelque part sur le tas.
3. Appel de fonction normale.
4. Appelez Corutin . Le corps de Corutin se démarque dans une pile régulière. Le programme est exécuté de la même manière que dans le cas d'une fonction régulière.
5. Un appel de fonction régulier de coroutine. Encore une fois, tout se passe toujours sur la pile [Remarque: vous ne pouvez pas suspendre la coroutine à partir de ce point, car ce n'est pas la fonction la plus élevée de la coroutine]
6. [: .]
7. – , , .
9. – , + .
10. 5.
11. 6.
12. . .

Utilisation pratique de la corutine

• générateurs
• code d'entrée / sortie asynchrone
• informatique paresseuse
• applications pilotées par les événements

Sommaire

• pourquoi en C ++ vous devez implémenter des coroutines en tant que fonctionnalité de langage dédiée
• Quelle est la différence entre les coroutines empilées et sans pile?
• pourquoi les coroutines sont nécessaires