Comment faire stackless coroutines diffèrent de stackful coroutines?

Tout d'abord, merci de prendre un coup d'oeil à CO2 🙂

Le Coup De Pouce.Coroutine doc décrit l'avantage de stackful coroutine bien:

stackfulness

Contrairement à une stackless coroutine un stackful coroutine
peut être suspendu à l'intérieur d'un ensemble structure de pile. L'exécution reprend à
exactement de la même point dans le code où il a été interrompu avant. Avec
un stackless coroutine, seule la routine de niveau supérieur peut être suspendu.
Toute routine appelée par la routine de niveau supérieur ne peut en suspendre l'exécution.
Cet interdit de fournir, de suspendre et de reprendre les opérations dans des routines dans
usage général de la bibliothèque.

de première classe continuation

De première classe d'une poursuite peut être passé comme
un argument, qui est retourné par une fonction et stockés dans une structure de données pour
être utilisé plus tard. Dans certaines implémentations (par exemple C# rendement), la
la poursuite ne peut pas être directement accessibles ou manipulé directement.

Sans stackfulness et de première classe sémantique, certains utiles, d'exécution
contrôle de flux ne peut pas être pris en charge (par exemple de la coopérative
le multitâche ou la vérification).

Ce que cela signifie pour vous? par exemple, imaginez que vous avez une fonction qui prend un visiteur:

template<class Visitor>
void f(Visitor& v);

Vous voulez le transformer en itérateur, avec stackful coroutine, vous pouvez:

asymmetric_coroutine<T>::pull_type pull_from([](asymmetric_coroutine<T>::push_type& yield)
{
    f(yield);
});

Mais avec stackless coroutine, il n'y a aucun moyen de le faire:

generator<T> pull_from()
{
    //yield can only be used here, cannot pass to f
    f(???);
}

En général, stackful coroutine est plus puissant que stackless coroutine.
Alors, pourquoi voulons-nous stackless coroutine? réponse courte: l'efficacité.

Stackful coroutine généralement besoin d'allouer une certaine quantité de mémoire pour accueillir son exécution-pile (il doit être assez grand), et le contexte-switch est plus cher par rapport à la stackless, par ex. le coup de pouce.Coroutine prend 40 cycles de CO2 prend seulement 7 cycles en moyenne sur ma machine, car la seule chose qu'un stackless coroutine besoins de la restauration est le compteur de programme.

Cela dit, avec le soutien de la langue, probablement stackful coroutine pouvez également prendre l'avantage de l'compilateur calculée max-taille de la pile tant qu'il n'y a pas de récursivité dans la coroutine, de sorte que l'utilisation de la mémoire peut également être améliorée.

Parlant de stackless coroutine, garder à l'esprit que cela ne signifie pas qu'il n'y a pas d'exécution de la pile à tous, cela signifie seulement qu'il utilise le même moteur d'exécution-pile de l'hôte, de sorte que vous pouvez appeler des fonctions récursives en tant que bien, juste que tous les récurrences qui va se passer sur l'hôte de l'exécution de la pile. En revanche, avec stackful coroutine, lorsque vous appelez une fonction récursive, les récurrences qui va se passer sur la coroutine est propre pile.

Pour répondre aux questions:

• Il y a des restrictions sur l'utilisation de stockage automatique des variables
  (c'est à dire les variables sur la pile")?

Pas. C'est l'émulation de la limitation des émissions de CO2. Avec le soutien de la langue, le stockage automatique des variables visible à la coroutine sera mis sur la coroutine de stockage interne. Remarque j'ai mis l'accent sur "visible à la coroutine", si la coroutine appelle une fonction qui utilise le stockage automatique des variables en interne, alors ces variables sera mis sur l'exécution de la pile. Plus précisément, stackless coroutine n'a qu'à préserver les variables/temporaires qui peuvent être utilisés après la reprise.

Pour être clair, vous pouvez utiliser le stockage automatique des variables de CO2 de la coroutine corps ainsi:

auto f() CO2_RET(co2::task<>, ())
{
    int a = 1; //not ok
    CO2_AWAIT(co2::suspend_always{});
    {
        int b = 2; //ok
        doSomething(b);
    }
    CO2_AWAIT(co2::suspend_always{});
    int c = 3; //ok
    doSomething(c);
} CO2_END

Aussi longtemps que la définition ne fait pas précéder toute await.

• Il y a des restrictions sur ce que les fonctions que j'pouvez appeler à partir d'un
  stackless coroutine?

Pas.

• Si il n'y a pas de sauvegarde de contexte de la pile pour un stackless coroutine,
  où puis-stockage automatique des variables d'aller quand la coroutine est
  en cours d'exécution?

Répondu ci-dessus, un stackless coroutine n'est pas pour le stockage automatique des variables utilisées dans les fonctions dites, ils vont juste être placé sur la normale à l'exécution de la pile.

Si vous avez le moindre doute, il suffit de cocher CO2 du code source, il peut vous aider à comprendre la mécanique sous le capot 😉