Provided by: manpages-fr-dev_3.27fr1.4-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             /* Consultez feature_test_macros(7) */
       #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);

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

       int  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 donnees cpu_set_t represente un << ensemble de CPUs >>.
       Les << ensembles de CPUs >> sont utilises par  sched_setaffinity(2)  et
       les interfaces similaires.

       Le  type  cpu_set_t  est  un  champ de bits. Cependant, la structure de
       donnees traitee est consideree comme opaque : toute  manipulation  d'un
       << ensemble  de  CPU >> devrait etre effectuee avec les macros decrites
       dans cette page.

       Les macros suivantes sont fournies pour operer sur l'ensemble set :

       CPU_ZERO()       Mettre a zero set, ainsi, il ne contient aucun CPU.

       CPU_SET()        Ajouter le CPU cpu a 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 specifie, il ne devrait pas produire d'effet
       de bord puisque les macros ci-dessus pourraient evaluer l'argument plus
       d'une fois.

       Le premier CPU disponible sur un systeme correspond a la valeur cpu  0,
       le   CPU   suivant   a  la  valeur  cpu  1.  La  constante  CPU_SETSIZE
       (habituellement 1024) specifie le nombre maximal de CPUs qui peut  etre
       enregistre dans cpu_set_t.

       Les   macros  suivantes  realisent  des  operations  logiques  sur  les
       << ensembles de CPUs >> :

       CPU_AND()        Enregistre l'intersection (ET logique)  des  ensembles
                        srcset1  et  srcset2  dans  destset  (qui peut etre un
                        ensemble source).

       CPU_OR()         Enregistre l'union (OU logique) des ensembles  srcset1
                        et  srcset2  dans  destset  (qui peut etre un ensemble
                        source).

       CPU_XOR()        Enregistre  le  OU  EXCLUSIF  logique  des   ensembles
                        srcset1  et  srcset2  dans  destset  (qui peut etre un
                        ensemble source). Le  OU  EXCLUSIF  signifie  que  les
                        ensembles   appartiennent   soit  a  srcset1,  soit  a
                        srcset2, mais pas aux deux a la fois.

       CPU_EQUAL()      Tester si deux ensembles de CPUs contiennent les memes
                        CPUs.

   Ensemble de CPUs de taille dynamique
       Certaines applications necessite des ensembles CPUs de taille dynamique
       (par exemple, pour allouer des ensembles plus grands que  ceux  definis
       avec  le  type cpu_set_t), la glibc propose aujourd'hui un jeu de macro
       pour cette fonctionnalite.

       Les macros suivantes sont utilisees  pour  allouer  et  desallouer  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
                        necessaire  pour  contenir  les  num_cpus-1 cpu. Cette
                        macro fournit la  valeur  de  l'argument  setsize  des
                        macros CPU_*_S() definies ci-dessous.

       CPU_FREE()       Liberer un ensemble alloue avec CPU_ALLOC().

       Les  macros  dont  le  nom  se  termine  par  << _S >>  sont les macros
       equivalentes aux macros sans << _S >> qui operent sur les ensembles  de
       taille dynamique de taille setsize.

VALEUR RENVOY'EE

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

       CPU_COUNT() et CPU_COUNT_S() renvoient le nombre de CPUs  present  dans
       set.

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

       CPU_ALLOC() renvoie un pointeur  en  cas  de  succes  et  NULL  en  cas
       d'echec. Les erreurs sont les memes que malloc(3).

       CPU_ALLOC_SIZE() renvoie le nombre d'octets necessaire pour sauvegarder
       un ensemble avec une cardinalite specifique.

       Les autres fonctions ne renvoient pas de valeur.

VERSIONS

       Les macros CPU_ZERO(), CPU_SET(),  CPU_CLR()  et  CPU_ISSET()  ont  ete
       ajoutees 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 glibc 2.7.

CONFORMIT'E

       Ces interfaces sont specifiques a Linux.

NOTES

       Pour dupliquer un ensemble, utilisez memcpy(3).

       Comme les ensembles de CPUs sont des champs de bits alloues  par  unite
       de  mots  de  type  long,  le  nombre  actuel  de CPUs dans un ensemble
       dynamique doit etre arrondi  au  multiple  suivant  de  sizeof(unsigned
       long).  Une  application  doit  considerer  les bits non utilises comme
       indefinis.

       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 donnees des arguments et des valeurs de retour vues dans
       le SYNOPSIS sont des suggestions sur ce qui est prevu dans chaque  cas.
       Cependant, puisque ces interfaces sont des macros, le compilateur ne va
       pas necessairement 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  recente,
       CPU_ALLOC()   alloue   deux  fois  plus  d'espace  que  necessaire,  et
       CPU_ALLOC_SIZE() renvoie une valeur deux fois plus grande que la valeur
       attendue. Ce bogue ne devrait pas affecter la semantique d'un programme
       mais il provoque une sur-consommation memoire et les macros operant sur
       un  ensemble  dynamique  sont  moins performantes. Ce bogue est corrige
       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.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone       au       sein        du        projet        perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Florentin   Duneau   et   l'equipe   francophone   de   traduction   de
       Debian (2006-2009).

       Veuillez  signaler  toute  erreur   de   traduction   en   ecrivant   a
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir acces a la version anglaise de  ce  document
       en utilisant la commande << man -L C <section> <page_de_man> >>.