Profiling/fr

From Lazarus wiki
Jump to: navigation, search

English (en) français (fr) русский (ru)

Profiling est une technique d'analyse des performances qui peuvent être utilisées pour trouver les goulots d'étranglement dans votre application. En particulier, elle englobe la mesure de la fréquence et de la durée des appels de fonction.

Profilage et optimisation

Le profilage peut aider à identifier les différentes parties 'critiques' de votre code, dont l'optimisation pourrait sérieusement améliorer la performance de votre programme. Il vaut mieux le faire au moment ou vous vous préparez à faire une réalisation(release) et que vous avez une fonctionnalité qui ralenti fortement votre code. C'est une perte de temps et de ressources d'optimiser quelque chose qui va être jeté les jours suivant pendant une quelconque restructuration de code.

Faites attention à ne pas sur-optimiser votre programme. Cela vaut rarement la peine de passer des jours à la seule obtention d'un gain d'exécution de 2%. On peut généralement éliminer 30% du temps d'exécution en juste une demi heure de codage avec quelques optimisations qui seront utiles.

Bien sûr, l'optimisation du code qui est très souvent réutilisé vaut un peu plus d'efforts pour gagner en performance.

Prise en charge du profileur par FreePascal

FreePascal a une prise en charge intégrée pour produire des exécutables appropriés (au moins) pour deux profileurs:

  • gprof, le profileur Gnu: permis avec l'option -pg.
  • Valgrind, en utilisant le plug-in Callgrind: permis avec l'option -gv.

Malheureusement, la prise en charge du profileur pourrait ne pas être disponible (a moins de: travailler directement de manière séparée) pour toutes les plateformes. gprof ne fonctionne plus avec linux depuis fpc 2.2.0. Valgrind devrait fonctionner avec Linux (et systèmes apparentés). Pour Windows des étapes supplémentaires pourraient être nécessaires pour la prise en charge de gprof fonctionne. Valgrind est tout simplement disponible uniquement pour Linux et quelques autres systèmes UNIX.

Utilisation de Valgrind/Callgrind

Valgrind était à l'origine seulement un débogueur de mémoire, mais maintenant il prend aussi en charge par exemple le profilage à l'aide du plug-in Callgrind( qui a remplacé le plugin calltree). Pour installer Valgrind avec Callgrind sur Debian, exécutez par exemple

 aptitude install valgrind valgrind-callgrind

Pour profiler votre programme, vous devez suivre trois étapes

  • Compilez votre programme avec l'option -gv .
  • Exécutez votre programme en utilisant valgrind
  • Analyser la sortie obtenue avec valgrind_annotate ou avec l'outil avec interface graphique KCacheGrind

Compilez votre programme avec

 fpc -gv myprogram.pas

Exécutez Valgrind en utilisant par exemple

 valgrind --tool=callgrind ./myprogram --options --to --my --program

Vous pouvez également profiler uniquement des parties spécifiques de votre programme. Par exemple vous pouvez démarrer le programme avec

 valgrind --instr-atstart=off ./myprogram --options --to --my --program

Au moment ou vous voulez que le profilage réel démarre, exécutez

 valgrind_control -i on

Pour arrêter le profilage, exécutez la même commande avec off au lieu de on. Pour obtenir uniquement des informations de profilage quand vous êtes dans une fonction particulière, vous pouvez transmettre l'option --toggle-collect=funcNamePrefix à valgrind. Reportez-vous à la documentation de Valgrind pour plus de détails.

Callgrind a créé un fichier de traçage avec un nom typique du genre callgrind.out.12345. Pour obtenir un rapport statistique lisible, exécutez par exemple

 callgrind_annotate callgrind.out.12345

Bien sûr, vous pouvez également faire une expérimentation avec les autres outils plug-ins qui sont fournies avec Valgrind. Cachegrind, par exemple, fait le profilage de l'utilisation du cache. d'autres plug-ins peuvent être utilisés pour profiler ou déboguer l'allocation de mémoire ou détecter les conditions de transfert de données.

Utilisation de KCacheGrind

