Scroll to navigation

SPROF(1) Manuel de l'utilisateur Linux SPROF(1)

NOM

sprof - Lire et afficher les données de profilage des objets partagés

SYNOPSIS

sprof [option]... chemin_objet_partagé [chemin_données_profil]

DESCRIPTION

La commande sprof affiche un résumé de profilage de l'objet (la bibliothèque) partagé indiqué comme premier paramètre de la ligne de commande. Le résumé du profilage est créé à partir de données de profilage précédemment générées dans le second paramètre (optionnel) de la ligne de commande. Si le chemin vers les données de profilage est absent, sprof tentera de le déduire à partir du soname de l'objet partagé, en recherchant dans le répertoire actuel un fichier avec le nom <soname>.profile.

OPTIONS

Les options suivantes de la ligne de commande indiquent la sortie de profilage à produire :
-c, --call-pairs
Afficher une liste des paires de chemins d'appel pour les interfaces exportées par l'objet partagé, ainsi que le nombre de fois que chaque chemin est utilisé.
-p, --flat-profile
Générer un fichier de profilage plat de toutes les fonctions de l'objet examiné, avec le nombre d'appels et de tics.
-q, --graph
Générer un graphe d'appels.

Si aucune des options ci-dessus n'est spécifiée, le comportement par défaut consiste à afficher un profilage plat et un graphe des appels.

Les options supplémentaires suivantes sont disponibles en ligne de commande :

-?, --help
Afficher un résumé des options et des paramètres de la ligne de commande puis quitter.
--usage
Afficher un court message d'aide puis quitter.
-V, --version
Afficher la version du programme puis quitter.

CONFORMITÉ

La commande sprof est une extension GNU non présente dans POSIX.1.

EXEMPLES

L'exemple suivant illustre l'utilisation de sprof. Il consiste dans un programme principal qui appelle deux fonctions d'un objet partagé. D'abord, le code du programme principal :


$ cat prog.c
#include <stdlib.h>
void x1(void);
void x2(void);
int
main(int argc, char *argv[])
{
    x1();
    x2();
    exit(EXIT_SUCCESS);
}


Les fonctions x1() et x2() sont définies dans le fichier source suivant, utilisé pour construire l'objet partagé :


$ cat libdemo.c
#include <unistd.h>
void
consumeCpu1(int lim)
{
    int j;
    for (j = 0; j < lim; j++)
	getppid();
}
void
x1(void) {
    int j;
    for (j = 0; j < 100; j++)
	consumeCpu1(200000);
}
void
consumeCpu2(int lim)
{
    int j;
    for (j = 0; j < lim; j++)
	getppid();
}
void
x2(void)
{
    int j;
    for (j = 0; j < 1000; j++)
	consumeCpu2(10000);
}


Maintenant, nous construisons l'objet partagé avec le nom réel libdemo.so.1.0.1 et le soname libdemo.so.1 :


$ cc -g -fPIC -shared -Wl,-soname,libdemo.so.1 \
        -o libdemo.so.1.0.1 libdemo.c


Puis, nous construisons les liens symboliques pour le soname de la bibliothèque et le nom de l'éditeur de liens de la bibliothèque :


$ ln -sf libdemo.so.1.0.1 libdemo.so.1
$ ln -sf libdemo.so.1 libdemo.so


Ensuite, nous compilons le programme principal en le liant à l'objet partagé, puis nous affichons les dépendances dynamiques du programme :


$ cc -g -o prog prog.c -L. -ldemo
$ ldd prog
	linux-vdso.so.1 =>  (0x00007fff86d66000)
	libdemo.so.1 => not found
	libc.so.6 => /lib64/libc.so.6 (0x00007fd4dc138000)
	/lib64/ld-linux-x86-64.so.2 (0x00007fd4dc51f000)


Afin d'avoir les informations de profilage de l'objet partagé, nous positionnons la variable d'environnement LD_PROFILE sur le soname de la bibliothèque :


