perkamon - en to fr translation catalogue (169 entries)

note: type: TH
en: 2008-08-15
fr: 15 août 2008

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: get_mempolicy - retrieve NUMA memory policy for a process
fr: get_mempolicy - Lire la politique mémoire NUMA d'un processus

note: type: Plain text
en: Link with I<-lnuma>.
fr: Effectuez l'édition des liens avec l'option I<-lnuma>.

note: type: Plain text
en: B<get_mempolicy>()  retrieves the NUMA policy of the calling process or of a memory address, depending on the setting of I<flags>.
fr: B<get_mempolicy>() lit la politique NUMA du processus appelant ou d'une adresse en mémoire, selon la valeur de I<flags>.

note: type: Plain text
en: A NUMA machine has different memory controllers with different distances to specific CPUs.  The memory policy defines from which node memory is allocated for the process.
fr: Une machine NUMA a différents contrôleurs mémoire à différentes distances de CPU particulières. La politique de la mémoire définit à partir de quel nœud la mémoire pour ce processus sera allouée.

note: type: Plain text
en: If I<flags> is specified as 0, then information about the calling process's default policy (as set by B<set_mempolicy>(2))  is returned.  The policy returned [I<mode> and I<nodemask>] may be used to restore the process's policy to its state at the time of the call to B<get_mempolicy>()  using B<set_mempolicy>(2).
fr: Si I<flags> est nul, la politique par défaut du processus appelant (définie par B<set_mempolicy>(2)) est renvoyée. La politique renvoyée (I<mode> et I<nodemask>) peut être utilisée avec B<set_mempolicy>(2) pour restaurer la politique du processus dans son état au moment de l'appel à B<get_mempolicy>().

note: type: Plain text
en: If I<flags> specifies B<MPOL_F_MEMS_ALLOWED> (available since Linux 2.6.24), the I<mode> argument is ignored and the set of nodes [memories] that the process is allowed to specify in subsequent calls to B<mbind>(2)  or B<set_mempolicy>(2)  [in the absence of any I<mode flags>] is returned in I<nodemask>.  It is not permitted to combine B<MPOL_F_MEMS_ALLOWED> with either B<MPOL_F_ADDR> or B<MPOL_F_NODE>.
fr: Si I<flags> indique B<MPOL_F_MEMS_ALLOWED> (disponible depuis Linux 2.6.24), le paramètre I<mode> est ignoré et l'ensemble des nœuds (mémoires) que le processus est autorisé à utiliser dans les appels suivants à B<mbind>(2) ou B<set_mempolicy>(2) (en l'absence de I<drapeaux de mode>) est renvoyé dans I<nodemask>. Il n'est pas permit de combiner B<MPOL_F_MEMS_ALLOWED> avec B<MPOL_F_ADDR> ou B<MPOL_F_NODE>.

note: type: Plain text
en: If I<flags> specifies B<MPOL_F_ADDR>, then information is returned about the policy governing the memory address given in I<addr>.  This policy may be different from the process's default policy if B<mbind>(2)  or one of the helper functions described in B<numa>(3)  has been used to establish a policy for the memory range containing I<addr>.
fr: Si I<flags> indique B<MPOL_F_ADDR>, l'information renvoyée concerne la politique gouvernant la mémoire à l'adresse I<addr>. Cette politique peut être différente de la politique par défaut du processus si B<mbind>(2) ou une des fonctions d'aide décrites dans B<numa>(3) a été utilisée pour mettre en place une politique pour la page contenant l'adresse I<addr>.

note: type: Plain text
en: If the I<mode> argument is not NULL, then B<get_mempolicy>()  will store the policy mode and any optional I<mode flags> of the requested NUMA policy in the location pointed to by this argument.  If I<nodemask> is not NULL, then the nodemask associated with the policy will be stored in the location pointed to by this argument.  I<maxnode> specifies the number of node IDs that can be stored into I<nodemask>\(emthat is, the maximum node ID plus one.  The value specified by I<maxnode> is always rounded to a multiple of I<sizeof(unsigned long)>.
fr: Si le paramètre I<mode> n'est pas NULL, B<get_mempolicy>() stockera le mode de politique et tout I<drapeau de mode> optionnel de la politique NUMA requise à l'endroit pointé par ce paramètre. Si I<nodemask> n'est pas NULL, le masque de nœud associé à la politique sera stockée à l'emplacement pointé par cet argument. I<maxnode> spécifie le nombre d'identifiants de nœuds qui peuvent être stockés dans I<nodemask>, c'est-à-dire, la valeur maximale de l'identifiant de nœud plus un. La valeur indiquée dans I<maxnode> est toujours arrondie à un multiple de I<sizeof(unsigned long)>.

note: type: Plain text
en: If I<flags> specifies both B<MPOL_F_NODE> and B<MPOL_F_ADDR>, B<get_mempolicy>()  will return the node ID of the node on which the address I<addr> is allocated into the location pointed to by I<mode>.  If no page has yet been allocated for the specified address, B<get_mempolicy>()  will allocate a page as if the process had performed a read [load] access to that address, and return the ID of the node where that page was allocated.
fr: Si I<flags> indique à la fois B<MPOL_F_NODE> et B<MPOL_F_ADDR>, B<get_mempolicy>() renverra, à l'endroit pointé par I<mode>, l'identifiant de nœud du nœud sur lequel l'adresse I<addr> est allouée. Si aucune page n'a encore été allouée pour l'adresse spécifiée, B<get_mempolicy>() allouera une page comme si le processus avait réalisé un accès en lecture [chargement] à cette adresse, et renverra l'identifiant du nœud où cette page a été allouée.

note: Note:  code returns next interleave node via 'mode' argument -Lee Schermerhorn type: Plain text
en: If I<flags> specifies B<MPOL_F_NODE>, but not B<MPOL_F_ADDR>, and the process's current policy is B<MPOL_INTERLEAVE>, then B<get_mempolicy>()  will return in the location pointed to by a non-NULL I<mode> argument, the node ID of the next node that will be used for interleaving of internal kernel pages allocated on behalf of the process.  These allocations include pages for memory-mapped files in process memory ranges mapped using the B<mmap>(2)  call with the B<MAP_PRIVATE> flag for read accesses, and in memory ranges mapped with the B<MAP_SHARED> flag for all accesses.
fr: Si I<flags> indique B<MPOL_F_NODE> mais pas B<MPOL_F_ADDR> et que la politique actuelle est B<MPOL_INTERLEAVE>, B<get_mempolicy>() renverra à l'endroit pointé par un paramètre I<mode> non nul l'identifiant du prochain nœud à utiliser pour l'entrelacement des pages internes du noyau allouées au nom du processus. Ces allocations incluent des pages pour les fichiers de mémoire projetée dans les plages de mémoire projetée du processus en utilisant l'appel B<mmap>(2) avec l'attribut B<MAP_PRIVATE> pour les accès en lecture, et dans les plages de mémoire projetée avec l'attribut B<MAP_SHARED> pour tous les autres accès.

note: type: Plain text
en: Other flag values are reserved.
fr: D'autres valeurs d'attribut sont réservées.

note: type: Plain text
en: For an overview of the possible policies see B<set_mempolicy>(2).
fr: Pour un survol des politiques possibles, consultez B<set_mempolicy>(2).

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: On success, B<get_mempolicy>()  returns 0; on error, -1 is returned and I<errno> is set to indicate the error.
fr: B<get_mempolicy>() renvoie 0 s'il réussit, ou -1 s'il échoue, auquel cas I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Part of all of the memory range specified by I<nodemask> and I<maxnode> points outside your accessible address space.
fr: Une partie de la plage mémoire spécifiée par I<nodemask> et I<maxnode> pointe en dehors de votre espace d'adressage accessible.

note: type: Plain text
en: The value specified by I<maxnode> is less than the number of node IDs supported by the system.  Or I<flags> specified values other than B<MPOL_F_NODE> or B<MPOL_F_ADDR>; or I<flags> specified B<MPOL_F_ADDR> and I<addr> is NULL, or I<flags> did not specify B<MPOL_F_ADDR> and I<addr> is not NULL.  Or, I<flags> specified B<MPOL_F_NODE> but not B<MPOL_F_ADDR> and the current process policy is not B<MPOL_INTERLEAVE>.  Or, I<flags> specified B<MPOL_F_MEMS_ALLOWED> with either B<MPOL_F_ADDR> or B<MPOL_F_NODE>.  (And there are other B<EINVAL> cases.)
fr: La valeur spécifiée par I<maxnode> est inférieure au nombre d'identifiants de nœud pris en charge par le système. Ou I<flags> spécifie des valeurs autres que B<MPOL_F_NODE> ou B<MPOL_F_ADDR> ; ou I<flags> spécifie B<MPOL_F_ADDR> et I<addr> est NULL, ou I<flags> ne spécifie pas B<MPOL_F_ADDR> et I<addr> n'est pas NULL. Ou I<flags> spécifie B<MPOL_F_NODE> mais pas B<MPOL_F_ADDR> et la politique actuelle du processus n'est pas B<MPOL_INTERLEAVE>. Ou I<flags> spécifie B<MPOL_F_MEMS_ALLOWED> avec B<MPOL_F_ADDR> ou B<MPOL_F_NODE>. (Et il y a d'autres cas pour B<EINVAL>)

