Provided by: manpages-fr-dev_3.17.1-1_all bug

NOM

       sched_setaffinity,  sched_getaffinity  - Définir et récupérer le masque
       d’affinité CPU d’un processus

SYNOPSIS

       #define _GNU_SOURCE
       #include <sched.h>

       int sched_setaffinity(pid_t pid, size_t cpusetsize,
                             cpu_set_t *mask);

       int sched_getaffinity(pid_t pid, size_t cpusetsize,
                             cpu_set_t *mask);

DESCRIPTION

       Le  masque  d’affinité  CPU  d’un  processus  détermine  l’ensemble  de
       processeurs  sur  lesquels  il  est  susceptible  de s’exécuter. Sur un
       système  multiprocesseur,  fixer  le  masque  d’affinité   CPU   permet
       d’obtenir  une  meilleure performance. Par exemple, en dédiant un CPU à
       un processus particulier (c’est-à-dire fixer le masque d’affinité de ce
       processus  pour  indiquer un seul CPU, et fixer le masque d’affinité de
       tous les autres  processus  pour  exclure  ce  CPU),  il  est  possible
       d’assurer   une   vitesse   d’exécution  maximale  pour  ce  processus.
       Restreindre un processus pour qu’il ne s’exécute que sur  un  seul  CPU
       réduit  le  coût lié à l’invalidation du cache qui se produit lorsqu’un
       processus cesse de s’exécuter sur un CPU puis est relancé sur un  autre
       CPU.

       Un  masque d’affinité CPU est représenté par la structure cpu_set_t, un
       ensemble de CPU  (« CPU  set »),  pointé  par  mask.  Des  macros  pour
       manipuler des ensembles de CPU sont décrites dans CPU_SET(3).

       sched_setaffinity()  fixe  le  masque  d’affinité CPU du processus dont
       l’identifiant est pid à la valeur donnée par mask. Si  pid  est  0,  le
       processus appelant est utilisé. L’argument cpusetsize est la taille (en
       octets) de la structure pointée par  mask.  Normalement,  cet  argument
       doit être spécifié comme sizeof(cpu_set_t).

       Si  le  processus  indiqué  par  pid  n’est  pas  actuellement en cours
       d’exécution sur l’un des CPU spécifiés dans mask,  alors  ce  processus
       est migré vers l’un des CPU spécifiés dans mask.

       La  fonction  sched_getaffinity()  écrit  dans  la  structure cpu_set_t
       pointée par mask le masque de préférences du processus pid.  L’argument
       cpusetsize  indique la taille (en octets) de mask. Si pid vaut zéro, le
       masque du processus en cours est renvoyé.

VALEUR RENVOYÉE

       sched_setaffinity()   et   sched_getaffinity()   renvoient   0    s’ils
       réussissent.  En cas d’échec, -1 est renvoyé, et errno contient le code
       d’erreur.

ERREURS

       EFAULT Une adresse mémoire fournie n’est pas correcte.

       EINVAL Le masque de bits d’affinité mask ne contient pas de processeurs
              qui  soit  actuellement  physiquement sur le système et autorisé
              pour le processus  d’après  les  restrictions  imposées  par  le
              mécanisme d’ensembles de CPU décrit dans cpuset(7).

       EINVAL (sched_getaffinity()  et,  pour  les  noyaux antérieurs à 2.6.9,
              sched_setaffinity()) cpusetsize est plus petit que la taille  du
              masque d’affinité utilisé par le noyau.

       EPERM  (sched_setaffinity())   Le   processus   appelant  n’a  pas  les
              privilèges appropriés. L’appelant doit  avoir  un  UID  effectif
              égal à l’UID effectif ou réel du processus identifié par pid, ou
              avoir la capacité CAP_SYS_NICE.

       ESRCH  Le processus numéro pid n’existe pas.

VERSIONS

       Les appels système d’affinité ont été introduit dans Linux  2.5.8.  Les
       fonctions  enveloppes  pour ces appels système ont été introduites dans
       la glibc 2.3.  Au  départ,  les  interfaces  de  la  glibc  avaient  un
       paramètre  cpusetsize  de  type  unsigned  int.  Dans  glibc  2.3.3, ce
       paramètre a été supprimé, mais il a été réintroduit dans  glibc  2.3.4,
       avec pour type size_t.

CONFORMITÉ

       Ces appels système sont spécifiques à Linux.

NOTES

       Après un appel à sched_setaffinity(), l’ensemble de CPU sur lesquels le
       processus s’exécutera est l’intersection de l’ensemble spécifié dans le
       paramètre  mask  et  l’ensemble  des  CPU  actuellement présents sur le
       système. Le système peut restreindre encore plus l’ensemble des CPU sur
       lesquels  le  processus peut tourner si le mécanisme « cpuset », décrit
       dans cpuset(7), est utilisé. Ces restrictions sur le véritable ensemble
       de  CPU  sur  lesquels  le  processus  peut  tourner sont imposées sans
       avertissement par le noyau.

       sched_setscheduler(2)  décrit  les  politiques  d’ordonnancement   sous
       Linux.

       Le  masque  d’affinité  est  en réalité un attribut de thread, qui peut
       être modifié indépendamment pour chacun  des  threads  d’un  groupe  de
       threads.  La  valeur  renvoyée  par  gettid(2)  peut  être  passée dans
       l’argument pid. Spécifier un pid de 0 fixera l’attribut pour le  thread
       appelant,  et  une  valeur  égale à celle renvoyée par getpid(2) fixera
       l’attribut pour le thread principal  du  groupe  de  thread.  (Si  vous
       utilisez     l’API     POSIX     des     threads,     alors    utilisez
       pthread_setaffinity_np(3) au lieu de sched_setaffinity().)

       Un processus fils créé par fork(2) hérite du masque d’affinité  CPU  de
       son  père. Le masque d’affinité est conservé au travers d’un execve(2).

       Cette page de manuel décrit l’interface de la  glibc  pour  les  appels
       liés  à  l’affinité  CPU. L’interface des appels système est légèrement
       différente, mask ayant le type unsigned long *, montrant  le  fait  que
       l’implémentation  des  ensembles de CPU est en réalité un simple masque
       de bits. En cas de succès,  l’appel  système  sched_getaffinity()  brut
       renvoie  la taille (en octets) du type cpumask_t utilisé en interne par
       le noyau pour représenter le masque d’ensemble de CPU.

VOIR AUSSI

       clone(2),    getcpu(2),     getpriority(2),     gettid(2),     nice(2),
       sched_get_priority_max(2),                   sched_get_priority_min(2),
       sched_getscheduler(2),      sched_setscheduler(2),      setpriority(2),
       CPU_SET(3),              sched_getcpu(3),              capabilities(7),
       pthread_setaffinity_np(3), cpuset(7)

COLOPHON

       Cette page fait partie de  la  publication  3.17  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement gérées par Julien Cristau <jcristau@debian.org> et l’équipe
       francophone de traduction de Debian.

       Veuillez  signaler  toute  erreur   de   traduction   en   écrivant   à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document
       en utilisant la commande « man -L C <section> <page_de_man> ».