sched_setaffinity

SCHED_SETAFFINITY(2)       Manuel du programmeur Linux      SCHED_SETAFFINITY(2)



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,
                             const 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(7) 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),
       sched(7)

COLOPHON
       Cette page fait partie de la publication 3.70 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 à
       <perkamon-fr@traduc.org>.

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



Linux                              10 mai 2014              SCHED_SETAFFINITY(2)