Ceci est une ancienne révision du document !


~~ODT~~

Check the available software for debugging and profiling available at mesocentre.

Débogage

Objectif : éliminer les erreurs dans les programmes → débogueur

Déboguer un programme consiste à l'arrêter sous certaines conditions pour examiner l'état de la pile d'appels et les valeurs stockées dans les variables.

L'utilisation d'un débogueur nécessite l'ajout de l'option -g à la compilation.

Conseils avant de de déboguer :

  • Aérer le code de commentaires
  • Indenter les lignes du code
  • Aucune optimisation de code
  • Afficher les messages de compilation

Tout d'abord on compile le programme avec l'option -g

$ gcc -g  program.c -o program

Puis on lance le débogueur :

[user@mesocomte0 matmul]# gdb matmul_for_debug.exe 
GNU gdb Fedora (6.8-27.el5)
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu"...
(gdb) 

Une console s'affiche et invite l'utilisateur à taper des commandes de débogage.

La liste des commandes de débogage les plus utilisées :

Commande Description
r <param>Exécute le programme : r param1 param2
l <ligne> Liste le programme source : l. Affiche uniquement la ligne <ligne> : l 29. Si plusieurs fichiers sources : l toto.c:29
b <ligne>b (Breakpoint) un point d'arrêt : b 30. b main. Un point d'arrêt conditionnel: b 3 Z > 92
cc (Continue continue) l'exécution après un arrêt
display varAffiche le contenu d'une variable : display toto
printfAffichage formaté des variables : printf "X = %d, Y = %d\n",X,Y
nn (Next) exécute la ligne suivante du programme et PAUSE
ss (Step) exécute la 1ere ligne de la fonction suivante et PAUSE
btbt (Backtrace) indique l'emplacement de l'erreur dans le programme

idb est un débogueur symbolique textuel fourni avec les compilateurs d'Intel. FIXME

Profiling

Objectif : déterminer les parties du code qui consomment le plus de temps CPU → Profiling

Trois étapes pour le «profiling» :

  1. Instrumentation du programme par le compilateur : -p, –pg
  2. Exécution du programme instrumenté fichier de données pour le profiler (mon.out,gmon.out,…)
  3. Utilisation du profiler pour l'extraction et la lecture des résultats : prof, gprof

Compilation :

$ gcc -p programe.c -o programme

Exécution :

$ ./programme
$ ls 
$ programme.c programme gmount.out

Lancement de gprof :

$ gprof
La commande gprof fournit un compte-rendu de la consommation CPU pour chaque routine du code
%
time 	cumulative seconds 	self seconds 	 calls 	self ms/call  total ms/call      name
36.9 	92.23 	                92.23     	87253 	    1.06      1.06 		   .saxpy [4]
29.9 	167.06 	                74.83   	45751 	    1.64      1.64 		   .pmv [5]
22.0 	222.15 	                55.09    	61502 	    0.90      0.90 	           .prodscal [6]
6.1 	237.48 	                15.33 	        10000 	    1.53      3.17 	           .scdmb [7]
5.1     250.19 	                12.71 	        10000 	    1.27      21.85                .gradconj [3]
0.0     250.22 	                0.03 	  	  	  		                   .__mcount [8]
0.0     250.25                  0.03 	  	  	  		                   .qincrement [9]
0.0     250.27 	                0.02             1 	    20.00   	20.00 	           .fctfx [10]
0.0     250.28                  0.01             6	    1.67     	1.67 	           .nrmerr [1]
0.0     250.28 	                0.00  	         20000 	    0.00       	0.00 	           .fctft [12]
0.0     250.28 	                0.00   	         252 	    0.00        0.00               ._sigsetmask [13]
0.0     250.28 	                0.00      	 170        0.00        0.00              thread_mutex_lock [14]

Analyse du résultat

  • La colonne % time indique le pourcentage du temps cpu total consommé par la routine courante.
  • La colonne cumulative seconds représente la somme partielle des temps cpu du haut de la liste jusqu'à la routine courante
  • La colonne self seconds représente le temps cpu de la routine courante
  • La colonne calls indique le nombre d'appels de la routine courante
  • La colonne self ms/call indique le temps cpu moyen (en milisecondes) consommé par appel à la routine courante, temps exclusif (ne contient pas la consommation des routines qu'elle appelle) uniquement
  • La colonne total ms/call indique le temps total (inclusif + exclusif) consommé par appel à la routine courante

Intel® Trace Analyzer and Collector

**Problème **: Comment déboguer une application parallèle MPI (Intel MPI) ?

**Solution **: Intel fournit un outil, ITAC, puissant et facile à utiliser.

Pour OpenMPI utiliser Scalasca

** Pré-requis **

Besoin d'une application MPI à compiler avec Intel MPI

L'environnement Intel est chargé par défaut dans votre session. Vous n'avez pas besoin d'utiliser : module

Exemple de programme : send/receive avec MPI

sendreceive.c
 
#include "mpi.h"
 
#include <stdio.h>
 
int main(argc,argv) 
int argc;
char *argv[];  {
int numtasks, rank, dest, source, rc, count, tag=1;  
char inmsg, outmsg='x';
MPI_Status Stat;
 
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
if (rank == 0) {
  dest = 1;
  source = 1;
  rc = MPI_Send(&outmsg, 1, MPI_CHAR, dest, tag, MPI_COMM_WORLD);
  rc = MPI_Recv(&inmsg, 1, MPI_CHAR, source, tag, MPI_COMM_WORLD, &Stat);
  } 
 
else if (rank == 1) {
  dest = 0;
  source = 0;
  rc = MPI_Recv(&inmsg, 1, MPI_CHAR, source, tag, MPI_COMM_WORLD, &Stat);
  rc = MPI_Send(&outmsg, 1, MPI_CHAR, dest, tag, MPI_COMM_WORLD);
  }
 
rc = MPI_Get_count(&Stat, MPI_CHAR, &count);
printf("Task %d: Received %d char(s) from task %d with tag %d \n",
       rank, count, Stat.MPI_SOURCE, Stat.MPI_TAG);
 
 
 
MPI_Finalize();
}

Compilation: pour générer les traces on utilise l'option -trace

$ mpiicc sendreceive.c -trace -o sendreceive

Exécution du programme

$ mpirun -np 2 ./sendreceive
A la fin de l'exécution on devrait avoir un fichier de trace : sendreceive.stf généré par Intel MPI

** Lancement de l'analyseur de trace**

$ traceanalyzer sendreceive.stf

Exemple d'un écran graphique de l'analyseur

  • outils_analyse.1424879040.txt.gz
  • Dernière modification : 2015/02/25 15:44
  • de admin