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 reprezintă 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 mască de biți. Cu toate acestea, structura de date trebuie tratată ca opacă: toate manipulările seturilor de CPU-uri trebuie efectuate prin intermediul macroinstrucțiunilor descrise în această pagină.

Următoarele macroinstrucțiuni sunt prevăzute pentru a opera asupra setului CPU set:

CPU_ZERO()
    Șterge set, astfel încât acesta să nu conțină CPU-uri.

CPU_SET()
    Adaugă CPU-ul cpu la set.

CPU_CLR()
    Elimină CPU-ul cpu din set.

CPU_ISSET()
    Testează pentru a vedea dacă CPU-ul cpu este un membru al set.

CPU_COUNT()
    Returnează numărul de CPU-uri din set.

În cazul în care este specificat un argument cpu, acesta nu ar trebui să producă 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, următorul CPU corespunde unei valori cpu de 1 și așa mai departe. Nu trebuie făcute presupuneri cu privire la faptul că anumite CPU-uri sunt disponibile sau că setul de CPU-uri este contiguu, deoarece CPU-urile pot fi deconectate dinamic sau pot fi absente. Constanta CPU_SETSIZE (în prezent 1024) specifică o valoare cu o unitate mai mare decât numărul maxim de CPU care poate fi stocat în cpu_set_t.

Următoarele macroinstrucțiuni efectuează operații logice asupra seturilor CPU:

CPU_AND()
    Stochează intersecția seturilor srcset1 și srcset2 în destset (care poate fi unul dintre seturile sursă).

CPU_OR()
    Stochează uniunea seturilor srcset1 și srcset2 în destset (care poate fi unul dintre seturile sursă).

CPU_XOR()
    Stochează XOR-ul seturilor srcset1 și srcset2 în destset (care poate fi unul dintre seturile sursă). XOR înseamnă setul de unități centrale care sunt fie în srcset1, fie în srcset2, dar nu în ambele.

CPU_EQUAL()
    Testează dacă două 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 decât cele definite de tipul de date standard cpu_set_t), glibc oferă în prezent un set de macroinstrucțiuni pentru a oferi suport pentru aceasta.

Următoarele 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 în intervalul 0 la num_cpus-1.

CPU_ALLOC_SIZE()
    Returnează dimensiunea în octeți a setului de CPU-uri care ar fi necesară pentru a conține CPU-uri în intervalul 0 la num_cpus-1. Această macroinstrucțiune furnizează valoarea care poate fi utilizată pentru argumentul setsize în macroinstrucțiunile CPU_*_S() descrise mai jos.

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

Macroinstrucțiunile ale căror nume se termină cu „_S” sunt analogice macroinstrucțiunilor cu nume similare fără sufix. Aceste macroinstrucțiuni îndeplinesc aceleași sarcini ca și analogii lor, dar operează pe setul (seturile) CPU alocat(e) dinamic, a cărui dimensiune este setsize octeți.

VALOAREA RETURNATĂ
CPU_ISSET() și CPU_ISSET_S() returnează nonzero dacă cpu este în set; în caz contrar, returnează 0.

CPU_COUNT() și CPU_COUNT_S() returnează numărul de CPU-uri din set.

CPU_EQUAL() și CPU_EQUAL_S() returnează o valoare diferită de zero dacă cele două seturi de CPU-uri sunt egale; altfel, acestea returnează 0.

CPU_ALLOC() returnează un indicator în caz de succes, sau NULL în caz de eșec. - Erorile sunt ca pentru malloc(3). -

CPU_ALLOC_SIZE() returnează numărul de octeți necesari pentru a stoca un set de CPU-uri de cardinalitatea specificată.

Celelalte funcții nu returnează nicio valoare.

STANDARDE
Linux.

ISTORIC
Macroinstrucțiunile CPU_ZERO(), CPU_SET(), CPU_CLR() și CPU_ISSET() au fost adăugate în glibc 2.3.3.

CPU_COUNT() a apărut pentru prima dată în 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 apărut pentru prima dată în glibc 2.7.

NOTE
Pentru a duplica un set CPU, utilizați memcpy(3).

Deoarece seturile CPU sunt măști de biți alocate în unități de cuvinte lungi, numărul real de CPU-uri dintr-un set CPU alocat dinamic va fi rotunjit la următorul multiplu de sizeof(unsigned long). O aplicație trebuie să considere conținutul acestor biți suplimentari ca fiind nedefinit.

În ciuda similitudinii numelor, rețineți că constanta CPU_SETSIZE indică numărul de CPU din tipul de date cpu_set_t (astfel, este efectiv o numărătoare a biților din masca de biți), în timp ce argumentul setsize al macroinstrucțiunilor CPU_*_S() este o dimensiune în octeți.

Tipurile de date pentru argumente și valorile de returnare prezentate în SINOPSIS sunt sugestii despre ce se așteaptă în fiecare caz. Cu toate acestea, deoarece aceste interfețe sunt implementate ca macroinstrucțiuni, compilatorul nu va detecta neapărat toate erorile de tip dacă încălcați sugestiile.

ERORI
Pe platformele pe 32 de biți cu glibc 2.8 și anterioare, CPU_ALLOC() alocă de două ori mai mult spațiu decât este necesar, iar CPU_ALLOC_SIZE() returnează o valoare de două ori mai mare decât ar trebui. Această eroare nu ar trebui să afecteze semantica unui program, dar duce la risipă de memorie și la o funcționare mai puțin eficientă a macroinstrucțiunilor care operează pe seturi CPU alocate dinamic. Aceste erori sunt rezolvate în glibc 2.9.

EXEMPLE
Următorul program demonstrează 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 <număr-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 în limba română a acestui manual a fost făcută de Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>

Această traducere este documentație gratuită; citiți Licența publică generală GNU Versiunea 3 (https://www.gnu.org/licenses/gpl-3.0.html) sau o versiune ulterioară cu privire la condiții privind drepturile de autor. NU se asumă NICIO RESPONSABILITATE.

Dacă găsiți erori în traducerea acestui manual, vă rugăm să trimiteți un e-mail la translation-team-ro@lists.sourceforge.net.