Pentru sincronizarea firelor de execuție, avem la dispoziție:

• mutex
• semafoare
• variabile de condiție
• bariere

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)

• ocuparea semforului (acquire) - decrementează contorul semaforului;
• eliberarea semaforului (release) - incrementeaza contorul semaforului.

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()

$ python3 example.py 
Thread 123145375227904 says add_counter=0
Thread 123145380483072 says subtract_counter=0
Thread 123145375227904 says add_counter=1
Thread 123145375227904 says subtract_counter=-1
Thread 123145375227904 says add_counter=2
Thread 123145380483072 says subtract_counter=-2
Thread 123145375227904 says subtract_counter=-2
Thread 123145385738240 says add_counter=3
Thread 123145380483072 says add_counter=4
Thread 123145375227904 says subtract_counter=-4

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).

În Python, o variabilă de condiție este reprezentată de clasa Condition.

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.

La crearea condiției, putem pasa constructorului ca parametru un mutex sau putem lăsa constructorul să creeze unul.

import threading
 
mutex = threading.Lock()
mutex_cond = threading.Condition (mutex)
default_mutex_cond = threading.Condition()

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.

Pentru a-și suspenda execuția și a aștepta la o variabilă condiție, un fir de execuție va apela una din funcțiile wait sau wait_for:

wait(timeout=None)
wait_for(predicate, timeout=None)

Diferența între cele două funcții este că wait așteaptă până o notificare este emisă, în timp ce wait_for așteaptă până predicatul va avea valoarea True.

Firul de execuție apelant trebuie să fi ocupat deja mutex-ul asociat, în momentul apelului. Funcția 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 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 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 debloca un singur fir de execuție blocat la o variabilă condiție se va semnaliza variabila condiție folosind notify:

notify(n=1)

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:

import threading
import time
 
mutex = threading.Lock()
cond = threading.Condition(mutex)
 
count = 0
 
def decrement_count():
    global count
    id = threading.get_ident()
    cond.acquire()
    print ('{} a blocat mutex-ul.'.format (id))
    while count == 0:
        cond.wait()
    count = count - 1
    print ('count = {}' .format(count))
    cond.release()
    print ('{} a eliberat mutex-ul.'.format(id))
 
 
def increment_count():
    global count
    id = threading.get_ident()
    if cond.acquire(blocking=False):
        print ('Mutex-ul a fost eliberat')
        print ('{} a blocat mutex-ul.'.format(id))
        count = count + 1
        cond.notify()
        print ('count = {}' .format(count))
        cond.release()
        print ('{} a eliberat mutex-ul.'.format(id))
 
t1 = threading.Thread (target=decrement_count)
t1.start()
 
time.sleep (2)
 
t2 = threading.Thread (target=increment_count)
t2.start()

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ă:

• ordinea în care sunt planificate firele de execuție nu este neapărat cea a creării lor
• ordinea în care sunt trezite firele de execuție ce așteaptă la o variabilă de condiție nu este neapărat ordinea în care acestea au intrat în așteptare.

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

• Detalii desfășurare joc.

Pentru rezolvarea laboratorului, va rugam sa clonati repository-ul. daca il aveti deja, va rugam sa rulati git pull.

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.

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.

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ă.

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ă:

• dacă da, marchează un câmp found pentru a înștiința și celălalt fir de execuție că a găsit numărul căutat.
• dacă nu, inspectează câmpul 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

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

LinuxTutorialPosixThreads

POSIX Threads Programming