set_mempolicy - Configurer la politique de la mémoire NUMA par
défaut pour un thread et ses enfants
Bibliothèque de règles NUMA (Non-Uniform Memory Access) (
libnuma,
-lnuma)
#include <numaif.h>
long set_mempolicy(int mode, const unsigned long *nodemask,
unsigned long maxnode);
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.
Le paramètre
mode doit spécifier l'un des attributs parmi
MPOL_DEFAULT,
MPOL_BIND,
MPOL_INTERLEAVE,
MPOL_PREFERRED et
MPOL_LOCAL (qui sont décrits en
détails ci-dessous). Toutes les modes de politique excepté
MPOL_DEFAULT nécessitent que l'appelant spécifie, dans le
paramètre
nodemask, le ou les nœuds auxquels s'appliquent
le mode.
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_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).
S'il réussit,
set_mempolicy() renvoie
0 ; s'il
échoue, il renvoie
-1 et écrit
errno en
conséquence.
- 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.
L'appel système
set_mempolicy() a été ajouté
dans Linux 2.6.7.
Cet appel système est spécifique à Linux.
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).
get_mempolicy(2),
getcpu(2),
mbind(2),
mmap(2),
numa(3),
cpuset(7),
numa(7),
numactl(8)
La traduction française de cette page de manuel a été
créée par Christophe Blaess
<
https://www.blaess.fr/christophe/>, Stéphan Rafin
<
[email protected]>, Thierry Vignaud
<
[email protected]>, François Micaux, Alain Portal
<
[email protected]>, Jean-Philippe Guérard
<
[email protected]>, Jean-Luc Coulon (f5ibh)
<
[email protected]>, Julien Cristau
<
[email protected]>, Thomas Huriaux <
[email protected]>,
Nicolas François <
[email protected]>, Florentin
Duneau <
[email protected]>, Simon Paillard
<
[email protected]>, Denis Barbier
<
[email protected]>, David Prévot <
[email protected]> et
Jean-Philippe MENGUAL <
[email protected]>
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 à
[email protected]