Provided by: manpages-fr-dev_3.57d1p1-1_all bug

NOM

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

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'affinité CPU d'un thread détermine l'ensemble de processeurs sur  lesquels  il
       est  susceptible  de  s'exécuter.  Sur  un  système  multiprocesseur,  définir  le  masque
       d'affinité CPU permet d'obtenir une meilleure performance. Par exemple, en dédiant un  CPU
       à  un  thread  particulier  (c'est-à-dire  définir  le masque d'affinité de ce thread pour
       indiquer un seul CPU, et définir le masque d'affinité de  tous  les  autres  threads  pour
       exclure  ce  CPU),  il  est  possible  d'assurer  une vitesse d'exécution maximale pour ce
       thread. 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 thread 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() définit le masque d'affinité CPU du thread dont l'identifiant est  pid
       à  la  valeur  donnée  par  mask. Si pid est 0, le thread 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 thread indiqué par pid n'est pas actuellement en cours d'exécution sur l'un des CPU
       spécifiés dans mask, alors ce thread 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 thread pid. L'argument cpusetsize indique la taille (en octets)
       de mask. Si pid vaut zéro, le masque du thread 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  thread  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  thread  appelant  n'a  pas  les  privilèges  appropriés.
              L'appelant  doit  avoir  un  UID  effectif  égal à l'UID effectif ou réel du thread
              identifié par pid, ou avoir la capacité CAP_SYS_NICE.

       ESRCH  Le thread numéro pid n'existe pas.

VERSIONS

       Les appels  système  d'affinité  ont  été  introduits  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 thread 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  thread  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
       thread 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 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 définira l'attribut pour le thread
       appelant, et une valeur égale à celle renvoyée par getpid(2) définira 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

       taskset(1), 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), pthread_setaffinity_np(3),
       sched_getcpu(3), capabilities(7), cpuset(7)

COLOPHON

       Cette page fait partie de la publication 3.57 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

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

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

       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> ».