Provided by: manpages-fr-dev_4.13-4_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  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.

       The cpu_set_t data type is implemented as a bit mask. However, the data structure should  be  treated  as
       opaque: all manipulation of CPU sets should be done via the macros described in this 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.

       The first CPU on the system corresponds to a cpu value of 0, the next CPU corresponds to a cpu  value  of
       1,  and  so  on.  No assumptions should be made about particular CPUs being available, or the set of CPUs
       being contiguous, since CPUs can be taken offline  dynamically  or  be  otherwise  absent.  The  constant
       CPU_SETSIZE (currently 1024) specifies a value one greater than the maximum CPU number that can be stored
       in cpu_set_t.

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

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

       CPU_OR()
              Enregistre  l'union  (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).  Le OU EXCLUSIF signifie que les ensembles appartiennent soit à srcset1, soit à
              srcset2, mais pas aux deux à la fois.

       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()  and CPU_EQUAL_S()  return nonzero if the two CPU sets are equal; otherwise they return 0.

       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.

       Les autres fonctions 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 glibc 2.7.

CONFORMITÉ

       Ces interfaces sont spécifiques à Linux.

NOTES

       Pour dupliquer un ensemble, utilisez memcpy(3).

       Since CPU sets are bit masks allocated in units of long words, the actual number of CPUs in a dynamically
       allocated CPU set will be rounded up to the next multiple of sizeof(unsigned long). An application should
       consider the contents of these extra bits to be undefined.

       Notwithstanding the similarity in the names, note that the constant CPU_SETSIZE indicates the  number  of
       CPUs  in the cpu_set_t data type (thus, it is effectively a count of the bits in the bit mask), while the
       setsize argument of the CPU_*_S()  macros is a size in bytes.

       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.

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
       surconsommation mémoire et les macros opérant sur un ensemble dynamique sont moins performantes. Ce bogue
       est corrigé avec la glibc 2.9.

EXEMPLES

       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;

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

VOIR AUSSI

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

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des
       instructions  pour  signaler  des  anomalies et la dernière version de cette page peuvent être trouvées à
       l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

       La  traduction  française   de   cette   page   de   manuel   a   été   créée   par   Christophe   Blaess
       <https://www.blaess.fr/christophe/>,   Stéphan   Rafin   <stephan.rafin@laposte.net>,   Thierry   Vignaud
       <tvignaud@mandriva.com>, François Micaux, Alain Portal  <aportal@univ-montp2.fr>,  Jean-Philippe  Guérard
       <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-luc.coulon@wanadoo.fr>,   Julien   Cristau
       <jcristau@debian.org>,     Thomas     Huriaux      <thomas.huriaux@gmail.com>,      Nicolas      François
       <nicolas.francois@centraliens.net>,     Florentin     Duneau    <fduneau@gmail.com>,    Simon    Paillard
       <simon.paillard@resel.enst-bretagne.fr>,    Denis    Barbier    <barbier@debian.org>,    David     Prévot
       <david@tilapin.org>,    Cédric    Boutillier    <cedric.boutillier@gmail.com>    et   Frédéric   Hantrais
       <fhantrais@gmail.com>

       Cette traduction est une documentation libre ; veuillez vous reporter à la  GNU  General  Public  License
       version 3   ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   concernant   les  conditions  de  copie  et  de
       distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel,  veuillez  envoyer  un  message  à
       debian-l10n-french@lists.debian.org ⟨⟩.