Laborator 8 - Thread-uri Linux

Un fir de execuție își încheie execuția în mod automat, la sfârșitul codului firului de execuție.

==== Interacțiunea cu firele de execuție ====

Pentru a schimba informații între programul principal si alte threaduri, vom folosi modulul queue. Folosind acest modul, putem implementa o coadă în care vom plasa mesajele din partea firelor de execuție.

Modululul suportă crearea a 6 tipuri diferite de cozi:

• Queue - coadă de tip FIFO, primul element inserat în coadă va fi primul extras;
• LifoQueue - ultimul element inserat în coadă va fi primul extras;
• PriorityQueue - Fiecare element are o prioritate, pe baza căreia se alege care element va fi cel extras;
• SimpleQueue - coadă de tip FIFO cu funcționalități limitate;
• Empty - se aruncă o excepție dacă se încearcă extragerea unui element când coada e goală;
• Full - se aruncă o excepție dacă se încearcă adăugarea unui element când coada e plină.

Pentru a crea o coadă, trebuie să instanțiem una din clasele expuse de modulul queue:

import queue
 
fifo_queue = queue.Queue()
lifo_queue = queue.LifoQueue()
priority_queue = queue.PriorityQueue()

Funcțiile put și put_nowait adaugă elemente în coadă.

q.put (item, block=True, timeout=None)
q.put_nowait (item)

Funcțiile get și get_nowait extrag elemente în coadă.

q.get (block=True, timeout=None)
q.get_nowait ()

Dacă coada este goală la apelarea uneia din cele două funcții, o excepție de tipul Empty este generată.

===== Exemplu ===== Mai jos vom crea un program care generează un thread ce primește valori de la programul principal și răspunde la aceastea.

TODO - primeste hello sau goodbye si raspunde cu SDE sau class. ===== Așteptarea cozilor =====

Similar cu așteptarea firelor de execuție, putem să apelăm funcția join pe o coadă, pentru a opri execuția pogramului până toate elementele din coadă au fost procesate.

Funcția join trebuie apelată în paralel cu funcția task_done. Fiecare thread va apela această funcție pentru a semnala terminarea procesării.

==== Thread Specific Data (TSD) ====

Uneori este util ca o variabilă să fie specifică unui fir de execuție (invizibilă pentru celelalte fire). Linux permite memorarea de perechi (cheie, valoare) într-o zonă special desemnată din stiva fiecărui fir de execuție al procesului curent. Cheia are același rol pe care îl are numele unei variabile: desemnează locația de memorie la care se află valoarea.

Fiecare fir de execuție va avea propria copie a unei “variabile” corespunzătoare unei chei k, pe care o poate modifica, fără ca acest lucru să fie observat de celelalte fire, sau să necesite sincronizare. De aceea, TSD este folosită uneori pentru a optimiza operațiile care necesită multă sincronizare între fire de execuție: fiecare fir calculează informația specifică, și există un singur pas de sincronizare la sfârșit, necesar pentru reunirea rezultatelor tuturor firelor de execuție.

Cheile sunt de tipul pthread_key_t, iar valorile asociate cu ele, de tipul generic void * (pointeri către locația de pe stivă unde este memorată variabila respectivă). Descriem în continuare operațiile disponibile cu variabilele din TSD:

=== Crearea și ștergerea unei variabile ===

O variabilă se creează folosind pthread_key_create:

int pthread_key_create(pthread_key_t *key, void (*destr_function) (void *));

Al doilea parametru reprezintă o funcție de cleanup. Acesta poate avea una din valorile:

• NULL și este ignorat
• pointer către o funcție de cleanup care se execută la terminarea firului de execuție

Pentru ștergerea unei variabile se apelează pthread_key_delete:

int pthread_key_delete(pthread_key_t key);

Funcția nu apelează funcția de cleanup asociată variabilei.

=== Modificarea și citirea unei variabile ===

După crearea cheii, fiecare fir de execuție poate modifica propria copie a variabilei asociate folosind funcția pthread_setspecific:

int pthread_setspecific(pthread_key_t key, const void *pointer);

Pentru a determina valoarea unei variabile de tip TSD se folosește funcția pthread_getspecific:

void* pthread_getspecific(pthread_key_t key);

==== Funcții pentru cleanup ====

Funcțiile de cleanup asociate TSD-urilor pot fi foarte utile pentru a asigura faptul că resursele sunt eliberate atunci când un fir se termină singur sau este terminat de către un alt fir. Uneori poate fi util să se poată specifica astfel de funcții fără a crea neapărat un TSD. Pentru acest scop există funcțiile de cleanup.

void pthread_cleanup_push(void (*routine) (void *), void *arg);

void pthread_cleanup_pop(int execute);

==== Atributele unui fir de execuție ====

