#include <malloc.h> struct mallinfo mallinfo(void); struct mallinfo2 mallinfo2(void);
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 :
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.
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.
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
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();
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 à