note: type: Plain text
en: The B<get_mempolicy>()  system call was added to the Linux kernel in version 2.6.7.
fr: L'appel système B<get_mempolicy>() a été ajouté au noyau Linux dans la version 2.6.7.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: This system call is Linux-specific.
fr: Cet appel système est spécifique à Linux.

note: type: Plain text
en: For information on library support, see B<numa>(7).
fr: Pour des informations sur la prise en charge par des bibliothèques, consultez B<numa>(7).

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<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/.

note: type: TH
en: 2013-04-03
fr: 3 avril 2013

note: type: Plain text
en: getcpu - determine CPU and NUMA node on which the calling thread is running
fr: getcpu - Déterminer le processeur et le nœud NUMA sur lesquels le thread appelant est en cours d'exécution

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Remarque> : il n'existe pas de fonction glibc autour de cet appel système ; consultez B<NOTES>.

note: type: Plain text
en: The B<getcpu>()  system call identifies the processor and node on which the calling thread or process is currently running and writes them into the integers pointed to by the I<cpu> and I<node> arguments.  The processor is a unique small integer identifying a CPU.  The node is a unique small identifier identifying a NUMA node.  When either I<cpu> or I<node> is NULL nothing is written to the respective pointer.
fr: L'appel système B<getcpu>() identifie le processeur et le nœud sur lesquels le thread ou processus appelant est en cours d'exécution et écrit le résultat dans les entiers pointés par les arguments I<cpu> et I<node>. Le processeur est un petit entier unique identifiant une CPU. Le nœud est un petit entier unique identifiant un nœud NUMA. Si I<cpu> ou I<node> est NULL, rien n'est écrit dans leur pointeur respectif.

note: type: Plain text
en: The third argument to this system call is nowadays unused, and should be specified as NULL unless portability to Linux 2.6.23 or earlier is required (see NOTES).
fr: Le troisième argument de cet appel système est aujourd'hui inutilisé, et devrait être indiqué comme valant NULL sauf si la portabilité vers Linux 2.6.23 ou antérieur est nécessaire (consultez les NOTES).

note: type: Plain text
en: The information placed in I<cpu> is guaranteed to be current only at the time of the call: unless the CPU affinity has been fixed using B<sched_setaffinity>(2), the kernel might change the CPU at any time.  (Normally this does not happen because the scheduler tries to minimize movements between CPUs to keep caches hot, but it is possible.)  The caller must allow for the possibility that the information returned in I<cpu> and I<node> is no longer current by the time the call returns.
fr: L'information placée dans I<cpu> n'est garantie d'être exacte qu'au moment de l'appel : à moins que l'affinité CPU n'ait été définie avec B<sched_setaffinity>(2), le noyau peut changer de processeur à tout moment. (Normalement, cela n'arrive pas car l'ordonnanceur essaie de minimiser les mouvements entre CPU et cache, mais c'est possible.) L'appelant doit être prêt à gérer la situation où les informations renvoyées dans I<cpu> et I<node> ne sont plus valables au retour de l'appel.

note: type: Plain text
en: On success, 0 is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, la valeur zéro est renvoyée. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: Arguments point outside the calling process's address space.
fr: Les arguments pointent en dehors de l'espace d'adressage du processus appelant.

note: type: Plain text
en: B<getcpu>()  was added in kernel 2.6.19 for x86_64 and i386.
fr: B<getcpu>() a été ajouté au noyau dans sa version 2.6.19 pour les architectures x86_64 et i386.

note: type: Plain text
en: B<getcpu>()  is Linux-specific.
fr: B<getcpu>() est spécifique à Linux.

note: type: Plain text
en: Linux makes a best effort to make this call as fast possible.  The intention of B<getcpu>()  is to allow programs to make optimizations with per-CPU data or for NUMA optimization.
fr: Linux fait de gros efforts pour rendre cet appel aussi rapide que possible. Le but de B<getcpu>() est de permettre aux programmes de réaliser des optimisations de données propres à chaque processeur et pour l'optimisation NUMA.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2); or use B<sched_getcpu>(3)  instead.
fr: La glibc ne fournit pas de fonction autour de cet appel système\ ; utilisez B<syscall>(2) pour l'appeler ; ou utilisez B<sched_getcpu>(3) à la place.

note: commit 4307d1e5ada595c87f9a4d16db16ba5edb70dcb1 Author: Ingo Molnar <mingo@elte.hu> Date:   Wed Nov 7 18:37:48 2007 +0100 x86: ignore the sys_getcpu() tcache parameter ===== Before kernel 2.6.24: ===== .I tcache is a pointer to a .IR "struct getcpu_cache" that is used as a cache by .BR getcpu (). Th
en: The I<tcache> argument is unused since Linux 2.6.24.  In earlier kernels, if this argument was non-NULL, then it specified a pointer to a caller-allocated buffer in thread-local storage that was used to provide a caching mechanism for B<getcpu>().  Use of the cache could speed B<getcpu>()  calls, at the cost that there was a very small chance that the returned information would be out of date.  The caching mechanism was considered to cause problems when migrating threads between CPUs, and so the argument is now ignored.
fr: Le paramètre I<tcache> n'est pas utilisé depuis la version 2.6.24 de Linux. Dans les noyaux antérieurs, si cet argument n'était pas NULL, il spécifiait un pointeur vers un tampon de l'appelant dans l'espace local de stockage du thread utilisé pour fournir un mécanisme de cache à B<getcpu>(). L'utilisation de ce cache pouvait accélérer les appels à B<getcpu>(), avec le faible risque que l'information renvoyée ne soit plus à jour. On a considéré que le mécanisme de cache entraînait des problèmes lors de la migration de threads entre processeurs, aussi, cet argument est aujourd'hui ignoré.

note: type: Plain text
en: mbind - set memory policy for a memory range
fr: mbind - Définir la politique mémoire pour une zone de mémoire

note: type: Plain text
en: B<mbind>()  sets the NUMA memory policy, which consists of a policy mode and zero or more nodes, for the memory range starting with I<addr> and continuing for I<len> bytes.  The memory policy defines from which node memory is allocated.
fr: B<mbind>() configure la politique mémoire NUMA, qui consiste en un mode de politique et zéro ou plusieurs nœuds, pour l'intervalle mémoire démarrant à I<addr> et s'étalant sur I<len> octets. La politique mémoire définit à partir de quel nœud la mémoire sera allouée.

