Provided by: manpages-fr-dev_3.17.1-1_all bug

NOM

       CPU_SET,  CPU_CLR,  CPU_ISSET,  CPU_ZERO,  CPU_COUNT,  CPU_AND, CPU_OR,
       CPU_XOR, CPU_EQUAL,  CPU_ALLOC,  CPU_ALLOC_SIZE,  CPU_FREE,  CPU_SET_S,
       CPU_CLR_S,  CPU_ISSET_S,  CPU_ZERO_S, CPU_COUNT_S, CPU_AND_S, CPU_OR_S,
       CPU_XOR_S, CPU_EQUAL_S - macros  de  manipulation  d’un  « ensemble  de
       CPUs »

SYNOPSIS

       #define _GNU_SOURCE
       #include <sched.h>

       void CPU_ZERO(cpu_set_t *set);

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

       void CPU_COUNT(cpu_set_t *set);

       void CPU_AND(cpu_set_t *destset,
                    cpu_set_t *srcset1, cpu_set_t *srcset2);
       void CPU_OR(cpu_set_t *destset,
                    cpu_set_t *srcset1, cpu_set_t *srcset2);
       void CPU_XOR(cpu_set_t *destset,
                    cpu_set_t *srcset1, cpu_set_t *srcset2);

       int  CPU_EQUAL(cpu_set_t *set1, cpu_set_t *set2);

       cpu_set_t *CPU_ALLOC(int num_cpus);
       void CPU_FREE(cpu_set_t *set);
       size_t CPU_ALLOC_SIZE(int num_cpus);

       void CPU_ZERO_S(size_t setsize, cpu_set_t *set);

       void CPU_SET_S(int cpu, size_t setsize, cpu_set_t *set);
       void CPU_CLR_S(int cpu, size_t setsize, cpu_set_t *set);
       int  CPU_ISSET_S(int cpu, size_t setsize, cpu_set_t *set);

       void CPU_COUNT_S(size_t setsize, cpu_set_t *set);

       void CPU_AND_S(size_t setsize, cpu_set_t *destset,
                    cpu_set_t *srcset1, cpu_set_t *srcset2);
       void CPU_OR_S(size_t setsize, cpu_set_t *destset,
                    cpu_set_t *srcset1, cpu_set_t *srcset2);
       void CPU_XOR_S(size_t setsize, cpu_set_t *destset,
                    cpu_set_t *srcset1, cpu_set_t *srcset2);

       int  CPU_EQUAL_S(size_t setsize, cpu_set_t *set1, cpu_set_t *set2);

DESCRIPTION

       La  structure  de  données cpu_set_t représente un « ensemble de CPUs».
       Les « ensembles de CPUs » sont utilisés par sched_setaffinity(2) et les
       interfaces similaires.

       Le  type  cpu_set_t  est  un  champ de bits. Cependant, la structure de
       données traitée est considérée comme opaque : toute  manipulation  d’un
       «ensemble de CPU » devrait être effectuée avec les macros décrites dans
       cette page.

       Les macros suivantes sont fournies pour opérer sur l’ensemble set :

       CPU_ZERO()       Mettre à zéro set, ainsi, il ne contient aucun CPU.

       CPU_SET()        Ajouter le CPU cpu à set.

       CPU_CLR()        Supprimer le CPU cpu de set.

       CPU_ISSET()      Tester si le CPU cpu est un membre de set.

       CPU_COUNT()      Renvoyer le nombre de CPU de set.

       Lorsque l’argument cpu est spécifié, il ne devrait pas produire d’effet
       de bord puisque les macros ci-dessus pourraient évaluer l’argument plus
       d’une fois.

       Le premier CPU disponible sur un système correspond à la valeur cpu  0,
       le   CPU   suivant   à  la  valeur  cpu  1.  La  constante  CPU_SETSIZE
       (habituellement 1024) spécifie le nombre maximum de CPUs qui peut  être
       enregistré dans cpu_set_t.

       Les   macros  suivantes  réalisent  des  opérations  logiques  sur  les
       « ensembles de CPUs » :

       CPU_AND()        Enregistre le ET  logique  des  ensembles  srcset1  et
                        srcset2  dans  destset  (qui  peut  être  un  ensemble
                        source).

       CPU_OR()         Enregistre le OU  logique  des  ensembles  srcset1  et
                        srcset2  dans  destset  (qui  peut  être  un  ensemble
                        source).

       CPU_XOR()        Enregistre  le  OU  EXCLUSIF  logique  des   ensembles
                        srcset1  et  srcset2  dans  destset  (qui peut être un
                        ensemble source).

       CPU_EQUAL()      Tester si deux ensembles de CPUs contiennent les mêmes
                        CPUs.

   Ensemble de CPUs de taille dynamique
       Certaines applications nécessite des ensembles CPUs de taille dynamique
       (par exemple, pour allouer des ensembles plus grands que  ceux  définis
       avec  le  type cpu_set_t), la glibc propose aujourd’hui un jeu de macro
       pour cette fonctionnalité.

       Les macros suivantes sont utilisées  pour  allouer  et  désallouer  des
       ensembles de CPUs :

       CPU_ALLOC()      Allouer  un  ensemble  CPUs  assez grand pour contenir
                        num_cpus-1 CPU.

       CPU_ALLOC_SIZE() Renvoie  la  taille  en  octets  de  l’ensemble   CPUs
                        nécessaire  pour  contenir  les  num_cpus-1 cpu. Cette
                        macro fournit la  valeur  de  l’argument  setsize  des
                        macros CPU_*_S() définies ci-dessous.

       CPU_FREE()       Libérer un ensemble alloué avec CPU_ALLOC().

       Les  macros  dont  le  nom  se  termine  par  « _S »  sont  les  macros
       équivalentes aux macros sans « _S » qui opèrent sur  les  ensembles  de
       taille dynamique de taille setsize.

