This is an old revision of the document!
Pentru sincronizarea firelor de execuție, avem la dispoziție:
Mutex-urile (mutual exclusion locks) sunt obiecte de sincronizare utilizate pentru a asigura accesul exclusiv într-o secțiune de cod în care se utilizează date partajate între două sau mai multe fire de execuție. Un mutex are două stări posibile: ocupat și liber. Un mutex poate fi ocupat de un singur fir de execuție la un moment dat. Atunci când un mutex este ocupat de un fir de execuție, el nu mai poate fi ocupat de niciun alt fir. În acest caz, o cerere de ocupare venită din partea unui alt fir, în general, va bloca firul până în momentul în care mutex-ul devine liber.
În Python, mutex-ul este reprezentat prin clasa threading.Lock. La creare mutex-ul este in starea unlocked. Odată ocupat de un thread, orice alt apel de ocupare a mutex-ului va eșua.
Folosind clasa threading.RLock, putem crea un mutex recursiv. Acest mutex poate fi ocupat de mai multe ori de același thread. Pentru a fi eliberat către un alt thread, thread-ul care a ocupat mutex-ul trebuie să apeleze funcția de eliberare de un număr egal de ori cu numărul de apeluri a funcției de ocupare a mutex-ului.
Funcțiile de ocupare/eliberare a unui mutex (acquire, release):
mutex.acquire (blocking=True, timeout=-1) mutex.release()
Dacă mutex-ul este liber în momentul apelului, acesta va fi ocupat de firul apelant și funcția va întoarce imediat. Dacă mutex-ul este ocupat de un alt fir, comportamentul funcției depinde de parametrul blockling:
True
- thread-ul se va bloca până mutex-ul este eliberat; dacă parametrul timeout are o valoare pozitivă, thread-ul se va bloca doar pentru timeout secunde (în acest caz funcția va întoarce True dacă mutex-ul a fost ocupat și False dacă nu);False
- funcția întoarce imediat valoarea True dacă funcția acquire a funcționat și valoarea False dacă apelul a eșuat (mutex-ul este ocupat de un alt fir de execuție).Nu este garantată o ordine FIFO de ocupare a unui mutex. Oricare din firele aflate în așteptare la deblocarea unui mutex pot să-l acapareze.
Pentru a elibera un mutex, este necesară apelarea funcției release.
Un exemplu de utilizare a unui mutex pentru a serializa accesul la variabila globală global_counter
:
import threading NUM_THREADS = 5 # global mutex mutex = threading.Lock() global_counter = 0 def thread_routine(): global global_counter thread_id = threading.get_ident() # acquire global mutex mutex.acquire() # print and modify global_counter print("Thread {} says global_counter={}".format (thread_id, global_counter)) global_counter = global_counter + 1 # release mutex - now other threads can modify global_counter mutex.release() threads = [] # all threads execute thread_routine for i in range (NUM_THREADS): t = threading.Thread (target=thread_routine) threads.append (t) t.start() for i in range (NUM_THREADS): threads[i].join()
$ python3 example.py Thread 123145557700608 says global_counter=0 Thread 123145562955776 says global_counter=1 Thread 123145557700608 says global_counter=2 Thread 123145568210944 says global_counter=3 Thread 123145562955776 says global_counter=4
Semafoarele sunt obiecte de sincronizare ce reprezintă o generalizare a mutex-urilor prin aceea că salvează numărul de operații de eliberare (incrementare) efectuate asupra lor. Practic, un semafor reprezintă un întreg care se incrementează/decrementează atomic. Valoarea unui semafor nu poate scădea sub 0. Dacă semaforul are valoarea 0, operația de decrementare se va bloca până când valoarea semaforului devine strict pozitivă. Mutex-urile pot fi privite, așadar, ca niște semafoare binare.
În Python, semafoarele sunt reprezentate de clasa Semaphore:
import threading semaphore = threading.Semaphore (value=1)
Funcția acquire are un comportament similar cu cel al funcție acquire specifice mutex-ului. Diferența este că în acest caz, la apelul acuire se verifică dacă contorul semaforului este mai mare ca 0.
Pe lângă clasa Semaphore, modulul threading exportă clasa BoundedSemaphore care se asigură că funcția release nu este apelată de mai multe ori decât funcția acquire. Dacă apelul funcției release va rezulta într-o creștere a contorului mai mare decât valoarea inițială, apelul funcției va rezulta într-o eroare.
import threading NUM_THREADS = 5 # global semaphore my_sem = threading.Semaphore(value=2) add_counter = 0 subtract_counter = 0 def add_routine(): global add_counter thread_id = threading.get_ident() # acquire global mutex my_sem.acquire() # print and modify global_counter print("Thread {} says add_counter={}".format (thread_id, add_counter)) add_counter = add_counter + 1 # release mutex - now other threads can modify global_counter my_sem.release() def subtract_routine(): global subtract_counter thread_id = threading.get_ident() # acquire global mutex my_sem.acquire() # print and modify global_counter print("Thread {} says subtract_counter={}".format (thread_id, subtract_counter)) subtract_counter = subtract_counter - 1 # release mutex - now other threads can modify global_counter my_sem.release() threads = [] # all threads execute thread_routine for i in range (NUM_THREADS): t1 = threading.Thread (target=add_routine) t2 = threading.Thread (target=subtract_routine) threads.append (t1) t1.start() threads.append (t2) t2.start() for i in range (NUM_THREADS): threads[i].join()
Variabilele condiție pun la dispoziție un sistem de notificare pentru fire de execuție, permițându-i unui fir să se blocheze în așteptarea unui semnal din partea unui alt fir. Folosirea corectă a variabilelor condiție presupune un protocol cooperativ între firele de execuție.
Mutex-urile și semafoarele permit blocarea altor fire de execuție. Variabilele de condiție se folosesc pentru a bloca firul curent până la îndeplinirea unei condiții.
Variabilele condiție sunt obiecte de sincronizare care-i permit unui fir de execuție să-și suspende execuția până când o condiție (predicat logic) devine adevărată. Când un fir de execuție determină că predicatul a devenit adevărat, va semnala variabila condiție, deblocând astfel unul sau toate firele de execuție blocate la acea variabilă condiție (în funcție de intenție).
O variabilă condiție trebuie întotdeauna folosită împreună cu un mutex pentru evitarea race-ului care se produce când un fir se pregătește să aștepte la variabila condiție în urma evaluării predicatului logic, iar alt fir semnalizează variabila condiție chiar înainte ca primul fir să se blocheze, pierzându-se astfel semnalul. Așadar, operațiile de semnalizare, testare a condiției logice și blocare la variabila condiție trebuie efectuate având ocupat mutex-ul asociat variabilei condiție. Condiția logică este testată sub protecția mutex-ului, iar dacă nu este îndeplinită, firul apelant se blochează la variabila condiție, eliberând atomic mutex-ul. În momentul deblocării, un fir de execuție va încerca să ocupe mutex-ul asociat variabilei condiție. De asemenea, testarea predicatului logic trebuie făcută într-o buclă, deoarece, dacă sunt eliberate mai multe fire deodată, doar unul va reuși să ocupe mutex-ul asociat condiției. Restul vor aștepta ca acesta să-l elibereze, însă este posibil ca firul care a ocupat mutex-ul să schimbe valoarea predicatului logic pe durata deținerii mutex-ului. Din acest motiv celelalte fire trebuie să testeze din nou predicatul pentru că, altfel, și-ar începe execuția presupunând predicatul adevărat, când el este, de fapt, fals.
Inițializarea unei variabile de condiție se face folosind macro-ul PTHREAD_COND_INITIALIZER sau funcția pthread_cond_init. Distrugerea unei variabile de condiție se face prin funcția pthread_cond_destroy.
// inițializare statică a unei variabile de condiție cu atribute implicite // NB: variabila de condiție nu este eliberată, // durata de viață a variabilei de condiție este durata de viață a programului. pthread_cond_t cond = PTHREAD_COND_INITIALIZER; // semnăturile funcțiilor de inițializare și eliberare de variabile de condiție: int pthread_cond_init (pthread_cond_t *cond, pthread_condattr_t *attr); int pthread_cond_destroy(pthread_cond_t *cond);
Ca și la mutex-uri:
attr
este NULL, se folosesc atribute impliciteEBUSY
. Pentru a-și suspenda execuția și a aștepta la o variabilă condiție, un fir de execuție va apela funcția pthread_cond_wait:
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
Firul de execuție apelant trebuie să fi ocupat deja mutex-ul asociat, în momentul apelului. Funcția pthread_cond_wait
va elibera mutex-ul și se va bloca, așteptând ca variabila condiție să fie semnalizată de un alt fir de execuție. Cele două operații sunt efectuate atomic. În momentul în care variabila condiție este semnalizată, se va încerca ocuparea mutex-ului asociat, și după ocuparea acestuia, apelul funcției va întoarce. Observați că firul de execuție apelant poate fi suspendat, după deblocare, în așteptarea ocupării mutex-ului asociat, timp în care predicatul logic, adevărat în momentul deblocării firului, poate fi modificat de alte fire. De aceea, apelul pthread_cond_wait
trebuie efectuat într-o buclă în care se testează valoarea de adevăr a predicatului logic asociat variabilei condiție, pentru a asigura o serializare corectă a firelor de execuție. Un alt argument pentru testarea în buclă a predicatului logic este acela că un apel pthread_cond_wait
poate fi întrerupt de un semnal asincron (vezi laboratorul de semnale), înainte ca predicatul logic să devină adevărat. Dacă firele de execuție care așteptau la variabila condiție nu ar testa din nou predicatul logic, și-ar continua execuția presupunând greșit că acesta e adevărat.
Pentru a-și suspenda execuția și a aștepta la o variabilă condiție, nu mai târziu de un moment specificat de timp, un fir de execuție va apela pthread_cond_timedwait:
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
Funcția se comportă la fel ca pthread_cond_wait
, cu excepția faptului că, dacă variabila condiție nu este semnalizată mai devreme de abstime
, firul apelant este deblocat, și, după ocuparea mutex-ului asociat, funcția se întoarce cu eroarea ETIMEDOUT
. Parametrul abstime
este absolut și reprezintă numărul de secunde trecute de la 1 ianuarie 1970, ora 00:00.
Pentru a debloca un singur fir de execuție blocat la o variabilă condiție se va semnaliza variabila condiție folosind pthread_cond_signal:
int pthread_cond_signal(pthread_cond_t *cond);
Dacă la variabila condiție nu așteaptă niciun fir de execuție, apelul funcției nu are efect și semnalizarea se va pierde. Dacă la variabila condiție așteaptă mai multe fire de execuție, va fi deblocat doar unul dintre acestea. Alegerea firului care va fi deblocat este făcută de planificatorul de fire de execuție. Nu se poate presupune că firele care așteaptă vor fi deblocate în ordinea în care și-au început așteptarea. Firul de execuție apelant trebuie să dețină mutex-ul asociat variabilei condiție în momentul apelului acestei funcții.
Exemplu:
pthread_mutex_t count_lock; pthread_cond_t count_nonzero; unsigned count; void decrement_count() { pthread_mutex_lock(&count_lock); while (count == 0) pthread_cond_wait(&count_nonzero, &count_lock); count = count - 1; pthread_mutex_unlock(&count_lock); } void increment_count() { pthread_mutex_lock(&count_lock); count = count + 1; pthread_cond_signal(&count_nonzero); pthread_mutex_unlock(&count_lock); }
Pentru a debloca toate firele de execuție blocate la o variabilă condiție, se semnalizează variabila condiție folosind pthread_cond_broadcast:
int pthread_cond_broadcast(pthread_cond_t *cond);
Dacă la variabila condiție nu așteaptă niciun fir de execuție, apelul funcției nu are efect și semnalizarea se va pierde. Dacă la variabila condiție așteaptă fire de execuție, toate acestea vor fi deblocate, dar vor concura pentru ocuparea mutex-ului asociat variabilei condiție. Firul de execuție apelant trebuie să dețină mutex-ul asociat variabilei condiție în momentul apelului acestei funcții.
În următorul program se utilizează o barieră pentru a sincroniza firele de execuție ale programului. Bariera este implementată cu ajutorului unei variabile de condiție.
#include <stdio.h> #include <pthread.h> #define NUM_THREADS 5 // implementarea unei bariere *non-reutilizabile* cu variabile de condiție struct my_barrier_t { // mutex folosit pentru a serializa accesele la datele interne ale barierei pthread_mutex_t lock; // variabila de condiție pe care se așteptă sosirea tuturor firelor de execuție pthread_cond_t cond; // număr de fire de execuție care trebuie să mai vină pentru a elibera bariera int nr_still_to_come; }; struct my_barrier_t bar; void my_barrier_init(struct my_barrier_t *bar, int nr_still_to_come) { pthread_mutex_init(&bar->lock, NULL); pthread_cond_init(&bar->cond, NULL); // câte fire de execuție sunt așteptate la barieră bar->nr_still_to_come = nr_still_to_come; } void my_barrier_destroy(struct my_barrier_t *bar) { pthread_cond_destroy(&bar->cond); pthread_mutex_destroy(&bar->lock); } void *thread_routine(void *arg) { int thd_id = (int) arg; // înainte de a lucra cu datele interne ale barierei trebuie să preluam mutex-ul pthread_mutex_lock(&bar.lock); printf("thd %d: before the barrier\n", thd_id); // suntem ultimul fir de execuție care a sosit la barieră? int is_last_to_arrive = (bar.nr_still_to_come == 1); // decrementăm numarul de fire de execuție așteptate la barieră bar.nr_still_to_come --; // cât timp mai sunt fire de execuție care nu au ajuns la barieră, așteptăm. while (bar.nr_still_to_come != 0) // mutex-ul se eliberează automat înainte de a incepe așteptarea pthread_cond_wait(&bar.cond, &bar.lock); // ultimul fir de execuție ajuns la barieră va semnaliza celelalte fire if (is_last_to_arrive) { printf(" let the flood in\n"); pthread_cond_broadcast(&bar.cond); } printf("thd %d: after the barrier\n", thd_id); // la ieșirea din funcția de așteptare se preia automat mutex-ul, care trebuie eliberat pthread_mutex_unlock(&bar.lock); return NULL; } int main(void) { int i; pthread_t tids[NUM_THREADS]; my_barrier_init(&bar, NUM_THREADS); for (i = 0; i < NUM_THREADS; i++) pthread_create(&tids[i], NULL, thread_routine, (void *) i); for (i = 0; i < NUM_THREADS; i++) pthread_join(tids[i], NULL); my_barrier_destroy(&bar); return 0; }
so@spook$ gcc -Wall cond_var.c -pthread so@spook$ ./a.out thd 0: before the barrier thd 2: before the barrier thd 3: before the barrier thd 4: before the barrier thd 1: before the barrier let the flood in thd 1: after the barrier thd 2: after the barrier thd 3: after the barrier thd 4: after the barrier thd 0: after the barrier
Din execuția programului se observă:
Standardul POSIX definește și un set de funcții și structuri de date de lucru cu bariere. Aceste funcții sunt disponibile dacă se definește macro-ul _XOPEN_SOURCE
la o valoare >= 600.
Bariera se va inițializa folosind pthread_barrier_init și se va distruge folosind pthread_barrier_destroy.
// pentru a folosi funcțiile de lucru cu bariere e nevoie să se definească // _XOPEN_SOURCE la o valoare >= 600. Pentru detalii consultați feature_test_macros(7). #define _XOPEN_SOURCE 600 #include <pthread.h> // attr -> un set de atribute, poate fi NULL (se folosesc atribute implicite) // count -> numărul de fire de execuție care trebuie să ajungă // la barieră pentru ca aceasta să fie eliberată int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned count); // trebuie să nu existe fire de execuție în așteptare la barieră // înainte de a apela funcția _destroy, altfel, se întoarce EBUSY // și nu se distruge bariera. int pthread_barrier_destroy(pthread_barrier_t *barrier);
Așteptarea la barieră se face prin apelul pthread_barrier_wait:
#define _XOPEN_SOURCE 600 #include <pthread.h> int pthread_barrier_wait(pthread_barrier_t *barrier);
Dacă bariera a fost creată cu count=N
, primele N-1
fire de execuție care apelează pthread_barrier_wait
se blochează. Când sosește ultimul (al N
-lea), va debloca toate cele N-1
fire de execuție. Funcția pthread_barrier_wait
întoarce trei valori:
EINVAL
– în cazul în care bariera nu este inițializată (singura eroare definită)PTHREAD_BARRIER_SERIAL_THREAD
– în caz de succes, un singur fir de execuție va întoarce valoarea aceasta – nu e specificat care este acel fir de execuție (nu e obligatoriu să fie ultimul ajuns la barieră)0
– valoare întoarsă în caz de succes de celelalte N-1
fire de execuție. Cu bariere POSIX, programul de mai sus poate fi simplificat:
#define _XOPEN_SOURCE 600 #include <pthread.h> #include <stdio.h> #define NUM_THREADS 5 pthread_barrier_t barrier; void *thread_routine(void *arg) { int thd_id = (int) arg; int rc; printf("thd %d: before the barrier\n", thd_id); // toate firele de execuție așteaptă la barieră. rc = pthread_barrier_wait(&barrier); if (rc == PTHREAD_BARRIER_SERIAL_THREAD) { // un singur fir de execuție (posibil ultimul) va întoarce PTHREAD_BARRIER_SERIAL_THREAD // restul firelor de execuție întorc 0 în caz de succes. printf(" let the flood in\n"); } printf("thd %d: after the barrier\n", thd_id); return NULL; } int main(void) { int i; pthread_t tids[NUM_THREADS]; // bariera este inițializată o singură dată și folosită de toate firele de execuție pthread_barrier_init(&barrier, NULL, NUM_THREADS); // firele de execuție vor executa codul funcției 'thread_routine'. // în locul unui pointer la date utile, se trimite în ultimul argument // un întreg - identificatorul firului de execuție for (i = 0; i < NUM_THREADS; i++) pthread_create(&tids[i], NULL, thread_routine, (void *) i); // așteptăm ca toate firele de execuție să se termine for (i = 0; i < NUM_THREADS; i++) pthread_join(tids[i], NULL); // eliberăm resursele barierei pthread_barrier_destroy(&barrier); return 0; }
so@spook$ gcc -Wall barrier.c -lpthread so@spook$ ./a.out thd 0: before the barrier thd 2: before the barrier thd 1: before the barrier thd 3: before the barrier thd 4: before the barrier let the flood in thd 4: after the barrier thd 2: after the barrier thd 3: after the barrier thd 0: after the barrier thd 1: after the barrier
Pentru rezolvarea laboratorului, va rugam sa clonati repository-ul. daca il aveti deja, va rugam sa rulati git pull
.
utils
din arhivă există un fișier utils.h
cu funcții utile.
sudo apt-get install manpages-posix manpages-posix-dev
Intrați în directorul 1-th_stack
și inspectați sursa, apoi compilați și rulați programul. Urmăriți cu pmap
sau folosind procfs
cum se modifică spațiul de adresă al programului:
watch -d pmap $(pidof th_stack) watch -d cat /proc/$(pidof th_stack)/maps
Zonele de memorie cu dimensiunea de 8MB (8192KB) care se creează după fiecare apel pthread_create
reprezintă noile stive alocate de către biblioteca libpthread
pentru fiecare thread în parte. Observați că, în plus, se mai mapează de fiecare dată o pagină (4KB) cu protecția ---p
(PROT_NONE, private - vizibil în procfs
) care are rolul de "pagină de gardă".
Motivul pentru care nu se termină programul este prezența unui while(1)
în funcția thread-urilor. Folosiți Ctrl+C
pentru a termina programul.
Intrați în directorul 2-th_vs_proc
și inspectați sursele. Ambele programe simulează un server care creează fire de execuție/procese. Compilați și rulați pe rând ambele programe.
În timp ce rulează, afișați, într-o altă consolă, câte fire de execuție/procese sunt create în ambele situații folosind comanda ps -L -C <nume_program>
.
ps -L -C threads ps -L -C processes
Verificați ce se întâmplă dacă la un moment dat un fir de execuție moare (sau un proces, în funcție de ce executabil testați). Testați utilizând funcția do_bad_task
la fiecare al 4-lea fir de execuție/process.
spook
are un singur core virtual, exercițiul următor trebuie realizat pe mașina fizică pentru a permite mai multor thread-uri să ruleze în același moment de timp.
Intrați în directorul 3-safety
și inspectați sursa malloc.c
. Funcțiile thread_function
și main
NU sunt thread-safe relativ la variabilele global_storage
și function_global_storage
(revedeți semnificația lui thread safety
). Există o condiție de cursă între cele două thread-uri create la incrementarea variabilei function_global_storage
, declarată în funcția thread_function
, și o altă condiție de cursă între toate thread-urile procesului la incrementarea variabilei globale global_storage
.
helgrind
, care poate detecta automat aceste condiții de cursă. Îl putem folosi în cazul nostru așa:
valgrind --tool=helgrind ./mutex
TODO 1
: Pentru a rezolva aceste doua conditii de cursa apelati functia increase_numbers intr-un mod thread_safe cu ajutor API-ului pus la dispozitie de critical.h
În fișierul malloc.c
se creează NUM_THREADS
thread-uri care alocă memorie în 1000 runde. Sunt șanse mari ca thread-urile să execute apeluri malloc
concurente.
După ce a-ti rezolvat TODO1
, compilati și rulati de mai multe ori. Observăm că programul rulează cu succes. Pentru a face verificări suplimentare, rulăm din nou helgrind
:
valgrind --tool=helgrind ./mutex
Observăm că nici helgrind
nu raportează vreo eroare, lucru care conduce la faptul că funcția malloc
ar fi thread-safe. (chiar daca acesta nu este protejat de API-ul pus la dispozitie)
Pentru a putea fi siguri trebuie să consultăm paginile de manual și codul sursă.
Thread-safe functions
.
Funcția malloc
din implementarea GLIBC este thread-safe, lucru indicat în pagina de manual malloc(3) (al treilea paragraf din secțiunea NOTES
) și vizibil în codul sursă prin prezența câmpului mutex
în structura malloc_state.
TODO 2
: Implementati un spinlock folosindu-va de operatii atomice.
Operatiile atomice existente in standardul GCC le gasiti la __atomic functions
In fisierul critical.c trebuie sa completati in dreptul comentarilor asociate TODO 2
, avand la dispozitie hint-uri.
Testati si rulati de mai multe ori, pentru a verifica consistenta variabilei globale: global_storage, executabilul ./spin
.
Inspectați fișierul blocked.c
din directorul 4-blocked
, compilați și executați binarul (repetați până detectați blocarea programului). Programul creează două fire de execuție care caută un număr magic, fiecare în intervalul propriu (nu este neapărat necesar ca numărul să fie găsit). Fiecare fir de execuție, pentru fiecare valoare din intervalul propriu, verifică dacă este valoarea căutată:
found
pentru a înștiința și celălalt fir de execuție că a găsit numărul căutat.found
al structurii celuilalt fir de execuție, pentru a vedea dacă acesta a găsit deja numărul căutat.
Determinați cauza blocării, reparați programul și explicați soluția. Puteți utiliza helgrind
, unul din tool-urile valgrind
, pentru a detecta problema:
$ valgrind --tool=helgrind ./blocked
helgrind
, problema constă în faptul că cele două thread-uri iau cele două mutex-uri în ordinea inversă, situație foarte probabilă în a cauza un deadlock.
Aveți o funcție de inițializare pe care vreți să o apelați o singură dată. Pornind de la sursa once.c
din directorul 5-once
, asigurați-vă că funcția init_func
este apelată o singură dată. Nu aveți voie să modificați funcția init_func
sau să folosiţi pthread_once
.
Citiți despre funcționalitatea pthread_once și revedeți secțiunea despre mutex.
Dorim să testăm care varianta este mai eficientă pentru a proteja incrementarea unei variabile.
Intrați în directorul 6-spin
, inspectați și compilați sursa spin.c
. În urma compilării vor rezulta două executabile, unul care folosește un mutex pentru sincronizare, iar altul un spinlock.
Comparați timpii de execuție:
time ./mutex time ./spin