note: type: Plain text
en: If the memory range specified by the I<addr> and I<len> arguments includes an "anonymous" region of memory\(emthat is a region of memory created using the B<mmap>(2)  system call with the B<MAP_ANONYMOUS>\(emor a memory-mapped file, mapped using the B<mmap>(2)  system call with the B<MAP_PRIVATE> flag, pages will be allocated only according to the specified policy when the application writes [stores] to the page.  For anonymous regions, an initial read access will use a shared page in the kernel containing all zeros.  For a file mapped with B<MAP_PRIVATE>, an initial read access will allocate pages according to the process policy of the process that causes the page to be allocated.  This may not be the process that called B<mbind>().
fr: Si la plage mémoire spécifiée par les paramètres I<addr> et I<len> inclut une région « anonyme » de mémoire (c'est-à-dire une région de mémoire créée avec l'appel système B<mmap>(2) et l'attribut B<MAP_ANONYMOUS>) ou un fichier de mémoire projetée, projection créée en utilisant l'appel système B<mmap>(2) et l'attribut B<MAP_PRIVATE>, les pages seront seulement allouées conformément à la politique spécifiée lorsque l'application écrit [stocke] dans la page. Pour les régions anonymes, un accès initial en lecture utilisera une page partagée du noyau contenant des zéros. Pour un fichier projeté avec B<MAP_PRIVATE>, un accès initial en lecture allouera des pages conformément à la politique de processus du processus qui a fait que cette page ait été allouée. Cela peut ne pas être le processus qui a appelé B<mbind>().

note: type: Plain text
en: The specified policy will be ignored for any B<MAP_SHARED> mappings in the specified memory range.  Rather the pages will be allocated according to the process policy of the process that caused the page to be allocated.  Again, this may not be the process that called B<mbind>().
fr: La politique spécifiée sera ignorée pour toute projection B<MAP_SHARED> dans la plage mémoire spécifiée. Plutôt, les pages seront allouées conformément à la politique de processus du processus qui a fait que la page ait été allouée. Cela peut ne pas être le processus qui a appelé B<mbind>().

note: type: Plain text
en: If the specified memory range includes a shared memory region created using the B<shmget>(2)  system call and attached using the B<shmat>(2)  system call, pages allocated for the anonymous or shared memory region will be allocated according to the policy specified, regardless which process attached to the shared memory segment causes the allocation.  If, however, the shared memory region was created with the B<SHM_HUGETLB> flag, the huge pages will be allocated according to the policy specified only if the page allocation is caused by the process that calls B<mbind>()  for that region.
fr: Si la plage de mémoire spécifiée inclut une région de mémoire partagée créée avec l'appel système B<shmget>(2) et attachée avec l'appel système B<shmat>(2), les pages allouées pour la région de mémoire anonyme ou partagée seront allouées conformément à la politique spécifiée, sans se soucier de quel processus attaché au segment de mémoire partagé a provoqué l'allocation. Si toutefois la région de mémoire partagée a été créée avec l'attribut B<SHM_HUGETLB>, les grosses pages seront allouées conformément à la politique spécifiée seulement si l'allocation de pages est provoquée par le processus qui a appelé B<mbind>() pour cette région.

note: type: Plain text
en: By default, B<mbind>()  has an effect only for new allocations; if the pages inside the range have been already touched before setting the policy, then the policy has no effect.  This default behavior may be overridden by the B<MPOL_MF_MOVE> and B<MPOL_MF_MOVE_ALL> flags described below.
fr: Par défaut, B<mbind>() n'a d'effet que sur les nouvelles allocations ; si des pages dans l'intervalle ont déjà été accédées avant de configurer la politique, alors la politique n'a pas d'effet. Ce comportement par défaut peut être écrasé par les attributs B<MPOL_MF_MOVE> et B<MPOL_MF_MOVE_ALL> décrits plus loin.

note: type: Plain text
en: The I<mode> argument must specify one of B<MPOL_DEFAULT>, B<MPOL_BIND>, B<MPOL_INTERLEAVE>, or B<MPOL_PREFERRED>.  All policy modes except B<MPOL_DEFAULT> require the caller to specify via the I<nodemask> argument, the node or nodes to which the mode applies.
fr: Le paramètre I<mode> doit spécifier l'un des attributs parmi B<MPOL_DEFAULT>, B<MPOL_BIND>, B<MPOL_INTERLEAVE> et B<MPOL_PREFERRED>. Toutes les modes de politique excepté B<MPOL_DEFAULT> nécessitent que l'appelant spécifie, dans le paramètre I<nodemask>, les nœuds auxquels s'appliquent le mode.

note: type: Plain text
en: The I<mode> argument may also include an optional I<mode flag >.  The supported I<mode flags> are:
fr: Le paramètre I<mode> peut aussi inclure un I<drapeau de mode> optionnel. Les I<drapeaux de mode> pris en charges sont :

note: type: TP
en: B<MPOL_F_STATIC_NODES> (since Linux-2.6.26)
fr: B<MPOL_F_STATIC_NODES> (depuis Linux 2.6.26)

note: type: Plain text
en: A nonempty I<nodemask> specifies physical node ids.  Linux does not remap the I<nodemask> when the process moves to a different cpuset context, nor when the set of nodes allowed by the process's current cpuset context changes.
fr: Un paramètre I<nodemask> non vide indique des identifiants des nœuds physiques. Linux ne réassocie pas I<nodemask> quand le processus change de contexte d'ensemble de processeurs ou après une modifications de l'ensemble de nœuds autorisés pour le contexte de l'ensemble de processeurs en cours pour le processus.

note: type: TP
en: B<MPOL_F_RELATIVE_NODES> (since Linux-2.6.26)
fr: B<MPOL_F_RELATIVE_NODES> (depuis Linux 2.6.26)

note: type: Plain text
en: A nonempty I<nodemask> specifies node ids that are relative to the set of node ids allowed by the process's current cpuset.
fr: Un paramètre I<nodemask> non vide indique des 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.

note: type: Plain text
en: I<nodemask> points to a bit mask of nodes containing up to I<maxnode> bits.  The bit mask size is rounded to the next multiple of I<sizeof(unsigned long)>, but the kernel will use bits only up to I<maxnode>.  A NULL value of I<nodemask> or a I<maxnode> value of zero specifies the empty set of nodes.  If the value of I<maxnode> is zero, the I<nodemask> argument is ignored.  Where a I<nodemask> is required, it must contain at least one node that is on-line, allowed by the process's current cpuset context [unless the B<MPOL_F_STATIC_NODES> mode flag is specified], and contains memory.
fr: I<nodemask> pointe sur un masque de bits qui contient jusqu'à I<maxnode> bits. La taille du masque de bits est arrondi au multiple supérieur de I<sizeof(unsigned long)>, mais le noyau n'utilisera que jusqu'à I<maxnode> bits. Une valeur NULL pour I<nodemask> ou une valeur I<maxnode> de zéro indique un ensemble vide de nœuds. Si la valeur de I<maxnode> est zéro, l'argument I<nodemask> est ignoré. Quand un I<nodemask> est exigé, il doit contenir au moins un nœud de connecté, autorisés dans le contexte de l'ensemble de processeurs du processus appelant (à moins que le drapeau B<MPOL_F_STATIC_NODES> ne soit fourni) et doit contenir de la mémoire.

note: type: Plain text
en: The B<MPOL_DEFAULT> mode requests that any nondefault policy be removed, restoring default behavior.  When applied to a range of memory via B<mbind>(), this means to use the process policy, which may have been set with B<set_mempolicy>(2).  If the mode of the process policy is also B<MPOL_DEFAULT>, the system-wide default policy will be used.  The system-wide default policy allocates pages on the node of the CPU that triggers the allocation.  For B<MPOL_DEFAULT>, the I<nodemask> and I<maxnode> arguments must be specify the empty set of nodes.
fr: Le mode B<MPOL_DEFAULT> demande à ce que toute politique n'étant pas une politique par défaut soit retirée, ce qui restaure le comportement par défaut. Lorsqu'il est appliqué à une plage mémoire via B<mbind>(), cela signifie d'utiliser la politique du processus qui peut être modifiée avec B<set_mempolicy>(2). Si le mode de la politique de processus est également B<MPOL_DEFAULT>, la politique par défaut du système sera utilisée. La politique par défaut du système alloue des pages sur le nœud de la CPU qui a déclenché l'allocation. Pour B<MPOL_DEFAULT>, les paramètres I<nodemask> et I<maxnode> doivent spécifier l'ensemble vide de nœuds.

note: type: Plain text
en: The B<MPOL_BIND> mode specifies a strict policy that restricts memory allocation to the nodes specified in I<nodemask>.  If I<nodemask> specifies more than one node, page allocations will come from the node with the lowest numeric node ID first, until that node contains no free memory.  Allocations will then come from the node with the next highest node ID specified in I<nodemask> and so forth, until none of the specified nodes contain free memory.  Pages will not be allocated from any node not specified in the I<nodemask>.
fr: Le mode B<MPOL_BIND> spécifie une politique stricte qui restreint l'allocation mémoire aux nœuds indiqués dans I<nodemask>. Si I<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 node dont l'identifiant est le prochain plus grand spécifié dans I<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 I<nodemask>.

note: type: Plain text
en: The B<MPOL_INTERLEAVE> mode specifies that page allocations be interleaved across the set of nodes specified in I<nodemask>.  This optimizes for bandwidth instead of latency by spreading out pages and memory accesses to those pages across multiple nodes.  To be effective the memory area should be fairly large, at least 1MB or bigger with a fairly uniform access pattern.  Accesses to a single page of the area will still be limited to the memory bandwidth of a single node.
fr: Le mode B<MPOL_INTERLEAVE> spécifie que les allocations de pages sont entrelacées à travers l'ensemble de nœuds spécifiés dans I<nodemask>. Cela optimise la bande passante au lieu de la latence en étalant les pages et l'accès mémoires à ces pages à travers plusieurs nœuds. Pour être efficace, la zone mémoire doit être relativement grande, au moins 1 Mo ou plus avec un modèle d'accès assez uniforme. Les accès à une unique page de la zone seront toujours limités à la bande passante d'un seul nœud.

note: type: Plain text
en: B<MPOL_PREFERRED> sets the preferred node for allocation.  The kernel will try to allocate pages from this node first and fall back to other nodes if the preferred nodes is low on free memory.  If I<nodemask> specifies more than one node ID, the first node in the mask will be selected as the preferred node.  If the I<nodemask> and I<maxnode> arguments specify the empty set, then the memory is allocated on the node of the CPU that triggered the allocation.  This is the only way to specify "local allocation" for a range of memory via B<mbind>().
fr: B<MPOL_PREFERRED> définit le nœud préféré pour les allocations. Le noyau essaiera d'abord d'allouer sur ce nœud, avant de ce rabattre sur d'autres nœuds si celui\(hyci n'a plus assez de mémoire libre. Si I<nodemask> précise plus d'un identifiant de nœud, le premier nœud du masque sera choisi comme le nœud préféré. Si les paramètres I<nodemask> et I<maxnode> indique un ensemble vide, la mémoire est allouée sur le nœud du CPU qui a déclenché l'allocation. C'est la seule façon d'indiquer une « allocation locale » pour une plage mémoire avec B<mbind>().

note: According to the kernel code, the following is not true --Lee Schermerhorn In 2.6.16 or later the kernel will also try to move pages to the requested node with this flag. type: Plain text
en: If B<MPOL_MF_STRICT> is passed in I<flags> and I<mode> is not B<MPOL_DEFAULT>, then the call will fail with the error B<EIO> if the existing pages in the memory range don't follow the policy.
fr: Si l'option B<MPOL_MF_STRICT> est passée dans I<flags> et si I<mode> n'est pas B<MPOL_DEFAULT>, l'appel échoue avec l'erreur B<EIO> si les pages existantes dans la projection ne suivent pas la politique.

note: type: Plain text
en: If B<MPOL_MF_MOVE> is specified in I<flags>, then the kernel will attempt to move all the existing pages in the memory range so that they follow the policy.  Pages that are shared with other processes will not be moved.  If B<MPOL_MF_STRICT> is also specified, then the call will fail with the error B<EIO> if some pages could not be moved.
fr: Si B<MPOL_MF_MOVE> est passé dans I<flags>, le noyau essaiera de déplacer toutes les pages de la projection pour qu'elles suivent la politique. Les pages partagées avec d'autres processus ne sont pas déplacées. Si B<MPOL_MF_STRICT> est également indiqué, l'appel échouera avec l'erreur B<EIO> si certaines pages ne peuvent pas être déplacées.

note: --------------------------------------------------------------- type: Plain text
en: If B<MPOL_MF_MOVE_ALL> is passed in I<flags>, then the kernel will attempt to move all existing pages in the memory range regardless of whether other processes use the pages.  The calling process must be privileged (B<CAP_SYS_NICE>)  to use this flag.  If B<MPOL_MF_STRICT> is also specified, then the call will fail with the error B<EIO> if some pages could not be moved.
fr: Si B<MPOL_MF_MOVE_ALL> est indiqué dans I<flags>, alors le noyau essaiera de déplacer toutes les pages de la projection, même si d'autres processus les utilisent. Le processus appelant doit être privilégié (avoir la capacité B<CAP_SYS_NICE>) pour utiliser cette option. Si B<MPOL_MF_STRICT> est également utilisé, l'appel renverra l'erreur B<EIO> si certaines pages ne peuvent pas être déplacées.

note: --------------------------------------------------------------- type: Plain text
en: On success, B<mbind>()  returns 0; on error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, B<mbind>() renvoie zéro. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: Part or all of the memory range specified by I<nodemask> and I<maxnode> points outside your accessible address space.  Or, there was an unmapped hole in the specified memory range.
fr: Une partie ou toute la plage mémoire spécifiée par I<nodemask> et I<maxnode> pointe en dehors de votre espace d'adressage accessible. Ou il y a un trou non projeté dans l'intervalle mémoire spécifié.

note: As at 2.6.23, this limit is "a page worth of bits", e.g., 8 * 4096 bits, assuming a 4kB page size. type: Plain text
en: An invalid value was specified for I<flags> or I<mode>; or I<addr + len> was less than I<addr>; or I<addr> is not a multiple of the system page size.  Or, I<mode> is B<MPOL_DEFAULT> and I<nodemask> specified a nonempty set; or I<mode> is B<MPOL_BIND> or B<MPOL_INTERLEAVE> and I<nodemask> is empty.  Or, I<maxnode> exceeds a kernel-imposed limit.  Or, I<nodemask> specifies one or more node IDs that are greater than the maximum supported node ID.  Or, none of the node IDs specified by I<nodemask> are on-line and allowed by the process's current cpuset context, or none of the specified nodes contain memory.  Or, the I<mode> argument specified both B<MPOL_F_STATIC_NODES> and B<MPOL_F_RELATIVE_NODES>.
fr: Une valeur non valable a été spécifiée pour I<flags> ou I<mode> ; ou I<addr + len> est plus petite que I<addr> ; ou I<addr> n'est pas un multiple de la taille de page système. Ou, I<mode> est B<MPOL_DEFAULT> et I<nodemask> spécifiait un ensemble non vide ; ou I<mode> était B<MPOL_BIND> ou B<MPOL_INTERLEAVE> et le masque de nœuds I<nodemask> est vide. Ou, I<maxnode> dépasse une limite imposée par le noyau. Ou, I<nodemask> spécifie un ou plusieurs identifiants de nœud qui sont plus grands que l'identifiant maximum de nœud pris en charge. Ou aucun des identifiants de nœuds spécifiés par I<nodemask> ne sont connectés et autorisés dans le contexte de l'ensemble de processeurs du processus appelant, ou aucun des nœuds spécifiés ne contient de mémoire. Ou le paramètre I<mode> indiquait à la fois B<MPOL_F_STATIC_NODES> et B<MPOL_F_RELATIVE_NODES>.

note: type: Plain text
en: B<MPOL_MF_STRICT> was specified and an existing page was already on a node that does not follow the policy; or B<MPOL_MF_MOVE> or B<MPOL_MF_MOVE_ALL> was specified and the kernel was unable to move all existing pages in the range.
fr: B<MPOL_MF_STRICT> a été utilisé et une page existante était déjà sur un nœud ne suivant pas la politique ; ou soit B<MPOL_MF_MOVE> soit B<MPOL_MF_MOVE_ALL> a été spécifié et le noyau n'a pas été capable de déplacer toutes les pages existantes dans la plage.

note: type: Plain text
en: Insufficient kernel memory was available.
fr: Pas assez de mémoire pour le noyau.

note: --------------------------------------------------------------- type: Plain text
en: The I<flags> argument included the B<MPOL_MF_MOVE_ALL> flag and the caller does not have the B<CAP_SYS_NICE> privilege.
fr: Le paramètre I<flags> inclus l'attribut B<MPOL_MF_MOVE_ALL> et l'appelant n'a pas le privilège B<CAP_SYS_NICE>.

note: type: Plain text
en: The B<mbind>()  system call was added to the Linux kernel in version 2.6.7.
fr: L'appel système B<mbind>() a été ajouté au noyau Linux dans la version 2.6.7.

note: type: Plain text
en: NUMA policy is not supported on a memory-mapped file range that was mapped with the B<MAP_SHARED> flag.
fr: La politique NUMA n'est pas supportée sur les plages de fichiers de mémoire projetée qui ont été projetées avec l'attribut B<MAP_SHARED>.

note: type: Plain text
en: The B<MPOL_DEFAULT> mode can have different effects for B<mbind>()  and B<set_mempolicy>(2).  When B<MPOL_DEFAULT> is specified for B<set_mempolicy>(2), the process's policy reverts to system default policy or local allocation.  When B<MPOL_DEFAULT> is specified for a range of memory using B<mbind>(), any pages subsequently allocated for that range will use the process's policy, as set by B<set_mempolicy>(2).  This effectively removes the explicit policy from the specified range, "falling back" to a possibly nondefault policy.  To select explicit "local allocation" for a memory range, specify a I<mode> of B<MPOL_PREFERRED> with an empty set of nodes.  This method will work for B<set_mempolicy>(2), as well.
fr: Le mode B<MPOL_DEFAULT> peut avoir des effets différents sur B<mbind>() et sur B<set_mempolicy>(2). Lorsque B<MPOL_DEFAULT> est spécifié pour B<set_mempolicy>(2), la politique du processus est remise à la politique par défaut du système ou l'allocation locale. Lorsque B<MPOL_DEFAULT> est spécifié pour une plage de mémoire utilisant B<mbind>(), toutes les pages allouées par la suite pour cette plage utiliseront la politique du processus telle qu'elle a été définie par B<set_mempolicy>(2). Cela supprime de manière effective la politique explicite de la plage spécifiée, ce qui peut éventuellement remettre une politique autre que celle par défaut. Pour choisir explicitement une « allocation locale » pour une plage mémoire, spécifiez I<mode> avec B<MPOL_PREFERRED> avec un ensemble vide de nœuds. Cette méthode fonctionnera aussi avec B<set_mempolicy>(2).

note: type: Plain text
en: Support for huge page policy was added with 2.6.16.  For interleave policy to be effective on huge page mappings the policied memory needs to be tens of megabytes or larger.
fr: La gestion de politique pour les pages immenses a été ajoutée dans le noyau 2.6.16. Pour que la politique d'entrelacement soit efficace sur les projections de pages immenses, la taille de la zone mémoire doit être au moins de dizaines de mégaoctets.

note: type: Plain text
en: B<MPOL_MF_STRICT> is ignored on huge page mappings.
fr: B<MPOL_MF_STRICT> est ignoré sur les projections de pages immenses.

note: type: Plain text
en: B<MPOL_MF_MOVE> and B<MPOL_MF_MOVE_ALL> are available only on Linux 2.6.16 and later.
fr: B<MPOL_MF_MOVE> et B<MPOL_MF_MOVE_ALL> ne sont disponibles qu'à partir de Linux 2.6.16.

note: type: TH
en: 2012-08-01
fr: 1er août 2012

note: type: Plain text
en: migrate_pages - move all pages in a process to another set of nodes
fr: migrate_pages - Déplacer toutes les pages d'un processus sur un autre ensemble de nœuds

note: type: Plain text
en: Link with I<-lnuma>.
fr: Effectuez l'édition des liens avec l'option I<-lnuma>.

note: type: Plain text
en: B<migrate_pages>()  attempts to move all pages of the process I<pid> that are in memory nodes I<old_nodes> to the memory nodes in I<new_nodes>.  Pages not located in any node in I<old_nodes> will not be migrated.  As far as possible, the kernel maintains the relative topology relationship inside I<old_nodes> during the migration to I<new_nodes>.
fr: B<migrate_pages>() essaye de déplacer toutes les pages du processus I<pid> qui sont sur les nœuds de mémoire I<old_nodes> vers les nœuds de mémoire I<new_nodes>. Les pages qui ne sont dans aucun nœud de I<old_nodes> ne seront pas déplacées. Le noyau maintient autant que possible les relations topologiques relatives à l'intérieur de I<old_nodes> durant le déplacement vers I<new_nodes>.

note: type: Plain text
en: The I<old_nodes> and I<new_nodes> arguments are pointers to bit masks of node numbers, with up to I<maxnode> bits in each mask.  These masks are maintained as arrays of unsigned I<long> integers (in the last I<long> integer, the bits beyond those specified by I<maxnode> are ignored).  The I<maxnode> argument is the maximum node number in the bit mask plus one (this is the same as in B<mbind>(2), but different from B<select>(2)).
fr: Les arguments I<old_nodes> et I<new_nodes> sont des pointeurs vers des masques de bits de numéros de nœuds, avec jusqu'à I<maxnode> bits dans chaque masque. Ces masques sont maintenus comme des tableaux d'entiers longs non signés (I<unsigned long>) ; dans le dernier entier long, les bits après ceux spécifiés par I<maxnode> sont ignorés. L'argument I<maxnode> vaut un plus le numéro maximal de nœud dans le masque de bit (qui a donc la même signification que dans B<mbind>(2), mais est différent de B<select>(2)).

note: type: Plain text
en: The I<pid> argument is the ID of the process whose pages are to be moved.  To move pages in another process, the caller must be privileged (B<CAP_SYS_NICE>)  or the real or effective user ID of the calling process must match the real or saved-set user ID of the target process.  If I<pid> is 0, then B<migrate_pages>()  moves pages of the calling process.
fr: L'argument I<pid> est l'identifiant du processus dont les pages doivent être déplacées. Pour déplacer les pages dans un autres processus, l'appelant doit être privilégié (B<CAP_SYS_NICE>) ou l'identifiant utilisateur réel ou effectif du processus appelant doit correspondre à l'identifiant utilisateur réel ou sauvé du processus cible. Si I<pid> vaut 0, alors B<migrate_pages>() déplace les pages du processus appelant.

note: type: Plain text
en: Pages shared with another process will be moved only if the initiating process has the B<CAP_SYS_NICE> privilege.
fr: Les pages partagées avec un autre processus ne seront déplacées que si le processus appelant possède le privilège B<CAP_SYS_NICE>.

note: type: Plain text
en: On success B<migrate_pages>()  returns the number of pages that could not be moved (i.e., a return of zero means that all pages were successfully moved).  On error, it returns -1, and sets I<errno> to indicate the error.
fr: S'il réussit, B<migrate_pages>() renvoie le nombre de pages qui n'ont pas pu être déplacées (c'est-à-dire qu'un code de retour de zéro signifie que toutes les pages ont été déplacés correctement). En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: Insufficient privilege (B<CAP_SYS_NICE>)  to move pages of the process specified by I<pid>, or insufficient privilege (B<CAP_SYS_NICE>)  to access the specified target nodes.
fr: Un privilège insuffisant (B<CAP_SYS_NICE>)  pour déplacer les pages du processus spécifié par I<pid> ou pour accéder aux nœuds de destination.

note: FIXME There are other errors type: Plain text
en: No process matching I<pid> could be found.
fr: Il n'y a pas de processus correspondant à I<pid>.

note: type: Plain text
en: The B<migrate_pages>()  system call first appeared on Linux in version 2.6.16.
fr: L'appel système B<migrate_pages>() est apparu pour la première fois sous Linux avec le noyau 2.6.16.

note: type: Plain text
en: Use B<get_mempolicy>(2)  with the B<MPOL_F_MEMS_ALLOWED> flag to obtain the set of nodes that are allowed by the calling process's cpuset.  Note that this information is subject to change at any time by manual or automatic reconfiguration of the cpuset.
fr: Utilisez B<get_mempolicy>(2) avec le drapeau B<MPOL_F_MEMS_ALLOWED> pour obtenir l'ensemble des nœuds autorisés par l'ensemble de processeurs du processus appelant. Notez que cette information peut changer à tout instant d'une fait d'une reconfiguration manuelle ou automatique de l'ensemble de processeurs.

note: type: Plain text
en: Use of B<migrate_pages>()  may result in pages whose location (node) violates the memory policy established for the specified addresses (see B<mbind>(2))  and/or the specified process (see B<set_mempolicy>(2)).  That is, memory policy does not constrain the destination nodes used by B<migrate_pages>().
fr: L'utilisation de B<migrate_pages>() peut causer des pages dont l'emplacement (le nœud) viole la politique mémoire établie pour les adresses indiquées (consultez B<mbind>(2)) ou pour le processus indiqué (consultez B<set_mempolicy>(2)). En d'autres termes, la politique mémoire ne restreint pas les nœuds de destination utilisés par B<migrate_pages>().

note: type: Plain text
en: The I<E<lt>numaif.hE<gt>> header is not included with glibc, but requires installing I<libnuma-devel> or a similar package.
fr: L'en-tête I<E<lt>numaif.hE<gt>> n'est pas inclus dans la glibc, mais nécessite l'installation de I<libnuma-devel> (ce nom peut varier suivant les distributions).

note: type: Plain text
en: I<Documentation/vm/page_migration> in the Linux kernel source tree
fr: I<Documentation/vm/page_migration> dans les sources du noyau Linux

note: type: TH
en: 2010-06-11
fr: 11 juin 2010

note: type: Plain text
en: move_pages - move individual pages of a process to another node
fr: move_pages - Déplacer des pages individuelles d'un processus sur un autre nœud

note: type: Plain text
en: B<move_pages>()  moves the specified I<pages> of the process I<pid> to the memory nodes specified by I<nodes>.  The result of the move is reflected in I<status>.  The I<flags> indicate constraints on the pages to be moved.
fr: B<move_pages>() déplace les I<pages> indiqué du processus I<pid> dans les nœuds indiqués par I<nodes>. Le résultat du déplacement est reflété dans I<status>. Les drapeaux I<flags> indiquent des contraintes sur les pages à déplacer.

note: type: Plain text
en: I<pid> is the ID of the process in which pages are to be moved.  To move pages in another process, the caller must be privileged (B<CAP_SYS_NICE>)  or the real or effective user ID of the calling process must match the real or saved-set user ID of the target process.  If I<pid> is 0, then B<move_pages>()  moves pages of the calling process.
fr: I<pid> est l'identifiant du processus dans lequel des pages doivent être déplacées. Pour déplacer des pages dans un autres processus, l'appelant doit être privilégié (B<CAP_SYS_NICE>) ou l'identifiant utilisateur réel ou effectif du processus appelant doit correspondre à l'identifiant utilisateur réel ou sauvé du processus cible. Si I<pid> vaut 0, alors B<move_pages>() déplace des pages du processus appelant.

note: type: Plain text
en: I<count> is the number of pages to move.  It defines the size of the three arrays I<pages>, I<nodes>, and I<status>.
fr: I<count> est le nombre de pages à déplacer. Il définit la taille des trois tableaux I<pages>, I<nodes> et I<status>.

note: FIXME what if they are not aligned? type: Plain text
en: I<pages> is an array of pointers to the pages that should be moved.  These are pointers that should be aligned to page boundaries.  Addresses are specified as seen by the process specified by I<pid>.
fr: I<pages> est un tableau de pointeurs vers des pages à déplacer. Ces pointeurs doivent être alignés sur des limites de pages. Les adresses sont indiquées comme elles sont vues par le processus indiqué par I<pid>.

note: type: Plain text
en: I<nodes> is an array of integers that specify the desired location for each page.  Each element in the array is a node number.  I<nodes> can also be NULL, in which case B<move_pages>()  does not move any pages but instead will return the node where each page currently resides, in the I<status> array.  Obtaining the status of each page may be necessary to determine pages that need to be moved.
fr: I<nodes> est un tableau d'entiers qui indiquent les emplacements voulus pour chaque page. Chaque élément du tableau est un numéro de nœud. I<nodes> peut aussi être NULL, auquel cas B<move_pages>() ne déplace aucune page mais renvoie dans I<status> le nœud où chaque page réside actuellement. Obtenir l'état de chaque page peut être nécessaire pour trouver les pages qui doivent être déplacées.

note: type: Plain text
en: I<status> is an array of integers that return the status of each page.  The array contains valid values only if B<move_pages>()  did not return an error.
fr: I<status> est un tableau d'entiers qui renvoie l'état de chaque page. Le tableau ne contient des valeurs correctes que si B<move_pages>() n'a pas renvoyé d'erreur.

note: type: Plain text
en: I<flags> specify what types of pages to move.  B<MPOL_MF_MOVE> means that only pages that are in exclusive use by the process are to be moved.  B<MPOL_MF_MOVE_ALL> means that pages shared between multiple processes can also be moved.  The process must be privileged (B<CAP_SYS_NICE>)  to use B<MPOL_MF_MOVE_ALL>.
fr: I<flags> indique quels types de page déplacer. B<MPOL_MF_MOVE> signifie que seules les pages qui ne peuvent être utilisées qu'exclusivement par le processus sont à déplacer. B<MPOL_MF_MOVE_ALL> signifie que les pages partagées entre plusieurs processus peuvent aussi être déplacée. Le processus doit être privilégié (B<CAP_SYS_NICE>) pour utiliser B<MPOL_MF_MOVE_ALL>.

note: type: SS
en: Page states in the status array
fr: États des pages dans le tableau array

note: type: Plain text
en: The following values can be returned in each element of the I<status> array.
fr: Les valeurs suivantes peuvent être renvoyées dans chaque élément du tableau I<status>.

note: type: Plain text
en: Identifies the node on which the page resides.
fr: Indique le nœud sur lequel la page réside.

note: type: Plain text
en: The page is mapped by multiple processes and can be moved only if B<MPOL_MF_MOVE_ALL> is specified.
fr: La page est projetée par plusieurs processus et ne peut être déplacée que si B<MPOL_MF_MOVE_ALL> est utilisé.

note: type: Plain text
en: The page is currently busy and cannot be moved.  Try again later.  This occurs if a page is undergoing I/O or another kernel subsystem is holding a reference to the page.
fr: La page est actuellement occupée et ne peut être déplacée. Essayez plus tard. Ceci arrive si la page est utilisée pour des entrées/sorties ou si une autre partie du noyau conserve une référence sur la page.

note: type: Plain text
en: This is a zero page or the memory area is not mapped by the process.
fr: C'est une page nulle ou la zone mémoire n'est pas projetée par le processus.

note: type: Plain text
en: Unable to write back a page.  The page has to be written back in order to move it since the page is dirty and the filesystem does not provide a migration function that would allow the move of dirty pages.
fr: Impossible de réécrire une page. La page doit être réécrite pour la déplacer puisque la page est sale et que le système de fichiers ne fournit pas de fonction de migration qui permettrait le déplacement de pages sales.

note: type: Plain text
en: A dirty page cannot be moved.  The filesystem does not provide a migration function and has no ability to write back pages.
fr: Une page sale ne peut pas être déplacée. Le système de fichiers ne fournit pas de fonction de déplacement et n'a pas la possibilité de réécrire la page.

note: type: Plain text
en: The page is not present.
fr: La page n'est pas présente.

note: type: Plain text
en: Unable to allocate memory on target node.
fr: Impossible d'allouer de la mémoire sur le nœud cible.

note: FIXME Is the following quite true: does the wrapper in numactl do the right thing? type: Plain text
en: On success B<move_pages>()  returns zero.  On error, it returns -1, and sets I<errno> to indicate the error.
fr: S'il réussit, B<move_pages>() renvoie zéro. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: Too many pages to move.
fr: Trop de pages à déplacer.

note: FIXME Clarify "current cpuset".  Is that the cpuset of the caller or the target? type: Plain text
en: One of the target nodes is not allowed by the current cpuset.
fr: Un des nœuds cibles n'est pas autorisés dans l'ensemble de processeurs en cours.

note: type: Plain text
en: Parameter array could not be accessed.
fr: Impossible d'accéder à un tableau en paramètre.

note: type: Plain text
en: Flags other than B<MPOL_MF_MOVE> and B<MPOL_MF_MOVE_ALL> was specified or an attempt was made to migrate pages of a kernel thread.
fr: Un drapeau autre que B<MPOL_MF_MOVE> ou B<MPOL_MF_MOVE_ALL> a été indiqué ou on a essayé de déplacer des pages d'un thread noyau.

note: type: Plain text
en: One of the target nodes is not online.
fr: Un des nœuds cibles n'est pas connecté.

note: type: Plain text
en: No pages were found that require moving.  All pages are either already on the target node, not present, had an invalid address or could not be moved because they were mapped by multiple processes.
fr: Aucune page nécessitant d'être déplacée n'a été trouvée. Toutes les pages sont déjà sur le nœud cible, absentes, avec une adresse non valable ou ne pouvaient être déplacées parce qu'elles étaient projetées par plusieurs processus.

note: type: Plain text
en: The caller specified B<MPOL_MF_MOVE_ALL> without sufficient privileges (B<CAP_SYS_NICE>).  Or, the caller attempted to move pages of a process belonging to another user but did not have privilege to do so (B<CAP_SYS_NICE>).
fr: L'appelant a indiqué B<MPOL_MF_MOVE_ALL> sans les privilèges suffisants (B<CAP_SYS_NICE>). Ou bien l'appelant a essayé de déplacer des pages d'un processus appartenant à un autre utilisateur mais n'était pas autorisé à le faire (B<CAP_SYS_NICE>).

note: type: Plain text
en: Process does not exist.
fr: Le processus n'existe pas.

note: type: Plain text
en: B<move_pages>()  first appeared on Linux in version 2.6.18.
fr: B<move_pages>() est apparu pour la première fois sous Linux avec le noyau 2.6.18.

note: FIXME Clarify "current cpuset".  Is that the cpuset of the caller or the target? type: Plain text
en: Use B<get_mempolicy>(2)  with the B<MPOL_F_MEMS_ALLOWED> flag to obtain the set of nodes that are allowed by the current cpuset.  Note that this information is subject to change at any time by manual or automatic reconfiguration of the cpuset.
fr: Utilisez B<get_mempolicy>(2) avec le drapeau B<MPOL_F_MEMS_ALLOWED> pour obtenir l'ensemble des nœuds autorisés par l'ensemble de processeurs courant. Notez que cette information peut changer à tout instant d'une fait d'une reconfiguration manuelle ou automatique de l'ensemble de processeurs.

note: type: Plain text
en: Use of this function may result in pages whose location (node) violates the memory policy established for the specified addresses (See B<mbind>(2))  and/or the specified process (See B<set_mempolicy>(2)).  That is, memory policy does not constrain the destination nodes used by B<move_pages>().
fr: L'utilisation de cette fonction peut causer des pages dont l'emplacement (le nœud) viole la politique mémoire établie pour les adresses indiquées (voir B<mbind>(2)) ou pour le processus indiqué (consultez B<set_mempolicy>(2)). En d'autres termes, la politique mémoire ne restreint pas les nœuds de destination utilisés par B<move_pages>().

note: type: TH
en: 2012-08-05
fr: 5 août 2012

note: type: Plain text
en: numa - overview of Non-Uniform Memory Architecture
fr: numa - Panorama des architectures à mémoire non uniforme

note: type: Plain text
en: Non-Uniform Memory Access (NUMA) refers to multiprocessor systems whose memory is divided into multiple memory nodes.  The access time of a memory node depends on the relative locations of the accessing CPU and the accessed node.  (This contrasts with a symmetric multiprocessor system, where the access time for all of the memory is the same for all CPUs.)  Normally, each CPU on a NUMA system has a local memory node whose contents can be accessed faster than the memory in the node local to another CPU or the memory on a bus shared by all CPUs.
fr: NUMA (« Non-Uniform Memory Access » : accès à la mémoire de façon non uniforme) se réfère aux systèmes multiprocesseur dont la mémoire est divisé en plusieurs nœuds mémoire. Le temps d'accès à un nœud mémoire dépend de la localisation relative du CPU utilisateur et du nœud utilisé (à l'opposé des systèmes multiprocesseur symétriques pour lesquels le temps d'accès à la mémoire est le même quel que soit le CPU). Normalement, chaque CPU sur un système NUMA a un nœud mémoire local pour lequel il peut accéder plus rapidement au contenu, par rapport aux mémoires des nœuds locaux aux autres CPU où à la mémoire sur un bus partagé par tous les CPU.

note: type: SS
en: NUMA system calls
fr: Appels système NUMA

note: type: Plain text
en: The Linux kernel implements the following NUMA-related system calls: B<get_mempolicy>(2), B<mbind>(2), B<migrate_pages>(2), B<move_pages>(2), and B<set_mempolicy>(2).  However, applications should normally use the interface provided by I<libnuma>; see "Library Support" below.
fr: Le noyau Linux implémente les appels système suivants liés aux NUM : B<get_mempolicy>(2), B<mbind>(2), B<migrate_pages>(2), B<move_pages>(2) et B<set_mempolicy>(2). Cependant les applications devraient normalement utiliser l'interface fournie par I<libnuma> ; consultez « Prise en charge par la bibliothèque » ci-dessous.

note: type: SS
en: /proc/[number]/numa_maps (since Linux 2.6.14)
fr: /proc/[number]/numa_maps (depuis Linux 2.6.14)

note: See also Changelog-2.6.14 type: Plain text
en: This file displays information about a process's NUMA memory policy and allocation.
fr: Ce fichier affiche des informations concernant l'allocation et la politique mémoire NUMA d'un processus.

note: type: Plain text
en: Each line contains information about a memory range used by the process, displaying\(emamong other information\(emthe effective memory policy for that memory range and on which nodes the pages have been allocated.
fr: Chaque ligne contient des informations concernant un intervalle mémoire utilisé par un processus, indiquant, entre autre, la politique mémoire effective pour cet intervalle mémoire et sur quels nœuds les pages ont été allouées.

note: type: Plain text
en: I<numa_maps> is a read-only file.  When I</proc/E<lt>pidE<gt>/numa_maps> is read, the kernel will scan the virtual address space of the process and report how memory is used.  One line is displayed for each unique memory range of the process.
fr: I<numa_maps> est un fichier en lecture seule. Quand I</proc/E<lt>pidE<gt>/numa_maps> est lu, le noyau analyse l'espace d'adressage virtuel du processus et indique comment la mémoire est utilisée. Une ligne est affichée pour chaque intervalle mémoire du processus.

note: type: Plain text
en: The first field of each line shows the starting address of the memory range.  This field allows a correlation with the contents of the I</proc/E<lt>pidE<gt>/maps> file, which contains the end address of the range and other information, such as the access permissions and sharing.
fr: Le premier champ de chaque ligne indique l'adresse de départ de l'intervalle mémoire. Ce champ permet une corrélation avec le contenu du fichier I</proc/E<lt>pidE<gt>/maps>, qui contient l'adresse de fin de l'intervalle et d'autres informations, comme les permissions d'accès et le partage.

note: type: Plain text
en: The second field shows the memory policy currently in effect for the memory range.  Note that the effective policy is not necessarily the policy installed by the process for that memory range.  Specifically, if the process installed a "default" policy for that range, the effective policy for that range will be the process policy, which may or may not be "default".
fr: Le second champ indique la politique mémoire effective actuellement pour l'intervalle mémoire. Notez que la politique effective n'est pas forcément la politique installée par le processus pour cet intervalle mémoire. En particulier, si le processus a installé une politique par défaut (« default ») pour cet intervalle, la politique effective pour cet intervalle sera la politique du processus, qui peut être ou ne pas être « default ».

note: type: Plain text
en: The rest of the line contains information about the pages allocated in the memory range, as follows:
fr: Le reste de la ligne contient des informations sur les pages allouées dans l'intervalle mémoire, comme ceci :

note: type: TP
en: I<NE<lt>nodeE<gt>=E<lt>nr_pagesE<gt>>
fr: I<NE<lt>nodeE<gt>=E<lt>nombre_pagesE<gt>>

note: type: Plain text
en: The number of pages allocated on I<E<lt>nodeE<gt>>.  I<E<lt>nr_pagesE<gt>> includes only pages currently mapped by the process.  Page migration and memory reclaim may have temporarily unmapped pages associated with this memory range.  These pages may show up again only after the process has attempted to reference them.  If the memory range represents a shared memory area or file mapping, other processes may currently have additional pages mapped in a corresponding memory range.
fr: Le nombre de pages allouées sur le nœud I<E<lt>nodeE<gt>>. I<E<lt>nombre_pagesE<gt>> ne comprend que les pages actuellement projetées par le processus. Un déplacement ou une libération de page peut avoir temporairement déprojeté les pages associées avec cet intervalle mémoire. Ces pages ne peuvent réapparaître que quand le processus essaie de les référencer. Si l'intervalle mémoire représente une zone de mémoire partagée ou une projection dans un fichier, d'autres processus peuvent actuellement avoir d'autres pages projetées dans l'intervalle mémoire associé.

note: type: TP
en: I<file=E<lt>filenameE<gt>>
fr: I<file=E<lt>nom_fichierE<gt>>

note: type: Plain text
en: The file backing the memory range.  If the file is mapped as private, write accesses may have generated COW (Copy-On-Write) pages in this memory range.  These pages are displayed as anonymous pages.
fr: Le fichier contenant l'intervalle mémoire. Si le fichier est une projection privée, des accès en écriture peuvent avoir produit des pages COW (« Copy-On-Write » : copie à l'écriture) dans cet intervalle mémoire. Ces pages sont affichées comme des pages anonymes.

note: type: Plain text
en: Memory range is used for the heap.
fr: L'intervalle mémoire est utilisé pour le tas.

note: type: Plain text
en: Memory range is used for the stack.
fr: L'intervalle mémoire est utilisé pour la pile.

note: type: Plain text
en: Huge memory range.  The page counts shown are huge pages and not regular sized pages.
fr: Gros intervalle mémoire. Le nombre de pages indiqué correspond à de grosses pages, pas à des pages de taille usuelle.

note: type: Plain text
en: The number of anonymous page in the range.
fr: Le nombre de pages anonymes dans l'intervalle.

note: type: Plain text
en: Number of dirty pages.
fr: Nombre de pages sales.

note: type: Plain text
en: Total number of mapped pages, if different from I<dirty> and I<anon> pages.
fr: Nombre total de pages projetées, n'étant ni sales (I<dirty>), ni anonymes (I<anon>).

note: type: TP
en: I<mapmax=E<lt>countE<gt>>
fr: I<mapmax=E<lt>compteE<gt>>

note: type: Plain text
en: Maximum mapcount (number of processes mapping a single page) encountered during the scan.  This may be used as an indicator of the degree of sharing occurring in a given memory range.
fr: Nombre maximal de processus projetant une même page (« mapcount ») rencontrés lors de l'analyse. Ceci peut être utilisé comme indicateur du degré de partage dans un intervalle mémoire donné.

note: type: TP
en: I<swapcache=E<lt>countE<gt>>
fr: I<swapcache=E<lt>compteE<gt>>

note: type: Plain text
en: Number of pages that have an associated entry on a swap device.
fr: Nombre de pages qui ont une entrée associée sur un périphérique de partage.

note: type: Plain text
en: The number of pages on the active list.  This field is shown only if different from the number of pages in this range.  This means that some inactive pages exist in the memory range that may be removed from memory by the swapper soon.
fr: Le nombre de pages sur la liste active. Ce champ n'est affiché que si ce nombre diffère du nombre de pages dans l'intervalle. Ceci signifie que certaines pages inactives existent dans l'intervalle mémoire, et qu'elles pourront être retirées de la mémoire prochainement par le « swapper » (processus de gestion des périphériques d'échange).

note: type: Plain text
en: Number of pages that are currently being written out to disk.
fr: Nombre de pages qui sont actuellement en cours d'écriture sur le disque.

note: type: Plain text
en: No standards govern NUMA interfaces.
fr: Aucune norme ne régi les interfaces NUMA.

note: type: Plain text
en: The Linux NUMA system calls and I</proc> interface are available only if the kernel was configured and built with the B<CONFIG_NUMA> option.
fr: Les appels système NUMA de Linux et les interfaces I</proc> ne sont disponibles que si le noyau est configuré et construit avec l'option B<CONFIG_NUMA>.

note: type: SS
en: Library support
fr: Prise en charge par la bibliothèque

note: type: Plain text
en: Link with I<-lnuma> to get the system call definitions.  I<libnuma> and the required I<E<lt>numaif.hE<gt>> header are available in the I<numactl> package.
fr: Faire l'édition des liens avec I<-lnuma> pour obtenir la définition des appels système. I<libnuma> et l'en-tête I<E<lt>numaif.hE<gt>> sont disponibles dans le paquet I<numactl>.

note: type: Plain text
en: However, applications should not use these system calls directly.  Instead, the higher level interface provided by the B<numa>(3)  functions in the I<numactl> package is recommended.  The I<numactl> package is available at E<.UR ftp://oss.sgi.com\:/www\:/projects\:/libnuma\:/download/> E<.UE .> The package is also included in some Linux distributions.  Some distributions include the development library and header in the separate I<numactl-devel> package.
fr: Cependant, les applications ne devraient pas utiliser ces appels système directement. À la place, l'interface de plus haut niveau fournie par les fonctions B<numa>(3) du paquet I<numactl> est recommandée. Le paquet I<numactl> est disponible à l'adresse E<.UR ftp://oss.sgi.com\:/www\:/projects\:/libnuma\:/download/> E<.UE .> Le paquet est aussi inclus dans certaines distributions. Certaines distributions inclues séparément la bibliothèque et les en-têtes pour le développement dans le paquet I<numactl-devel>.

note: type: Plain text
en: set_mempolicy - set default NUMA memory policy for a process and its children
fr: set_mempolicy - Configurer la politique de la mémoire NUMA par défaut pour un processus et ses fils

note: type: Plain text
en: B<set_mempolicy>()  sets the NUMA memory policy of the calling process, which consists of a policy mode and zero or more nodes, to the values specified by the I<mode>, I<nodemask> and I<maxnode> arguments.
fr: B<set_mempolicy>()  définit la politique de la mémoire NUMA du processus appelant, qui consiste en un mode de politique et zéro ou plusieurs nœuds, aux valeurs spécifiées dans les arguments I<mode>, I<nodemask> et I<maxnode>.

note: type: Plain text
en: This system call defines the default policy for the process.  The process policy governs allocation of pages in the process's address space outside of memory ranges controlled by a more specific policy set by B<mbind>(2).  The process default policy also controls allocation of any pages for memory-mapped files mapped using the B<mmap>(2)  call with the B<MAP_PRIVATE> flag and that are only read [loaded] from by the process and of memory-mapped files mapped using the B<mmap>(2)  call with the B<MAP_SHARED> flag, regardless of the access type.  The policy is applied only when a new page is allocated for the process.  For anonymous memory this is when the page is first touched by the application.
fr: Cet appel système définit la politique par défaut pour le processus. La politique de processus 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 B<mbind>(2). La politique de processus par défaut contrôle également l'allocation de toute page pour les fichiers projetés de mémoire, projetés en utilisant l'appel système B<mmap>(2)  avec l'attribut B<MAP_PRIVATE> et qui ne sont seulement lus (chargés) par la tâche, et des fichiers projetés de mémoire, projetés en utilisant B<mmap>(2)  B<MAP_SHARED> quel que soit le type d'accès. La politique n'est appliquée que lorsqu'une nouvelle page est allouée pour le processus. Pour la mémoire anonyme, cela est fait lorsque l'application accède pour la première fois à la page.

note: type: Plain text
en: The I<mode> argument must specify one of B<MPOL_DEFAULT>, B<MPOL_BIND>, B<MPOL_INTERLEAVE>, or B<MPOL_PREFERRED>.  All modes except B<MPOL_DEFAULT> require the caller to specify via the I<nodemask> argument one or more nodes.
fr: L'argument I<mode> doit spécifier l'un des attributs parmi B<MPOL_DEFAULT>, B<MPOL_BIND>, B<MPOL_INTERLEAVE> et B<MPOL_PREFERRED>. Tous les modes sauf B<MPOL_DEFAULT> nécessitent que l'appelant spécifie, dans le paramètre I<nodemask>, un ou plusieurs modes.

note: type: Plain text
en: The I<mode> argument may also include an optional I<mode flag>.  The supported I<mode flags> are:
fr: L'argument I<mode> peut aussi contenir des attributs optionnels. Les valeurs possibles sont :

note: type: TP
en: B<MPOL_F_STATIC_NODES> (since Linux 2.6.26)
fr: B<MPOL_F_STATIC_NODES> (depuis Linux 2.6.26)

note: type: Plain text
en: A nonempty I<nodemask> specifies physical node ids.  Linux does will not remap the I<nodemask> when the process moves to a different cpuset context, nor when the set of nodes allowed by the process's current cpuset context changes.
fr: Une valeur non vide de I<nodemask> indique des identifiants de nœuds physiques. Linux ne va pas recalculer le I<nodemask> quand le processus est déplacé vers un contexte différent, ni quand l'ensemble des nœuds autorisés par le contexte du processus actuel est modifié.

note: type: TP
en: B<MPOL_F_RELATIVE_NODES> (since Linux 2.6.26)
fr: B<MPOL_F_RELATIVE_NODES> (depuis Linux 2.6.26)

note: type: Plain text
en: I<nodemask> points to a bit mask of node IDs that contains up to I<maxnode> bits.  The bit mask size is rounded to the next multiple of I<sizeof(unsigned long)>, but the kernel will use bits only up to I<maxnode>.  A NULL value of I<nodemask> or a I<maxnode> value of zero specifies the empty set of nodes.  If the value of I<maxnode> is zero, the I<nodemask> argument is ignored.
fr: I<nodemask> pointe vers un masque de bits d'identifiants de nœuds qui contient jusqu'à I<maxnode> bits. La taille du masque de bits est arrondie au multiple supérieur de I<sizeof(unsigned long)>, mais le noyau n'utilisera que jusqu'à I<maxnode> bits. Une valeur NULL pour I<nodemask> ou une valeur I<maxnode> de zéro indique un ensemble vide de nœuds. Si la valeur de I<maxnode> est zéro, l'argument I<nodemask> est ignoré.

note: type: Plain text
en: Where a I<nodemask> is required, it must contain at least one node that is on-line, allowed by the process's current cpuset context, [unless the B<MPOL_F_STATIC_NODES> mode flag is specified], and contains memory.  If the B<MPOL_F_STATIC_NODES> is set in I<mode> and a required I<nodemask> contains no nodes that are allowed by the process's current cpuset context, the memory policy reverts to I<local allocation>.  This effectively overrides the specified policy until the process's cpuset context includes one or more of the nodes specified by I<nodemask>.
fr: Quand une valeur de I<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 B<MPOL_F_STATIC_NODES> ne soit spécifié), et qui contient de la mémoire. Si l'attribut B<MPOL_F_STATIC_NODES> est mis dans I<mode> et si un I<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 (I<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 I<nodemask>.

note: type: Plain text
en: The B<MPOL_DEFAULT> mode specifies that any nondefault process memory policy be removed, so that the memory policy "falls back" to the system default policy.  The system default policy is "local allocation"\(emthat is, allocate memory on the node of the CPU that triggered the allocation.  I<nodemask> must be specified as NULL.  If the "local node" contains no free memory, the system will attempt to allocate memory from a "near by" node.
fr: Le mode B<MPOL_DEFAULT> est le mode par défaut et signifie que l'on alloue la mémoire localement, c'est-à-dire dans le nœud de la CPU qui a déclenché l'allocation. I<nodemask> doit être spécifié comme NULL. Si le «\ nœud local\ » ne contient pas de mémoire, le système tentera d'allouer de la mémoire à partir d'un nœud «\ à proximité\ ».

note: type: Plain text
en: The B<MPOL_BIND> mode defines a strict policy that restricts memory allocation to the nodes specified in I<nodemask>.  If I<nodemask> specifies more than one node, page allocations will come from the node with the lowest numeric node ID first, until that node contains no free memory.  Allocations will then come from the node with the next highest node ID specified in I<nodemask> and so forth, until none of the specified nodes contain free memory.  Pages will not be allocated from any node not specified in the I<nodemask>.
fr: Le mode B<MPOL_BIND> définit une politique stricte qui restreint l'allocation mémoire aux nœuds spécifiés dans I<nodemask>. Si I<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 node dont l'identifiant est le prochain plus grand spécifié dans I<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 I<nodemask>.

note: NOTE:  the following sentence doesn't make sense in the context of set_mempolicy() -- no memory area specified. To be effective the memory area should be fairly large, at least 1MB or bigger. type: Plain text
en: B<MPOL_INTERLEAVE> interleaves page allocations across the nodes specified in I<nodemask> in numeric node ID order.  This optimizes for bandwidth instead of latency by spreading out pages and memory accesses to those pages across multiple nodes.  However, accesses to a single page will still be limited to the memory bandwidth of a single node.
fr: B<MPOL_INTERLEAVE> entrelace les allocations de pages à travers les nœuds spécifiés dans I<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 d'un seul nœud.

note: type: Plain text
en: B<MPOL_PREFERRED> sets the preferred node for allocation.  The kernel will try to allocate pages from this node first and fall back to "near by" nodes if the preferred node is low on free memory.  If I<nodemask> specifies more than one node ID, the first node in the mask will be selected as the preferred node.  If the I<nodemask> and I<maxnode> arguments specify the empty set, then the policy specifies "local allocation" (like the system default policy discussed above).
fr: Le mode B<MPOL_PREFERRED> définit le nœud préféré pour l'allocation. Le noyau essayera 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 I<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 I<nodemask> et I<maxnode> spécifient l'ensemble vide, la mémoire est allouée sur le nœud de la CPU qui a déclenché l'allocation (comme pour B<MPOL_DEFAULT>).

note: type: Plain text
en: The process memory policy is preserved across an B<execve>(2), and is inherited by child processes created using B<fork>(2)  or B<clone>(2).
fr: La politique mémoire de processus est préservée au travers d'un B<execve>(2), et est héritée par les processus fils créés avec B<fork>(2)  ou B<clone>(2).

note: type: Plain text
en: On success, B<set_mempolicy>()  returns 0; on error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, B<set_mempolicy>()  renvoie 0\ ; s'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: Plain text
en: I<mode> is invalid.  Or, I<mode> is B<MPOL_DEFAULT> and I<nodemask> is nonempty, or I<mode> is B<MPOL_BIND> or B<MPOL_INTERLEAVE> and I<nodemask> is empty.  Or, I<maxnode> specifies more than a page worth of bits.  Or, I<nodemask> specifies one or more node IDs that are greater than the maximum supported node ID.  Or, none of the node IDs specified by I<nodemask> are on-line and allowed by the process's current cpuset context, or none of the specified nodes contain memory.  Or, the I<mode> argument specified both B<MPOL_F_STATIC_NODES> and B<MPOL_F_RELATIVE_NODES>.
fr: I<mode> n'est pas valide. Ou, I<mode> est B<MPOL_DEFAULT> et I<nodemask> n'est pas vide, ou I<mode> est B<MPOL_BIND> ou B<MPOL_INTERLEAVE> et I<nodemask> est vide. Ou, I<maxnode> spécifie plus qu'une page de bits. Ou, I<nodemask> spécifie un ou plusieurs identifiants de nœud qui sont plus grands que l'identifiant maximum de nœud pris en charge, ou qui ne sont pas autorisés dans le contexte de la tâche appelante. Ou aucun des identifiants de nœuds spécifiés par I<nodemask> ne sont connectés, ou aucun des nœuds spécifiés ne contient de mémoire.

note: type: Plain text
en: The B<set_mempolicy>(), system call was added to the Linux kernel in version 2.6.7.
fr: L'appel système B<set_mempolicy>() a été ajouté au noyau Linux dans la version 2.6.7.

note: type: Plain text
en: Process policy is not remembered if the page is swapped out.  When such a page is paged back in, it will use the policy of the process or memory range that is in effect at the time the page is allocated.
fr: La politique du processus n'est pas mémorisée si la page est délogée. Lorsqu'une telle page est réimportée en mémoire, elle utilisera la politique du processus ou de la plage mémoire qui était effective au moment où la page a été allouée.
