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 de la structure contenant les
détails des allocations mémoires effectuées par
malloc(3) et pour d'autres fonctions associées. La structure est
déclarée 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; /* Maximum total d'espace alloué (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
- Le « niveau haut » d'espace alloué
— c'est-à-dire la quantité d'espace 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é total d'espace libérable en plus 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).
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 », met é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 enclos
mémoires (« arenas ») sont exclues. Consultez
malloc_stats(3) et
malloc_info(3) pour les alternatives qui
contiennent des renseignements sur d'autres enclos mémoires.
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.
EXEMPLE¶
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 pas
à 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 suivant directement
la position du dernier bloc à libérer (le nombre suivant directement
le 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
============= 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) : 104000
Espace alloué total (uordblks) : 31168
Espace libre total (fordblks) : 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) : 52000
Espace alloué total (uordblks) : 83168
Espace libre total (fordblks) : 31168
Source du programme¶
#include <malloc.h>
#include "tlpi_hdr.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("Plus grand bloc libérable (keepcost) : %d\n", mi.keepcost);
}
int
main(int argc, char *argv[])
{
#define MAX_ALLOCS 2000000
char *alloc[MAX_ALLOCS];
int nbBlocs, j, debutLib, finLib, pasLib;
size_t tailleBloc;
if (argc < 3 || strcmp(argv[1], "--help") == 0)
usageErr("%s nb-blocs taille-bloc [pas-lib [début-lib "
"[fin-lib]]]\n", argv[0]);
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 (j = 0; j < nbBlocs; j++) {
if (nbBlocs >= MAX_ALLOCS)
fatal("Trop d'allocations");
alloc[j] = malloc(tailleBloc);
if (alloc[j] == NULL)
errExit("malloc");
}
printf("\n============= Après allocation des blocs =============\n");
display_mallinfo();
for (j = debutLib; j < finLib; j += pasLib)
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 3.44 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> ».