mallopt(3) Library Functions Manual mallopt(3) NOM mallopt - Definir les parametres d'allocation de memoire BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include int mallopt(int param, int value); DESCRIPTION La fonction mallopt() ajuste les parametres qui controlent le comportement des fonctions liees a l'allocation de memoire (voir malloc(3)). Le parametre param indique le parametre a modifier, et value indique la nouvelle valeur pour ce parametre. Les valeurs suivantes peuvent etre assignees a param : M_ARENA_MAX Si ce parametre a une valeur non nulle, il definit une limite dure sur le nombre maximal d'arenes qui peuvent etre creees. Une arene represente une reserve de memoire qui peut etre utilisee par des appels a malloc(3) (et fonctions similaires) pour repondre a des requetes d'allocation. Les arenes sont securisees vis-a-vis des fils d'execution et peuvent repondre a de multiples requetes concurrentes. Un compromis est a trouver entre le nombre de fils d'execution et le nombre d'arenes. Plus il y a d'arenes et plus la competition par fil d'execution est basse au detriment d'une consommation memoire plus elevee. La valeur par defaut de ce parametre est 0, ce qui signifie que la limite du nombre d'arenes est determinee conformement a la valeur de M_ARENA_TEST. Ce parametre est disponible depuis la glibc 2.10 a l'aide de --enable-experimental-malloc, et par defaut depuis la glibc 2.15. Dans certaines versions de l'allocateur il n'y avait pas de limite sur le nombre d'arenes creees (sur CentOS 5 et RHEL 5 par exemple). Lors de l'utilisation de versions plus recentes de la glibc, les applications peuvent dans certains cas faire preuve d'une grande competition lors de l'acces aux arenes. Dans ces cas, il peut etre benefique d'augmenter M_ARENA_MAX pour la faire correspondre au nombre de fils d'execution. Il s'agit d'un comportement similaire aux strategies appliquees par tcmalloc et jemalloc (a des reserves d'allocation par fil d'execution par exemple). M_ARENA_TEST Ce parametre definit, en nombre d'arenes creees, la valeur pour laquelle la configuration du systeme sera examinee afin de determiner une limite dure sur le nombre d'arenes creees. Consultez M_ARENA_MAX pour la definition d'une arene. Le calcul de la limite dure du nombre d'arenes est definit par l'implementation et est generalement un multiple du nombre de CPU disponibles. Le resultat est definitif une fois la limite dure calculee, et il contraint le nombre total d'arenes. La valeur par defaut du parametre M_ARENA_TEST est 2 sur les systemes ou sizeof(long) vaut 4 ; autrement, la valeur par defaut est 8. Ce parametre est disponible depuis la glibc 2.10 a l'aide de --enable-experimental-malloc, et par defaut depuis la glibc 2.15. La valeur de M_ARENA_TEST n'est pas utilisee lorsque M_ARENA_MAX a une valeur non nulle. M_CHECK_ACTION Ce parametre controle le comportement de la glibc lorsque des erreurs de programmation sont detectees (par exemple, lors qu'un pointeur est libere plusieurs fois). Les 3 bits de poids faible (bits 2, 1 et 0) de cette valeur ont les significations suivantes : Bit 0 Lorsque ce bit est positionne, un message d'une ligne detaillant l'erreur est affiche sur stderr. Le message commence par la chaine "*** glibc detected ***", suivi par le nom du programme, le nom de la fonction de l'allocation memoire qui a detecte l'erreur, une breve description de l'erreur, puis l'adresse memoire ou l'erreur a ete detectee. Bit 1 Lorsque ce bit est positionne, apres avoir affiche un message d'erreur configure par le bit 0, le programme est termine en appelant abort(3). Depuis la glibc 2.4, si le bit 0 est egalement positionne, alors le programme affiche egalement -- entre l'affichage d'un message d'erreur et l'abandon du programme -- l'etat de la pile a la maniere de backtrace(3) et les projections en memoire du processus a la maniere de /proc/pid/maps (voir proc(5)). Bit 2 (depuis la glibc 2.4) Ce bit a un effet uniquement si le bit 0 est egalement positionne. Lorsqu'il est positionne, alors le message d'erreur d'une ligne decrivant l'erreur est simplifie et contient uniquement le nom de la fonction ou l'erreur a ete detectee ainsi qu'une breve description de l'erreur. Les autres bits de value sont ignores. La combinaison des bits decrits ci-dessus permet de configurer M_CHECK_ACTION avec les valeurs suivantes : 0 Ignorer les erreurs et continuer l'execution (sans resultats definis). 1 Afficher un message d'erreur detaille et continuer l'execution. 2 Interrompre le programme. 3 Afficher un message d'erreur detaille, l'etat de la pile et des projections en memoire, puis interrompre le programme. 5 Afficher un message d'erreur simple et continuer l'execution. 7 Afficher un message d'erreur simple, l'etat de la pile et des projections en memoire, puis interrompre le programme. Depuis la glibc 2.3.4, M_CHECK_ACTION a pour valeur par defaut 3. Dans la glibc 2.3.3 et anterieures, la valeur par defaut est 1). Il est recommande d'utiliser une valeur M_CHECK_ACTION non nulle, car sinon l'arret impromptu du programme risque d'etre differe, ce qui rend tres difficile de retrouver l'origine du probleme. M_MMAP_MAX Ce parametre indique le nombre maximal de requetes d'allocation qui peuvent etre servies simultanement avec mmap(2). Il permet de preserver les performances de certains systemes qui ont un nombre limite de tables internes a disposition de mmap(2). La valeur par defaut est 65 536, valeur qui n'a pas de sens particulier mais sert seulement de protection. Configurer ce parametre a 0 desactive l'utilisation de mmap(2) pour servir de grandes requetes d'allocation. M_MMAP_THRESHOLD Lorsqu'une requete d'allocation superieure ou egale au seuil M_MMAP_THRESHOLD (en octets) ne peut etre satisfaite depuis la liste de blocs libres, les fonctions d'allocation de memoire utilisent mmap(2) plutot que d'augmenter la taille du segment de donnees avec sbrk(2). Allouer de la memoire avec mmap(2) permet toujours aux blocs de memoire alloues d'etre rendus de maniere independante au systeme. Cela represente un avantage significatif compare au tas qui ne peut etre desalloue que si la memoire est liberee par le haut. D'autre part, il y a certains inconvenients a utiliser mmap(2) : l'espace desalloue n'est pas considere comme libere, l'empechant d'etre reutilise pour de futures allocations ; de la memoire peut etre gaspillee car les allocations a l'aide de mmap(2) doivent etre alignees sur une taille de page ; et le noyau doit effectuer la tache couteuse de remise a zero de la memoire allouee par mmap(2). Trouver un compromis entre ces effets mene a une valeur du parametre M_MMAP_THRESHOLD par defaut a 128*1024. La limite basse de ce parametre est 0. La limite haute est DEFAULT_MMAP_THRESHOLD_MAX : c'est-a-dire 512*1024 sur les systemes 32 bits ou 4*1024*1024*sizeof(long) sur les systemes 64 bits. Note : de nos jours, la glibc configure ce seuil dynamiquement. La valeur initiale est 128*1024, mais lorsque sont liberes des blocs de taille superieure au seuil mais inferieure ou egale a DEFAULT_MMAP_THRESHOLD_MAX, le seuil est ajuste a la taille du bloc libere. Quand le mecanisme de seuil dynamique est active, le seuil de desallocation du tas est egalement configure dynamiquement a deux fois le seuil mmap. L'ajustement dynamique du seuil mmap est desactive des lors qu'un des parametres M_TRIM_THRESHOLD, M_TOP_PAD, M_MMAP_THRESHOLD, ou M_MMAP_MAX est configure. M_MXFAST (depuis glibc 2.3) Definir la limite superieure (en octets) pour les requetes d'allocation memoire qui sont satisfaites en utilisant des << fastbins >>. Les << fastbins >> sont des espaces de stockage qui contiennent des blocs de memoire desalloues de meme taille, sans fusion des blocs libres adjacents. La reallocation ulterieure de blocs de cette taille peut etre effectuee tres rapidement en allouant a partir du << fastbin \[u00BB], bien que d'un autre cote la fragmentation de la memoire et l'empreinte memoire totale du programme puissent augmenter. La valeur par defaut de ce parametre est 64*sizeof(size_t)/4 (c'est-a-dire 64 sur les architectures 32 bits). La plage de ce parametre va de 0 a 80*sizeof(size_t)/4. Fixer M_MXFAST a 0 desactive l'utilisation des << fastbins >>. M_PERTURB (depuis glibc 2.4) Si ce parametre est configure a une valeur non nulle, tous les octets de memoire allouee (autrement qu'avec calloc(3)) sont initialises au complement de la valeur de l'octet le moins significatif de value. Lorsque la memoire allouee est liberee avec free(3), les octets liberes prennent tous la valeur de l'octet le moins significatif de value. Cette fonctionnalite permet de detecter des erreurs lorsque les programmes supposent que la memoire allouee a ete initialisee a zero, ou reutilisent des valeurs depuis une zone memoire precedemment liberee. La valeur par defaut de ce parametre est 0. M_TOP_PAD Ce parametre definit la quantite en octets de bourrage a utiliser lors de l'appel a sbrk(2) pour modifier la taille du segment de donnees. Ce parametre a un effet dans les circonstances suivantes : - Lorsque la taille du segment de donnees est augmentee, M_TOP_PAD octets sont ajoutes a la requete sbrk(2). - Lorsque le tas est desalloue suite a l'appel free(3) (voir M_TRIM_THRESHOLD), cet espace supplementaire est preserve en haut du tas. Dans tous les cas, la quantite de bourrage est toujours arrondie a la taille d'une page systeme. La valeur M_TOP_PAD resulte d'un compromis entre l'augmentation du nombre d'appels systeme (avec une valeur faible) et le gaspillage de memoire inutilisee en haut du tas (avec une valeur elevee). La valeur par defaut de ce parametre est 128*1024. M_TRIM_THRESHOLD Lorsque la quantite de memoire libre et contigue en haut du tas depasse ce seuil, free(3) utilise sbrk(2) pour rendre cette memoire au systeme d'exploitation. (Cela peut etre utile pour les programmes qui sont executes encore longtemps apres avoir libere une quantite importante de memoire.)Le parametre M_TRIM_THRESHOLD indique la taille minimale (en octet) que ce bloc de memoire doit atteindre avant que sbrk(2) ne soit utilise pourreduire le tas. La valeur par defaut de ce parametre est 128*1024, en octets. Une valeur de -1 desactive completement la desallocation. La valeur M_TRIM_THRESHOLD resulte d'un compromis entre l'augmentation du nombre d'appels systeme (avec une valeur faible) et le gaspillage de memoire inutilisee en haut du tas (avec une valeur elevee). Variables d'environnement Un certain nombre des parametres de mallopt() peuvent etre modifies a travers de variables d'environnement. Ces variables ont l'avantage de ne pas necessiter la modification du code source du programme. Pour etre prises en compte, ces variables doivent etre definies avant le premier appel a une fonction d'allocation memoire. Les parametres passes par la fonction mallopt() sont prioritaires devant ceux issus des variables d'environnement. Pour des raisons de securite, ces variables sont ignorees dans le cas de programmes setuid ou setgid. Les variables d'environnement sont les suivantes (notez le caractere de soulignement (<< underscore >>) qui les termine) : MALLOC_ARENA_MAX Controle du meme parametre que M_ARENA_MAX de mallopt(). MALLOC_ARENA_TEST Controle du meme parametre que M_ARENA_TEST de mallopt(). MALLOC_CHECK_ Cette variable d'environnement controle le meme parametre que M_CHECK_ACTION de mallopt(). Si elle est configuree a une valeur non nulle, une mise en oeuvre specifique des fonctions d'allocation memoire est utilisee, grace a la fonctionnalite malloc_hook(3). Cette mise en oeuvre effectue des verifications d'erreurs supplementaires, au prix d'un ralentissement par rapport au jeu standard de fonctions d'allocation memoire. Cependant, elle ne detecte pas toutes les erreurs possibles : des fuites memoires peuvent encore se produire. La valeur de cette variable d'environnement doit etre un seul chiffre, dont le sens est comme decrit pour M_CHECK_ACTION. Tout caractere au-dela du premier chiffre est ignore. Pour des raisons de securite, MALLOC_CHECK_ est ignore par defaut dans le cas de programmes setuid ou setgid. Cependant, si le fichier /etc/suid-debug existe (peu importe son contenu), alors la valeur de MALLOC_CHECK_ est prise en compte pour les programmes setuid ou setgid. MALLOC_MMAP_MAX_ Controle du meme parametre que M_MMAP_MAX de mallopt(). MALLOC_MMAP_THRESHOLD_ Controle du meme parametre que M_MMAP_THRESHOLD de mallopt(). MALLOC_PERTURB_ Controle du meme parametre que M_PERTURB de mallopt(). MALLOC_TRIM_THRESHOLD_ Controle du meme parametre que M_TRIM_THRESHOLD de mallopt(). MALLOC_TOP_PAD_ Controle du meme parametre que M_TOP_PAD de mallopt(). VALEUR RENVOYEE En cas de succes, mallopt() renvoie 1. En cas d'erreur, il renvoie 0. ERREURS En cas d'erreur, errno n'est pas positionne. VERSIONS Une fonction similaire existe sur de nombreux derives de System V, mais les valeurs permises de param varient d'un systeme a l'autre. SVID definit les options M_MXFAST, M_NLBLKS, M_GRAIN et M_KEEP, mais seule la premiere d'entre elles est disponible dans la glibc. STANDARDS Aucun. HISTORIQUE glibc 2.0. BOGUES Indiquer une valeur non valable pour param ne genere pas d'erreur. Une erreur de calcul dans la mise en oeuvre glibc implique qu'un appel de la forme suivante : mallopt(M_MXFAST, n) n'active pas les << fastbins >> pour toutes les allocations d'une taille jusqu'a n. Pour obtenir l'effet attendu, n doit etre arrondi a un multiple superieur ou egal a (2k+1)*sizeof(size_t), ou k est un entier. Si mallopt() est utilise pour configurer M_PERTURB, tous les octets de memoire alloues sont initialises au complement de value, puis lorsque la memoire est liberee les octets sont initialises a value. Cependant, une erreur de sizeof(size_t) est presente dans le code mis en oeuvre : au lieu d'initialiser precisement le bloc de memoire libere par l'appel free(p), c'est le bloc demarrant a p+sizeof(size_t) qui est initialise. EXEMPLES Le programme ci-dessous illustre l'utilisation de M_CHECK_ACTION. Si le programme est appele avec un parametre (entier), alors celui-ci est utilise pour M_CHECK_ACTION. Le programme alloue un bloc de memoire, puis le libere deux fois, ce qui constitue une erreur. L'exemple de session ci-dessous montre ce qu'il se passe lorsqu'un programme est execute avec la glibc et la valeur par defaut de M_CHECK_ACTION : $ ./a.out main(): fin du premier appel free() *** glibc detected *** ./a.out: double free or corruption (top): 0x09d30008 *** ======= Backtrace: ========= /lib/libc.so.6(+0x6c501)[0x523501] /lib/libc.so.6(+0x6dd70)[0x524d70] /lib/libc.so.6(cfree+0x6d)[0x527e5d] ./a.out[0x80485db] /lib/libc.so.6(__libc_start_main+0xe7)[0x4cdce7] ./a.out[0x8048471] ======= Memory map: ======== 001e4000-001fe000 r-xp 00000000 08:06 1083555 /lib/libgcc_s.so.1 001fe000-001ff000 r--p 00019000 08:06 1083555 /lib/libgcc_s.so.1 [some lines omitted] b7814000-b7817000 rw-p 00000000 00:00 0 bff53000-bff74000 rw-p 00000000 00:00 0 [stack] Abandon L'exemple suivant montre les cas d'autres valeurs de M_CHECK_ACTION: $ ./a.out 1 # Diagnostique l'erreur et continue main(): fin du premier appel free() *** glibc detected *** ./a.out: double free or corruption (top): 0x09cbe008 *** main(): fin du second appel free() $ ./a.out 2 # Interrompt le programme sans message d'erreur main(): fin du premier appel free() Abandon $ ./a.out 0 # Ignore l'erreur et continue main(): fin du premier appel free() main(): fin du second appel free() L'exemple suivant montre comment configurer le meme parametre avec la variable d'environnement MALLOC_CHECK_ : $ MALLOC_CHECK_=1 ./a.out main(): fin du premier appel free() *** glibc detected *** ./a.out: free(): invalid pointer: 0x092c2008 *** main(): fin du second appel free() Source du programme #include #include #include int main(int argc, char *argv[]) { char *p; if (argc > 1) { if (mallopt(M_CHECK_ACTION, atoi(argv[1])) != 1) { fprintf(stderr, "mallopt() failed"); exit(EXIT_FAILURE); } } p = malloc(1000); if (p == NULL) { fprintf(stderr, "malloc() failed"); exit(EXIT_FAILURE); } free(p); printf("%s(): returned from first free() call\n", __func__); free(p); printf("%s(): returned from second free() call\n", __func__); exit(EXIT_SUCCESS); } VOIR AUSSI mmap(2), sbrk(2), mallinfo(3), malloc(3), malloc_hook(3), malloc_info(3), malloc_stats(3), malloc_trim(3), mcheck(3), mtrace(3), posix_memalign(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 mallopt(3)