CPU_SET(3)                 Library Functions Manual                 CPU_SET(3)

NUME
       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 - macroinstruc<?>iuni pentru manipularea
       seturilor CPU

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

SINOPSIS
       #define _GNU_SOURCE             /* Consulta<?>i 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);

DESCRIERE
       Structura de date cpu_set_t reprezinta un set de CPU-uri.  Seturile de
       CPU-uri sunt utilizate de sched_setaffinity(2) <?>i interfe<?>e
       similare.

       Tipul de date cpu_set_t este implementat ca o masca de bi<?>i. Cu toate
       acestea, structura de date trebuie tratata ca opaca: toate manipularile
       seturilor de CPU-uri trebuie efectuate prin intermediul
       macroinstruc<?>iunilor descrise in aceasta pagina.

       Urmatoarele macroinstruc<?>iuni sunt prevazute pentru a opera asupra
       setului CPU set:

       CPU_ZERO()
              <?>terge set, astfel incat acesta sa nu con<?>ina CPU-uri.

       CPU_SET()
              Adauga CPU-ul cpu la set.

       CPU_CLR()
              Elimina CPU-ul cpu din set.

       CPU_ISSET()
              Testeaza pentru a vedea daca CPU-ul cpu este un membru al set.

       CPU_COUNT()
              Returneaza numarul de CPU-uri din set.

       In cazul in care este specificat un argument cpu, acesta nu ar trebui
       sa produca efecte secundare, deoarece macroinstruc<?>iunile de mai sus
       pot evalua argumentul de mai multe ori.

       Primul CPU din sistem corespunde unei valori cpu de 0, urmatorul CPU
       corespunde unei valori cpu de 1 <?>i a<?>a mai departe. Nu trebuie
       facute presupuneri cu privire la faptul ca anumite CPU-uri sunt
       disponibile sau ca setul de CPU-uri este contiguu, deoarece CPU-urile
       pot fi deconectate dinamic sau pot fi absente. Constanta CPU_SETSIZE
       (in prezent 1024) specifica o valoare cu o unitate mai mare decat
       numarul maxim de CPU care poate fi stocat in cpu_set_t.

       Urmatoarele macroinstruc<?>iuni efectueaza opera<?>ii logice asupra
       seturilor CPU:

       CPU_AND()
              Stocheaza intersec<?>ia seturilor srcset1 <?>i srcset2 in
              destset (care poate fi unul dintre seturile sursa).

       CPU_OR()
              Stocheaza uniunea seturilor srcset1 <?>i srcset2 in destset
              (care poate fi unul dintre seturile sursa).

       CPU_XOR()
              Stocheaza XOR-ul seturilor srcset1 <?>i srcset2 in destset (care
              poate fi unul dintre seturile sursa). XOR inseamna setul de
              unita<?>i centrale care sunt fie in srcset1, fie in srcset2, dar
              nu in ambele.

       CPU_EQUAL()
              Testeaza daca doua seturi de CPU-uri con<?>in exact acelea<?>i
              CPU-uri.

   Seturi de CPU-uri dimensionate dinamic
       Deoarece unele aplica<?>ii pot necesita capacitatea de a dimensiona
       dinamic seturile CPU (de exemplu, pentru a aloca seturi mai mari decat
       cele definite de tipul de date standard cpu_set_t), glibc ofera in
       prezent un set de macroinstruc<?>iuni pentru a oferi suport pentru
       aceasta.

       Urmatoarele macroinstruc<?>iuni sunt utilizate pentru alocarea <?>i
       eliberarea seturilor CPU:

       CPU_ALLOC()
              Alocarea unui set de CPU suficient de mare pentru a con<?>ine
              CPU-uri in intervalul 0 la num_cpus-1.

       CPU_ALLOC_SIZE()
              Returneaza dimensiunea in octe<?>i a setului de CPU-uri care ar
              fi necesara pentru a con<?>ine CPU-uri in intervalul 0 la
              num_cpus-1.  Aceasta macroinstruc<?>iune furnizeaza valoarea
              care poate fi utilizata pentru argumentul setsize in
              macroinstruc<?>iunile CPU_*_S() descrise mai jos.

       CPU_FREE()
              Elibereaza un set de CPU-uri alocat anterior prin CPU_ALLOC().

       Macroinstruc<?>iunile ale caror nume se termina cu ,,_S" sunt analogice
       macroinstruc<?>iunilor cu nume similare fara sufix. Aceste
       macroinstruc<?>iuni indeplinesc acelea<?>i sarcini ca <?>i analogii
       lor, dar opereaza pe setul (seturile) CPU alocat(e) dinamic, a carui
       dimensiune este setsize octe<?>i.

