Optimisation C++ : profilage et accélération de code | PythonLib

Pourquoi C++ ne pardonne pas la paresse : introduction aux performances

Avez-vous déjà écrit du code C++ qui tournait « bizarrement lent » ? Pas juste « un peu moins rapide », mais vraiment lent, faisant souffrir le processeur et attendre l'utilisateur. C++ nous donne un contrôle incroyable sur le matériel, mais ce pouvoir exige de la responsabilité. Une copie malheureuse, un conteneur sous-optimal ou un appel virtuel oublié, et votre programme commence à gaspiller des cycles CPU.

Dans cet article, nous n'allons pas nous contenter de principes abstraits. Nous allons retrousser nos manches, analyser des exemples de code concrets, apprendre à utiliser des outils de profilage professionnels et découvrir les techniques d'optimisation qui fonctionnent vraiment en 2024. Prêt à rendre votre C++ plus rapide ? C'est parti !

Première étape : ne devinez pas, profilez ! Outils de profilage C++

La première règle du club des optimiseurs : n'optimisez jamais à l'aveugle. Votre intuition ment souvent. Seul un profileur peut vous montrer où se trouve le véritable goulot d'étranglement. Passons en revue trois outils de profilage essentiels que tout développeur C++ devrait connaître.

1. perf — le couteau suisse Linux

Si vous travaillez sous Linux, perf est votre meilleur ami. Il fonctionne au niveau du noyau, utilise les compteurs matériels du processeur et a un impact minimal sur les performances.

Exemple de profilage de base :

// example.cpp - notre programme "lent"\n#include <vector>\n#include <algorithm>\n#include <iostream>\n\nvoid slow_function() {\n    std::vector<int> data(1000000);\n    for (int i = 0; i < 100; ++i) {\n        std::sort(data.begin(), data.end()); // on trie ce qui est déjà trié !\n    }\n}\n\nint main() {\n    slow_function();\n    std::cout << "Done" << std::endl;\n    return 0;\n}

Compilez avec les flags -O2 -g (optimisation + symboles de débogage) :

g++ -O2 -g example.cpp -o example\nperf record ./example\nperf report

Vous verrez que 99% du temps est passé dans std::sort. Évident ? Oui. Mais perf vous le montrera avec une précision à la ligne de code près. Et si vous avez un projet complexe avec des centaines de fonctions, c'est indispensable.

2. Valgrind (Callgrind) — le détective du cache

Valgrind est un émulateur qui ralentit le programme de 10 à 20 fois, mais fournit des informations incroyablement détaillées : combien de fois un défaut de cache s'est produit, combien d'instructions ont été exécutées, quelles branches ont été mal prédites.

Lancement :

valgrind --tool=callgrind ./example\ncallgrind_annotate callgrind.out.12345

Vous verrez non seulement le temps, mais aussi le nombre de défauts de cache L1 et LL (Last Level). Si vous avez beaucoup de défauts, il est temps de penser à la localité des données.

3. Tracy Profiler — pour les jeux et applications interactives

Tracy est un profileur moderne et puissant avec une belle interface graphique. Il prend en charge l'instrumentation manuelle (insertion de macros) et l'échantillonnage automatique. Idéal pour les jeux, le rendu et les applications GUI.

Exemple d'instrumentation manuelle :

#include <tracy/Tracy.hpp>\n\nvoid render_frame() {\n    ZoneScoped; // macro Tracy\n    // ... rendu complexe ...\n}

Après le lancement, vous vous connectez au processus via l'interface graphique de Tracy et visualisez les frames, les appels de fonction et le temps de chaque section en temps réel.

Où se cachent les ralentissements : problèmes de performance typiques en C++

Maintenant que nous savons profiler, regardons les causes les plus fréquentes de code lent en C++. Spoiler : ce ne sont souvent pas les algorithmes, mais les petits détails.

Problème 1 : Copies inutiles (l'élision de copie ne sauve pas tout)

Beaucoup pensent que le RVO (Return Value Optimization) et la sémantique de mouvement résolvent tous les problèmes. Mais regardez ce code :

#include <string>\n#include <vector>\n\nstd::vector<std::string> get_data() {\n    std::vector<std::string> result;\n    re