SCHED_SETAFFINITY(2)

NOM
sched_setaffinity, sched_getaffinity, CPU_CLR, CPU_ISSET, CPU_SET, CPU_ZERO - Définir et obtenir le masque d'affinité CPU d'un processus

SYNOPSIS
#define _GNU_SOURCE
#include <sched.h>

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

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

void CPU_CLR(int cpu, cpu_set_t *set);
int CPU_ISSET(int cpu, cpu_set_t *set);
void CPU_SET(int cpu, cpu_set_t *set);
void CPU_ZERO(cpu_set_t *set);

DESCRIPTION
Le masque d'affinité CPU d'un processus détermine l'ensemble des processeurs sur lesquels il est susceptible de s'exécuter. Sur un système multiprocesseurs, définir le masque d'affinité CPU permet d'améliorer les performances. Par exemple, en dédiant une CPU à un processus particulier (c'est-à-dire en fixant le masque d'affinité de ce processus pour indiquer une seule CPU et en fixant le masque d'affinité de tous les autres processus pour exclure cette CPU), il est possible d'assurer une vitesse d'exécution maximale pour ce processus. Restreindre l'exécution d'un processus sur une seule CPU prévient également du coût de performance provoqué par l'invalidation du cache qui se produit lorsqu'un processus cesse son exécution sur une CPU et la recommence sur une autre CPU. Un masque d'affinité CPU est représenté par la structure cpu_set_t, un « ensemble de CPU », pointée par mask. Quatre macros sont fournies pour manipuler ces ensembles. CPU_ZERO() vide un ensemble. CPU_SET() et CPU_CLR() ajoute et retire, respectivement, la CPU indiquée d'un ensemble. CPU_ISSET() teste l'appartenance de la CPU à un ensemble ; cela est utile après le retour de sched_getaffinity(). La première CPU disponible sur le système correspond à une valeur cpu de 0, la CPU suivante correspond à une valeur cpu de 1, et ainsi de suite. La constante CPU_SETSIZE (1024) indique une valeur de un de plus que le nombre maximum de CPU qui peuvent appartenir à un ensemble de CPU. sched_setaffinity() fixe le masque d'affinité CPU du processus dont l'identifiant est pid à la valeur indiquée dans mask. Si pid vaut zéro, il s'agit du processus appelant. L'argument cpusetsize est la taille (en octet) 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 actuellement pas en cours d'exécution sur l'une des CPU spécifiées dans mask, le processus est déplacé sur l'une des CPU spécifiées dans mask. sched_getaffinity() écrit le masque d'affinité du processus dont l'identifiant est pid dans la structure cpu_set_t pointée par mask. L'argument cpusetsize indique la taille (en octets) de mask. Si pid vaut zéro, le masque du processus appelant est renvoyé.

VALEUR RENVOYÉE
S'ils réussissent, sched_setaffinity() et sched_getaffinity() renvoient 0. S'ils échouent, ils renvoient -1 et errno contient le code d'erreur.

ERREURS

EFAULT
    Une adresse mémoire est invalide.

EINVAL
    Le masque des préférences mask ne contient pas de processeurs présents sur le système, ou cpusetsize est plus petit que la taille du masque d'affinité utilisé par le noyau.

EPERM
    Le processus appelant n'a pas les privilèges appropriés. Le processus qui invoque sched_setaffinity() 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
    Impossible de trouver le processus du pid indiqué.

VERSIONS
Les appels système d'affinité CPU ont été introduits dans le noyau Linux 2.5.8. Les appels bibliothèque ont été introduits dans glibc 2.3. Initialement, les interfaces de la glibc incluaient un argument cpusetsize. Cet argument a été retiré dans la glibc 2.3.3 mais réintroduit dans la glibc 2.3.4.

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

NOTES
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 un appel à gettid(2) peut être passée à l'argument pid. Définir pid à 0 positionnera l'attribut pour le thread actuel et passer une valeur égale à celle renvoyée par un appel à getpid(2) positionnera l'attribut pour le thread principal du groupe de threads. Un processus fils créé avec fork(2) hérite du masque d'affinité CPU de son père. Le masque d'affinité est préservé à travers un execve(2). Cette page de manuel décrit l'interface de la glibc pour les appels d'affinité CPU. L'interface actuelle des appels système est légèrement différente, mask ayant pour type unsigned long *, reflétant le fait que l'implémentation sous-jacente des ensembles de CPU est en réalité un simple masque de bits. S'il réussit, l'appel système brut sched_getaffinity() renvoie la taille (en octets) du type de donnée cpumask_t utilisé en interne par le noyau pour représenter le masque de bits de l'ensemble 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), capabilities(7), cpuset(7)

TRADUCTION

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 18 juillet 2003 et révisée le 17 juillet 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 2 sched_setaffinity ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.