Sign in Join
Wiki copytemporary

Profiling/fr: what changed

Revision 3 to 4. Removed lines have a minus sign; added lines have a plus sign.

OldNewLine
11**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.
22
33## Profilage et optimisation
44
55Le 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.
66
77Faites 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.
88
99Bien sûr, l'optimisation du code qui est très souvent réutilisé vaut un peu plus d'efforts pour gagner en performance.
1010
1111## Prise en charge du profileur par FreePascal
1212
1313FreePascal a une prise en charge intégrée pour produire des exécutables appropriés (au moins) pour deux profileurs:
1414
1515- gprof, le profileur Gnu: permis avec l'option `-pg`.
1616- Valgrind, en utilisant le plug-in Callgrind: permis avec l'option `-gv`.
1717
1818Malheureusement, 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.
1919
2020## Utilisation de Valgrind/Callgrind
2121
2222Valgrind é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
2323
24-` aptitude install valgrind valgrind-callgrind`
24+```text
25+ aptitude install valgrind valgrind-callgrind
26+```
2527
2628Pour profiler votre programme, vous devez suivre trois étapes
2729
2830- Compilez votre programme avec l'option `-gv` .
2931- Exécutez votre programme en utilisant `valgrind`
3032- Analyser la sortie obtenue avec `valgrind_annotate` ou avec l'outil avec interface graphique `KCacheGrind`
3133
3234Compilez votre programme avec
3335
34-` fpc -gv myprogram.pas`
36+```text
37+ fpc -gv myprogram.pas
38+```
3539
3640Exécutez Valgrind en utilisant par exemple
3741
38-` valgrind --tool=callgrind ./myprogram --options --to --my --program`
42+``` pascal
43+ valgrind --tool=callgrind ./myprogram --options --to --my --program
44+```
3945
4046Vous pouvez également profiler uniquement des parties spécifiques de votre programme. Par exemple vous pouvez démarrer le programme avec
4147
42-` valgrind --instr-atstart=off ./myprogram --options --to --my --program`
48+``` pascal
49+ valgrind --instr-atstart=off ./myprogram --options --to --my --program
50+```
4351
4452Au moment ou vous voulez que le profilage réel démarre, exécutez
4553
46-` valgrind_control -i on`
54+```text
55+ valgrind_control -i on
56+```
4757
4858Pour 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.
4959
5060Callgrind 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
5161
52-` callgrind_annotate callgrind.out.12345`
62+```text
63+ callgrind_annotate callgrind.out.12345
64+```
5365
5466Bien 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.
5567
5668## Utilisation de KCacheGrind
5769
5870Bien 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
5971
60-` aptitude install kcachegrind graphviz`
72+```text
73+ aptitude install kcachegrind graphviz
74+```
6175
6276(Le paquet `graphviz` est nécessaire si vous voulez générer avec KCacheGrind des graphes d'appel.)
6377
6478![](/wiki-images/0/0a/KCacheGrind_Lazarus_Screenshot.png)
6579
6680Exé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.
6781
6882Sur la gauche, vous verrez un 'profil plat', lequel liste pour chaque fonction : (dans le top 100)
6983
7084- Incl: durée passée dans la fonction, *y compris* ce qui est appelé (les fonctions appelées par la fonction).
7185- Self: durée passée au sein de la fonction elle-même, *à l'exception* de ce qui est appelé.
7286- Called: le nombre de fois où la fonction a été appelée.
7387
7488*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.
7589
7690Sur 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.
7791
7892## Profilage de la mémoire
7993
8094### Heaptrc, LineInfo
8195
8296Pour 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:
8397
8498- keepreleased: Toute la mémoire libérée, est gardée et vérifiée si écrasée.
8599- disabled: désactiver le traçage. Ceci est utile pour des programmes compilés avec heaptrc et devrait fonctionner normalement.
86100- 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).
87101- 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.
88102- log=\<filename\>: Au lieu d'écrire sur la sortie standard(stdout), vous pouvez donner un nom de fichier log.
89103
90104Commentaire: **heaptrc** entrera en conflit avec **cmem** si vous avez de déboguer des bibliothèques externes. Valgrind devrait être utilisée dans ce cas.
91105
92106### Vérification de mémoire avec Valgrind
93107
94108Il 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:
95109
96-` valgrind --tool=memcheck --leak-check=summary --log-file=log.txt ./project1`
110+```text
111+ valgrind --tool=memcheck --leak-check=summary --log-file=log.txt ./project1
112+```
97113
98114Le 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.
99115
100116Pour obtenir encore plus d'informations exécutez avec
101117
102-` valgrind --tool=memcheck --leak-check=full --log-file=log.txt --show-reachable=yes --num-callers=128 ./project1`
118+```text
119+ valgrind --tool=memcheck --leak-check=full --log-file=log.txt --show-reachable=yes --num-callers=128 ./project1
120+```
103121
104122---
105123*From the Free Pascal wiki, page "Profiling/fr", as it stood on 2017-11-19 after a change by FTurtle, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*
106124Category: Debugging/fr

Back to history