Provided by: manpages-fr-dev_3.57d1p1-1_all bug

NOM

       malloc_info - Exporter l'état de malloc vers un flux

SYNOPSIS

       #include <malloc.h>

       int malloc_info(int options, FILE *fp);

DESCRIPTION

       La fonction malloc_info() exporte un flux XML décrivant l'état actuel d'allocation mémoire
       pour l'appelant. Cette chaîne de caractères est affichée sur le descripteur de fichier fp.
       Cette  chaîne  contient les informations concernant tous les enclos mémoires (« arenas »),
       consultez malloc(3).

       Dans la mise en œuvre actuelle, le paramètre options doit être nul.

VALEUR RENVOYÉE

       En cas de succès, malloc_info() renvoie zéro. En cas d'erreur, -1  est  renvoyé  et  errno
       contient le code d'erreur.

ERREURS

       EINVAL Le paramètre options n'était pas nul.

VERSIONS

       malloc_info() est disponible depuis la glibc 2.10.

CONFORMITÉ

       Cette fonction est une extension GNU.

NOTES

       L'information  d'allocation  mémoire  est  fournie  sous  forme de flux XML (plutôt que de
       structure C) car les informations fournies pourront évoluer dans le futur,  en  raison  de
       modifications dans le code mis en œuvre. La sortie XML comporte un champ de version.

       La  fonction  open_memstream(3) peut être utilisée pour envoyer la sortie de malloc_info()
       directement dans un tampon en mémoire plutôt que dans un fichier.

       La fonction malloc_info() est conçue  pour  combler  les  manques  de  malloc_stats(3)  et
       mallinfo(3).

