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.

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ă nonzero dacă cele două seturi de CPU-uri sunt egale; altfel 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 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.