Provided by: manpages-fr-dev_4.21.0-2_all bug

NOM

       mallinfo, mallinfo2 - Obtenir les paramètres d'allocation de mémoire

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <malloc.h>

       struct mallinfo mallinfo(void);
       struct mallinfo2 mallinfo2(void);

DESCRIPTION

       Ces  fonctions  renvoient  une  copie  de  la structure contenant les informations sur les
       allocations mémoires effectuées par malloc(3) et les fonctions qui lui sont associées.  La
       structure  renvoyée  par chaque fonction contient les mêmes champs. Cependant, la fonction
       plus ancienne mallinfo() est obsolète puisque le type des  champs  est  trop  petit  (voir
       BOGUES).

       Il  est  à  noter  que  toutes les allocations ne sont pas observables par ces fonctions ;
       consultez BOGUES et envisagez l'utilisation de malloc_info(3) à la place.

       La structure mallinfo2 renvoyée par mallinfo2() est définie comme suit :

           struct mallinfo {
               size_t arena;     /* Espace alloué en mémoire non projetée (octet) */
               size_t ordblks;   /* Nombre de fragments libres */
               size_t smblks;    /* Nombre de blocs « fastbin » libres */
               size_t hblks;     /* Nombre de zones de mémoire projetée */
               size_t hblkhd;    /* Espace alloué en zones de mém. projetée (octet) */
               size_t usmblks;   /* Voir ci-dessous */
               size_t fsmblks;   /* Espace en blocs « fastbin » libérés (octet) */
               size_t uordblks;  /* Espace alloué total (octet) */
               size_t fordblks;  /* Espace libre total (octet) */
               size_t keepcost;  /* Plus grand espace libérable (octet) */
           };

       La structure mallinfo renvoyée par la fonction obsolète mallinfo() est exactement la  même
       mis à part que les champs sont de type int.

       Les champs de la structure contiennent les informations suivantes :

       arena     La  quantité de mémoire allouée par d'autres moyens que mmap(2) (c'est-à-dire la
                 mémoire allouée dans le tas). Ce chiffre inclut à la fois  les  blocs  en  cours
                 d'utilisation et ceux marqués comme libres.

       ordblks   Le nombre de blocs libres normaux (c'est-à-dire non « fastbin »).

       smblks    Le nombre de blocs libres « fastbin » (consultez mallopt(3)).

       hblks     Le  nombre  de blocs actuellement alloués par mmap(2). Consultez mallopt(3) pour
                 l'explication de M_MMAP_THRESHOLD.

       hblkhd    Le nombre d'octets des blocs actuellement alloués par mmap(2).

       usmblks   Ce champ n'est pas  utilisé  et  vaut  toujours 0.  Historiquement,  c’était  le
                 « niveau haut » d'espace alloué — c'est-à-dire la quantité d'espace maximale qui
                 a déjà été allouée. Ce champ n'est maintenu que  dans  les  environnements  sans
                 thread.

       fsmblks   Le nombre total d'octets dans les blocs libres « fastbin ».

       uordblks  Le nombre total d'octets consommés par des allocations en cours d'utilisation.

       fordblks  Le nombre total d'octets dans les blocs libres.

       keepcost  La  quantité totale d'espace libérable au sommet du tas. C'est le nombre maximal
                 d'octets qui pourraient au mieux  (c'est-à-dire  en  ignorant  les  restrictions
                 d'alignement de page, etc.) être libérés par malloc_trim(3).

VERSIONS

       La fonction mallinfo2() a été ajoutée dans la version 2.33 de la glibc.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌────────────────────────┬──────────────────────┬─────────────────────────────────────────┐
       │InterfaceAttributValeur                                  │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │mallinfo(), mallinfo2() │ Sécurité des threads │ MT-Unsafe init const:mallopt            │
       └────────────────────────┴──────────────────────┴─────────────────────────────────────────┘
       mallinfo()/malloinfo2() accède à des objets globaux internes. S'ils sont modifiés de façon
       non atomique, les résultats peuvent ne pas  être  cohérents.  L'identifiant  mallopt  dans
       const::mallopt  signifie  que  mallopt()  modifie  ces  objets  globaux  internes de façon
       atomique, rendant mallinfo()/mallinfo2()  suffisamment  sûr,  d'autres  modifications  non
       atomiques ne le garantissant peut-être pas.

STANDARDS

       Ces  fonctions  ne  sont pas spécifiées par les normes POSIX ou C. Une fonction mallinfo()
       existe sur de nombreux dérivés de System V et était spécifiée dans SVID.

BOGUES

       Les renseignements ne sont renvoyés que pour la zone principale d'allocation  de  mémoire.
       Les  allocations  dans  les  autres  domaines  sont  exclues. Consultez malloc_stats(3) et
       malloc_info(3) pour les alternatives  qui  contiennent  des  renseignements  sur  d'autres
       domaines.

       Les  champs  de  la structure mallinfo renvoyée par l'ancienne fonction mallinfo() sont de
       type int. Cependant, puisque certaines valeurs servant à  la  gestion  interne  pourraient
       être  de  type  long,  les  valeurs  rendues  pourraient être arrondies à zéro et être par
       conséquent incorrectes.

EXEMPLES

       Le programme ci-dessous utilise mallinfo2() pour récupérer les  statistiques  d'allocation
       de  mémoire avant et après l'allocation et la libération de certains blocs de mémoire. Les
       statistiques sont affichées sur la sortie standard.

       Les deux premiers paramètres en ligne de commande définissent le nombre et la  taille  des
       blocs à allouer avec malloc(3).

       Les trois arguments restants définissent les blocs alloués qui devraient être libérés avec
       free(3). Ces trois arguments sont facultatifs et définissent (dans l'ordre) : la taille du
       tas  à  utiliser  dans  la  boucle  qui libère les blocs (1 par défaut, ce qui signifie de
       libérer tous les blocs de l'intervalle), la position du premier  bloc  à  libérer  (0  par
       défaut,  ce  qui  signifie le premier bloc alloué) et un nombre supérieur d’une unité à la
       position du dernier bloc à libérer (le nombre supérieur de 1 au nombre  maximal  de  blocs
       par  défaut). Si aucun de ces trois arguments n'est présent, tous les blocs seront libérés
       par défaut.

       Dans l'exemple suivant,  1000 allocations  de  100 octets  sont  effectuées,  puis  chaque
       deuxième bloc alloué est libéré :

           $ ./a.out 1000 100 2
           ============= Avant allocation des blocs =============
           Total d'o. en mém. non projetée (arena) : 0
           Nb. de fragments libres (ordblks) :       1
           Nb. de blocs fastbin libres (smblks) :    0
           Nb. de zones de mémoire projetée :        0
           Octets en mém. non projetée (hblkhd) :    0
           Max. total d'espace alloué (usmblks) :    0
           Octets libres en fastbins (fsmblks) :     0
           Espace alloué total (uordblks) :          0
           Espace libre total (fordblks) :           0
           Bloc sup. maxi. libérable (keepcost) :    0

           ============= Après libération des blocs =============
           Total d'o en mém. non projetée (arena) : 135168
           Nb. de fragments libres (ordblks) :      1
           Nb. de blocs fastbin libres (smblks) :   0
           Nb. de zones de mémoire projetée :       0
           Octets en mém. non projetée (hblkhd) :   0
           Max. total d'espace alloué (usmblks) :   0
           Octets libres en fastbins (fsmblks) :    0
           Espace alloué total (uordblks) :         104000
           Espace libre total (fordblks) :          31168
           Bloc sup. maxi. libérable (keepcost) :   31168

           ============= Avant allocation des blocs =============
           Total d'o en mém. non projetée (arena) : 135168
           Nb. de fragments libres (ordblks) :      501
           Nb. de blocs fastbin libres (smblks) :   0
           Nb. de zones de mémoire projetée :       0
           Octets en mém. non projetée (hblkhd) :   0
           Max. total d'espace alloué (usmblks) :   0
           Octets libres en fastbins (fsmblks) :    0
           Espace alloué total (uordblks) :         52000
           Espace libre total (fordblks) :          83168
           Bloc sup. maxi. libérable (keepcost) :   31168

   Source du programme

       #include <malloc.h>
       #include <stdlib.h>
       #include <string.h>

       static void
       display_mallinfo2(void)
       {
           struct mallinfo2 mi;

           mi = mallinfo2();

           printf("Total d'o en mém. non projetée (arena) : %zu\n", mi.arena);
           printf("Nb. de fragments libres (ordblks) :      %zu\n", mi.ordblks);
           printf("Nb. de blocs fastbin libres (smblks) :   %zu\n", mi.smblks);
           printf("Nb. de zones de mémoire projetée :       %zu\n", mi.hblks);
           printf("Octets en mém. non projetée (hblkhd) :   %zu\n", mi.hblkhd);
           printf("Max. total d'espace alloué (usmblks) :   %zu\n", mi.usmblks);
           printf("Octets libres en fastbins (fsmblks) :    %zu\n", mi.fsmblks);
           printf("Espace alloué total (uordblks) :         %zu\n", mi.uordblks);
           printf("Espace libre total (fordblks) :          %zu\n", mi.fordblks);
           printf("Bloc sup. maxi. libérable (keepcost) :   %zu\n", mi.keepcost);
       }

       int
       main(int argc, char *argv[])
       {
       #define MAX_ALLOCS 2000000
           char *alloc[MAX_ALLOCS];
           size_t blockSize, numBlocks, freeBegin, freeEnd, freeStep;

           if (argc < 3 || strcmp(argv[1], "--help") == 0) {
               fprintf(stderr, "%s nb-blocs taille-bloc [pasLib "
                       "[debutLib [finLib]]]\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           nbBlocs = atoi(argv[1]);
           tailleBloc = atoi(argv[2]);
           pasLib = (argc > 3) ? atoi(argv[3]) : 1;
           debutLib = (argc > 4) ? atoi(argv[4]) : 0;
           finLib = (argc > 5) ? atoi(argv[5]) : nbBlocs;

           printf("============= Avant allocation des blocs =============\n");
           display_mallinfo2();

           for (size_t j = 0; j < numBlocks; j++) {
               if (numBlocks >= MAX_ALLOCS) {
                   fprintf(stderr, "Trop d'allocations\n");
                   exit(EXIT_FAILURE);
               }

               alloc[j] = malloc(tailleBloc);
               if (alloc[j] == NULL)
                   perror("malloc");
                   exit(EXIT_FAILURE);
           }

           printf("\n============= Après allocation des blocs =============\n");
           display_mallinfo2();

           for (size_t j = freeBegin; j < freeEnd; j += freeStep)
               free(alloc[j]);

           printf("\n============= Après libération des blocs =============\n");
           display_mallinfo2();

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       mmap(2), malloc(3), malloc_info(3), malloc_stats(3), malloc_trim(3), mallopt(3)

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 Grégoire Scano
       <gregoire.scano@malloc.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⟩.