Prédiction des branchements et boucles intensives
Aider le CPU à prédire les branchements et écrire des boucles que le compilateur peut optimiser
Prédiction des branchements et boucles intensives est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.
Le prédicteur de branchement
Les CPU modernes prédisent l’instruction suivante avant que la précédente ne soit terminée. Lorsque la prédiction est incorrecte, la chaîne de traitement s’arrête — ce qui coûte 10 à 20 cycles.
Branchements prévisibles
Les branchements qui prennent presque toujours la même direction (ou suivent un schéma clair) sont bien prédits. Les branchements aléatoires sont catastrophiques.
Les données triées aident
Parcourir des données triées avec une condition est souvent plus rapide que parcourir des données non triées : le prédicteur apprend le schéma.
// Often much faster on sorted data
std::sort(v.begin(), v.end());
int sum = 0;
for (int x : v) {
if (x > 128) sum += x;
}Code sans branchement
Remplacez les branchements par des opérations arithmétiques lorsque c’est possible. Le CPU évalue les deux chemins et choisit sans effectuer de branchement.
// Branchy
int max(int a, int b) { return (a > b) ? a : b; }
// Branchless (often equivalent in machine code)
int max(int a, int b) { return a + (b - a) * (b > a); }std::max, le meilleur choix
Les compilateurs modernes produisent souvent automatiquement du code sans branchement. Écrivez simplement un code clair et laissez l’optimiseur travailler — mais examinez le désassemblage dans les chemins critiques.
Indications likely et unlikely
C++20 a ajouté [[likely]] et [[unlikely]] pour fournir une indication au compilateur.
if (error_condition) [[unlikely]] {
handle_error();
}Déroulage des boucles
Effectuer davantage de travail par itération réduit la fréquence des branchements. Les compilateurs modernes déroulent les boucles d’eux-mêmes ; n’utilisez #pragma unroll que si les mesures montrent que cela aide.
Éviter les charges mixtes dans les boucles
Une boucle comportant deux cas qui s’alternent aléatoirement déjoue la prédiction. Séparez-la en deux boucles (une par cas) lorsque c’est possible.
// Slow: random switching
for (auto& x : v) {
if (x.type == A) process_A(x);
else process_B(x);
}
// Faster: partition first
std::partition(v.begin(), v.end(), [](auto& x) { return x.type == A; });
for (size_t i = 0; i < boundary; ++i) process_A(v[i]);
for (size_t i = boundary; i < v.size(); ++i) process_B(v[i]);Mettre en ligne les fonctions critiques
Le surcoût d’un appel de fonction peut être comparable au corps de la fonction dans les boucles critiques. Les indications inline aident ; __attribute__((always_inline)) (GCC/Clang) est plus contraignant.
Ne faites pas confiance à votre intuition
Les compilateurs et les CPU sont très intelligents. Mesurez avant d’optimiser. La version « évidente » sans branchement peut être plus lente que celle avec branchements une fois le prédicteur entraîné.
SIMD pour les boucles larges
La vectorisation automatique transforme une boucle en instructions SIMD lorsque c’est possible. Utilisez un code propre, des types simples et évitez les dépendances de données entre les itérations.
Optimisation guidée par le profil (PGO)
Compilez, exécutez, recueillez les données de profilage, puis recompilez avec ces indications. Les compilateurs utilisent ces données pour mieux prédire quelles branches sont critiques.
Vérification rapide
Pourquoi trier les données avant une boucle de filtrage peut-il parfois accélérer l’exécution ?
Récapitulatif
Les erreurs de prédiction des branchements coûtent des cycles. Conservez des branchements prévisibles (les données triées aident), utilisez les indications likely et unlikely, partitionnez les charges pour garder des boucles uniformes et faites confiance au compilateur pour optimiser, sauf si le profilage prouve le contraire.
Apprends C++ avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 51
- Leçons
- 203
Questions Fréquemment Posées
La leçon « Prédiction des branchements et boucles intensives » est-elle gratuite ?
Oui — le texte complet de « Prédiction des branchements et boucles intensives » 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 « Prédiction des branchements et boucles intensives » ?
Aider le CPU à prédire les branchements et écrire des boucles que le compilateur peut optimiser 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 2 sur 4.
Combien de temps prend la leçon « Prédiction des branchements et boucles intensives » ?
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
- Organisations des données adaptées au cache
- Prédiction des branchements et boucles intensives
- Profilage avec perf, vtune et les sanitizers
- Micro-évaluation des performances avec Google Benchmark