Discussion :

[ParkerL31884]

Salut à tous,

ayant réussi à faire marcher gprof correctement, je m'aperçois que le résultat est une première base, mais un peu insuffisante.

En particulier, j'aimerais au moins avoir précisément le coût de chaque ligne (je pense que c'est une fonctionnalité assez standard). S'il y a une présentation agréable c'est évidemment un plus mais bon.

Je précise que je suis sous Windows 7 64 bits, et que je compile avec gcc/gfortran 4.8.1 64 bits. Mon contexte, ce sont des simus scientifiques, 10-20000 lignes environ.

Auriez-vous des outils adaptés à proposer ? Idéalement gratuits mais je suis preneur de noms si c'est vraiment bien.

Parmi les payants, y a t il parmi vous des retour d'expérience avec Intel VTune ? il saura analyser le code compilé avec gcc ? comment est-il ?

Sinon j'ai Visual Studio avec le plugin Intel Fortran (sur mon PC pro), est-ce qu'il y a quelque chose de bien dedans sur ce point (je l'utilise très peu jusqu'ici) ?

Merci pour votre aide.

[moomba]

Bonjour,

Les meilleurs profileurs que je connaissent sont Valgrind (avec callgrind) qui est opensource ou Intel Vtune sous licence. Je les utilise sous Linux. Valgrind ne fonctionne pas sous Windows, Intel Vtune je ne sais pas.

Intel Vtune peut être téléchargé gratuitement pour une utilisation non commerciale :
http://software.intel.com/en-us/non-...re-development
Mais uniquement sous linux dans ce cas.

Vtune Amplifier est très puissant (notamment car il utilise les compteurs hardware), mais n'est pas capable de profiler du code MPI, uniquement du séquentiel ou du OpenMP.

Valgrind est plus lent et plus verbeux, mais permet de débugger au passage, et les dernières versions supportent MPI.

Valgrind donnera le temps passé au niveau de chaque ligne de code avec l'outils KCacheGrind. Idem pour Intel Vtune, il te donnera le temps passé par ligne.

Par contre, si tu veut qu'ils te donnent autre chose que des lignes de code assembleur au niveau de l'affichage, tu dois compiler ton code en -g sous gcc/g++/gfortran, ou en -g -traceback sous icc/icpc/ifort.

[Matthieu Brucher]

Tout dépend ce que tu veux faire, il y a plusieurs types de profiles existants. Dans ton cas, si tu veux le coût par ligne, il me semble que l'émulation est la seule solution, mais elle repose sur une émulation généralement imparfaite du processeur. Le seul que je connaisse qui fait ça est Valgrind.
Si tu veux faire de l'échantillonnage ou de l'instrumentation, tu n'as que le coût par fonction (je ne me souviens pas avoir vu un coût ligne par ligne avec VTune ou dans Parallel Studio, même sous Linux), avec plus ou moins d'overhead et de précision, mais c'est généralement plus rapide à faire tourner et plus précis sur un processeur donné.
Malheureusement, sous Windows, il y a peu d'outils "GNU" qui fonctionnent, donc à part passer sous Linux (surtout si tu utilises des outils gnu), tu n'as pas trop d'options...
Par ailleurs, -g ne suffit pas pour avoir toute la pile des appels avec gcc, il a tendance à en sucrer pas mal. Pour les outils Intel, il y a des options spécifiques, je ne sais pas si traceback suffit (j'en utilise personnellement une autre).
J'ai quelques tutos sur le profiling sur mon site DVP (Valgrind, Parallel Studio et Visual Studio).

[moomba]

Si tu veux faire de l'échantillonnage ou de l'instrumentation, tu n'as que le coût par fonction (je ne me souviens pas avoir vu un coût ligne par ligne avec VTune ou dans Parallel Studio, même sous Linux)

Si. Exemple : http://mdkey.org/wp-content/uploads/...ce_Results.jpg
Bien sûr, si tu n'as pas compilé avec les flags de debug, il ne donne que la visualisation du code assembleur.

Par ailleurs, -g ne suffit pas pour avoir toute la pile des appels avec gcc, il a tendance à en sucrer pas mal. Pour les outils Intel, il y a des options spécifiques, je ne sais pas si traceback suffit (j'en utilise personnellement une autre).

Ca m’intéresse, je n'ai jamais eu de souci sous gfortran avec le -g, mais je pourrais avoir manqué quelque chose. As tu un exemple ?

Edit : petit oublis : Vtune ne gère pas MPI (mais ok pour OpenMP). Valgrind le supporte à un niveau "par processus" si compilé avec le wrapeur MPI.

[Matthieu Brucher]

Ah oui, tu as raison.

Pour gfortran, comme gcc et g++, il y a parfois des niveaux qui sautent lors de l'inlining (ca se voit bien avec gdb).

[moomba]

Je vais regarder ça de plus prés. Merci pour ces infos. Je pense que ParkerL31884 devrait trouver ici les réponses qu'il cherchait.