Thread: sincronizzazione Esercitazioni del 16 Ottobre 2009

Transcript

1 Thread: sincronizzazione Esercitazioni del 16 Ottobre 2009 Luca Fossati, Fabrizio Castro, Vittorio Zaccaria 19 ottobre 2009

2 Sequenze di esecuzione - 2 Sequenze di esecuzione - 2 Esercizio 1 Sequenze di esecuzione - 2 Dato il seguente programma e le seguenti sequenze di esecuzione, dire quali possono essere prodotte da tale programma e quali no; si suppone sempre una esecuzione atomica dell istruzione printf. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 5 pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; 6 7 int e = 0; 8 9 void * th_fun1( void * arg){ 10 printf( X - 1\n ); 11 pthread_mutex_lock(& mutexa); 12 e = 1; 13 printf( X - 2\n ); 14 printf( X - 3\n ); 15 pthread_mutex_unlock (& mutexa); 16 printf( X - 4\n ); 17 return NULL; 18 } 19 void * th_fun2( void * arg){ 20 printf( Y - 1\n ); 21 while(e == 0) 22 ; 23 pthread_mutex_lock(& mutexa); 24 printf( Y - 2\n ); 25 pthread_mutex_unlock (& mutexa); 26 printf( Y - 3\n ); 27 return NULL; 28 } 29 int main( int argc, char * argv[]){ 30 pthread_t th1, th2; 31 int d; pthread_create(& th1, NULL, th_fun2, NULL); 34 pthread_create(& th2, NULL, th_fun1, NULL); pthread_join(th1, NULL); 37 pthread_join(th2, NULL); return 0; 40 } Con la variabile e si garantisce che la sezione critica di th_fun2 venga eseguita dopo la sezione critica di th_fun1, per cui tutte le tracce di esecuzione in cui Y-2 e eseguita dopo la sequenza X 2, X 3 sono valide. Notare che questo include anche la serializzazione del thread th_fun1 seguito dal thread th_fun2.

3 Race-Condition Race-Condition Esercizio 2 Race-Condition Identificare le race-conditions presenti nel seguente programma e modificare quest ultimo in modo tale da risolvere il seguente problema: Due persone (P1 e P2) diverse devono maneggiare due conti in banca (C1 e C2): P1 deve depositare 10 in C1 e prelevare 20 da C2; P2 deve depositare 40 in C1 e 20 in C2. Notare che i due conti in banca devono poter essere maneggiati separatamente. Risolvere il problema sostituendo a? lock o unlock e a il nome del mutex relativo. # include <stdlib.h> # include <stdio.h> # include <pthread.h> pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutexb = PTHREAD_MUTEX_INITIALIZER; int conto1 = 100; int conto2 = 100; void * persona1( void * arg){ pthread_mutex_?(& ); conto1 += 10; pthread_mutex_?(& ); pthread_mutex_?(& ); conto2 -= 20; pthread_mutex_?(& ); return NULL; } void * persona2( void * arg){ pthread_mutex_lock(& ); conto2 += 20; pthread_mutex_unlock (& ); pthread_mutex_?(& ); conto1 += 40; pthread_mutex_?(& ); return NULL; } int main( int argc, char * argv[]){ pthread_t th1, th2; pthread_create(& th1, NULL, persona1, NULL); pthread_create(& th2, NULL, persona2, NULL); pthread_join(th1, NULL); pthread_join(th2, NULL); } return 0;

4 Race-Condition Race-Condition Soluzione La race condition esiste per il fatto che entrambi i conti correnti sono modificati in parallelo da entrambe le persone. Per correggere il problema è necessario proteggere l accesso ai conti in banca con due mutex, uno per ogni conto corrente. # include <stdlib.h> # include <stdio.h> # include <pthread.h> pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutexb = PTHREAD_MUTEX_INITIALIZER; int conto1 = 100; int conto2 = 100; void * persona1( void * arg){ pthread_mutex_lock(& mutexa); conto1 += 10; pthread_mutex_unlock (& mutexa); pthread_mutex_lock(& mutexb); conto2 -= 20; pthread_mutex_unlock (& mutexb); return NULL; } void * persona2( void * arg){ pthread_mutex_lock(& mutexb); conto2 += 20; pthread_mutex_unlock (& mutexb); pthread_mutex_lock(& mutexa); conto1 += 40; pthread_mutex_unlock (& mutexa); return NULL; } int main( int argc, char * argv[]){ pthread_t th1, th2; pthread_create(& th1, NULL, persona1, NULL); pthread_create(& th2, NULL, persona2, NULL); pthread_join(th1, NULL); pthread_join(th2, NULL); } return 0;