VALOAREA RETURNATA
       CPU_ISSET() <?>i CPU_ISSET_S() returneaza nonzero daca cpu este in set;
       in caz contrar, returneaza 0.

       CPU_COUNT() <?>i CPU_COUNT_S() returneaza numarul de CPU-uri din set.

       CPU_EQUAL() <?>i CPU_EQUAL_S() returneaza nonzero daca cele doua seturi
       de CPU-uri sunt egale; altfel returneaza 0.

       CPU_ALLOC() returneaza un indicator in caz de succes, sau NULL in caz
       de e<?>ec. - Erorile sunt ca pentru malloc(3). -

       CPU_ALLOC_SIZE() returneaza numarul de octe<?>i necesari pentru a stoca
       un set de CPU-uri de cardinalitatea specificata.

       Celelalte func<?>ii nu returneaza nicio valoare.

STANDARDE
       Linux.

ISTORIC
       Macroinstruc<?>iunile CPU_ZERO(), CPU_SET(), CPU_CLR() <?>i CPU_ISSET()
       au fost adaugate in glibc 2.3.3.

       CPU_COUNT() a aparut pentru prima data in glibc 2.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(), and CPU_EQUAL_S()
       au aparut pentru prima data in glibc 2.7.

NOTE
       Pentru a duplica un set CPU, utiliza<?>i memcpy(3).

       Deoarece seturile CPU sunt ma<?>ti de bi<?>i alocate in unita<?>i de
       cuvinte lungi, numarul real de CPU-uri dintr-un set CPU alocat dinamic
       va fi rotunjit la urmatorul multiplu de sizeof(unsigned long). O
       aplica<?>ie trebuie sa considere con<?>inutul acestor bi<?>i
       suplimentari ca fiind nedefinit.

       In ciuda similitudinii numelor, re<?>ine<?>i ca constanta CPU_SETSIZE
       indica numarul de CPU din tipul de date cpu_set_t (astfel, este efectiv
       o numaratoare a bi<?>ilor din masca de bi<?>i), in timp ce argumentul
       setsize al macroinstruc<?>iunilor CPU_*_S() este o dimensiune in
       octe<?>i.

       Tipurile de date pentru argumente <?>i valorile de returnare prezentate
       in SINOPSIS sunt sugestii despre ce se a<?>teapta in fiecare caz. Cu
       toate acestea, deoarece aceste interfe<?>e sunt implementate ca
       macroinstruc<?>iuni, compilatorul nu va detecta neaparat toate erorile
       de tip daca incalca<?>i sugestiile.

ERORI
       Pe platformele pe 32 de bi<?>i cu glibc 2.8 <?>i anterioare,
       CPU_ALLOC() aloca de doua ori mai mult spa<?>iu decat este necesar, iar
       CPU_ALLOC_SIZE() returneaza o valoare de doua ori mai mare decat ar
       trebui.  Aceasta eroare nu ar trebui sa afecteze semantica unui
       program, dar duce la risipa de memorie <?>i la o func<?>ionare mai
       pu<?>in eficienta a macroinstruc<?>iunilor care opereaza pe seturi CPU
       alocate dinamic. Aceste erori sunt rezolvate in glibc 2.9.

EXEMPLE
       Urmatorul program demonstreaza utilizarea unora dintre
       macroinstruc<?>iunile utilizate pentru seturile de CPU alocate dinamic.

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

       #include <assert.h>

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

           if (argc < 2) {
               fprintf(stderr, "Utilizare: %s <numar-cpu>\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 (size_t cpu = 0; cpu < num_cpus; cpu += 2)
               CPU_SET_S(cpu, size, cpusetp);

           printf("CPU_COUNT() al setului:    %d\n", CPU_COUNT_S(size, cpusetp));

           CPU_FREE(cpusetp);
           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       sched_setaffinity(2), pthread_attr_setaffinity_np(3),
       pthread_setaffinity_np(3), cpuset(7)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.15    17 mai 2025                       CPU_SET(3)