Sur Ubuntu:<\/p>\n
\r\napt-get install kcachegrind valgrind graphviz\r\n<\/pre>\nV\u00e9rifiez ensuite que les commandes \u00ab\u00a0valgrind\u00a0\u00bb et kcachegrind sont bien pr\u00e9sentes.<\/p>\n
Instrumenter avec Callgrind<\/h1>\n
Le processus d’instrumentation de callgrind est tr\u00e8s simple. Il suffit de rajouter l’invocation de Callgrind avant le programme cible. Par exemple:<\/p>\n
\r\nvalgrind --tool=callgrind .\/test\r\n<\/pre>\nPrenons maintenant un code simple pour tester le profilage (test.c):<\/p>\n
\r\n#include <stdio.h>\r\n\r\nint main(int argc, char **argv)\r\n{\r\n int i;\r\n int j;\r\n\r\n double result = 0.0;\r\n\r\n for (i = 0; i < 100000; ++i)\r\n {\r\n for (j = 0; j < 10000; ++j) { result += i + j * 0,1; } } printf("--> %g\\n", result );\r\n\r\n return 0;\r\n}\r\n<\/pre>\nCompilons le code en mode d\u00e9bug :<\/p>\n
\r\ngcc -g -O3 -o test .\/test.c\r\n<\/pre>\nPuis instrumentons le avec Callgrind, notez que l’ex\u00e9cution est ralentie.<\/p>\n
\r\nvalgrind --tool=callgrind .\/test\r\n<\/pre>\nRemarquez qu’un fichier callgrind.out.PID<\/b> a maintenant \u00e9t\u00e9 g\u00e9n\u00e9r\u00e9 dans le r\u00e9pertoire courant. Ce fichier contient les informations mesur\u00e9es lors de l’\u00e9x\u00e9cution.<\/p>\n
Visualisation en Console<\/h1>\n
Il est possible de consulter le contenu du profil en console en utilisant callgrind_anotate<\/b>. Cet outil s’utilise comme suit:<\/p>\n
\r\ncallgrind_annotate .\/callgrind.out.31458\r\n<\/pre>\nCela produira une sortie assez compacte:<\/p>\n
——————————————————————————–
\nProfile data file ‘.\/callgrind.out.31458’ (creator: callgrind-3.11.0)
\n——————————————————————————–
\nI1 cache:
\nD1 cache:
\nLL cache:
\nTimerange: Basic block 0 – 1000321106
\nTrigger: Program termination
\nProfiled target: .\/a.out (PID 31458, part 1)
\nEvents recorded: Ir
\nEvents shown: Ir
\nEvent sort order: Ir
\nThresholds: 99
\nInclude dirs:
\nUser annotated:
\nAuto-annotation: off<\/p>\n——————————————————————————–
\nIr
\n——————————————————————————–
\n7,000,800,236 PROGRAM TOTALS<\/p>\n——————————————————————————–
\nIr file:function
\n——————————————————————————–
\n7,000,700,025 .\/test.c:main [\/home\/jbbesnard\/a.out]<\/p><\/blockquote>\nOn y trouve peu d’information pour l’instant, uniquement dans la partie basse le fait que tous les \u00e9chantillons \u00e9taient dans la fonction main. Pour obtenir des informations plus int\u00e9ressantes, il faut passer des param\u00e8tre au programme.<\/p>\n
Par exemple pour visualiser les fonction appelantes et les fonction appel\u00e9es:<\/p>\n
\r\ncallgrind_annotate --tree=both .\/callgrind.out.31458\r\n<\/pre>\nOn obtient les fonction appel\u00e9es dans le main (ici printf):<\/p>\n
——————————————————————————–
\nIr file:function
\n——————————————————————————–<\/p>\n7,000,700,025 * .\/test.c:main [\/home\/jbbesnard\/a.out]
\n3,900 > ???:printf (1x) [\/usr\/lib64\/libc-2.17.so]
\n776 > ???:_dl_runtime_resolve (1x) [\/usr\/lib64\/ld-2.17.so]<\/p><\/blockquote>\nMais on peut aller plus loin en ayant un code annot\u00e9 pour les principales fonction :<\/p>\n
\r\ncallgrind_annotate --auto=yes .\/callgrind.out.31458\r\n<\/pre>\nOn obtient en compl\u00e9ment de la sortie pr\u00e9c\u00e9dente:<\/p>\n
\r\n--------------------------------------------------------------------------------\r\n-- Auto-annotated source: .\/test.c\r\n--------------------------------------------------------------------------------\r\nIr\r\n\r\n.\r\n. int main(int argc, char **argv)\r\n5 {\r\n. int i;\r\n. int j;\r\n.\r\n2 double result = 0.0;\r\n.\r\n300,004 for (i = 0; i < 100000; ++i)\r\n. {\r\n7,000,400,011 for (j = 0; j < 10000; ++j) { result += i + j * 0,1; } } printf("--> %g\\n", result );\r\n3,900 => ???:printf (1x)\r\n776 => ???:_dl_runtime_resolve (1x)\r\n.\r\n1 return 0;\r\n2 }\r\n\r\n--------------------------------------------------------------------------------\r\n Ir\r\n--------------------------------------------------------------------------------\r\n100 percentage of events annotated\r\n<\/pre>\nOn voit ici que la majorit\u00e9 des \u00e9chantillons sont dans leur grande majorit\u00e9 regroupp\u00e9s dans la boucle interne faisant le calcul. Cela permet de pointer pr\u00e9cis\u00e9ment le point chaud du code.<\/p>\n
Controller Callgrind<\/h1>\n
Calgrind fournit \u00e9galement un outil callgrind_control pour interragir avec un programme en cours de profilage. Pour illustre ce point, nous allons volontairement cr\u00e9er un situation de bloquage dans le programme cible. Nous proposons le code suivant:<\/p>\n
\r\n#include <stdio.h>\r\n\r\nvoid bar()\r\n{\r\n while(1)\r\n {\r\n \/* BLOCAGE *\/\r\n sleep(1);\r\n }\r\n}\r\n\r\nint main(int argc, char **argv)\r\n{\r\n bar();\r\n return 0;\r\n}\r\n<\/pre>\nCompilons le code en mode d\u00e9bug :<\/p>\n
\r\ngcc -g -O3 -o ddlk .\/d.c\r\n<\/pre>\nEt lan\u00e7ons le dans Callgrind:<\/p>\n
\r\nvalgrind --tool=callgrind .\/ddlk\r\n<\/pre>\nCe programme ne se terminera jamais, par contre il est possible de le surveiller \u00e0 \u00ab\u00a0distance\u00a0\u00bb avec l’outil callgrind_control. Ce outils est tr\u00e8s utiles pour diff\u00e9rentes manipulation. Pour ce faire, nous allons laisser le programme bloqu\u00e9 s’\u00e9x\u00e9cuter et ouvrir une autre console.<\/p>\n
On peut tout d’abord observer l’\u00e9tat du programme:<\/p>\n
\r\ncallgrind_control -s\r\n<\/pre>\nPID 31946: .\/ddlk
\nsending command status internal to pid 31946
\nNumber of running threads: 1, thread IDs: 1
\nEvents collected: Ir
\nFunctions: 129 (executed 2,337, contexts 129)
\nBasic blocks: 1,435 (executed 22,738, call sites 198)<\/p><\/blockquote>\nOn peut ensuite demander la g\u00e9n\u00e9ration d’un backtrace \u00e0 distance:<\/p>\n
\r\ncallgrind_control -s\r\n<\/pre>\nPID 31946: .\/ddlk
\nsending command status internal to pid 31946<\/p>\nFrame: Backtrace for Thread 1
\n[ 0] __nanosleep_nocancel (148 x)
\n[ 1] nanosleep (148 x)
\n[ 2] sleep (147 x)
\n[ 3] bar (1 x)
\n[ 4] main (1 x)
\n[ 5] (below main) (1 x)
\n[ 6] 0x000000000040044b (1 x)
\n[ 7] 0x00000000000011e0<\/p><\/blockquote>\nIci on voit clairement que le code est bloqu\u00e9 dans bar. Ceci peut \u00eatre tr\u00e8s pratique pour comprendre pourquoi un code bloque. Il est \u00e9galement possible de forcer l’\u00e9criture des \u00e9v\u00e8nement et de d\u00e9sactiver\/r\u00e9activer l’instrumentation (voir aide -h).<\/p>\n
Visualiser avec Kcachegrind<\/h1>\n
Il est \u00e9galement possible d’utliser une interface graphique pour observer un profil Valgrind. Pour ce faire, on utilise la commande suivante:<\/p>\n
\r\nkcachegrind .\/callgrind.out.31458\r\n<\/pre>\nVous obtiendrez alors une sortie telle que celle-ci:<\/p>\n
![\"\"](\"http:\/\/learningcenter.paratools.com\/wp-content\/uploads\/2017\/04\/cg.jpeg\")
<\/a><\/p>\n