mallinfo, mallinfo2 - Obtenir les paramètres d'allocation de
mémoire
Bibliothèque C standard (
libc,
-lc)
#include <malloc.h>
struct mallinfo mallinfo(void);
struct mallinfo2 mallinfo2(void);
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
- This field is unused, and is always 0. Historically, it was
the "highwater mark" for allocated space—that is, the
maximum amount of space that was ever allocated (in bytes); this field was
maintained only in nonthreading environments.
- 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).
La fonction
mallinfo2() a été ajoutée dans la
version 2.33 de la glibc.
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.
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.
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.
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
#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, "Too many 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);
}
mmap(2),
malloc(3),
malloc_info(3),
malloc_stats(3),
malloc_trim(3),
mallopt(3)
La traduction française de cette page de manuel a été
créée par Christophe Blaess
<
https://www.blaess.fr/christophe/>, Stéphan Rafin
<
[email protected]>, Thierry Vignaud
<
[email protected]>, François Micaux, Alain Portal
<
[email protected]>, Jean-Philippe Guérard
<
[email protected]>, Jean-Luc Coulon (f5ibh)
<
[email protected]>, Julien Cristau
<
[email protected]>, Thomas Huriaux <
[email protected]>,
Nicolas François <
[email protected]>, Florentin
Duneau <
[email protected]>, Simon Paillard
<
[email protected]>, Denis Barbier
<
[email protected]>, David Prévot <
[email protected]> et
Grégoire Scano <
[email protected]>
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 à
[email protected]