5 Deadlock con Mutex - 1 Deadlock con Mutex - 1 Esercizio 3 Deadlock con Mutex - 1 Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock e produrre il grafo di attesa. Ricordasi che, usando i mutex, sia ha possibilità di deadlock nel caso due o più thread diversi acquisiscano due o più mutex in ordine diverso, con tali sequenze di acquisizione innestate una dentro l altra; questa è la situazione più comune, ma non l unica, attravero la quale si può avere una situazione di deadlock. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 5 pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; 6 pthread_mutex_t mutexb = PTHREAD_MUTEX_INITIALIZER; 7 8 void * thread1( void * arg){ 9 pthread_mutex_lock(& mutexa); 10 pthread_mutex_lock(& mutexb); 11 printf( Sono il thread_1\n ); 12 pthread_mutex_unlock (& mutexb); 13 pthread_mutex_unlock (& mutexa); 14 return NULL; 15 } 16 void * thread2( void * arg){ 17 pthread_mutex_lock(& mutexb); 18 pthread_mutex_lock(& mutexa); 19 printf( Sono il thread_2\n ); 20 pthread_mutex_unlock (& mutexa); 21 pthread_mutex_unlock (& mutexb); 22 return NULL; 23 } int main( int argc, char * argv[]){ 26 pthread_t th1, th2; pthread_create(& th1, NULL, thread1, NULL); 29 pthread_create(& th2, NULL, thread2, NULL); 30 pthread_join(th1, NULL); 31 pthread_join(th2, NULL); return 0; 34 } Si può facilmente identificare la situazione che porta alla generazione di un deadlock: thread1 blocca mutexa e contemporaneamente thread2 blocca mutexb; nessuno dei due thread potrà più procedere, in quanto thread1 aspetta che venga sbloccato mutexb da thread2 e thread2 che venga sbloccato mutexa da thread1.

6 Deadlock con Mutex - 2 Deadlock con Mutex - 2 Esercizio 4 Deadlock con Mutex - 2 Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock e produrre il grafo di attesa. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 5 pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; 6 pthread_mutex_t mutexb = PTHREAD_MUTEX_INITIALIZER; 7 8 void foo( int val){ 9 pthread_mutex_lock(& mutexb); 10 val *= 2; 11 if( val > 4) 12 pthread_mutex_unlock (& mutexb); 13 } void * thread1( void * arg){ 16 pthread_mutex_lock(& mutexa); 17 foo(( int) arg); /* Invocato con 2, non sblocchera mutex B */ 18 pthread_mutex_unlock (& mutexa); 19 if(( int) arg < 2) 20 pthread_mutex_unlock (& mutexb); /* non sblocca B */ 21 pthread_mutex_lock(& mutexa); /* Attende A */ 22 printf( Sono alla fine del thread1\n ); 23 pthread_mutex_unlock (& mutexa); 24 return NULL; 25 } 26 void * thread2( void * arg){ 27 pthread_mutex_lock(& mutexa); 28 pthread_mutex_lock(& mutexb); /* Attesa infinita su B */ 29 printf( Sono alla fine del thread2\n ); 30 pthread_mutex_unlock (& mutexb); 31 pthread_mutex_unlock (& mutexa); 32 return NULL; 33 } int main( int argc, char * argv[]){ 36 pthread_t th1, th2; pthread_create(& th1, NULL, thread1, ( void *) 2); 39 pthread_create(& th2, NULL, thread2, NULL); 40 pthread_join(th1, NULL); 41 pthread_join(th2, NULL); return 0; 44 }

