Allocation de la trame d’une coroutine
Raisonner sur l’allocation et la durée de vie de la trame d’une coroutine
Allocation de la trame d’une coroutine est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
Où vit l’état
Les variables locales d’une coroutine persistent pendant les suspensions. Elles ne peuvent pas vivre sur la pile : la fonction retourne entre deux suspensions. Elles vivent plutôt dans un cadre de coroutine alloué sur le tas.
Ce que contient le cadre
Le cadre contient :
- Les paramètres de la coroutine
- L’objet promesse
- Les variables locales qui persistent pendant les suspensions
- Les pointeurs de fonction de reprise et de destruction
Coût de l’allocation sur le tas
Chaque appel de coroutine alloue un cadre. Les allocations ne sont pas gratuites — ce coût est important pour les coroutines à haute fréquence. Les compilateurs optimisants peuvent supprimer cette allocation lorsque la durée de vie est limitée — c’est ce qu’on appelle HALO (optimisation de la suppression des allocations sur le tas, avec eLision).
Quand HALO intervient
Le compilateur peut éviter l’allocation sur le tas lorsque :
- La durée de vie de la coroutine peut être prouvée comme étant entièrement contenue
- La mise en ligne prouve que le cadre tient sur la pile
- La taille du cadre est fixe au moment de la compilation
Allocateurs personnalisés
Vous pouvez fournir des allocateurs personnalisés à vos cadres de coroutine en surchargeant operator new à l’intérieur du type de promesse.
struct promise_type {
void* operator new(size_t size) {
return std::malloc(size);
}
void operator delete(void* ptr) {
std::free(ptr);
}
};Pools de cadres
Pour les systèmes asynchrones à haut débit, allouez les cadres depuis un pool afin d’éviter le surcoût de l’allocateur général. Chaque fil d’exécution ou type de tâche peut avoir son propre pool.
Taille du cadre
La taille du cadre dépend du plus grand ensemble de variables susceptibles d’être actives pendant un point de suspension. L’ajout de variables locales l’augmente.
Réduire la taille du cadre
Conseils :
- Restreignez strictement la portée des variables
- Évitez les grands tableaux locaux — utilisez explicitement le tas
- Déplacez les valeurs temporaires dans des fonctions auxiliaires distinctes qui ne sont pas des coroutines
Inspecter les cadres
Les compilateurs peuvent afficher la taille des cadres. Avec clang, utilisez -fcoro-aligned-allocation et examinez-la à l’aide des options de diagnostic. Le désassemblage révèle la disposition du cadre.
Durée de vie et nettoyage
Le cadre de coroutine est détruit lorsque final_suspend se termine (ou plus tôt s’il est explicitement détruit). Les membres RAII sont correctement détruits.
Sécurité mémoire
Une poignée de coroutine est un pointeur brut. Conserver une poignée après la destruction de la coroutine constitue un comportement indéfini. Les types de bibliothèque encapsulent les poignées dans RAII pour éviter cela.
Quand s’en préoccuper
La plupart des applications n’ont jamais besoin de réfléchir à l’allocation des cadres. Préoccupez-vous-en uniquement si vous avez des millions de coroutines ou des contraintes de performances extrêmes. Commencez par profiler.
Vérification rapide
Pourquoi un cadre de coroutine vit-il généralement sur le tas ?
Récapitulatif
Les coroutines allouent un cadre sur le tas pour préserver leur état pendant les suspensions. Les compilateurs peuvent supprimer cette allocation (HALO) lorsque c’est possible. Les allocateurs personnalisés et les pools de cadres sont utiles dans les systèmes à haut débit — la plupart des programmes n’ont pas besoin de s’en préoccuper.
Questions Fréquemment Posées
La leçon « Allocation de la trame d’une coroutine » est-elle gratuite ?
Oui — le texte complet de « Allocation de la trame d’une coroutine » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Allocation de la trame d’une coroutine » ?
Raisonner sur l’allocation et la durée de vie de la trame d’une coroutine Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Allocation de la trame d’une coroutine » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Concepts des coroutines : co_await, co_yield, co_return
- Implémenter un générateur simple
- Tâches asynchrones et types awaiter
- Allocation de la trame d’une coroutine