pthread_setaffinity_np(3) Library Functions Manual pthread_setaffinity_np(3) NOM pthread_setaffinity_np, pthread_getaffinity_np - Definir et obtenir l'affinite CPU d'un thread BIBLIOTHEQUE Bibliotheque de threads POSIX (libpthread, -lpthread) SYNOPSIS #define _GNU_SOURCE /* Consultez feature_test_macros(7) */ #include int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize, const cpu_set_t *cpuset); int pthread_getaffinity_np(pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset); DESCRIPTION La fonction pthread_setaffinity_np() definit le masque d'affinite CPU du thread thread comme etant l'ensemble de CPU pointe par cpuset. Si l'appel reussit et que le thread n'est pas en cours d'execution sur un des CPU de cpuset, alors il est deplace sur un de ces CPU. La fonction pthread_getaffinity_np() renvoie, dans le tampon pointe par cpuset, le masque d'affinite CPU du thread thread. Pour plus de details sur les masques d'affinite CPU, consultez sched_setaffinity(2). Pour une description d'un jeu de macros qui peuvent etre utilisees pour manipuler et inspecter des ensembles de CPU, consultez CPU_SET(3). Le parametre cpusetsize est la longueur (en octets) du tampon pointe par cpuset. Typiquement, ce parametre sera sizeof (cpu_set_t) (il peut prendre d'autres valeurs, si on utilise les macros decrites dans CPU_SET(3) pour allouer dynamiquement un ensemble de CPU). VALEUR RENVOYEE En cas de succes, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un code d'erreur non nul. ERREURS EFAULT Une adresse memoire fournie n'est pas correcte. EINVAL (pthread_setaffinity_np()) Le masque de bits d'affinite mask ne contient pas de processeurs qui soit actuellement physiquement sur le systeme et autorise pour le thread d'apres les restrictions imposees par le mecanisme d'ensembles de CPU decrit dans cpuset(7). EINVAL (pthread_setaffinity_np()) Le cpuset indique un CPU en dehors de l'ensemble pris en charge par le noyau (l'option de configuration du noyau CONFIG_NR_CPUS definie l'intervalle de l'ensemble pris en charge par le type de donnees du noyau utilise pour representer les ensembles de CPU). EINVAL (pthread_getaffinity_np()) cpusetsize est plus petit que le taille du masque d'affinite utilise par le noyau. ESRCH Aucun fil d'execution avec pour identifiant thread n'a pu etre trouve. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |pthread_setaffinity_np(), | Securite des threads | MT-Safe | |pthread_getaffinity_np() | | | +---------------------------------+--------------------------+---------+ STANDARDS GNU ; d'ou le suffixe << _np >> (non portable) dans leur nom. HISTORIQUE glibc 2.3.4. Dans la glibc 2.3.3, uniquement, les versions de ces fonctions n'avaient pas de parametre cpusetsize. A la place, la taille de l'ensemble de CPU fourni a l'appel systeme sous-jacent etait toujours sizeof(cpu_set_t). NOTES Apres un appel a pthread_setaffinity_np(), l'ensemble de CPU sur lesquels le processus s'executera est l'intersection de l'ensemble specifie dans le parametre cpuset 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. Ces fonctions sont implementees en utilisant les appels systeme sched_setaffinity(2) et sched_getaffinity(2). Un nouveau thread cree avec pthread_create(3) herite d'une copie du masque d'affinite CPU de son createur. EXEMPLES Dans le programme suivant, le thread principal utilise pthread_setaffinity_np() pour definir son masque d'affinite CPU incluant les CPU 0 a 7 (qui peuvent ne pas etre tous presents sur le systeme), puis appelle pthread_getaffinity_np() pour verifier le masque d'affinite CPU finalement utilise pour le thread. #define _GNU_SOURCE #include #include #include #include #include int main(void) { int s; cpu_set_t cpuset; pthread_t thread; thread = pthread_self(); /* Set affinity mask to include CPUs 0 to 7. */ CPU_ZERO(&cpuset); for (size_t j = 0; j < 8; j++) CPU_SET(j, &cpuset); s = pthread_setaffinity_np(thread, sizeof(cpuset), &cpuset); if (s != 0) errc(EXIT_FAILURE, s, "pthread_setaffinity_np"); /* Check the actual affinity mask assigned to the thread. */ s = pthread_getaffinity_np(thread, sizeof(cpuset), &cpuset); if (s != 0) errc(EXIT_FAILURE, s, "pthread_getaffinity_np"); printf("Set returned by pthread_getaffinity_np() contained:\n"); for (size_t j = 0; j < CPU_SETSIZE; j++) if (CPU_ISSET(j, &cpuset)) printf(" CPU %zu\n", j); exit(EXIT_SUCCESS); } VOIR AUSSI sched_setaffinity(2), CPU_SET(3), pthread_attr_setaffinity_np(3), pthread_self(3), sched_getcpu(3), cpuset(7), pthreads(7), sched(7) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais et Jean- Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.9.1 15 juin 2024 pthread_setaffinity_np(3)