oracular (2) set_mempolicy.2.gz

Provided by: manpages-fr-dev_4.23.1-1_all bug

NOM

       set_mempolicy  -  Configurer  la politique de la mémoire NUMA par défaut pour un thread et
       ses enfants

BIBLIOTHÈQUE

       Bibliothèque de règles NUMA (Non-Uniform Memory Access) (libnuma, -lnuma)

SYNOPSIS

       #include <numaif.h>

       long set_mempolicy(int mode, const unsigned long *nodemask,
                          unsigned long maxnode);

DESCRIPTION

       set_mempolicy() définit la politique de la mémoire NUMA du thread appelant,  qui  consiste
       en  un  mode  de  politique  et  zéro  ou plusieurs nœuds, aux valeurs spécifiées dans les
       arguments mode, nodemask et maxnode.

       Une machine NUMA a différents contrôleurs mémoire à différentes distances des  processeurs
       particuliers.  La  politique  de la mémoire définit le nœud à partir duquel la mémoire est
       allouée pour le thread.

       Cet appel système définit la politique par défaut pour le thread. La politique  de  thread
       gouverne  l'allocation  de page dans l'espace adressable du processus en dehors des plages
       mémoire contrôlées par une politique plus spécifique définie par mbind(2). La politique de
       thread par défaut contrôle également l'allocation de toute page pour les fichiers projetés
       en mémoire en utilisant l'appel système mmap(2) avec l'attribut MAP_PRIVATE, qui n’est lue
       (chargée) que par le thread, et pour les fichiers projetés en mémoire en utilisant l'appel
       mmap(2) avec l'attribut MAP_SHARED, quel  que  soit  le  type  d'accès.  La  politique  ne
       s'applique  que  lorsqu'une  nouvelle  page  est  allouée  pour le thread. Pour la mémoire
       anonyme, cela est fait lorsque la page est modifiée pour la première fois par le thread.

       The  mode  argument  must  specify  one  of  MPOL_DEFAULT,   MPOL_BIND,   MPOL_INTERLEAVE,
       MPOL_WEIGHTED_INTERLEAVE,  MPOL_PREFERRED,  or  MPOL_LOCAL  (which are described in detail
       below). All modes except MPOL_DEFAULT require the caller to specify the node or  nodes  to
       which the mode applies, via the nodemask argument.

       L'argument mode peut aussi contenir des attributs optionnels. Les valeurs possibles sont :

       MPOL_F_NUMA_BALANCING (depuis Linux 5.12)
              Quand  mode  est  MPOL_BIND, activer l’équilibrage NUMA du noyau pour la tâche s’il
              est géré par le noyau. Si l'attribut n'est pas pris en charge par le noyau  ou  est
              utilisé  avec  un  autre mode que MPOL_BIND, -1 est renvoyé et errno est positionné
              sur EINVAL.

       MPOL_F_RELATIVE_NODES (depuis Linux 2.6.26)
              Un paramètre nodemask non vide  indique  les  identifiants  des  nœuds  relatifs  à
              l'ensemble  des  identifiants  de nœuds autorisés pour le contexte de l'ensemble de
              processeurs en cours pour le processus.

       MPOL_F_STATIC_NODES (depuis Linux 2.6.26)
              Une valeur non vide de nodemask indique des identifiants de nœuds physiques.  Linux
              ne va pas recalculer le nodemask quand le processus est déplacé vers un contexte de
              processeurs différent, ni quand l'ensemble des nœuds autorisés par le  contexte  du
              processus actuel est modifié.

       nodemask  pointe  vers  un  masque  de  bits  d'identifiants de nœuds qui contient jusqu'à
       maxnode bits. La  taille  du  masque  de  bits  est  arrondie  au  multiple  supérieur  de
       sizeof(unsigned long), mais le noyau n'utilisera que jusqu'à maxnode bits. Une valeur NULL
       pour nodemask ou une valeur maxnode de zéro indique un  ensemble  vide  de  nœuds.  Si  la
       valeur de maxnode est zéro, l'argument nodemask est ignoré.

       Quand  une  valeur  de  nodemask  est  nécessaire,  elle  doit  contenir  au moins un nœud
       actuellement disponible et autorisé par le contexte  du  processus  actuel  (à  moins  que
       l'attribut  MPOL_F_STATIC_NODES  ne  soit  spécifié),  et  qui  contient de la mémoire. Si
       l'attribut MPOL_F_STATIC_NODES est mis dans mode et si un nodemask nécessaire ne  contient
       aucun  nœud autorisé par le contexte du processus actuel, la politique pour la mémoire est
       forcée à allocation locale (local allocation). La politique sera réellement modifiée, sauf
       si le contexte du processus actuel contient au moins un des nœuds spécifiés par nodemask.

       L'argument mode doit inclure une des valeurs suivantes :

       MPOL_DEFAULT
              Ce mode indique que toute politique de mémoire du thread autre que celle par défaut
              doit être supprimée, afin que  la  politique  de  mémoire  se  « rabatte »  sur  la
              politique  par  défaut  du  système. La politique par défaut du système est « local
              allocation », c'est-à-dire allouer la mémoire sur  le  nœud  du  processeur  qui  a
              déclenché  l'allocation.  nodemask  doit  être  spécifié  comme  NULL. Si le « nœud
              local » ne contient pas de mémoire  libre,  le  système  tentera  d'allouer  de  la
              mémoire à partir d'un nœud « à proximité ».

       MPOL_BIND
              Ce  mode définit une politique stricte qui restreint l'allocation mémoire aux nœuds
              spécifiés dans nodemask. Si nodemask indique plus d'un  nœud,  les  allocations  de
              pages  se  feront d'abord à partir du nœud dont l'identifiant numérique est le plus
              petit jusqu'à ce que ce nœud ne contienne plus de mémoire libre. Les allocations se
              feront  ensuite  à  partir  du  nœud  dont l'identifiant est le prochain plus grand
              spécifié dans nodemask et ainsi de suite jusqu'à ce que plus un seul  nœud  indiqué
              ne  contienne  de  mémoire libre. Il n'y aura pas d'allocation de pages à partir de
              nœuds non indiqués dans nodemask.

       MPOL_INTERLEAVE
              Ce mode entrelace les allocations de pages  à  travers  les  nœuds  spécifiés  dans
              nodemask  dans  l'ordre  de l'identifiant numérique de nœud. Cela optimise la bande
              passante au lieu de la latence en étalant les accès pages et mémoires à ces pages à
              travers  plusieurs nœuds. Toutefois, les accès à une seule page seront limités à la
              bande passante mémoire d'un seul nœud.

       MPOL_WEIGHTED_INTERLEAVE (since Linux 6.9)
              This mode interleaves page allocations  across  the  nodes  specified  in  nodemask
              according  to  the  weights  in  /sys/kernel/mm/mempolicy/weighted_interleave.  For
              example,  if  bits  0,  2,  and  5  are  set  in  nodemask,  and  the  contents  of
              /sys/kernel/mm/mempolicy/weighted_interleave/node0,       /sys/.../node2,       and
              /sys/.../node5 are 4, 7, and 9, respectively, then pages in  this  region  will  be
              allocated on nodes 0, 2, and 5 in a 4:7:9 ratio.

       MPOL_PREFERRED
              Ce  mode définit le nœud préféré pour l'allocation. Le noyau essaiera d'allouer des
              pages d'abord à partir de ce nœud et se repliera sur  des  nœuds  voisins  s'il  ne
              reste  que peu de mémoire libre sur le nœud préféré. Si nodemask spécifie plus d'un
              identifiant de nœud, le premier nœud du masque sera choisi comme le  nœud  préféré.
              Si  les  arguments  nodemask  et  maxnode  spécifient l'ensemble vide, la politique
              indique « local allocation » (comme la politique  par  défaut  du  système  abordée
              ci-dessus).

       MPOL_LOCAL (depuis Linux 3.8)
              Ce  mode  indique  « local  allocation » ;  la  mémoire  est allouée sur le nœud du
              processeur qui  a  déclenché  l'allocation  (le  « local  node »).  Les  paramètres
              nodemask  et  maxnode  doivent  indiquer  l'ensemble vide. Si le « local node » est
              faible en mémoire, le noyau essaiera d'allouer de  la  mémoire  à  partir  d'autres
              nœuds. Le noyau allouera de la mémoire à partir du « local node » à chaque fois que
              de la mémoire dans ce nœud sera disponible. Si le « local node » n'est pas autorisé
              par le contexte de l’ensemble de processeurs actuel du processus, le noyau essaiera
              d'allouer de la mémoire à partir d'autres nœuds. Le noyau allouera de la mémoire  à
              partir  du  « local  node »  à  chaque fois que ce sera autorisé par le contexte de
              l’ensemble de processeurs actuel du processus.

       La politique mémoire de thread est préservée au travers d'un execve(2)  et  est  récupérée
       par les processus enfant créés avec fork(2) ou clone(2).

VALEUR RENVOYÉE

       S'il  réussit,  set_mempolicy()   renvoie 0 ; s'il échoue, il renvoie -1 et écrit errno en
       conséquence.

ERREURS

       EFAULT Une partie de la plage mémoire spécifiée par nodemask et maxnode pointe  en  dehors
              de l’espace d'adressage accessible.

       EINVAL mode n'est pas valable. Soit mode est MPOL_DEFAULT et nodemask n'est pas vide, soit
              mode est MPOL_BIND ou  MPOL_INTERLEAVE  et  nodemask  est  vide.  Ou  bien  maxnode
              spécifie  plus  qu'une  page  de  bits.  Ou alors nodemask spécifie un ou plusieurs
              identifiants de nœud qui sont plus grands que l'identifiant maximal de nœud pris en
              charge,  ou qui ne sont pas autorisés dans le contexte de l’ensemble de processeurs
              actuel du processus, ou bien aucun des nœuds n'a de mémoire. Ou alors le  paramètre
              mode   spécifie   MPOL_F_STATIC_NODES   et   MPOL_F_RELATIVE_NODES.   Ou  alors  le
              MPOL_F_NUMA_BALANCING n'est pas pris en charge par le noyau ou est utilisé avec  un
              autre mode que MPOL_BIND.

       ENOMEM La mémoire disponible du noyau n'était pas suffisante.

STANDARDS

       Linux.

HISTORIQUE

       Linux 2.6.7.

NOTES

       La  politique  de  mémoire n'est pas mémorisée si la page est transférée. Lorsqu'une telle
       page est réimportée en mémoire, elle utilisera la politique  du  thread  ou  de  la  plage
       mémoire qui était effective au moment où la page est allouée.

       Pour des informations sur la prise en charge des bibliothèques, consultez numa(7).

VOIR AUSSI

       get_mempolicy(2), getcpu(2), mbind(2), mmap(2), numa(3), cpuset(7), numa(7), numactl(8)

TRADUCTION

       La  traduction  française  de  cette  page  de  manuel  a  été créée par Christophe Blaess
       <https://www.blaess.fr/christophe/>, Stéphan  Rafin  <stephan.rafin@laposte.net>,  Thierry
       Vignaud  <tvignaud@mandriva.com>,  François Micaux, Alain Portal <aportal@univ-montp2.fr>,
       Jean-Philippe   Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)    <jean-
       luc.coulon@wanadoo.fr>,    Julien    Cristau    <jcristau@debian.org>,    Thomas   Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau  <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
       Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>  et  Jean-Philippe  MENGUAL
       <jpmengual@debian.org>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General
       Public  License  version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   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 à ⟨debian-l10n-french@lists.debian.org⟩.