$ export LD_PROFILE=libdemo.so.1


Puis, nous définissons la variable d'environnement LD_PROFILE_OUTPUT avec le chemin du répertoire où devrait être écrite la sortie de profilage et nous créons ce répertoire s'il n'existe pas encore :


$ export LD_PROFILE_OUTPUT=$(pwd)/prof_data
$ mkdir -p $LD_PROFILE_OUTPUT


LD_PROFILE a pour conséquence que la sortie de profilage s'ajoute au fichier de sortie s'il existe, aussi nous nous assurons qu'il n'y a pas de données de profilage préexistantes :


$ rm -f $LD_PROFILE_OUTPUT/$LD_PROFILE.profile


Puis, nous lançons le programme pour produire la sortie de profilage, écrite dans un fichier du répertoire indiqué dans LD_PROFILE_OUTPUT :


$ LD_LIBRARY_PATH=. ./prog
$ ls prof_data
libdemo.so.1.profile


Nous utilisons alors l'option sprof -p pour générer un fichier de profilage plat avec le nombre d'appels et de tics :


$ sprof -p libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
Profil plat :
Chaque échantillon est compté toutes les 0.01 secondes.
  %   cumulative   self              self     total
 time   seconds   seconds    calls  us/call  us/call  name
 60.00      0.06     0.06      100   600.00           consumeCpu1
 40.00      0.10     0.04     1000    40.00           consumeCpu2
  0.00      0.10     0.00        1     0.00           x1
  0.00      0.10     0.00        1     0.00           x2


L'option sprof -q génère un graphe d'appel :


$ sprof -q libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
index % time    self  children    called     name
                0.00    0.00      100/100         x1 [1]
[0]    100.0    0.00    0.00      100         consumeCpu1 [0]
-----------------------------------------------
                0.00    0.00        1/1           <UNKNOWN>
[1]      0.0    0.00    0.00        1         x1 [1]
                0.00    0.00      100/100         consumeCpu1 [0]
-----------------------------------------------
                0.00    0.00     1000/1000        x2 [3]
[2]      0.0    0.00    0.00     1000         consumeCpu2 [2]
-----------------------------------------------
                0.00    0.00        1/1           <UNKNOWN>
[3]      0.0    0.00    0.00        1         x2 [3]
                0.00    0.00     1000/1000        consumeCpu2 [2]
-----------------------------------------------


Ci-dessus et ci-dessous, les chaînes "<UNKNOWN>" représentent les identifiants à l'extérieur du fichier de l'objet examiné (dans cet exemple, il s'agit des instances de main()).

L'option sprof -c génère une liste d’une paire d’appels et du nombre de leurs occurrences :


$ sprof -c libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
<UNKNOWN>                  x1                                 1
x1                         consumeCpu1                      100
<UNKNOWN>                  x2                                 1
x2                         consumeCpu2                     1000


VOIR AUSSI

gprof(1), ldd(1), ld.so(8)

COLOPHON

Cette page fait partie de la publication 5.07 du projet man-pages Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page, peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

La traduction française de cette page de manuel a été créée par Gérard Delafond <gerard@delafond.org>, Alain Portal <aportal@univ-montp2.fr>, Christophe Blaess <https://www.blaess.fr/christophe/>, David Prévot <david@tilapin.org>, Denis Barbier <barbier@debian.org>, Florentin Duneau <fduneau@gmail.com>, François Micaux, Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Jean-Philippe Guérard <fevrier@tigreraye.org>, Julien Cristau <jcristau@debian.org>, Nicolas François <nicolas.francois@centraliens.net>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry Vignaud <tvignaud@mandriva.com>, Thomas Blein <tblein@tblein.eu>, Thomas Huriaux <thomas.huriaux@gmail.com> et Jean-Philippe MENGUAL <jpmengual@debian.org>

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à <debian-l10n-french@lists.debian.org>.

9 juin 2020 Linux