7 Deadlock con Semafori - 1 Deadlock con Semafori - 1 Questo programma è stato chiaramente strutturato male, in quanto thread1 non libererà mai la risorsa mutexb nel caso l argomento val della funzione foo sia uguale a 2. In questo caso, se thread1 blocca mutexb prima che lo faccia thread2, quest ultimo resterà bloccato in attesa che venga liberato, cosa che non accadrà mai. Il grafo di attesa e mostrato in figura 1. Figura 1: Grafo di attesa. Esercizio 5 Deadlock con Semafori - 1 Un deadlock dovuto ad accesso sincronizzato alle risorse puo in generale verificarsi se: Mutua esclusione: almeno una delle risorse del sistema deve essere non condivisibile (ossia usata da un processo alla volta oppure libera). Possesso ed attesa: i processi che possiedono almeno una risorsa, devono attendere prima di richiederne altre (gia allocate ad altri processi). Impossibilita di prelazione: solo il processo che detiene la risorsa puo rilasciarla. Attesa circolare. Un semaforo puo essere visto come un tipo particolare di risorsa quando e usato come un mutex (range contatore 0,1). Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock e produrre il grafo di attesa. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 # include <semaphore.h> 5 6 pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; 7 sem_t sem; 8 9 int c,e = 0;

8 Deadlock con Semafori - 1 Deadlock con Semafori void * th_fun1( void * arg){ 12 int i = 0; 13 for(i = 0; i < ( int) arg; i++){ 14 pthread_mutex_lock(& mutexa); 15 sem_wait(& sem); 16 pthread_mutex_unlock (& mutexa); 17 } 18 return NULL; 19 } 20 void * th_fun2( void * arg){ 21 int i = 0; 22 for(i = 0; i < ( int) arg; i++){ 23 pthread_mutex_lock(& mutexa); 24 sem_post(& sem); 25 pthread_mutex_unlock (& mutexa); 26 } 27 return NULL; 28 } 29 int main( int argc, char * argv[]){ 30 pthread_t th1, th2; sem_init(& sem, 0, 0); 33 pthread_create(& th1, NULL, th_fun1, ( void *) 3); 34 pthread_create(& th2, NULL, th_fun2, ( void *) 4); pthread_join(th1, NULL); 37 pthread_join(th2, NULL); return 0; 40 } É presente un deadlock nel caso l istruzione sem_wait si blocca perchè il semaforo è vuoto; in una tale situazione, th_fun1 aspetta th_fun2, ma, nello stesso momento, th_fun2 è bloccato in attesa che mutexa venga rilasciato da th_fun1. Il grafo di attesa e mostrato in figura 2. Figura 2: Grafo di attesa.

9 Deadlock con Semafori - 2 Deadlock con Semafori - 2 Esercizio 6 Deadlock con Semafori - 2 Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock e produrre il grafo di attesa. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 # include <semaphore.h> 5 6 sem_t sem_vuoto1; 7 sem_t sem_pieno1; 8 9 sem_t sem_vuoto2; 10 sem_t sem_pieno2; int coda1; 13 int coda2; void * th_fun1( void * arg){ 16 sem_wait(& sem_vuoto1); 17 sem_wait(& sem_pieno2); 18 coda1 = rand(); 19 printf( Il valore della coda2 e %d\n, coda2); 20 sem_post(& sem_pieno1); 21 sem_post(& sem_vuoto2); 22 return NULL; 23 } 24 void * th_fun2( void * arg){ 25 sem_wait(& sem_vuoto2); 26 sem_wait(& sem_pieno1); 27 coda2 = rand(); 28 printf( Il valore della coda1 e %d\n, coda1); 29 sem_post(& sem_pieno2); 30 sem_post(& sem_vuoto1); 31 return NULL; 32 } 33 int main( int argc, char * argv[]){ 34 pthread_t th1, th2; sem_init(& sem_vuoto1, 0, 0); 37 sem_init(& sem_vuoto2, 0, 0); 38 sem_init(& sem_pieno1, 0, 1); 39 sem_init(& sem_pieno2, 0, 1); 40 pthread_create(& th1, NULL, th_fun1, ( void *) 3); 41 pthread_create(& th2, NULL, th_fun2, ( void *) 4); pthread_join(th1, NULL); 44 pthread_join(th2, NULL); return 0;