VALEUR RENVOYÉE

       CPU_ISSET()  et CPU_ISSET_S() renvoient une valeur non nulle si cpu est
       présent dans set, 0 sinon.

       CPU_COUNT() et CPU_COUNT_S() renvoient le nombre de CPUs  présent  dans
       set.

       CPU_EQUAL() et CPU_EQUAL_S() renvoient une valeur non nulle si les deux
       ensemble CPUs sont égaux, 0 sinon.

       CPU_ALLOC() renvoie un pointeur  en  cas  de  succès  et  NULL  en  cas
       d’échec. Les erreurs sont les mêmes que malloc(3).

       CPU_ALLOC_SIZE() renvoie le nombre d’octets nécessaire pour sauvegarder
       un ensemble avec une cardinalité spécifique.

       Ces autres routines ne renvoient pas de valeur.

VERSIONS

       Les macros CPU_ZERO(), CPU_SET(),  CPU_CLR()  et  CPU_ISSET()  ont  été
       ajoutées dans la glibc 2.3.3.

       CPU_COUNT() est apparue dans le glibc2.6.

       CPU_AND(),     CPU_OR(),     CPU_XOR(),    CPU_EQUAL(),    CPU_ALLOC(),
       CPU_ALLOC_SIZE(), CPU_FREE(), CPU_ZERO_S(),  CPU_SET_S(),  CPU_CLR_S(),
       CPU_ISSET_S(),  CPU_AND_S(),  CPU_OR_S(),  CPU_XOR_S() et CPU_EQUAL_S()
       sont apparues en premier dans la glibc2.7.

CONFORMITÉ

       Ces interfaces sont spécifiques à Linux.

NOTES

       Pour dupliquer un ensemble, utilisez memcpy(3).

       Comme les ensembles de CPUs sont des champs de bits alloués  par  unité
       de  mots  de  type  long,  le  nombre  actuel  de CPUs dans un ensemble
       dynamique doit être arrondi  au  multiple  suivant  de  sizeof(unsigned
       long).  Une  application  doit  considérer  les bits non utilisés comme
       indéfinis.

       Notez que la constante CPU_SETSIZE indique le nombre de  CPUs  dans  la
       structure  cpu_set_t  (c’est un comptage de bits dans le champ de bits)
       alors que l’argument setsize des macros CPU_*_S()  est  une  taille  en
       octets.

       Les  types  de données des arguments et des valeurs de retour vues dans
       le SYNOPSIS sont des suggestions sur ce qui est prévu dans chaque  cas.
       Cependant, puisque ces interfaces sont des macros, le compilateur ne va
       pas nécessairement attraper toutes les erreurs de type si  vous  violez
       ces suggestions.

EXEMPLE

       Le programme suivant est un exemple d’utilisation de macros dans le cas
       d’un ensemble de CPUs dynamique.

       #define _GNU_SOURCE
       #include <sched.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <stdio.h>
       #include <assert.h>

       int
       main(int argc, char *argv[])
       {
           cpu_set_t *cpusetp;
           size_t size;
           int num_cpus, cpu;

           if (argc < 2) {
               fprintf(stderr, "Usage: %s <num-cpus>\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           num_cpus = atoi(argv[1]);

           cpusetp = CPU_ALLOC(num_cpus);
           if (cpusetp == NULL) {
               perror("CPU_ALLOC");
               exit(EXIT_FAILURE);
           }

           size = CPU_ALLOC_SIZE(num_cpus);

           CPU_ZERO_S(size, cpusetp);
           for (cpu = 0; cpu < num_cpus; cpu += 2)
               CPU_SET_S(cpu, size, cpusetp);

           printf("CPU_COUNT() of set:    %d\n", CPU_COUNT_S(size, cpusetp));

           CPU_FREE(cpusetp);
           exit(EXIT_SUCCESS);
       }

BOGUES

       Sur une  plate-forme  32 bits  avec  une  glibc 2.8  ou  plus  récente,
       CPU_ALLOC()   alloue   deux  fois  plus  d’espace  que  nécessaire,  et
       CPU_ALLOC_SIZE() renvoie une valeur deux fois plus grande que la valeur
       attendue. Ce bogue ne devrait pas affecter la sémantique d’un programme
       mais il provoque une sur-consommation mémoire et les macros opérant sur
       un  ensemble  dynamique  sont  moins performantes. Ce bogue est corrigé
       avec la glibc 2.9.

VOIR AUSSI

       sched_setaffinity(2),                   pthread_attr_setaffinity_np(3),
       pthread_setaffinity_np(3), cpuset(7)

COLOPHON

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

       Cette page de manuel a été traduite  et  est  maintenue  par  Florentin
       Duneau <fduneau AT gmail DOT com> et l’équipe francophone de traduction
       de Debian.

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