Provided by: manpages-fr-dev_4.19.0-7_all 
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).
┌────────────────────────┬──────────────────────┬─────────────────────────────────────────┐
│Interface │ Attribut │ Valeur │
├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
│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⟩.