10 Deadlock con Semafori - 3 Deadlock con Semafori } Nessuno dei due thread riesce a procedere in quanto entrambi devono aspettare che l altro thread faccia l incremento di sem_vuoto. Esercizio 7 Deadlock con Semafori - 3 Indicare se nell esercizio 5 sono presenti deadlock se il semaforo e inizializzato a 1. Esercizio 8 Valore Variabili - 1 Dato il seguente programma, riempire la tabella in figura 3 segnando il valore delle variabili in corrispondenza degli statement indicati. Il valore di una variabile puo essere indicato come: Intero, carattere, stringa, se univocamente individuabile. NE: se la variabile non esiste. UND: se la variabile esiste ma non e stata ancora inizializzata. Nel caso in cui una variabile puo avere massimo due valori V1 e V2 indicare il valore come V1/V2. Per i casi in cui la variabile puo avere piu di due valori utilizzare il simbolo UNK. Con l etichetta Dopo Linea X si intende il valore (o i valori) assumibili dalla variabile tra lo statement X e lo statement next(x) all interno dello stesso thread. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 5 pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; 6 7 int c = 0, e = 0; 8 9 void * th_fun1( void * arg){ 10 int a = 0, b = ( int) arg; 11 pthread_mutex_lock(& mutexa); 12 e = 1; 13 a = b + c; 14 pthread_mutex_unlock (& mutexa); 15 return ( void *) a; 16 } 17 void * th_fun2( void * arg){ 18 while(e == 0) 19 ; 20 pthread_mutex_lock(& mutexa); 21 c = (( int) arg)*2;

11 Valore Variabili - 2 Valore Variabili pthread_mutex_unlock (& mutexa); 23 return ( void *) c; 24 } 25 int main( int argc, char * argv[]){ 26 pthread_t th1, th2; 27 int d; pthread_create(& th1, NULL, th_fun1, ( void *) 3); 30 pthread_create(& th2, NULL, th_fun2, ( void *) 4); pthread_join(th1, (void *)&d); 33 pthread_join(th2, (void *)&d); return 0; 36 } Thread Dopo Linea Valore delle Variabili a b c d e th1 12 th1 13 th1 14 th2 22 main 32 main 33 Figura 3: Tabella iniziale. Thread Dopo Linea Valore delle Variabili a b c d e th UND 1 th UND 1 th (prima di riga 21)/8 (dopo) UND 1 th2 22 3/NE 3 /NE 8 UND/3 1 main 32 NE NE 0 (prima di riga 21)/8 (dopo) 3 1 main 33 NE NE Figura 4: Tabella finale coi valori delle variabili. Esercizio 9 Valore Variabili - 2 Dato il seguente programma: disegnare un grafo di sincronizzazione fra i thread (P0, F1, F2, N1, N2, N3, N4). Il grafo di sincronizzazione è composto da:

12 Valore Variabili - 2 Valore Variabili - 2 cerchi, rappresentanti i thread; frecce uni-direzionali, da un thread T1 ad un thread T2, quando T1 esegue un post su almeno uno dei semafori su cui T2 è in attesa; frecce bi-direzionali, tra un thread T1 e un thread T2, quando T1 esegue un post su almeno uno dei semafori su cui T2 è in attesa e, viceversa, T2 esegue un post su almeno uno dei semafori su cui T1 è in attesa. riempire la tabella dei valori delle variabili (Figura 5) segnando il valore di ciascuna variabile in corrispondenza degli statement indicati. Il valore di una variabile o semaforo può essere indicato come: Intero, carattere, stringa, se univocamente individuabile. NE: se la variabile non esiste. UND: se la variabile esiste ma non è stata ancora inizializzata. UNK: se la variabile può avere più di uno valore. Prestare attenzione all etichetta Condizione. In particolare, con Subito dopo statement X si intende il valore (o i valori) assumibili dalle variabili tra lo statement X e lo statement immediatamente successivo all interno del thread indicato nella condizione stessa. 1 # include <stdlib.h> 2 # include <stdio.h> 3 # include <pthread.h> 4 # include <semaphore.h> 5 6 # define NSEM 7 7 # define DELAY sleep( rand()%2) sem_t sem_start[ NSEM]; 11 sem_t sem_stop[ NSEM]; 12 int ret_status[ NSEM]; void *P( void * arg) 15 { 16 int base = ( int) arg; 17 int alfa; 18 int status; 19 int index; 20 sem_wait(&sem_start[base]); 21 for( alfa =0; alfa <=1; alfa ++) 22 { 23 int off = ( base ==0)? 3 : 1; 24 index = base +1+ off* alfa; 25 sem_post(&sem_start[index]); 26 if( alfa ==1)