EXEMPLE

       Le  programme  ci-dessous accepte jusqu'à quatre paramètres en ligne de commande, dont les
       trois premiers sont obligatoires. Le premier paramètre  indique  le  nombre  de  processus
       légers  (« threads »)  que  le  programme  doit  créer. Tous les threads, thread principal
       compris, allouent le nombre  de  blocs  de  mémoire  indiqué  en  deuxième  paramètre.  Le
       troisième  paramètre  contrôle la taille des blocs à allouer. Le thread principal crée des
       blocs de cette taille, le deuxième thread créé par le programme alloue des blocs deux fois
       plus grands, le troisième thread alloue des blocs trois fois plus grands, ainsi de suite.

       Le programme appelle malloc_info() deux fois pour afficher l'état de l'allocation mémoire.
       Le premier appel est effectué avant la création de thread ou l'allocation de  mémoire.  Le
       deuxième appel est effectué une fois que tous les threads ont alloué de la mémoire.

       Dans  l'exemple  suivant,  les  paramètres commandent la création d'un thread additionnel,
       allouant 10000 blocs de mémoire, comme le thread principal. Une fois les blocs de  mémoire
       alloués, malloc_info() affiche l'état des deux enclos mémoire.

           $ getconf GNU_LIBC_VERSION
           glibc 2.13
           $ ./a.out 1 10000 100
           ============ Avant allocation des blocs ============
           <malloc version="1">
           <heap nr="0">
           <sizes>
           </sizes>
           <total type="fast" count="0" size="0"/>
           <total type="rest" count="0" size="0"/>
           <system type="current" size="135168"/>
           <system type="max" size="135168"/>
           <aspace type="total" size="135168"/>
           <aspace type="mprotect" size="135168"/>
           </heap>
           <total type="fast" count="0" size="0"/>
           <total type="rest" count="0" size="0"/>
           <system type="current" size="135168"/>
           <system type="max" size="135168"/>
           <aspace type="total" size="135168"/>
           <aspace type="mprotect" size="135168"/>
           </malloc>

           ============ Après allocation des blocs ============
           <malloc version="1">
           <heap nr="0">
           <sizes>
           </sizes>
           <total type="fast" count="0" size="0"/>
           <total type="rest" count="0" size="0"/>
           <system type="current" size="1081344"/>
           <system type="max" size="1081344"/>
           <aspace type="total" size="1081344"/>
           <aspace type="mprotect" size="1081344"/>
           </heap>
           <heap nr="1">
           <sizes>
           </sizes>
           <total type="fast" count="0" size="0"/>
           <total type="rest" count="0" size="0"/>
           <system type="current" size="1032192"/>
           <system type="max" size="1032192"/>
           <aspace type="total" size="1032192"/>
           <aspace type="mprotect" size="1032192"/>
           </heap>
           <total type="fast" count="0" size="0"/>
           <total type="rest" count="0" size="0"/>
           <system type="current" size="2113536"/>
           <system type="max" size="2113536"/>
           <aspace type="total" size="2113536"/>
           <aspace type="mprotect" size="2113536"/>
           </malloc>

   Source du programme
       #include <unistd.h>
       #include <stdlib.h>
       #include <pthread.h>
       #include <malloc.h>
       #include <errno.h>

       static size_t tailleBloc;
       static int nbThreads, nbBlocs;

       #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                               } while (0)

       static void *
       thread_func(void *arg)
       {
           int j;
           int tn = (int) arg;

           /* Le multiplicateur '(2 + tn)' s'assure que chaque thread (dont
              le thread principal) alloue une quantité de mémoire différente */

           for (j = 0; j < nbBlocs; j++)
               if (malloc(tailleBloc * (2 + tn)) == NULL)
                   errExit("malloc-thread");

           sleep(100);         /* Attendre que le thread principal se termine */
           return NULL;
       }

       int
       main(int argc, char *argv[])
       {
           int j, tn, tpsSommeil;
           pthread_t *thr;

           if (argc < 4) {
               fprintf(stderr,
                       "%s nb-threads nb-blocs taille-bloc [tps-sommeil]\n",
                       argv[0]);
               exit(EXIT_FAILURE);
           }

           nbThreads = atoi(argv[1]);
           nbBlocs = atoi(argv[2]);
           tailleBloc = atoi(argv[3]);
           tpsSommeil = (argc > 4) ? atoi(argv[4]) : 0;

           thr = calloc(nbThreads, sizeof(pthread_t));
           if (thr == NULL)
               errExit("calloc");

           printf("============ Avant allocation des blocs ============\n");
           malloc_info(0, stdout);

           /* Crée les threads allouant des quantités de mémoire différentes */

           for (tn = 0; tn < nbThreads; tn++) {
               errno = pthread_create(&thr[tn], NULL, thread_func,
                                      (void *) tn);
               if (errno != 0)
                   errExit("pthread_create");

               /* Si un intervalle de sommeil existe après le démarrage de
                  chaque thread, les threads ne vont sans doute pas se battre
                  pour les mutex malloc, et par conséquent les enclos mémoire
                  supplémentaires ne seront pas alloués (consultez malloc(3)).
                  */

               if (tpsSommeil > 0)
                   sleep(tpsSommeil);
           }

           /* Le thread principal alloue également de la mémoire */

           for (j = 0; j < nbBlocs; j++)
               if (malloc(tailleBloc) == NULL)
                   errExit("malloc");

           sleep(2);           /* Donne à tous les threads une chance
                                  de terminer les allocations */

           printf("\n============ Après allocation des blocs ============\n");
           malloc_info(0, stdout);

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       mallinfo(3), malloc(3), malloc_stats(3), mallopt(3), open_memstream(3)

COLOPHON

       Cette  page  fait partie de la publication 3.57 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Depuis    2010,    cette   traduction   est   maintenue   à   l'aide   de   l'outil   po4a
       <http://po4a.alioth.debian.org/> par l'équipe de traduction francophone au sein du  projet
       perkamon <http://perkamon.alioth.debian.org/>.

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>  ou  par  un  rapport  de  bogue   sur   le   paquet
       manpages-fr.

       Vous  pouvez  toujours  avoir  accès  à la version anglaise de ce document en utilisant la
       commande « man -L C <section> <page_de_man> ».