sched_setaffinity, sched_getaffinity, CPU_CLR, CPU_ISSET, CPU_SET, CPU_ZERO − Définir et obtenir le masque d’affinité CPU d’un processus.

#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);

Le masque d’affinité CPU d’un processus détermine l’ensemble des CPU sur lesquelles il peut s’exécuter. Sur un système multiprocesseurs, fixer 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 spécifier une seule CPU et en fixant le masque d’affinité de tous les autres processus pour exclure cette CPU), il est possible d’assurrer une vitesse d’exécution maximum 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 de cache qui survient 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 les ensembles de CPU. CPU_ZERO() efface un ensemble. CPU_SET() et CPU_CLR() ajoute et retire, respectivement, la CPU indiquée d’un ensemble. CPU_ISSET() teste si la CPU fait partie d’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) spécifie une valeur plus grande de un que le nombre maximum de CPU qui peuvent appartenir à un ensemble de CPU.

sched_setaffinity() fixe le masque d’affinité du processus dont l’ID est pid à la valeur spécifiée dans mask. Si pid vaut zéro, il s’agit du processus appelant. L’argument cpusetsize est la longueur (en octet) de la donnée pointée par mask. Normalement, cet argument devrait être spécifié comme sizeof(cpu_set_t).

Si le processus spécifié 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’ID est pid dans la structure cpu_set_t pointée par mask. L’argument cpusetsize spécifie la taille (en octet) de mask. Si pid vaut zéro, le masque du processus en cours est renvoyé.

S’ils réussissent, sched_setaffinity() et sched_getaffinity() renvoient 0. S’ils échouent, ils renvoient −1 et errno sera rempli avec le code d’erreur.

EFAULT

Une adresse mémoire est invalide.

EINVAL

Le masque mask des préférences 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é.

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

Le masque d’affinité est actuellement un attribut par thread qui peut être ajusté de manière indépendante 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.

Un 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 glibc pour les appels d’affinité CPU. L’interface actuelle d’appels système est légèrement différente avec le mask ayant pour type unsigned long *, reflétant le fait que l’implémentation sous-jacente des ensembles de CPU est 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 system call returns the size (in bytes) of the cpumask_t qui est utilisé en interne par le noyau pour représenter le masque de bits de l’ensemble CPU.

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 glibc incluaient un argument cpusetsize. Cet argument a été retiré dans la glibc 2.3.2 mais réintroduit dans la glibc 2.3.4.

clone(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)

sched_setscheduler(2) décrit le fonctionnement de l’ordonnancement sous Linux.

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 9 août 2006.

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=en man 2 sched_setaffinity ». N’hésitez pas à signaler à l’auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.