13 Valore Variabili - 2 Valore Variabili { 28 sem_wait(&sem_stop[index]); 29 status = ret_status[ index]; 30 } /* STATEMENT A */ 31 } 32 index = base + 1; 33 sem_wait(&sem_stop[index]); 34 status = ret_status[ index]; /* STATEMENT B */ 35 ret_status[ base]= ( alfa); 36 sem_post(&sem_stop[base]); 37 } void *N( void * arg) 40 { 41 int tid= ( int) arg; 42 sem_wait(& sem_start[( int) tid]); 43 ret_status[ tid]= ( tid % 2)? 4 : 3; 44 sem_post(& sem_stop[( int) tid]); /* STATEMENT C */ 45 } int main( int argc, char * argv[]){ 49 pthread_t th_p, th_f1, th_f2; 50 pthread_t th_n1, th_n2, th_n3, th_n4; 51 int i; 52 for(i=0; i<nsem;i++) 53 { 54 sem_init(& sem_start[i],0,0); 55 sem_init(& sem_stop[i],0,0); 56 } 57 srand(time(null)); pthread_create(& th_p0, NULL, P, ( void *) 0); /* P0 */ 60 pthread_create(& th_f1, NULL, P, ( void *) 1); /* F1 */ 61 pthread_create(& th_f2, NULL, P, ( void *) 4); /* F2 */ pthread_create(& th_n1, NULL, N, ( void *) 2); /* N1 */ 64 pthread_create(& th_n2, NULL, N, ( void *) 3); /* N2 */ 65 pthread_create(& th_n3, NULL, N, ( void *) 5); /* N3 */ 66 pthread_create(& th_n4, NULL, N, ( void *) 6); /* N4 */ sem_post(& sem_start [0]); 69 sem_wait(& sem_stop [0]); pthread_join( th_p0, NULL); 72 pthread_join( th_f1, NULL); 73 pthread_join( th_f2, NULL); pthread_join( th_n1, NULL); 76 pthread_join( th_n2, NULL); 77 pthread_join( th_n3, NULL);

14 Valore Variabili - 2 Valore Variabili pthread_join( th_n4, NULL); return 0; 81 } Thread Thread ID Condizione Variabili alfa status sem_stop[6] P0 th_p0 subito dopo statement A in F1 (prima iterazione) P0 th_p0 subito dopo statement A in F2 (prima iterazione) P0 th_p0 subito dopo statement B F1 th_f1 subito dopo statement C in N2 F1 th_f1 subito dopo statement B F2 th_f2 subito dopo statement C in N3 F2 th_f2 subito dopo statement B Figura 5: Tabella dei valori delle variabili. Soluzione Grafo di sincronizzazione. Il grafo connette con delle freccie bi-direzionali P0 a (F1, F2), F2 a (N1, N2) ed F3 a (N3, N4), ed è mostrato in Figura 6. Figura 6: Grafo di sincronizzazione. Notare che gli indici index all interno dell array dei semafori e lo stato di ritorno (ret_status) sono legati ai thread secondo la tabella in Figura 7. La struttura di sincronizzazione in pratica è tale per cui P0, F1 ed F2 fanno partire due thread ciascuno tramite un post sul semaforo sem_start, aspettando la loro terminazione in ordine inverso (attesa su sem_stop). Quindi, P0 fa partire F1 ed F2 e poi attende che termini prima F2 seguito da F1. F1 fa partire N1 ed N2 aspettando che termini prima N2 e poi N1. Infine F2 fa partire N3 ed N4 aspettando che termini prima N4 poi N3.

15 Valore Variabili - 2 Valore Variabili - 2 thread P0 F1 N1 N2 F2 N3 N4 index ret_status Figura 7: Indice e stato di ritorno di ciascun thread. Valore delle variabili. La soluzione sara disponibile venerdi 23 ottobre.