Provided by: manpages-fr_4.18.1-1_all bug

NOM

       memusage - Profiler l'utilisation par un programme de la mémoire

SYNOPSIS

       memusage [option]... programme [optionprogramme]...

DESCRIPTION

       memusage  est  un  script  bash  qui  profile l'utilisation de la mémoire par le programme
       programme. Il précharge la bibliothèque libmemusage.so dans l'environnement de  l'appelant
       (au  moyen  de  la  variable  d'environnement LD_PRELOAD ; voir ld.so(8)). La bibliothèque
       libmemusage.so trace l'allocation de mémoire  en  interceptant  les  appels  à  malloc(3),
       calloc(3),  free(3)  et  realloc(3) ;  facultativement, les appels à mmap(2), mremap(2) et
       munmap(2) peuvent aussi être interceptés.

       memusage peut produire les données collectées sous une forme textuelle ou il peut utiliser
       memusagestat(1)  (voir  l'option  -p  ci-dessous) pour créer un fichier PNG fournissant la
       représentation graphique des données collectées.

   Résumé de l'utilisation de la mémoire
       La ligne « Memory usage summary » produite par memusage contient trois champs :

           heap total
                  Somme des  paramètres  taille  de  tous  les  appels  malloc(3),  les  produits
                  (nmemb*taille) de tous les appels calloc(3) et la somme des paramètres longueur
                  de tous les appels mmap(2). Dans le cas d'appels realloc(3) et mremap(2), si la
                  nouvelle  taille  d'une allocation est plus grande que la taille précédente, la
                  somme de toutes les différences (nouvelle taille  moins  ancienne  taille)  est
                  ajoutée.

           heap peak
                  Maximum  de  tous  les  paramètres  taille  de  malloc(3), de tous les produits
                  (nmemb*taille) de calloc(3) et de tous les paramètres taille  de  realloc,  des
                  paramètres longueur de mmap(2) et des paramètres nouvelle_taille de mremap(2).

           stack peak
                  Avant  le  premier appel à toute fonction suivie, l'adresse du pointeur de pile
                  (pointeur de pile de base) est sauvegardée. Après  chaque  appel  de  fonction,
                  l'adresse  du  pointeur  de  pile  effectif  est  lue  et la différence avec le
                  pointeur de pile de base est calculée. La plus grande de  ces  différences  est
                  alors le « pic de la pile » (« stack peak »).

       Immédiatement  après la ligne de résumé, un tableau montre le nombre d'appels, le total de
       la mémoire allouée ou désallouée et le  nombre  d'échecs  d'appels  pour  chaque  fonction
       interceptée.  Pour  realloc(3) et mremap(2), le champ supplémentaire « nomove » montre les
       réallocations qui ont changé l'adresse d'un bloc et le champ supplémentaire « dec » montre
       les  réallocations  qui  ont  diminué  la  taille  du  bloc.  Pour  realloc(3),  le  champ
       supplémentaire « free » montre les réallocations qui ont provoqué la libération d'un  bloc
       (c'est-à-dire dont la taille réallouée est de 0).

       La colonne « realloc/total memory » du tableau produit par memusage ne reflète pas les cas
       où realloc(3) est utilisé pour réallouer un bloc de mémoire pour qu'il ait une taille plus
       petite  qu'avant.  Ce  cas peut faire que la somme de toutes les cellules « total memory »
       (sauf « free ») est plus grande que la cellule « free/total memory ».

   Histogrammes des tailles de bloc
       L'« Histogram for block sizes » fournit une répartition  des  allocations  de  mémoire  en
       paquets de tailles diverses.

OPTIONS

       -n nom, --progname=nom
              Nom du fichier de programme à profiler.

       -p fichier, --png=fichier
              Créer un fichier graphique PNG et l'enregistrer dans fichier.

       -d fichier, --data=fichier
              Créer un fichier de données binaires et l'enregistrer dans fichier.

       -u, --unbuffered
              Ne pas mettre la sortie en tampon.

       -b taille, --buffer=taille
              Rassembler les entrées de taille avant de les écrire.

       --no-timer
              Désactiver  l'échantillonnage  basé  sur le temporisateur (SIGPROF) de la valeur du
              pointeur de pile.

       -m, --mmap
              Tracer aussi mmap(2), mremap(2) et munmap(2).

       -?, --help
              Afficher l'aide puis quitter.

       --usage
              Afficher une brève description sur l'utilisation et quitter.

       -V, --version
              Afficher les informations de version, puis quitter.

       Les options suivantes ne s'appliquent que lors de la création d'une sortie graphique :

       -t, --time-based
              Utiliser le temps (plutôt que le nombre d'appels  de  fonction)  comme  échelle  de
              l'axe X.

       -T, --total
              Créer aussi un graphique de l'usage total de la mémoire.

       --title=nom
              Utiliser nom comme titre du graphique.

       -x taille, --x-size=taille
              Créer un graphique d'une largeur de taille pixels.

       -y taille, --y-size=taille
              Créer un graphique d'une hauteur de taille pixels.

CODE DE RETOUR

       Le code de retour est égal au code de retour du programme profilé.

BOGUES

       Pour signaler des bogues, voir ⟨http://www.gnu.org/software/libc/bugs.html

EXEMPLES

       Ci-dessous se trouve un programme simple qui réalloue de façon cyclique un bloc de mémoire
       qui atteint un sommet avant de réallouer la mémoire de façon cyclique dans des blocs  plus
       petits  qui  diminuent  jusqu'à  zéro.  Après  compilation  du  programme et exécution des
       commandes suivantes, un graphique de l'utilisation de  la  mémoire  par  le  programme  se
       trouve dans le fichier memusage.png :

           $ memusage --data=memusage.dat ./a.out
           ...
           Memory usage summary: heap total: 45200, heap peak: 6440, stack peak: 224
                   total calls  total memory  failed calls
            malloc|         1           400             0
           realloc|        40         44800             0  (nomove:40, dec:19, free:0)
            calloc|         0             0             0
              free|         1           440
           Histogram for block sizes:
             192-207             1   2% ================
           ...
            2192-2207            1   2% ================
            2240-2255            2   4% =================================
            2832-2847            2   4% =================================
            3440-3455            2   4% =================================
            4032-4047            2   4% =================================
            4640-4655            2   4% =================================
            5232-5247            2   4% =================================
            5840-5855            2   4% =================================
            6432-6447            1   2% ================
           $ memusagestat memusage.dat memusage.png

   Source du programme
       #include <stdio.h>
       #include <stdlib.h>

       #define CYCLES 20

       int
       main(int argc, char *argv[])
       {
           int i, j;
           size_t size;
           int *p;

           size = sizeof(*p) * 100;
           printf("malloc: %zu\n", size);
           p = malloc(size);

           for (i = 0; i < CYCLES; i++) {
               if (i < CYCLES / 2)
                   j = i;
               else
                   j--;

               size = sizeof(*p) * (j * 50 + 110);
               printf("realloc: %zu\n", size);
               p = realloc(p, size);

               size = sizeof(*p) * ((j + 1) * 150 + 110);
               printf("realloc: %zu\n", size);
               p = realloc(p, size);
           }

           free(p);
           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       memusagestat(1), mtrace(1), ld.so(8)

TRADUCTION

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

       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⟩.