Architetture dei Calcolatori e Sistemi Operativi

Transcript

1 Prof. Gerardo Pelosi & Ing. Michele Scandale 30 Ottobre 2014 Gerardo Pelosi 1

2 Esercizio 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 disegnare il grafo di attesa. pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutexb = PTHREAD_MUTEX_INITIALIZER; void *thread1(void *arg) { pthread_mutex_lock(&mutexa); pthread_mutex_lock(&mutexb); printf("thread_1\n"); pthread_mutex_unlock(&mutexb); pthread_mutex_unlock(&mutexa); return NULL; void *thread2(void *arg) { pthread_mutex_lock(&mutexb); pthread_mutex_lock(&mutexa); printf("thread_2\n"); pthread_mutex_unlock(&mutexa); pthread_mutex_unlock(&mutexb); return NULL; // main is omitted... Gerardo Pelosi <gerardo.pelosi@polimi.it> 2

3 Esercizio 1 Si può facilmente verificare che nel caso in cui thread1 prende il lock su mutexa e contemporanemante thread2 prende il lock su mutexb si ha un deadlock: infatti thread1 aspetta la risorsa mutexb la quale non è rilasciata da thread2 poichè in attesa per la risorsa mutex1. Gerardo Pelosi <gerardo.pelosi@polimi.it> 3

4 Esercizio 1 Si può facilmente verificare che nel caso in cui thread1 prende il lock su mutexa e contemporanemante thread2 prende il lock su mutexb si ha un deadlock: infatti thread1 aspetta la risorsa mutexb la quale non è rilasciata da thread2 poichè in attesa per la risorsa mutex1. Grafo di attesa Thread1 MutexA MutexB Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 3

5 Esercizio 1 Si può facilmente verificare che nel caso in cui thread1 prende il lock su mutexa e contemporanemante thread2 prende il lock su mutexb si ha un deadlock: infatti thread1 aspetta la risorsa mutexb la quale non è rilasciata da thread2 poichè in attesa per la risorsa mutex1. Grafo di attesa Thread1 locked MutexA MutexB Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 3

6 Esercizio 1 Si può facilmente verificare che nel caso in cui thread1 prende il lock su mutexa e contemporanemante thread2 prende il lock su mutexb si ha un deadlock: infatti thread1 aspetta la risorsa mutexb la quale non è rilasciata da thread2 poichè in attesa per la risorsa mutex1. Grafo di attesa Thread1 locked MutexA MutexB locked Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 3

7 Esercizio 1 Si può facilmente verificare che nel caso in cui thread1 prende il lock su mutexa e contemporanemante thread2 prende il lock su mutexb si ha un deadlock: infatti thread1 aspetta la risorsa mutexb la quale non è rilasciata da thread2 poichè in attesa per la risorsa mutex1. Grafo di attesa Thread1 locked MutexA wait MutexB locked Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 3

8 Esercizio 1 Si può facilmente verificare che nel caso in cui thread1 prende il lock su mutexa e contemporanemante thread2 prende il lock su mutexb si ha un deadlock: infatti thread1 aspetta la risorsa mutexb la quale non è rilasciata da thread2 poichè in attesa per la risorsa mutex1. Grafo di attesa Thread1 locked MutexA wait wait MutexB locked Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 3

9 Esercizio 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 disegnare il grafo di attesa. pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutexb = PTHREAD_MUTEX_INITIALIZER; void foo(int val) { pthread_mutex_lock(&mutexb); val *= 2; if(val > 4) pthread_mutex_unlock(&mutexb); void *thread1(void *arg) { pthread_mutex_lock(&mutexa); foo((int)arg); pthread_mutex_unlock(&mutexa); if((int)arg < 2) pthread_mutex_unlock(&mutexb); pthread_mutex_lock(&mutexa); printf("end of thread1\n"); pthread_mutex_unlock(&mutexa); return NULL; void *thread2(void *arg) { pthread_mutex_lock(&mutexa); pthread_mutex_lock(&mutexb); printf("end of thread2\n"); pthread_mutex_unlock(&mutexb); pthread_mutex_unlock(&mutexa); return NULL; int main() { pthread_t th1, th2; pthread_create(&th1, NULL, thread1, (void*)2); pthread_create(&th2, NULL, thread2, NULL); pthread_join(th1, NULL); pthread_join(th2, NULL); return 0; Gerardo Pelosi <gerardo.pelosi@polimi.it> 4

10 Esercizio 2 Si può notare come thread1 non rilasci il lock su mutexb, in quando arg vale 2. Quindi se thread1 prende il lock su mutexa prima di thread2 quest ultimo rimarrà bloccato per sempre. Si ha quindi un deadlock se dopo la prima sezione critica di thread1 è eseguita la sezione critica di thread2. Gerardo Pelosi <gerardo.pelosi@polimi.it> 5

11 Esercizio 2 Si può notare come thread1 non rilasci il lock su mutexb, in quando arg vale 2. Quindi se thread1 prende il lock su mutexa prima di thread2 quest ultimo rimarrà bloccato per sempre. Si ha quindi un deadlock se dopo la prima sezione critica di thread1 è eseguita la sezione critica di thread2. Grafo di attesa Thread1 MutexA MutexB Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 5

12 Esercizio 2 Si può notare come thread1 non rilasci il lock su mutexb, in quando arg vale 2. Quindi se thread1 prende il lock su mutexa prima di thread2 quest ultimo rimarrà bloccato per sempre. Si ha quindi un deadlock se dopo la prima sezione critica di thread1 è eseguita la sezione critica di thread2. Grafo di attesa Thread1 MutexA locked MutexB Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 5

13 Esercizio 2 Si può notare come thread1 non rilasci il lock su mutexb, in quando arg vale 2. Quindi se thread1 prende il lock su mutexa prima di thread2 quest ultimo rimarrà bloccato per sempre. Si ha quindi un deadlock se dopo la prima sezione critica di thread1 è eseguita la sezione critica di thread2. Grafo di attesa Thread1 MutexA locked locked MutexB Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 5

14 Esercizio 2 Si può notare come thread1 non rilasci il lock su mutexb, in quando arg vale 2. Quindi se thread1 prende il lock su mutexa prima di thread2 quest ultimo rimarrà bloccato per sempre. Si ha quindi un deadlock se dopo la prima sezione critica di thread1 è eseguita la sezione critica di thread2. Grafo di attesa Thread1 MutexA locked locked MutexB wait Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 5

15 Esercizio 2 Si può notare come thread1 non rilasci il lock su mutexb, in quando arg vale 2. Quindi se thread1 prende il lock su mutexa prima di thread2 quest ultimo rimarrà bloccato per sempre. Si ha quindi un deadlock se dopo la prima sezione critica di thread1 è eseguita la sezione critica di thread2. Grafo di attesa Thread1 wait MutexA locked locked MutexB wait Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 5

16 Esercizio 3 Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock. pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; sem_t sem; void *th_fun1(void *arg){ for (int i = 0; i < (int)arg; ++i) { pthread_mutex_lock(&mutexa); sem_wait(&sem); pthread_mutex_unlock(&mutexa); return NULL; void *th_fun2(void *arg){ for(int i = 0; i < (int)arg; ++i) { pthread_mutex_lock(&mutexa); sem_post(&sem); pthread_mutex_unlock(&mutexa); return NULL; int main() { pthread_t th1, th2; sem_init(&sem, 0, 0); pthread_create(&th1, NULL, th_fun1, (void *)3); pthread_create(&th2, NULL, th_fun2, (void *)4); pthread_join(th1, NULL); pthread_join(th2, NULL); return 0; Gerardo Pelosi <gerardo.pelosi@polimi.it> 6

17 Esercizio 3 Si può verificare un deadlock se th_fun1 esegue sem_wait quando il semaforo è ancora a zero: il lock su mutexa non verrà rilasciato, impedendo a th_fun2 di entrare nella sezione critica ed eseguire sem_post. Gerardo Pelosi <gerardo.pelosi@polimi.it> 7

18 Esercizio 3 Si può verificare un deadlock se th_fun1 esegue sem_wait quando il semaforo è ancora a zero: il lock su mutexa non verrà rilasciato, impedendo a th_fun2 di entrare nella sezione critica ed eseguire sem_post. Grafo di attesa Thread1 MutexA Sem Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 7

19 Esercizio 3 Si può verificare un deadlock se th_fun1 esegue sem_wait quando il semaforo è ancora a zero: il lock su mutexa non verrà rilasciato, impedendo a th_fun2 di entrare nella sezione critica ed eseguire sem_post. Grafo di attesa Thread1 locked MutexA Sem Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 7

20 Esercizio 3 Si può verificare un deadlock se th_fun1 esegue sem_wait quando il semaforo è ancora a zero: il lock su mutexa non verrà rilasciato, impedendo a th_fun2 di entrare nella sezione critica ed eseguire sem_post. Grafo di attesa Thread1 locked MutexA wait Sem Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 7

21 Esercizio 3 Si può verificare un deadlock se th_fun1 esegue sem_wait quando il semaforo è ancora a zero: il lock su mutexa non verrà rilasciato, impedendo a th_fun2 di entrare nella sezione critica ed eseguire sem_post. Grafo di attesa Thread1 locked MutexA wait wait Sem Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 7

22 Esercizio 3 Si può verificare un deadlock se th_fun1 esegue sem_wait quando il semaforo è ancora a zero: il lock su mutexa non verrà rilasciato, impedendo a th_fun2 di entrare nella sezione critica ed eseguire sem_post. Grafo di attesa Thread1 locked MutexA wait wait Sem Thread2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 7

23 Esercizio 4 Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock. sem_t empty1, full1, empty2, full2; int queue1, queue2; void *th_fun1(void *arg) { sem_wait(&empty1); sem_wait(&full2); queue1 = rand(); printf("queue2: %d\n", queue2); sem_post(&full1); sem_post(&empty2); return NULL; void *th_fun2(void *arg) { sem_wait(&empty2); sem_wait(&full1); queue2 = rand(); printf("queue1: %d\n", queue1); sem_post(&full2); sem_post(&empty1); return NULL; int main() { pthread_t th1, th2; sem_init(&empty1, 0, 0); sem_init(&empty2, 0, 0); sem_init(&full1, 0, 1); sem_init(&full2, 0, 1); pthread_create(&th1, NULL, th_fun1, NULL); pthread_create(&th2, NULL, th_fun2, NULL); pthread_join(th1, NULL); pthread_join(th2, NULL); return 0; Gerardo Pelosi <gerardo.pelosi@polimi.it> 8

24 Esercizio 4 I due thread entrano in deadlock poichè entrambi eseguono sem_wait rispettivamente su empty1 e empty2, i quali sono inizialmente a zero, e solo mutuamente potrebbero essere notificati. Gerardo Pelosi <gerardo.pelosi@polimi.it> 9

25 Esercizio 5 Dato il seguente programma, riempire la tabella segnando il valore delle variabili a, b, c, d, e in corrispondena degli statement indicati. Indicare i possibili valori se sono al più due, indicare UNK se i possibili valori sono più di due, UND se la variabile non è inizializzata, NE se non esiste. pthread_mutex_t mutexa = PTHREAD_MUTEX_INITIALIZER; int c = 0; int e = 0; void *th_fun1(void *arg) { int a = 0, b = (int)arg; pthread_mutex_lock(&mutexa); e = 1; // Stat. A a = b + c; // Stat. B pthread_mutex_unlock(&mutexa); // Stat. C return (void *)a; void *th_fun2(void *arg) { while (e == 0); pthread_mutex_lock(&mutexa); c = ((int)arg) * 2; pthread_mutex_unlock(&mutexa); // Stat. D return (void *)c; int main() { pthread_t th1, th2; int d; pthread_create(&th1, NULL, th_fun2, (void *)3); pthread_create(&th2, NULL, th_fun1, (void *)4); pthread_join(th1, (void *)&d); // Stat. E pthread_join(th2, (void *)&d); // Stat. F return 0; Gerardo Pelosi <gerardo.pelosi@polimi.it> 10

26 Esercizio 5 thread condizione a b c d e th_fun1 th_fun1 th_fun1 th_fun2 main main subito dopo A subito dopo B subito dopo C subito dopo D subito dopo E subito dopo F Gerardo Pelosi <gerardo.pelosi@polimi.it> 11

27 Esercizio 5 thread condizione a b c d e th_fun1 subito dopo A UND 1 th_fun1 subito dopo B UND 1 th_fun1 subito dopo C 4 4 0/6 UND/6 1 th_fun2 subito dopo D 4/NE 4/NE 6 UND 1 main subito dopo E 4/NE 4/NE main subito dopo F NE NE Gerardo Pelosi <gerardo.pelosi@polimi.it> 12

28 Esercizio 6 Considerando il seguente programma: disegnare il grafo di sincronizzazione fra i thread P0, F1, F2, N1, N2, N3, N4. In tale grafo: nodi rappresentano thread arco da T 1 a T 2 quando T 1 esegue un post su almeno un semaforo su cui T 2 è in attesa. riempire la tabella dei valori delle variabili: indicare NE se la variabile non esiste; UND se la variabile non è stata inizializzata; UNK se la variabile può avere più di un solo valore. Gerardo Pelosi <gerardo.pelosi@polimi.it> 13

29 #define NSEM 7 sem_t sem_start[nsem]; sem_t sem_stop[nsem]; int ret_status[nsem]; void *P(void *arg) { int base = (int) arg; int alpha, status, index; sem_wait(&sem_start[base]); for (alpha = 0; alpha <= 1; ++alpha) { int off = (base == 0)? 3 : 1; index = base off * alpha; sem_post(&sem_start[index]); if (alpha == 1) { sem_wait(&sem_stop[index]); status = ret_status[index]; // Stat. A index = base + 1; sem_wait(&sem_stop[index]); status = ret_status[index]; // Stat. B ret_status[base] = alpha; sem_post(&sem_stop[base]); void *N(void *arg) { int tid = (int)arg; sem_wait(&sem_start[tid]); ret_status[tid] = (tid % 2)? 4 : 3; sem_post(&sem_stop[tid]); // Stat. C int main() { pthread_t th_p0, th_f1, th_f2; pthread_t th_n1, th_n2, th_n3, th_n4; for(int i = 0; i < NSEM; ++i) { sem_init(&sem_start[i], 0, 0); sem_init(&sem_stop[i], 0, 0); srand(time(null)); pthread_create(&th_p0, NULL, P, (void *) 0); // P0 pthread_create(&th_f1, NULL, P, (void *) 1); // F1 pthread_create(&th_f2, NULL, P, (void *) 4); // F2 pthread_create(&th_n1, NULL, N, (void *) 2); // N1 pthread_create(&th_n2, NULL, N, (void *) 3); // N2 pthread_create(&th_n3, NULL, N, (void *) 5); // N3 pthread_create(&th_n4, NULL, N, (void *) 6); // N4 sem_post(&sem_start [0]); sem_wait(&sem_stop [0]); pthread_join(th_p0, NULL); pthread_join(th_f1, NULL); pthread_join(th_f2, NULL); pthread_join(th_n1, NULL); pthread_join(th_n2, NULL); pthread_join(th_n3, NULL); pthread_join(th_n4, NULL); return 0; Gerardo Pelosi <gerardo.pelosi@polimi.it> 14

30 Esercizio 6 thread condizione alpha status sem_stop[6] P0 P0 P0 F1 F1 F2 F2 subito dopo A in F1 (prima iter) subito dopo A in F2 (prima iter) subito dopo B in P0 subito dopo C in N2 subito dopo B in F1 subito dopo C in N3 subito dopo B in F2 Gerardo Pelosi <gerardo.pelosi@polimi.it> 15

31 Esercizio 6 Grafo di sincronizzazione Si può notare che ogni thread esegue sia post che wait, dunque nel grafo si avrà che ogni nodo ha archi entranti e uscenti. Analizzando i thread con funzione P si ha: sem_wait su sem_start[base], sem_stop[base (base==0? 3 : 1)], sem_stop[base + 1] sem_post su sem_start[base + 1], sem_start[base (base==0? 3 : 1)], sem_stop[base] Basta sostituire i possibili valori di base per ottenere gli archi entranti e uscenti dei relativi nodi. P0 F1 F2 N1 N2 N3 N4 Gerardo Pelosi <gerardo.pelosi@polimi.it> 16

32 Esercizio 6 La struttura di sincronizzazione è tale per cui P0, F1 ed F2 fanno partire due thread ciascuno tramite un post su un semaforo dell array sem_start, poi attendono la loro terminazione in ordine inverso (tramite un wait su un semaforo dell array sem_stop). 1 P0 fa partire F1 ed F2 e poi attende che termini prima F2 seguito da F1. 2 F1 fa partire N1 ed N2 aspettando che termini prima N2 e poi N1. 3 Infine, F2 fa partire N3 ed N4 aspettando che termini prima N4 poi N3. Notare che i valori della variabile index (usata come indice degli array di semafori); e quello della variabile ret_status[...] sono legati ai thread secondo la tabella mostrata di seguito. thread P0 F1 N1 N2 F2 N3 N4 index ret_status[index] Gerardo Pelosi <gerardo.pelosi@polimi.it> 17

33 Esercizio 6 thread condizione alpha status sem_stop[6] P0 subito dopo A in F1 (prima iter) UNK 1 UNK 2 UNK 3 P0 subito dopo A in F2 (prima iter) 1 UND 0 P0 subito dopo B in P F1 subito dopo C in N2 UNK 5 UNK 6 UNK F1 subito dopo B in F1 2 3 UNK F2 subito dopo C in N3 UNK 7 UNK 8 UNK F2 subito dopo B in F Gerardo Pelosi <gerardo.pelosi@polimi.it> 18

34 Esercizio 6 Note: 1 può valere 0 o 1. 2 può essere UND o valere lo status di ritorno di F2 che è 2. 3 può valere 0 o 1. 4 sem_wait(&sem_stop[6]) è sicuramente stata risolta quindi il semaforo vale 0. 5 il thread F1 può essere uscito dal ciclo (alfa=2) oppure no (alfa=1), come potrebbe anche aver terminato (NE). 6 potrebbe essere UND nel caso non sia ancora stata assegnata, 4 nel caso valga il ritorno di N2, 3 nel caso valga il ritorno di N1, o potrebbe valere anche NE nel caso F1 abbia già terminato. 7 N3 è l ultimo ad essere aspettato da F2 per cui alfa potrebbe assumere 3 valori (0,1,2), come potrebbe anche non esistere più (NE). 8 potrebbe essere UND, 3 nel caso valga il valore di ritorno di N4, 4 nel caso valga il valore di ritorno di N3, oppure potrebbe non esistere più (NE). 9 sem_wait(&sem_stop[6]) è sicuramente stata risolta quindi il semaforo vale 0. Gerardo Pelosi <gerardo.pelosi@polimi.it> 19

35 Esercizio 7 Si consideri il seguente programma: pthread_mutex_t elem = PTHREAD_MUTEX_INITIALIZER; sem_t check; int counter = 0; void *sequence(void *arg) { int num; printf("sequence starget.\n"); // statement A for (num = 1; num <= 3; num++) { pthread_mutex_lock(&elem); sem_post(&check); counter++; // statement B pthread_mutex_unlock(&elem); printf("sequence ended.\n"); return NULL; void *single(void *arg) { sem_wait(&check); pthread_mutex_lock(&elem); sem_wait(&check); counter --; pthread_mutex_unlock(&elem); return NULL; // statement C // statement D Gerardo Pelosi <gerardo.pelosi@polimi.it> 20

36 Esercizio 7 int main() { pthread_t T1, T2; sem_init(&check, 0, 0); pthread_create(&t2, NULL, single, (void*)1); pthread_create(&t1, NULL, sequence, NULL); pthread_join(t1); // statement E pthread_join(t2); return 0; completare la tabella indicando lo stato di esistenza della variabile locale e del parametro nell istante di tempo specificato da ciascuna condizione. Completare ogni casella con ESISTE, NON ESISTE o PUÒ ESISTERE. completare la tabella indicando i valori delle variabili globali nell istante di tempo specificato da ciascuna condizione. Usare X quando non definito, nel caso più valori sono disponibili riportarli tutti. individuare eventuali deadlock ed indicare gli statement dove si bloccano i due thread precisando anche l iterazione di T1 e i valori di counter. Gerardo Pelosi <gerardo.pelosi@polimi.it> 21

37 Esercizio 7 Tabella: Esistenza di num e arg condizione num in T1 arg in T2 subito dopo A subito dopo C subito dopo E Tabella: Valore di check e counter condizione check counter subito dopo B (num = 1) subito dopo B (num = 2) subito dopo B (num = 3) subito dopo C subito dopo D Gerardo Pelosi <gerardo.pelosi@polimi.it> 22

38 Esercizio 7 Tabella: Esistenza di num e arg condizione num in T1 arg in T2 subito dopo A esiste esiste subito dopo C può esister esiste subito dopo E non esiste può esistere Gerardo Pelosi <gerardo.pelosi@polimi.it> 23

39 Esercizio 7 Tabella: Valore di check e counter condizione check counter subito dopo B (num = 1) 1/0 1 subito dopo B (num = 2) 2/1 2 subito dopo B (num = 3) 3/2/1 3/2 subito dopo C 2/1/0 3/2/1/0 subito dopo D 1/0 2/1 Gerardo Pelosi <gerardo.pelosi@polimi.it> 24

40 Esercizio 7 È possibile avere un deadlock nell ipotesi che T1 abbia eseguito la prima iterazione rilasciando la sezione critica e T2 sia entrato nella sezione critica e abbia stia eseguendo la seconda sem_wait. In tale situazione T2 rimane bloccato su sem_wait, mentre T1 rimane bloccato su pthread_mutex_lock all inizio della seconda iterazione del ciclo. La variabile counter ha valore 1. Gerardo Pelosi <gerardo.pelosi@polimi.it> 25