Provided by: manpages-fr-dev_4.13-4_all 
NOM
mallinfo - Obtenir les paramètres d'allocation de mémoire
SYNOPSIS
#include <malloc.h>
struct mallinfo mallinfo(void);
DESCRIPTION
La fonction mallinfo() renvoie une copie d'une structure contenant les détails des allocations mémoire
effectuées par malloc(3) et d'autres fonctions associées.
Il est à noter que toutes les allocations ne sont pas observables par mallinfo() ; consultez BOGUES et
considérez l'utilisation de malloc_info(3) à la place.
La structure renvoyée est définie comme suit :
struct mallinfo {
int arena; /* Espace alloué en mémoire non projetée (o) */
int ordblks; /* Nombre de fragments libres */
int smblks; /* Nombre de blocs « fastbin » libres */
int hblks; /* Nombre de zones de mémoire projetée */
int hblkhd; /* Espace alloué en zones de mém. projetée (o) */
int usmblks; /* Voir plus bas (octet) */
int fsmblks; /* Espace en blocs « fastbin » libérés (octet) */
int uordblks; /* Espace alloué total (octet) */
int fordblks; /* Espace libre total (octet) */
int keepcost; /* Plus grand espace libérable (octet) */
};
Les champs de la structure mallinfo 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).
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌────────────┬──────────────────────┬──────────────────────────────┐
│ Interface │ Attribut │ Valeur │
├────────────┼──────────────────────┼──────────────────────────────┤
│ mallinfo() │ Sécurité des threads │ MT-Unsafe init const:mallopt │
└────────────┴──────────────────────┴──────────────────────────────┘
mallinfo() 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() suffisamment sûr, d'autres
modifications non atomiques ne le garantissant peut-être pas.
CONFORMITÉ
Cette fonction n'est pas spécifiée par les standards POSIX ou C. Une fonction similaire 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 sont notés 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 mallinfo() 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_mallinfo(void)
{
struct mallinfo mi;
mi = mallinfo();
printf("Total d'o en mém. non projetée (arena) : %d\n", mi.arena);
printf("Nb. de fragments libres (ordblks) : %d\n", mi.ordblks);
printf("Nb. de blocs fastbin libres (smblks) : %d\n", mi.smblks);
printf("Nb. de zones de mémoire projetée : %d\n", mi.hblks);
printf("Octets en mém. non projetée (hblkhd) : %d\n", mi.hblkhd);
printf("Max. total d'espace alloué (usmblks) : %d\n", mi.usmblks);
printf("Octets libres en fastbins (fsmblks) : %d\n", mi.fsmblks);
printf("Espace alloué total (uordblks) : %d\n", mi.uordblks);
printf("Espace libre total (fordblks) : %d\n", mi.fordblks);
printf("Bloc sup. maxi. libérable (keepcost) : %d\n", mi.keepcost);
}
int
main(int argc, char *argv[])
{
#define MAX_ALLOCS 2000000
char *alloc[MAX_ALLOCS];
int numBlocks, freeBegin, freeEnd, freeStep;
size_t blockSize;
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_mallinfo();
for (int 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_mallinfo();
for (int j = freeBegin; j < freeEnd; j += freeStep)
free(alloc[j]);
printf("\n============= Après libération des blocs =============\n");
display_mallinfo();
exit(EXIT_SUCCESS);
}
VOIR AUSSI
mmap(2), malloc(3), malloc_info(3), malloc_stats(3), malloc_trim(3), mallopt(3)
COLOPHON
Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des
instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à
l'adresse https://www.kernel.org/doc/man-pages/.
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 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.
Linux 1 novembre 2020 MALLINFO(3)