.\" -*- coding: UTF-8 -*- .\" Copyright, the authors of the Linux man-pages project .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH CPU_SET 3 "17 mai 2025" "Pagini de manual de Linux 6.15" .SH 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 .SH BIBLIOTECA Biblioteca C standard (\fIlibc\fP, \fI\-lc\fP) .SH SINOPSIS .nf \fB#define _GNU_SOURCE\fP /* Consultați feature_test_macros(7) */ \fB#include \fP .P \fBvoid CPU_ZERO(cpu_set_t *\fP\fIset\fP\fB);\fP .P \fBvoid CPU_SET(int \fP\fIcpu\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP \fBvoid CPU_CLR(int \fP\fIcpu\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP \fBint CPU_ISSET(int \fP\fIcpu\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP .P \fBint CPU_COUNT(cpu_set_t *\fP\fIset\fP\fB);\fP .P \fBvoid CPU_AND(cpu_set_t *\fP\fIdestset\fP\fB,\fP \fB cpu_set_t *\fP\fIsrcset1\fP\fB, cpu_set_t *\fP\fIsrcset2\fP\fB);\fP \fBvoid CPU_OR(cpu_set_t *\fP\fIdestset\fP\fB,\fP \fB cpu_set_t *\fP\fIsrcset1\fP\fB, cpu_set_t *\fP\fIsrcset2\fP\fB);\fP \fBvoid CPU_XOR(cpu_set_t *\fP\fIdestset\fP\fB,\fP \fB cpu_set_t *\fP\fIsrcset1\fP\fB, cpu_set_t *\fP\fIsrcset2\fP\fB);\fP .P \fBint CPU_EQUAL(cpu_set_t *\fP\fIset1\fP\fB, cpu_set_t *\fP\fIset2\fP\fB);\fP .P \fBcpu_set_t *CPU_ALLOC(int \fP\fInum_cpus\fP\fB);\fP \fBvoid CPU_FREE(cpu_set_t *\fP\fIset\fP\fB);\fP \fBsize_t CPU_ALLOC_SIZE(int \fP\fInum_cpus\fP\fB);\fP .P \fBvoid CPU_ZERO_S(size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP .P \fBvoid CPU_SET_S(int \fP\fIcpu\fP\fB, size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP \fBvoid CPU_CLR_S(int \fP\fIcpu\fP\fB, size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP \fBint CPU_ISSET_S(int \fP\fIcpu\fP\fB, size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP .P \fBint CPU_COUNT_S(size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIset\fP\fB);\fP .P \fBvoid CPU_AND_S(size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIdestset\fP\fB,\fP \fB cpu_set_t *\fP\fIsrcset1\fP\fB, cpu_set_t *\fP\fIsrcset2\fP\fB);\fP \fBvoid CPU_OR_S(size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIdestset\fP\fB,\fP \fB cpu_set_t *\fP\fIsrcset1\fP\fB, cpu_set_t *\fP\fIsrcset2\fP\fB);\fP \fBvoid CPU_XOR_S(size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIdestset\fP\fB,\fP \fB cpu_set_t *\fP\fIsrcset1\fP\fB, cpu_set_t *\fP\fIsrcset2\fP\fB);\fP .P \fBint CPU_EQUAL_S(size_t \fP\fIsetsize\fP\fB, cpu_set_t *\fP\fIset1\fP\fB, cpu_set_t *\fP\fIset2\fP\fB);\fP .fi .SH DESCRIERE Structura de date \fIcpu_set_t\fP reprezintă un set de CPU\-uri. Seturile de CPU\-uri sunt utilizate de \fBsched_setaffinity\fP(2) și interfețe similare. .P Tipul de date \fIcpu_set_t\fP 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ă. .P Următoarele macroinstrucțiuni sunt prevăzute pentru a opera asupra setului CPU \fIset\fP: .TP \fBCPU_ZERO\fP() Șterge \fIset\fP, astfel încât acesta să nu conțină CPU\-uri. .TP \fBCPU_SET\fP() Adaugă CPU\-ul \fIcpu\fP la \fIset\fP. .TP \fBCPU_CLR\fP() Elimină CPU\-ul \fIcpu\fP din \fIset\fP. .TP \fBCPU_ISSET\fP() Testează pentru a vedea dacă CPU\-ul \fIcpu\fP este un membru al \fIset\fP. .TP \fBCPU_COUNT\fP() Returnează numărul de CPU\-uri din \fIset\fP. .P În cazul în care este specificat un argument \fIcpu\fP, acesta nu ar trebui să producă efecte secundare, deoarece macroinstrucțiunile de mai sus pot evalua argumentul de mai multe ori. .P Primul CPU din sistem corespunde unei valori \fIcpu\fP de 0, următorul CPU corespunde unei valori \fIcpu\fP 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 \fBCPU_SETSIZE\fP (în prezent 1024) specifică o valoare cu o unitate mai mare decât numărul maxim de CPU care poate fi stocat în \fIcpu_set_t\fP. .P Următoarele macroinstrucțiuni efectuează operații logice asupra seturilor CPU: .TP \fBCPU_AND\fP() Stochează intersecția seturilor \fIsrcset1\fP și \fIsrcset2\fP în \fIdestset\fP (care poate fi unul dintre seturile sursă). .TP \fBCPU_OR\fP() Stochează uniunea seturilor \fIsrcset1\fP și \fIsrcset2\fP în \fIdestset\fP (care poate fi unul dintre seturile sursă). .TP \fBCPU_XOR\fP() Stochează XOR\-ul seturilor \fIsrcset1\fP și \fIsrcset2\fP în \fIdestset\fP (care poate fi unul dintre seturile sursă). XOR înseamnă setul de unități centrale care sunt fie în \fIsrcset1\fP, fie în \fIsrcset2\fP, dar nu în ambele. .TP \fBCPU_EQUAL\fP() Testează dacă două seturi de CPU\-uri conțin exact aceleași CPU\-uri. .SS "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 \fIcpu_set_t\fP), glibc oferă în prezent un set de macroinstrucțiuni pentru a oferi suport pentru aceasta. .P Următoarele macroinstrucțiuni sunt utilizate pentru alocarea și eliberarea seturilor CPU: .TP \fBCPU_ALLOC\fP() Alocarea unui set de CPU suficient de mare pentru a conține CPU\-uri în intervalul 0 la \fInum_cpus\-1\fP. .TP \fBCPU_ALLOC_SIZE\fP() Returnează dimensiunea în octeți a setului de CPU\-uri care ar fi necesară pentru a conține CPU\-uri în intervalul 0 la \fInum_cpus\-1\fP. Această macroinstrucțiune furnizează valoarea care poate fi utilizată pentru argumentul \fIsetsize\fP în macroinstrucțiunile \fBCPU_*_S\fP() descrise mai jos. .TP \fBCPU_FREE\fP() Eliberează un set de CPU\-uri alocat anterior prin \fBCPU_ALLOC\fP(). .P 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 \fIsetsize\fP octeți. .SH "VALOAREA RETURNATĂ" \fBCPU_ISSET\fP() și \fBCPU_ISSET_S\fP() returnează nonzero dacă \fIcpu\fP este în \fIset\fP; în caz contrar, returnează 0. .P \fBCPU_COUNT\fP() și \fBCPU_COUNT_S\fP() returnează numărul de CPU\-uri din \fIset\fP. .P \fBCPU_EQUAL\fP() și \fBCPU_EQUAL_S\fP() returnează nonzero dacă cele două seturi de CPU\-uri sunt egale; altfel returnează 0. .P \fBCPU_ALLOC\fP() returnează un indicator în caz de succes, sau NULL în caz de eșec. \- Erorile sunt ca pentru \fBmalloc\fP(3). \- .P \fBCPU_ALLOC_SIZE\fP() returnează numărul de octeți necesari pentru a stoca un set de CPU\-uri de cardinalitatea specificată. .P Celelalte funcții nu returnează nicio valoare. .SH STANDARDE Linux. .SH ISTORIC Macroinstrucțiunile \fBCPU_ZERO\fP(), \fBCPU_SET\fP(), \fBCPU_CLR\fP() și \fBCPU_ISSET\fP() au fost adăugate în glibc 2.3.3. .P \fBCPU_COUNT\fP() a apărut pentru prima dată în glibc 2.6. .P \fBCPU_AND\fP(), \fBCPU_OR\fP(), \fBCPU_XOR\fP(), \fBCPU_EQUAL\fP(), \fBCPU_ALLOC\fP(), \fBCPU_ALLOC_SIZE\fP(), \fBCPU_FREE\fP(), \fBCPU_ZERO_S\fP(), \fBCPU_SET_S\fP(), \fBCPU_CLR_S\fP(), \fBCPU_ISSET_S\fP(), \fBCPU_AND_S\fP(), \fBCPU_OR_S\fP(), \fBCPU_XOR_S\fP(), and \fBCPU_EQUAL_S\fP() au apărut pentru prima dată în glibc 2.7. .SH NOTE Pentru a duplica un set CPU, utilizați \fBmemcpy\fP(3). .P 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 \fIsizeof(unsigned long)\fP. O aplicație trebuie să considere conținutul acestor biți suplimentari ca fiind nedefinit. .P În ciuda similitudinii numelor, rețineți că constanta \fBCPU_SETSIZE\fP indică numărul de CPU din tipul de date \fIcpu_set_t\fP (astfel, este efectiv o numărătoare a biților din masca de biți), în timp ce argumentul \fIsetsize\fP al macroinstrucțiunilor \fBCPU_*_S\fP() este o dimensiune în octeți. .P 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. .SH ERORI .\" http://sourceware.org/bugzilla/show_bug.cgi?id=7029 Pe platformele pe 32 de biți cu glibc 2.8 și anterioare, \fBCPU_ALLOC\fP() alocă de două ori mai mult spațiu decât este necesar, iar \fBCPU_ALLOC_SIZE\fP() 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. .SH EXEMPLE Următorul program demonstrează utilizarea unora dintre macroinstrucțiunile utilizate pentru seturile de CPU alocate dinamic. .P .\" SRC BEGIN (CPU_SET.c) .EX #define _GNU_SOURCE #include #include #include #include \& #include \& int main(int argc, char *argv[]) { cpu_set_t *cpusetp; size_t size, num_cpus; \& if (argc < 2) { fprintf(stderr, "Utilizare: %s \[rs]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\[rs]n", CPU_COUNT_S(size, cpusetp)); \& CPU_FREE(cpusetp); exit(EXIT_SUCCESS); } .EE .\" SRC END .SH "CONSULTAȚI ȘI" \fBsched_setaffinity\fP(2), \fBpthread_attr_setaffinity_np\fP(3), \fBpthread_setaffinity_np\fP(3), \fBcpuset\fP(7) .PP .SH TRADUCERE Traducerea în limba română a acestui manual a fost făcută de Remus-Gabriel Chelu . .PP Această traducere este documentație gratuită; citiți .UR https://www.gnu.org/licenses/gpl-3.0.html Licența publică generală GNU Versiunea 3 .UE sau o versiune ulterioară cu privire la condiții privind drepturile de autor. NU se asumă NICIO RESPONSABILITATE. .PP Dacă găsiți erori în traducerea acestui manual, vă rugăm să trimiteți un e-mail la .MT translation-team-ro@lists.sourceforge.net .ME .