Provided by: manpages-fr-dev_3.57d1p1-1_all bug

NOM

       mallopt - Définir les paramètres d'allocation de mémoire

SYNOPSIS

       #include <malloc.h>

       int mallopt(int param, int value);

DESCRIPTION

       La  fonction  mallopt() ajuste les paramètres qui contrôlent le comportement des fonctions
       liées à l'allocation de mémoire (voir malloc(3)). Le paramètre param indique le  paramètre
       à modifier, et value indique la nouvelle valeur pour ce paramètre.

       Les valeurs suivantes peuvent être assignées à param :

       M_CHECK_ACTION
              Ce  paramètre  contrôle  le  comportement  de  la  glibc  lorsque  des  erreurs  de
              programmation sont détectées (par exemple, lors qu'un pointeur est libéré 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 positionné, un message d'une  ligne  détaillant  l'erreur
                     est  affiché  sur  stderr.  Le  message  commence  par  la chaîne "*** glibc
                     detected ***", suivi par le nom du programme,  le  nom  de  la  fonction  de
                     l'allocation  mémoire  qui  a  détecté  l'erreur,  une  brève description de
                     l'erreur, puis l'adresse mémoire à laquelle l'erreur a été détectée.

              Bit 1  Lorsque ce bit est positionné,  après  avoir  affiché  un  message  d'erreur
                     configuré  par  le  bit 0,  le  programme  est terminé en appelant abort(3).
                     Depuis la version 2.4 de la glibc, si le  bit 0  est  également  positionné,
                     alors  le  programme  affiche  également  — entre  l'affichage  d'un message
                     d'erreur et l'abandon du programme — l'état de  la  pile  à  la  manière  de
                     backtrace(3)  et  les  projections  en  mémoire du processus à la manière 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 également positionné. Lorsqu'il
                     est positionné, alors le message d'erreur d'une ligne décrivant l'erreur est
                     simplifié et contient uniquement le nom de la fonction  où  l'erreur  a  été
                     détectée ainsi qu'une brève description de l'erreur.

              Les autres bits de value sont ignorés.

              La  combinaison des bits décrits ci-dessus permet de configurer M_CHECK_ACTION avec
              les valeurs suivantes :

                   0  Ignore les erreurs et continue l'exécution (sans résultats définis).

                   1  Affiche un message d'erreur détaillé et continue l'exécution.

                   2  Interrompt le programme.

                   3  Affiche un message d'erreur détaillé, l'état de la pile et des  projections
                      en mémoire, puis interrompt le programme.

                   5  Affiche un message d'erreur simple et continue l'exécution.

                   7  Affiche un message d'erreur simple, l'état de la pile et des projections en
                      mémoire, puis interrompt le programme.

              Depuis la version 2.3.4 de la glibc, M_CHECK_ACTION a pour valeur par défaut  3  (1
              jusqu'à la version 2.3.3).

              Il est recommandé d'utiliser une valeur M_CHECK_ACTION non nulle, car sinon l'arrêt
              impromptu du programme risque  d'être  différé,  ce  qui  rend  très  difficile  de
              retrouver l'origine du problème.

       M_MMAP_MAX
              Ce  paramètre  indique  le nombre maximum de requêtes d'allocation qui peuvent être
              servies simultanément avec mmap(2). Il permet  de  préserver  les  performances  de
              certains  systèmes  qui  ont  un  nombre limité de tables internes à disposition de
              mmap(2).

              La valeur par défaut est  65 536,  qui  n'a  pas  de  sens  particulier  mais  sert
              seulement  de  protection.  Configurer  ce paramètre à 0 désactive l'utilisation de
              mmap(2) pour servir de grandes requêtes d'allocation.

       M_MMAP_THRESHOLD
              Lorsqu'une requête d'allocation supérieure ou égale au seuil  M_MMAP_THRESHOLD  (en
              octets)  ne  peut  être  satisfaite  depuis la liste de blocs libres, les fonctions
              d'allocation de mémoire utilisent mmap(2)  plutôt  que  d'augmenter  la  taille  du
              segment de données avec sbrk(2).

              Allouer la mémoire avec mmap(2) permet toujours aux blocs de mémoire alloués d'être
              rendus de manière indépendante au système. Cela représente un avantage significatif
              comparé  au  tas  qui  ne  peut être désalloué que si la mémoire est libérée par le
              haut. D'autre part, il y a certains inconvénients  à  utiliser  mmap(2) :  l'espace
              désalloué  n'est  pas  considéré  comme libéré l'empêchant d'être réutilisé pour de
              futures allocations ; de la mémoire peut être gaspillée  car  les  allocations  via
              mmap(2)  doivent  être alignées sur une taille de page ; et le noyau doit effectuer
              la tâche coûteuse de remise à zéro de la mémoire allouée par  mmap(2).  Trouver  un
              compromis  entre  ces  effets  mène  à une valeur du paramètre M_MMAP_THRESHOLD par
              défaut à 128*1024.

              La   limite   basse   de   ce   paramètre   est   0.   La    limite    haute    est
              DEFAULT_MMAP_THRESHOLD_MAX :  c'est-à-dire  512*1024  sur  les  systèmes 32 bits ou
              4*1024*1024*sizeof(long) sur les systèmes 64 bits.

              Note : de nos jours, la glibc configure ce seuil dynamiquement. La valeur  initiale
              est  128*1024,  mais  lorsque  sont libérés des blocs de taille supérieure au seuil
              mais inférieure ou égale à DEFAULT_MMAP_THRESHOLD_MAX, le seuil  est  ajusté  à  la
              taille  du  bloc libéré. Quand le mécanisme de seuil dynamique est activé, le seuil
              de désallocation du tas est également configuré dynamiquement à deux fois le  seuil
              mmap.  L'ajustement  dynamique  du  seuil  mmap  est  désactivé  dès lors qu'un des
              paramètres  M_TRIM_THRESHOLD,  M_TOP_PAD,  M_MMAP_THRESHOLD,  ou   M_MMAP_MAX   est
              configuré.

       M_MXFAST (depuis glibc 2.3)
              Définir la limite supérieure (en octets) pour les requêtes d'allocation mémoire qui
              sont satisfaites en utilisant des « fastbins ». Les « fastbins » sont  des  espaces
              de stockage qui contiennent des blocs de mémoire désalloués de la même taille, sans
              fusion des blocs libres adjacents. La réallocation ultérieure  de  blocs  de  cette
              taille  peut  être  effectuée  très  rapidement  en  allouant à partir du « fastbin
              \[u00BB], mais d'un autre côté  la  fragmentation  de  la  mémoire  et  l'empreinte
              mémoire  totale  du programme augmentera. La valeur par défaut de ce paramètre vaut
              64*sizeof(size_t)/4 (c'est-à-dire 64 sur des architectures 32 bits).  Ce  paramètre
              doit  être  compris  entre 0 et 80*sizeof(size_t)/4. Définir M_MXFAST à 0 désactive
              l'utilisation des « fastbins ».

       M_PERTURB (depuis glibc 2.4)
              Si ce paramètre est configuré à une valeur non nulle, tous les  octets  de  mémoire
              allouée  (autrement  qu'avec calloc(3)) sont initialisés au complément de la valeur
              de l'octet le moins significatif de value. Lorsque la mémoire allouée  est  libérée
              avec  free(3),  les  octets  libérés  prennent  tous  la valeur de l'octet le moins
              significatif de value. Cette fonctionnalité permet de détecter des erreurs  lorsque
              les  programmes  supposent  que  la  mémoire  allouée  a été initialisée à zéro, ou
              réutilisent des valeurs depuis une zone mémoire précédemment libérée.

       M_TOP_PAD
              Ce paramètre définit la quantité en octets de bourrage à utiliser lors de l'appel à
              sbrk(2) pour modifier la taille du segment de données. Ce paramètre a un effet dans
              les circonstances suivantes :

              *  Lorsque la taille du segment de données est  augmentée,  M_TOP_PAD  octets  sont
                 ajoutés à la requête sbrk(2).

              *  Lorsque  le  tas  est désalloué suite à l'appel free(3) (voir M_TRIM_THRESHOLD),
                 cet espace supplémentaire est préservé en haut du tas.

              Dans tous les cas, la quantité de bourrage est toujours arrondie à la taille  d'une
              page système.

              La  valeur M_TOP_PAD résulte d'un compromis entre l'augmentation du nombre d'appels
              système (avec une valeur faible) et le gaspillage de mémoire inutilisée en haut  du
              tas (avec une valeur élevée).

              La valeur par défaut de ce paramètre est 128*1024.

       M_TRIM_THRESHOLD
              Lorsque  la  quantité de mémoire libre et contigüe en haut du tas dépasse ce seuil,
              free(3) utilise sbrk(2) pour rendre cette mémoire au système d'exploitation.  (Cela
              peut  être utile pour les programmes qui sont exécutés encore longtemps après avoir
              libéré une quantité importante de mémoire.)

              La valeur par défaut de ce paramètre est 128*1024, en  octets.  Une  valeur  de  -1
              désactive complètement la désallocation.

              La  valeur  M_TRIM_THRESHOLD  résulte d'un compromis entre l'augmentation du nombre
              d'appels système (avec une valeur faible) et le gaspillage de mémoire inutilisée en
              haut du tas (avec une valeur élevée).

   Variables d'environnement
       Un certain nombre des paramètres de mallopt() peuvent être modifiés à travers de variables
       d'environnement. Ces variables ont l'avantage de ne pas nécessiter la modification du code
       source du programme. Pour être prises en compte, ces variables doivent être définies avant
       le premier appel à une  fonction  d'allocation  mémoire.  Les  paramètres  passés  par  la
       fonction mallopt() sont prioritaires devant ceux issus des variables d'environnement. Pour
       des raisons de sécurité, ces variables sont ignorées dans le cas de programmes  setuid  ou
       setgid.

       Les   variables  d'environnement  disponibles  — toutes  terminées  par  le  caractère  de
       soulignement (« underscore ») — sont les suivantes :

       MALLOC_CHECK_
              Cette variable d'environnement contrôle le même  paramètre  que  M_CHECK_ACTION  de
              mallopt().  Si  elle  est  configurée  à  une  valeur  non nulle, une mise en œuvre
              spécifique  des  fonctions  d'allocation  mémoire  est   utilisée,   grâce   à   la
              fonctionnalité  malloc_hook(3).  Cette  mise  en  œuvre  effectue des vérifications
              d'erreurs supplémentaires, au prix d'un ralentissement par rapport au jeu  standard
              de  fonctions  d'allocation  mémoire.  Cependant,  elle  ne  détecte pas toutes les
              erreurs possibles : des fuites mémoires peuvent encore se produire.

              La valeur de cette variable d'environnement doit être un seul chiffre, dont le sens
              est comme décrit pour M_CHECK_ACTION. Tout caractère au-delà du premier chiffre est
              ignoré.

              Pour des raisons de sécurité, MALLOC_CHECK_ est ignoré par défaut 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_
              Contrôle le même paramètre que M_MMAP_MAX de mallopt().

       MALLOC_MMAP_THRESHOLD_
              Contrôle le même paramètre que M_MMAP_THRESHOLD de mallopt().

       MALLOC_PERTURB_
              Contrôle le même paramètre que M_PERTURB de mallopt().

       MALLOC_TRIM_THRESHOLD_
              Contrôle le même paramètre que M_TRIM_THRESHOLD de mallopt().

       MALLOC_TOP_PAD_
              Contrôle le même paramètre que M_TOP_PAD de mallopt().

VALEUR RENVOYÉE

       En cas de succès, mallopt() renvoie 1. En cas d'erreur, il renvoie 0.

ERREURS

       En cas d'erreur, errno n'est pas positionné.

CONFORMITÉ

       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 », mais les valeurs permises de param varient
       d'un  système à l'autre. SVID définit les options M_MXFAST, M_NLBLKS, M_GRAIN, and M_KEEP,
       mais seule la première d'entre elles est disponible dans la glibc.

BOGUES

       Indiquer une valeur invalide pour param ne génère pas d'erreur.

       Une erreur de calcul dans la mise  en  œuvre  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'à n. Pour
       obtenir l'effet  attendu,  n  doit  être  arrondi  à  un  multiple  supérieur  ou  égal  à
       (2k+1)*sizeof(size_t), où k est un entier.

       Les  variables  MALLOC_MMAP_THRESHOLD_  et  MALLOC_MMAP_MAX_ ne sont pas ignorées pour les
       programmes setgid.

       Si mallopt() est utilisé pour configurer M_PERTURB, tous les  octets  de  mémoire  alloués
       sont  initialisés  au  complément de value, puis lorsque la mémoire est libérée les octets
       sont initialisés à value. Cependant, une erreur de sizeof(size_t)  est  présente  dans  le
       code  mis  en  œuvre :  au  lieu  d'initialiser  précisément le bloc de mémoire libéré par
       l'appel free(p), c'est bloc démarrant à p+sizeof(size_t) qui est initialisé.

EXEMPLE

       Le programme ci-dessous illustre l'utilisation de  M_CHECK_ACTION.  Si  le  programme  est
       appelé  avec  un  paramètre  (entier),  alors celui-ci est utilisé pour M_CHECK_ACTION. Le
       programme alloue un bloc de mémoire, puis le  libère  deux  fois,  ce  qui  constitue  une
       erreur.

       L'exemple  de  session ci-dessous montre ce qu'il se passe lorsqu'un programme est exécuté
       avec la glibc et la valeur par défaut 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  même  paramètre  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 <malloc.h>
       #include <stdio.h>
       #include <stdlib.h>

       int
       main(int argc, char *argv[])
       {
           char *p;

           if (argc > 1) {
               if (mallopt(M_CHECK_ACTION, atoi(argv[1])) != 1) {
                   fprintf(stderr, "échec de mallopt()");
                   exit(EXIT_FAILURE);
               }
           }

           p = malloc(1000);
           if (p == NULL) {
               fprintf(stderr, "échec de malloc()");
               exit(EXIT_FAILURE);
           }

           free(p);
           printf("main(): fin du premier appel free()\n");

           free(p);
           printf("main(): fin du second appel free()\n");

           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)

COLOPHON

       Cette page fait partie de la publication 3.57 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> ».