Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       sched_setaffinity,  sched_getaffinity  - Definir et recuperer le masque
       d'affinite CPU d'un processus

SYNOPSIS

       #define _GNU_SOURCE             /* Consultez feature_test_macros(7) */
       #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'affinite  CPU  d'un  processus  determine  l'ensemble  de
       processeurs  sur  lesquels  il  est  susceptible  de s'executer. Sur un
       systeme  multiprocesseur,  fixer  le  masque  d'affinite   CPU   permet
       d'obtenir  une  meilleure performance. Par exemple, en dediant un CPU a
       un processus particulier (c'est-a-dire fixer le masque d'affinite de ce
       processus  pour  indiquer un seul CPU, et fixer le masque d'affinite de
       tous les autres  processus  pour  exclure  ce  CPU),  il  est  possible
       d'assurer   une   vitesse   d'execution  maximale  pour  ce  processus.
       Restreindre un processus pour qu'il ne s'execute que sur  un  seul  CPU
       reduit  le  cout lie a l'invalidation du cache qui se produit lorsqu'un
       processus cesse de s'executer sur un CPU puis est relance sur un  autre
       CPU.

       Un  masque d'affinite CPU est represente par la structure cpu_set_t, un
       ensemble de CPU (<< CPU set >>),  pointe  par  mask.  Des  macros  pour
       manipuler des ensembles de CPU sont decrites dans CPU_SET(3).

       sched_setaffinity()  fixe  le  masque  d'affinite CPU du processus dont
       l'identifiant est pid a la valeur donnee par mask. Si  pid  est  0,  le
       processus appelant est utilise. L'argument cpusetsize est la taille (en
       octets) de la structure pointee par  mask.  Normalement,  cet  argument
       doit etre specifie comme sizeof(cpu_set_t).

       Si  le  processus  indique  par  pid  n'est  pas  actuellement en cours
       d'execution sur l'un des CPU specifies dans mask,  alors  ce  processus
       est migre vers l'un des CPU specifies dans mask.

       La  fonction  sched_getaffinity()  ecrit  dans  la  structure cpu_set_t
       pointee par mask le masque de preferences du processus pid.  L'argument
       cpusetsize  indique la taille (en octets) de mask. Si pid vaut zero, le
       masque du processus en cours est renvoye.

VALEUR RENVOY'EE

       sched_setaffinity()   et   sched_getaffinity()   renvoient   0    s'ils
       reussissent.  En cas d'echec, -1 est renvoye, et errno contient le code
       d'erreur.

ERREURS

       EFAULT Une adresse memoire fournie n'est pas correcte.

       EINVAL Le masque de bits d'affinite mask ne contient pas de processeurs
              qui  soit  actuellement  physiquement sur le systeme et autorise
              pour le processus  d'apres  les  restrictions  imposees  par  le
              mecanisme d'ensembles de CPU decrit dans cpuset(7).

       EINVAL (sched_getaffinity()  et,  pour  les  noyaux anterieurs a 2.6.9,
              sched_setaffinity()) cpusetsize est plus petit que la taille  du
              masque d'affinite utilise par le noyau.

       EPERM  (sched_setaffinity())   Le   processus   appelant  n'a  pas  les
              privileges appropries. L'appelant doit  avoir  un  UID  effectif
              egal a l'UID effectif ou reel du processus identifie par pid, ou
              avoir la capacite CAP_SYS_NICE.

       ESRCH  Le processus numero pid n'existe pas.

VERSIONS

       Les appels systeme d'affinite ont ete introduits dans Linux 2.5.8.  Les
       fonctions  enveloppes  pour ces appels systeme ont ete introduites dans
       la glibc 2.3.  Au  depart,  les  interfaces  de  la  glibc  avaient  un
       parametre  cpusetsize  de  type  unsigned  int.  Dans  glibc  2.3.3, ce
       parametre a ete supprime, mais il a ete reintroduit dans  glibc  2.3.4,
       avec pour type size_t.

CONFORMIT'E

       Ces appels systeme sont specifiques a Linux.

NOTES

       Apres un appel a sched_setaffinity(), l'ensemble de CPU sur lesquels le
       processus s'executera est l'intersection de l'ensemble specifie dans le
       parametre  mask  et  l'ensemble  des  CPU  actuellement presents sur le
       systeme. Le systeme peut restreindre encore plus l'ensemble des CPU sur
       lesquels le processus peut tourner si le mecanisme << cpuset >>, decrit
       dans cpuset(7), est utilise. Ces restrictions sur le veritable ensemble
       de  CPU  sur  lesquels  le  processus  peut  tourner sont imposees sans
       avertissement par le noyau.

       sched_setscheduler(2)  decrit  les  politiques  d'ordonnancement   sous
       Linux.

       Le  masque  d'affinite  est  en realite un attribut de thread, qui peut
       etre modifie independamment pour chacun  des  threads  d'un  groupe  de
       threads.  La  valeur  renvoyee  par  gettid(2)  peut  etre  passee dans
       l'argument pid. Specifier un pid de 0 fixera l'attribut pour le  thread
       appelant,  et  une  valeur  egale a celle renvoyee 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 cree par fork(2) herite du masque d'affinite  CPU  de
       son pere. Le masque d'affinite est conserve au travers d'un execve(2).

       Cette  page  de  manuel  decrit l'interface de la glibc pour les appels
       lies a l'affinite CPU. L'interface des appels  systeme  est  legerement
       differente,  mask  ayant  le type unsigned long *, montrant le fait que
       l'implementation des ensembles de CPU est en realite un  simple  masque
       de  bits.  En  cas  de succes, l'appel systeme sched_getaffinity() brut
       renvoie la taille (en octets) du type cpumask_t utilise en interne  par
       le noyau pour representer 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.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone       au       sein        du        projet        perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Christophe  Blaess  <URL:http://www.blaess.fr/christophe/> (1996-2003),
       Alain  Portal  <URL:http://manpagesfr.free.fr/>  (2003-2006).    Julien
       Cristau et l'equipe francophone de traduction de Debian (2006-2009).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.