Atributele reprezintă o modalitate de specificare a unui comportament diferit de comportamentul implicit. Atunci când un fir de execuție este creat cu pthread_create se pot specifica atributele pentru respectivul fir de execuție. Atributele implicite sunt suficiente pentru marea majoritate a aplicațiilor. Cu ajutorul unui atribut se pot schimba:

• starea: unificabil sau detașabil
• politica de alocare a procesorului pentru firul de execuție respectiv (round robin, FIFO, sau system default)
• prioritatea (cele cu prioritate mai mare vor fi planificate, în medie, mai des)
• dimensiunea și adresa de start a stivei

Mai multe detalii puteți găsi în secțiunea suplimentară dedicată. ==== Cedarea procesorului ====

Un fir de execuție cedează dreptul de execuție unui alt fir, în urma unuia din următoarele evenimente:

• efectuează un apel blocant (cerere de I/O, sincronizare cu un alt fir de execuție) și kernel-ul decide că este rentabil să facă un context switch
• i-a expirat cuanta de timp alocată de către kernel
• cedează voluntar dreptul, folosind funcția sched_yield:

  int sched_yield(void);

Dacă există alte procese interesate de procesor, unul dintre procese va acapara procesorul, iar dacă nu există niciun alt proces în așteptare pentru procesor, firul curent își continuă execuția. ==== Alte operații ==== Dacă dorim să fim siguri că un cod de inițializare se execută o singură dată putem folosi funcția:

pthread_once_t once_control = PTHREAD_ONCE_INIT;
int pthread_once(pthread_once_t *once_control, void (*init_routine) (void));

Scopul funcției pthread_once este de a asigura că o bucată de cod (de obicei folosită pentru inițializări) se execută o singură dată. Argumentul once_control este un pointer la o variabilă inițializată cu PTHREAD_ONCE_INIT. Prima oară când această funcție este apelată ea va apela funcția init_routine și va schimba valoarea variabilei once_control pentru a ține minte că inițializarea a avut loc. Următoarele apeluri ale acestei funcții cu același once_control nu vor face nimic.

Funcția pthread_once întoarce 0 în caz de succes sau cod de eroare în caz de eșec.

Pentru a determina dacă doi identificatori se referă la același fir de execuție se poate folosi:

int pthread_equal(pthread_t thread1, pthread_t thread2);

Pentru aflarea/modificarea priorităților sunt disponibile următoarele apeluri:

int pthread_setschedparam(pthread_t target_thread, int policy, const struct sched_param *param);
int pthread_getschedparam(pthread_t target_thread, int *policy, struct sched_param *param);

==== Compilare ====

La compilare trebuie specificată și biblioteca libpthread (deci se va folosi argumentul -lpthread).

==== Exemplu ====

În continuare, este prezentat un exemplu simplu în care sunt create 2 fire de execuție, fiecare afișând un caracter de un anumit număr de ori pe ecran.

exemplu.c

#include <pthread.h>
#include <stdio.h>
 
/* parameter structure for every thread */
struct parameter {
	char character; /* printed character */
	int number;     /* how many times */
};
 
/* the function performed by every thread */
void* print_character(void *params)
{
	struct parameter *p = (struct parameter *) params;
	int i;
 
	for (i = 0; i < p->number; i++)
		printf("%c", p->character);
	printf("\n");
 
	return NULL;
}
 
int main()
{
	pthread_t fir1, fir2;
	struct parameter fir1_args, fir2_args;
 
	/* create one thread that will print 'x' 11 times */
	fir1_args.character = 'x';
	fir1_args.number = 11;
	if (pthread_create(&fir1, NULL, &print_character, &fir1_args)) {
		perror("pthread_create");
		exit(1);
	}
 
	/* create one thread that will print 'y' 13 times */
	fir2_args.character = 'y';
	fir2_args.number = 13;
	if (pthread_create(&fir2, NULL, &print_character, &fir2_args)) {
		perror("pthread_create");
		exit(1);
	}
 
	/* wait for completion */
	if (pthread_join(fir1, NULL))
		perror("pthread_join");
	if (pthread_join(fir2, NULL))
		perror("pthread_join");
 
	return 0;
}

Comanda utilizată pentru a compila acest exemplu va fi:

gcc -o exemplu exemplu.c -lpthread

====== Exerciţii de laborator ======

===== Exercițiul 0 - Joc interactiv (2p) =====

• Detalii desfășurare joc.

===== Linux (9p) =====

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

==== Exercițiul 1 - Thread Stack (2p) ====

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. ==== Exercițiul 2 - Fire de execuție vs Procese (2p) ====

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. ==== Exercițiul 3 - Thread safety (2p) ====

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.

==== Exercițiul 4 - Blocked (2p) ====

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.

==== Exercitiul 6 - Mutex vs Spinlock (1p) ====

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