mallinfo(3) Library Functions Manual mallinfo(3) NOM mallinfo, mallinfo2 - Obtenir les parametres d'allocation de memoire BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include struct mallinfo mallinfo(void); struct mallinfo2 mallinfo2(void); DESCRIPTION Ces fonctions renvoient une copie de la structure contenant les informations sur les allocations memoires effectuees par malloc(3) et les fonctions qui lui sont associees. La structure renvoyee par chaque fonction contient les memes champs. Cependant, la fonction plus ancienne mallinfo() est obsolete puisque le type des champs est trop petit (voir BOGUES). Il est a noter que toutes les allocations ne sont pas observables par ces fonctions ; consultez BOGUES et envisagez l'utilisation de malloc_info(3) a la place. La structure mallinfo2 renvoyee par mallinfo2() est definie comme suit : struct mallinfo { size_t arena; /* Espace alloue en memoire non projetee (octet) */ size_t ordblks; /* Nombre de fragments libres */ size_t smblks; /* Nombre de blocs << fastbin >> libres */ size_t hblks; /* Nombre de zones de memoire projetee */ size_t hblkhd; /* Espace alloue en zones de mem. projetee (octet) */ size_t usmblks; /* Voir ci-dessous */ size_t fsmblks; /* Espace en blocs << fastbin >> liberes (octet) */ size_t uordblks; /* Espace alloue total (octet) */ size_t fordblks; /* Espace libre total (octet) */ size_t keepcost; /* Plus grand espace liberable (octet) */ }; La structure mallinfo renvoyee par la fonction obsolete mallinfo() est exactement la meme mis a part que les champs sont de type int. Les champs de la structure contiennent les informations suivantes : arena La quantite de memoire allouee par d'autres moyens que mmap(2) (c'est-a-dire la memoire allouee dans le tas). Ce chiffre inclut a la fois les blocs en cours d'utilisation et ceux marques comme libres. ordblks Le nombre de blocs libres normaux (c'est-a-dire non << fastbin >>). smblks Le nombre de blocs libres << fastbin >> (consultez mallopt(3)). hblks Le nombre de blocs actuellement alloues par mmap(2). Consultez mallopt(3) pour l'explication de M_MMAP_THRESHOLD. hblkhd Le nombre d'octets des blocs actuellement alloues par mmap(2). usmblks Ce champ n'est pas utilise et vaut toujours 0. Historiquement, c'etait le << niveau haut >> d'espace alloue -- c'est-a-dire la quantite d'espace maximale qui a deja ete allouee. 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 consommes par des allocations en cours d'utilisation. fordblks Le nombre total d'octets dans les blocs libres. keepcost La quantite totale d'espace liberable au sommet du tas. C'est le nombre maximal d'octets qui pourraient au mieux (c'est-a-dire en ignorant les restrictions d'alignement de page, etc.) etre liberes par malloc_trim(3). ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +------------+--------------------------+------------------------------+ |Interface | Attribut | Valeur | +------------+--------------------------+------------------------------+ |mallinfo(), | Securite des threads | MT-Unsafe init const:mallopt | |mallinfo2() | | | +------------+--------------------------+------------------------------+ mallinfo()/malloinfo2() accede a des objets globaux internes. S'ils sont modifies de facon non atomique, les resultats peuvent ne pas etre coherents. L'identifiant mallopt dans const::mallopt signifie que mallopt() modifie ces objets globaux internes de facon atomique, rendant mallinfo()/mallinfo2() suffisamment sur, d'autres modifications non atomiques ne le garantissant peut-etre pas. STANDARDS Aucun. HISTORIQUE mallinfo() glibc 2.0. SVID. mallinfo2() glibc 2.33. BOGUES Les renseignements ne sont renvoyes que pour la zone principale d'allocation de memoire. 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 renvoyee par l'ancienne fonction mallinfo() sont de type int. Cependant, puisque certaines valeurs servant a la gestion interne pourraient etre de type long, les valeurs rendues pourraient etre arrondies a zero et etre par consequent incorrectes. EXEMPLES Le programme ci-dessous utilise mallinfo2() pour recuperer les statistiques d'allocation de memoire avant et apres l'allocation et la liberation de certains blocs de memoire. Les statistiques sont affichees sur la sortie standard. Les deux premiers parametres en ligne de commande definissent le nombre et la taille des blocs a allouer avec malloc(3). Les trois arguments restants definissent les blocs alloues qui devraient etre liberes avec free(3). Ces trois arguments sont facultatifs et definissent (dans l'ordre) : la taille du tas a utiliser dans la boucle qui libere les blocs (1 par defaut, ce qui signifie de liberer tous les blocs de l'intervalle), la position du premier bloc a liberer (0 par defaut, ce qui signifie le premier bloc alloue) et un nombre superieur d'une unite a la position du dernier bloc a liberer (le nombre superieur de 1 au nombre maximal de blocs par defaut). Si aucun de ces trois arguments n'est present, tous les blocs seront liberes par defaut. Dans l'exemple suivant, 1000 allocations de 100 octets sont effectuees, puis chaque deuxieme bloc alloue est libere : $ ./a.out 1000 100 2 ============== Before allocating blocks ============== Total non-mmapped bytes (arena): 0 # of free chunks (ordblks): 1 # of free fastbin blocks (smblks): 0 # of mapped regions (hblks): 0 Bytes in mapped regions (hblkhd): 0 Max. total allocated space (usmblks): 0 Free bytes held in fastbins (fsmblks): 0 Total allocated space (uordblks): 0 Total free space (fordblks): 0 Topmost releasable block (keepcost): 0 ============== After allocating blocks ============== Total non-mmapped bytes (arena): 135168 # of free chunks (ordblks): 1 # of free fastbin blocks (smblks): 0 # of mapped regions (hblks): 0 Bytes in mapped regions (hblkhd): 0 Max. total allocated space (usmblks): 0 Free bytes held in fastbins (fsmblks): 0 Total allocated space (uordblks): 104000 Total free space (fordblks): 31168 Topmost releasable block (keepcost): 31168 ============== After freeing blocks ============== Total non-mmapped bytes (arena): 135168 # of free chunks (ordblks): 501 # of free fastbin blocks (smblks): 0 # of mapped regions (hblks): 0 Bytes in mapped regions (hblkhd): 0 Max. total allocated space (usmblks): 0 Free bytes held in fastbins (fsmblks): 0 Total allocated space (uordblks): 52000 Total free space (fordblks): 83168 Topmost releasable block (keepcost): 31168 Source du programme #include #include #include static void display_mallinfo2(void) { struct mallinfo2 mi; mi = mallinfo2(); printf("Total non-mmapped bytes (arena): %zu\n", mi.arena); printf("# of free chunks (ordblks): %zu\n", mi.ordblks); printf("# of free fastbin blocks (smblks): %zu\n", mi.smblks); printf("# of mapped regions (hblks): %zu\n", mi.hblks); printf("Bytes in mapped regions (hblkhd): %zu\n", mi.hblkhd); printf("Max. total allocated space (usmblks): %zu\n", mi.usmblks); printf("Free bytes held in fastbins (fsmblks): %zu\n", mi.fsmblks); printf("Total allocated space (uordblks): %zu\n", mi.uordblks); printf("Total free space (fordblks): %zu\n", mi.fordblks); printf("Topmost releasable block (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 num-blocks block-size [free-step " "[start-free [end-free]]]\n", argv[0]); exit(EXIT_FAILURE); } numBlocks = atoi(argv[1]); blockSize = atoi(argv[2]); freeStep = (argc > 3) ? atoi(argv[3]) : 1; freeBegin = (argc > 4) ? atoi(argv[4]) : 0; freeEnd = (argc > 5) ? atoi(argv[5]) : numBlocks; printf("============== Before allocating blocks ==============\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(blockSize); if (alloc[j] == NULL) { perror("malloc"); exit(EXIT_FAILURE); } } printf("\n============== After allocating blocks ==============\n"); display_mallinfo2(); for (size_t j = freeBegin; j < freeEnd; j += freeStep) free(alloc[j]); printf("\n============== After freeing blocks ==============\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 francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Gregoire Scano Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 mallinfo(3)