noble (1) sprof.1.gz

Provided by: manpages-fr_4.21.0-2_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⟩.