En quoi les coroutines empilées diffèrent-elles des coroutines empilées?

tout d'Abord, merci de prendre un coup d'oeil à CO2:)

Le Boost.Coroutine doc décrit bien l'avantage de la coroutine empilée:

stackfulness

par opposition à une coroutine sans empilement une corotine empilée peut être suspendu à l'intérieur d'un ensemble structure de pile. L'exécution reprend à exactement le même point dans le code où il a été suspendu avant. Avec un stackless coroutine, seule la routine de haut niveau peut être suspendue. Toute routine appelée par cette routine de haut niveau ne peut pas elle-même être suspendue. Ceci interdit de suspendre/reprendre les opérations dans les routines une bibliothèque polyvalente.

suite de première classe

une continuation de première classe peut être passée comme un argument, retourné par une fonction et stocké dans une structure de données à ê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 empilement et sémantique de première classe, une certaine exécution utile les flux de contrôle ne peuvent pas être pris en charge (par exemple les flux coopératifs). multitâche ou Checkpoint).

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 la coroutine empilée, vous pouvez:

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

mais avec la coroutine stackless, 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, la coroutine empilée est plus puissante que la coroutine empilée. Alors pourquoi voulons-nous de la corotine sans empilement? réponse courte: l'efficacité.

coroutine empilable a généralement besoin d'allouer une certaine quantité de mémoire pour accommoder sa pile d'exécution (doit être assez grande), et le commutateur de contexte est plus coûteux que le commutateur sans empilement, par exemple Boost.Coroutine prend 40 cycles alors que le CO2 ne prend que 7 cycles en moyenne sur ma machine, parce que la seule chose qu'une coroutine stackless doit restaurer est le compteur de programme.

cela dit, avec le support du langage, coroutine empilable peut probablement aussi profiter de la taille max calculée par le compilateur pour la pile aussi longtemps qu'il n'y a pas de récursion dans la coroutine, donc l'utilisation de la mémoire peut aussi être améliorée.

en parlant de coroutine stackless, gardez à l'esprit que cela ne signifie pas que il n'y a pas de pile runtime-stack du tout, cela signifie seulement qu'il utilise la même pile runtime que le côté hôte, donc vous pouvez aussi appeler des fonctions récursives, juste que toutes les récursions se produiront sur la pile runtime-stack de l'hôte. En revanche, avec la coroutine empilée, quand vous appelez fonctions récursives, les récursions se produiront sur la propre pile de la coroutine.

Pour répondre à ces questions:

• y a-t-il des limites à l'utilisation des variables de stockage automatique? (c'est à dire des variables "sur la pile")?

Non. C'est la limitation de L'émulation du CO2. Avec le soutien de langue, les variables de stockage automatique visible à la coroutine sera placé sur le stockage interne de la coroutine. Notez mon accent sur "visible à la coroutine", si la coroutine appelle une fonction qui utilise des variables de stockage automatiques en interne, alors ces variables seront placées sur la pile runtime-stack. Plus précisément, la coroutine stackless ne doit préserver que les variables / temporairesqui peuvent être utilisées après la reprise.

pour être clair, vous pouvez utiliser des variables de stockage automatique dans le corps coroutine de CO2 aussi bien:

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

tant que la définition ne précède pas tout await.

• y a-t-il des limites aux fonctions que je peux appeler à partir d'un coroutine stackless?

Non.

• s'il n'y a pas de sauvegarde du contexte stack pour une coroutine stackless, où puis-automatique les variables de stockage vont quand la coroutine est en cours d'exécution?

réponse ci-dessus, une coroutine stackless ne se soucie pas des variables de stockage automatiques utilisées dans les fonctions appelées, elles seront simplement placées sur la pile d'exécution normale.

si vous avez le moindre doute, vérifiez simplement le code source de CO2, il peut vous aider à comprendre la mécanique sous le capot ;)