Bien que la sortie de callgrind_annotate peut certainement faire la lumière sur les caractéristiques de performance de votre programme, l'outil avec interface graphique KCacheGrind peut vous donner des informations encore plus intéressant, présentée sous différentes formes: des listes d'appellant/appelé, des cartes d'appelant/appelé et des graphiques d'appel. Pour l'installer sur Debian, exécutez

 aptitude install kcachegrind graphviz

(Le paquet graphviz est nécessaire si vous voulez générer avec KCacheGrind des graphes d'appel.)

Exemple de KCacheGrind affichant des informations de profilage pour Lazarus ( Cliquez pour agrandir)

Exécutez KCachegrind avec un appel simple à kcachegrind. Vous pouvez maintenant ouvrir un fichier de traçage en utilisant l'interface graphique et tout devraient être auto-explicatif.

Sur la gauche, vous verrez un 'profil plat', lequel liste pour chaque fonction : (dans le top 100)

  • Incl: durée passée dans la fonction, y compris ce qui est appelé (les fonctions appelées par la fonction).
  • Self: durée passée au sein de la fonction elle-même, à l'exception de ce qui est appelé.
  • Called: le nombre de fois où la fonction a été appelée.

Note: Si vous cliquez sur l'un des entêtes de colonne pour trier la liste, vous pourriez avoir besoin de faire une réactualisation (F5) pour veiller à ce que le top 100 en ce qui concerne cette colonne sera affiché. Une autre astuce: dans les options de configuration, vous pouvez rendre la liste plus longue que seulement le top 100.

Sur la droite, vous verrez un certain nombre d'onglets, vous permettant de voir des listes et des cartes d'appelants et d'appelés, ainsi qu'un graphique d'appels, ce qui est très utile pour voir d'un coup d'œil qui appelle le plus.

Profilage de la mémoire

Heaptrc, LineInfo

Pour détecter des fuites de mémoire, compilez simplement avec -gh. Cela va compiler comme si vous avez ajouté l'unité heaptrc en tant que première unité de la section uses de votre programme. Heaptrc est lié au gestionnaire de mémoire de fpc et vérifie plusieurs choses. En collaboration avec l'option -gl (par ajout de l'unité lineinfo) il vous donnera des informations utiles et backtraces, là où un bloc de mémoire a été allouée. Il prend en charge certaines options qui peuvent être contrôlée via l'option d'environnement HEAPTRC contenant des mots-clés:

  • keepreleased: Toute la mémoire libérée, est gardée et vérifiée si écrasée.
  • disabled: désactiver le traçage. Ceci est utile pour des programmes compilés avec heaptrc et devrait fonctionner normalement.
  • nohalt: normalement heaptrc s'arrête sur la première erreur qu'il trouve. Ajouter ce mot clé si le programme doit continuer( comme il le ferait normalement, sans heaptrc).
  • haltonnotreleased: Normalement heaptrc imprime pour chaque bloc non libéré un backtrace, qui peut prendre un certain temps. Ajouter ce mot clé pour faire un arrêt après la première fuite de mémoire signalée.
  • log=<filename>: Au lieu d'écrire sur la sortie standard(stdout), vous pouvez donner un nom de fichier log.

Commentaire: heaptrc entrera en conflit avec cmem si vous avez de déboguer des bibliothèques externes. Valgrind devrait être utilisée dans ce cas.

Vérification de mémoire avec Valgrind

Il y a des fuites de mémoire que heaptrc ne trouve pas. Le programme valgrind dispose d'un outil appelé memcheck, qui fait beaucoup plus de comptabilité que heaptrc et trouve quelques bugs de plus. L'inconvénient est que valgrind est lent comme un escargot, aussi ne faites cela que si heaptrc n'a pas pu vous aider. Voici un exemple:

 valgrind --tool=memcheck --leak-check=summary --log-file=log.txt ./project1

Le fichier log.txt trouvera presque toujours quelque chose, parce qu'il cherche aussi à vérifier les bibliothèques externes utilisées et certaines bibliothèques communes sont mal codées.

Pour obtenir encore plus d'informations exécutez avec

 valgrind --tool=memcheck --leak-check=full --log-file=log.txt --show-reachable=yes --num-callers=128 ./project1