Profilage du code C++ : trouver les goulots d'étranglement pour les débutants

Introduction : pourquoi est-il important de profiler le code C++ ?

C++ est l'un des langages de programmation les plus rapides, mais même avec lui, on peut écrire du code lent. Souvent, les développeurs passent des heures à optimiser les mauvaises parties du programme, en se fiant à leur intuition. Le profilage est une approche scientifique de l'optimisation : vous mesurez où le programme passe le plus de temps, et vous améliorez ces endroits de manière ciblée.

Pour les programmeurs C++ débutants, le profilage peut sembler complexe, mais en réalité, les outils de base s'apprennent en une soirée. Dans cet article, nous allons examiner trois outils populaires : gprof, perf et Valgrind, et apprendre à interpréter leurs résultats.

Qu'est-ce que le profilage et quelles sont les différentes méthodes ?

Le profilage est la collecte de données sur le fonctionnement d'un programme pendant son exécution. Il existe deux approches principales :

\n
• Profilage par instrumentation — des "sondes" spéciales sont ajoutées au code du programme (par exemple, gprof). Inconvénient : cela ralentit l'exécution du programme.
\n
• Profilage par échantillonnage — à intervalles réguliers, le profileur "jette un coup d'œil" dans le programme et enregistre quelle fonction est en cours d'exécution (par exemple, perf). Cela ne ralentit quasiment pas le programme.
\n

Il existe également des outils pour rechercher les fuites mémoire (Valgrind) et analyser le cache. Pour commencer, il suffit de maîtriser gprof et perf.

Outil 1 : gprof — le classique du profilage

gprof est un profileur intégré pour GCC. Il fonctionne en deux étapes : la collecte des données et leur analyse.

Comment utiliser gprof

Compilez d'abord le programme avec l'option -pg :

g++ -pg -o my_program my_program.cpp

Exécutez le programme :

./my_program

Après l'exécution, un fichier gmon.out apparaît. Lancez maintenant gprof :

gprof my_program gmon.out > report.txt

Ouvrez report.txt et regardez le tableau :

Flat profile:\nEach sample counts as 0.01 seconds.\n  %   cumulative   self              self     total\n time   seconds   seconds    calls  ms/call  ms/call  name\n 60.00      0.06     0.06    10000     0.01     0.01  slow_function\n 30.00      0.09     0.03     5000     0.01     0.02  medium_function\n 10.00      0.10     0.01        1    10.00    10.00  main

Dans la colonne % time, on voit le pourcentage de temps pris par la fonction. Dans notre exemple, slow_function est le principal candidat à l'optimisation.

Conseil : Pour les petits programmes, gprof est parfaitement adapté. Pour les grands projets, il peut donner des données imprécises en raison des optimisations du compilateur.

Outil 2 : perf — un puissant échantillonneur pour Linux

perf est un profileur intégré au noyau Linux. Il fonctionne par échantillonnage et ne ralentit quasiment pas le programme. Idéal pour les systèmes de production.

Utilisation de base de perf

Compilez le programme avec les symboles de débogage (option -g) :

g++ -g -o my_program my_program.cpp

Lancez le profilage :

perf record ./my_program

Une fois le programme terminé, consultez le rapport :

perf report

Vous verrez une interface interactive. En cliquant sur une fonction, vous pouvez voir quelles lignes de code ont été exécutées le plus souvent. Exemple de sortie :

Samples: 1K of event 'cycles'\nEvent count (approx.): 250000000\nOverhead  Command      Shared Object     Symbol\n  45.32%  my_program   my_program        [.] slow_function\n  30.15%  my_program   my_program        [.] medium_function\n  12.50%  my_program   libc-2.31.so      [.] malloc\n   8.03%  my_program   my_program        [.] main

Important : perf nécessite les droits root pour collecter des données sur le noy