Provided by: manpages-fr_4.19.0-7_all bug

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  paramètres  de  la  ligne  de  commande,  puis
              terminer.

       --usage
              Afficher un court message d'aide et terminer.

       -V, --version
              Afficher la version du programme et terminer.

STANDARDS

       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)
           {
               for (unsigned int j = 0; j < lim; j++)
           getppid();
           }

           void
           x1(void) {
               for (unsigned int j = 0; j < 100; j++)
           consumeCpu1(200000);
           }

           void
           consumeCpu2(int lim)
           {
               for (unsigned int j = 0; j < lim; j++)
           getppid();
           }

           void
           x2(void)
           {
               for (unsigned int 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)

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  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   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⟩.