Esercizi di mutua esclusione e sincronizzazione
|
|
|
- Barbara Venturini
- 5 anni fa
- Visualizzazioni
Transcript
1 Esercizi di mutua esclusione e sincronizzazione Alessandro A. Nacci alessandro.nacci@polimi.it ACSO 2014/2014 1
2 Chi sono Dottorando in Ingegneria Informatica (3 anno) Il vostro esercitatore di ACSO per quest anno Lavoro al NECSTLab & JOL Contattatemi per Il materiale del corso sarà disponibile su 2
3 3
4 Thread: cosa sono Nell ambito di un processo è possibile attivare diversi flussi di controllo, detti thread, che procedono in parallelo tra loro I thread di uno stesso processo condividono lo spazio di indirizzamento e altre risorse. Normalmente la creazione e gestione di un thread da parte del Sistema Operativo è meno costosa, in termini di risorse quali il tempo macchina, della creazione e gestione di un processo. 4
5 Thread e SO Thread 1 Thread 2 Thread 3 Thread.. Thread 1 Thread 2 Thread 3 Thread.. Processo Processo 2 Processo Processo 2 Processo Processo 3 Processo Processo 3 Processo 1 Processo Processo 4 Processo 1 Processo Processo 4 Sistema Operativo Sistema Operativo (a) User-Level (b) Kernel-Level User Level: il sistema operativo ha conoscenza solamente dell esistenza dei processi; i thread esistono all interno del processo e sono ad esso strettamente collegati: se uno di questi thread si blocca (per esempio in attesa di una operazione di I/O) tutto il processo viene bloccato, inclusi gli altri thread che lo compongono. Siccome il processo viene visto dal sistema operativo come una unità atomica e indivisibile, non è possibile, nel caso di sistemi multi-processore, eseguire in contemporanea su processori diversi thread appartenenti allo stesso processo. La gestione di tali thread ha un costo inferiore rispetto ai thread kernel-level in quanto non passa attraverso il sistema operativo. 5 Kernel Level: il sistema operativo ha diretta conoscenza dell esistenza dei thread, che possono essere, di conseguenza, gestiti separatamente dallo stesso: (a) un thread si può porre in attesa di un evento (e.g. I/O) e gli altri thread del processo continuano la loro esecuzione, (b) in un sistema multiprocessore (come quasi tutti i normali PC al giorno d oggi) thread di uno stesso processo possono essere mandati in esecuzione in contemporanea, (c) etc. La gestione di questi thread richiede il passaggio attraverso il sistema operativo quindi, come vedrete in seguito nel corso, ha associato un costo non indi erente in termini di prestazioni.
6 Thread: usiamoli PThread: Principali Funzioni int pthread create(pthread t *thread, const pthread attr t *attr, void *(*start routine) (void *), void *arg); int pthread join(pthread t thread, void **retval); 6
7 Esercizio 1 Scrivere un programma che faccia partire tre thread: il secondo e il terzo possono partire solamente dopo la terminazione del primo. Tutti e tre i thread stampano a schermo il loro identificatore usando la funzione pthread t pthread self(void). 7
8 Esercizio 1 Scrivere un programma che faccia partire tre thread: il secondo e il terzo possono partire solamente dopo la terminazione del primo. Tutti e tre i thread stampano a schermo il loro identificatore usando la funzione pthread t pthread self(void). #i n c l u d e < stdlib.h> #i n c l u d e <stdio.h> #i n c l u d e <pthread.h> void th fun(void arg){ printf( %d\n, pthread self ()); int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, th fun, NULL) ; pthread join(th1, NULL); pthread create(&th2, NULL, th fun, NULL) ; pthread create(&th3, NULL, th fun, NULL) ; return 0; 7
9 Esercizio 1 Scrivere un programma che faccia partire tre thread: il secondo e il terzo possono partire solamente dopo la terminazione del primo. Tutti e tre i thread stampano a schermo il loro identificatore usando la funzione pthread t pthread self(void). #i n c l u d e < stdlib.h> #i n c l u d e <stdio.h> #i n c l u d e <pthread.h> void th fun(void arg){ printf( %d\n, pthread self ()); int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, th fun, NULL) ; pthread join(th1, NULL); pthread create(&th2, NULL, th fun, NULL) ; pthread create(&th3, NULL, th fun, NULL) ; Soluzione errata: il flusso di esecuzione principale (main) potrebbe terminare prima che siano terminati i thread 2 e 3, impedendo quindi una loro corretta esecuzione. return 0; 7
10 Esercizio 1 Soluzione Scrivere un programma che faccia partire tre thread: il secondo e il terzo possono partire solamente dopo la terminazione del primo. Tutti e tre i thread stampano a schermo il loro identificatore usando la funzione pthread t pthread self(void). void th fun(void arg){ printf( %d\n, pthread self ()); int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, th fun, NULL) ; pthread join(th1, NULL); pthread create(&th2, NULL, th fun, NULL) ; pthread create(&th3, NULL, th fun, NULL) ; pthread join(th2, NULL); pthread join(th3, NULL); Soluzione corretta:è necessario usare la funzione join anche per i thread 2 e 3, in modo tale da assicurazione che il il flusso di esecuzione principale (main) non termini prima dei thread da lui creati. return 0; 8
11 Esercizio 2 Scrivere un programma che crei due thread per accellerare il calcolo del fattoriale del numero specificato alla riga di comando del programma stesso. Come possiamo accelerare il calcolo del fattoriale? 9
12 Esercizio 2 Scrivere un programma che crei due thread per accellerare il calcolo del fattoriale del numero specificato alla riga di comando del programma stesso. Come possiamo accelerare il calcolo del fattoriale? n! =n (n 1) (n 2) (n 3)... 1 n! =n (n 1) (n 2)... ( n 2 ) (n 2 1) (n 2 2)... 1 Fino a n/2 Da n/2 a 1 Possono andare in parallelo 9
13 Esercizio 2 Fattoriale parziale Vogliamo un funzione che dato in ingresso un numero di partenza n_start dato in ingresso un numero di arrivo n_end restituisca il parziale del fattoriale tra n_start ed n_end int calcolapazialefattoriale(int start, int end) { int fattoriale = 1; int i; for (i = start; i <= end; i++) { fattoriale += i; return fattoriale; 10
14 Esercizio 2 Fattoriale parziale Vogliamo un funzione che dato in ingresso un numero di partenza n_start dato in ingresso un numero di arrivo n_end restituisca il parziale del fattoriale tra n_start ed n_end int calcolapazialefattoriale(int start, int end) { int fattoriale = 1; int i; for (i = start; i <= end; i++) { fattoriale += i; return fattoriale; 10
15 Esercizio 2 Ma con i thread La funzione implementata non può essere associata al alcun thread poiché non ne rispetta l interfaccia void fact(void arg){ int fattoriale = 1; int i = 0; for(i = ((num )arg) >start ; i <= ((num )arg) >end ; i++){ fattoriale = i ; return ( void ) fattoriale; { 11
16 Esercizio 2 Ma con i thread La funzione implementata non può essere associata al alcun thread poiché non ne rispetta l interfaccia typedef struct num { int start, end; num ; void fact(void arg){ int fattoriale = 1; int i = 0; for(i = ((num )arg) >start ; i <= ((num )arg) >end ; i++){ fattoriale = i ; return ( void ) fattoriale; { 11
17 Esercizio 2 Ma con i thread La funzione implementata non può essere associata al alcun thread poiché non ne rispetta l interfaccia typedef struct num { int start, end; num ; void fact(void arg){ int fattoriale = 1; int i = 0; for(i = ((num )arg) >start ; i <= ((num )arg) >end ; i++){ fattoriale = i ; return ( void ) fattoriale; { 11
18 Esercizio 2 Pensiamo al main() int main( int argc, char argv []) { pthread t th1, th2 ; long fattoriale1 = 0, fattoriale2 = 0; num t h arg1, th arg2 ; th arg1. start = 1; th arg1.end = atoi (argv [1]) /2; th arg2. start = atoi (argv [1])/2 + 1; th arg2.end = atoi (argv [1]) ; pthread create(&th1, NULL, fact, (void )&th arg1); pthread create(&th2, NULL, fact, (void )&th arg2); pthread join(th1, (void )&f a t t o r i a l e 1 ) ; pthread join(th2, (void )&f a t t o r i a l e 2 ) ; argv[1] è il primo valore passato come parametro all esecuzione del programma!./mioprogramma 4 argv[1] = 4 printf( Il fattoriale del numero %d e %ld\n, atoi ( argv [1]), fattoriale1 fattoriale2); return 0; 12
19 Esercizio 2 Pensiamo al main() int main( int argc, char argv []) { pthread t th1, th2 ; long fattoriale1 = 0, fattoriale2 = 0; num t h arg1, th arg2 ; th arg1. start = 1; th arg1.end = atoi (argv [1]) /2; th arg2. start = atoi (argv [1])/2 + 1; th arg2.end = atoi (argv [1]) ; pthread create(&th1, NULL, fact, (void )&th arg1); pthread create(&th2, NULL, fact, (void )&th arg2); pthread join(th1, (void )&f a t t o r i a l e 1 ) ; pthread join(th2, (void )&f a t t o r i a l e 2 ) ; argv[1] è il primo valore passato come parametro all esecuzione del programma!./mioprogramma 4 argv[1] = 4 printf( Il fattoriale del numero %d e %ld\n, atoi ( argv [1]), fattoriale1 fattoriale2); return 0; 12
20 Esercizio 2 Pensiamo al main() int main( int argc, char argv []) { pthread t th1, th2 ; long fattoriale1 = 0, fattoriale2 = 0; num t h arg1, th arg2 ; th arg1. start = 1; th arg1.end = atoi (argv [1]) /2; th arg2. start = atoi (argv [1])/2 + 1; th arg2.end = atoi (argv [1]) ; pthread create(&th1, NULL, fact, (void )&th arg1); pthread create(&th2, NULL, fact, (void )&th arg2); pthread join(th1, (void )&f a t t o r i a l e 1 ) ; pthread join(th2, (void )&f a t t o r i a l e 2 ) ; argv[1] è il primo valore passato come parametro all esecuzione del programma!./mioprogramma 4 argv[1] = 4 printf( Il fattoriale del numero %d e %ld\n, atoi ( argv [1]), fattoriale1 fattoriale2); return 0; 12
21 Esercizio 2 Pensiamo al main() int main( int argc, char argv []) { pthread t th1, th2 ; long fattoriale1 = 0, fattoriale2 = 0; num t h arg1, th arg2 ; th arg1. start = 1; th arg1.end = atoi (argv [1]) /2; th arg2. start = atoi (argv [1])/2 + 1; th arg2.end = atoi (argv [1]) ; pthread create(&th1, NULL, fact, (void )&th arg1); pthread create(&th2, NULL, fact, (void )&th arg2); pthread join(th1, (void )&f a t t o r i a l e 1 ) ; pthread join(th2, (void )&f a t t o r i a l e 2 ) ; argv[1] è il primo valore passato come parametro all esecuzione del programma!./mioprogramma 4 argv[1] = 4 printf( Il fattoriale del numero %d e %ld\n, atoi ( argv [1]), fattoriale1 fattoriale2); return 0; 12
22 Esercizio 2 Pensiamo al main() int main( int argc, char argv []) { pthread t th1, th2 ; long fattoriale1 = 0, fattoriale2 = 0; num t h arg1, th arg2 ; th arg1. start = 1; th arg1.end = atoi (argv [1]) /2; th arg2. start = atoi (argv [1])/2 + 1; th arg2.end = atoi (argv [1]) ; pthread create(&th1, NULL, fact, (void )&th arg1); pthread create(&th2, NULL, fact, (void )&th arg2); pthread join(th1, (void )&f a t t o r i a l e 1 ) ; pthread join(th2, (void )&f a t t o r i a l e 2 ) ; argv[1] è il primo valore passato come parametro all esecuzione del programma!./mioprogramma 4 argv[1] = 4 printf( Il fattoriale del numero %d e %ld\n, atoi ( argv [1]), fattoriale1 fattoriale2); return 0; 12
23 Esercizio 2 Considerazioni Notate come sia fondamentale dichiarare fattoriale1 e fattoriale2 come long e non come int Questo garantisce correttezza di funzionamento anche su sistemi a 64bit, dove i puntatori puntano a celle di memoria grandi 64bit 13
24 Thread e scope delle variabili Lo scoping delle variabili all interno dei thread funziona in modo analogo a quanto succede per le normali funzioni, con l unica di erenza che esistono più pile, una per ogni thread; per quanto riguarda lo heap e le variabili globali, invece è presenta una sola area che li contiene, condivisa tra tutti i thread del processo. REGOLE IMPORTANTI! Stesso heap tra thread differenti Stesse variabili globali tra thread differenti Stack differenti tra thread differenti 14
25 Esercizio 3 Descrizione output programma int valore = 0; void somma( void arg){ int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); return 0; 15
26 Esercizio 3 Descrizione output programma int valore = 0; void somma( void arg){ int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); > thread: valore = 3 pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); return 0; 15
27 Esercizio 3 Descrizione output programma int valore = 0; void somma( void arg){ int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); > thread: valore = 3 > thread: valore = 7 pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); return 0; 15
28 Esercizio 3 Descrizione output programma int valore = 0; void somma( void arg){ int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); > thread: valore = 3 > thread: valore = 7 > thread: valore = 12 return 0; 15
29 Esercizio 3 Descrizione output programma int valore = 0; void somma( void arg){ int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); > thread: valore = 3 > thread: valore = 7 > thread: valore = 12 return 0; 15
30 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); return 0; 16
31 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); > thread: valore = 3 pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); return 0; 16
32 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); > thread: valore = 3 > thread: valore = 4 pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); return 0; 16
33 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); > thread: valore = 3 > thread: valore = 4 > thread: valore = 5 return 0; 16
34 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); > thread: valore = 3 > thread: valore = 4 > thread: valore = 5 return 0; 16
35 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1, NULL); pthread create(&th2, NULL, somma, (void )4); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); > thread: valore = 3 SERVONO LE JOIN IN QUESTO > thread: CASO? valore = 4 > thread: valore = 5 return 0; 16
36 Esercizio 4 Descrizione output programma void somma( void arg){ int valore = 0; int i = 0; for(i = 0; i < ( int)arg; i++){ valore++; printf( thread: valore = %d\n, valore ) ; return NULL ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; int main( int argc, char argv []) { pthread t th1, th2, th3 ; pthread create(&th1, NULL, somma, (void )3); pthread join(th1 pthread, NULL); join(th3, NULL); pthread create(&th2, NULL, somma, (void )4); return 0; pthread join(th2, NULL); pthread create(&th1, NULL, somma, (void )3); pthread create(&th2, NULL, somma, (void )4); pthread create(&th3, NULL, somma, (void )5); pthread join(th1, NULL); pthread join(th2, NULL); pthread create(&th3, NULL, somma, (void )5); pthread join(th3, NULL); > thread: valore = 3 SERVONO LE JOIN IN QUESTO > thread: CASO? valore = 4 > thread: valore = 5 return 0; 16
37 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
38 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
39 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
40 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
41 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
42 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
43 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
44 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 Esercizio 5 Valore delle variabili FATTO A LEZIONE 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 c = a a; 11 return ( void )a; int main( int argc, char argv []) { 14 p t h r e a d t th1, th2, th3 ; 15 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 18 p t h r e a d join(th1, (void )&d) ; 19 p t h r e a d create(&th2, NULL, th fun, (void )d); 20 p t h r e a d join(th2, (void )&d) ; 21 p t h r e a d create(&th3, NULL, th fun, (void )d); 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 15 unk unk 0 unk unk Dopo Linea 10 (dopo instr. 17) unk 3 18 unk unk 9 3 unk 10 (dopo instr. 19) unk unk unk 10 (dopo instr. 21) * unk unk 156* unk
45 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
46 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
47 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
48 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
49 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
50 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
51 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
52 Esercizio 6 Valore delle variabili 1 #i n c l u d e < stdlib.h> 2 #i n c l u d e <stdio.h> Dopo Linea 3 #i n c l u d e <pthread.h> 4 5 int c = 0; 6 7 void th fun(void arg){ 8 int a = 0, b = ( int)arg; 9 a = b + c; 10 return ( void )a; int main( int argc, char argv []) { 13 p t h r e a d t th1, th2, th3 ; 14 long d; p t h r e a d create(&th1, NULL, th fun, (void )3); 17 p t h r e a d create(&th2, NULL, th fun, (void )4); 18 p t h r e a d create(&th3, NULL, th fun, (void )5); p t h r e a d join(th1, (void )&d) ; 21 p t h r e a d join(th2, (void )&d) ; 22 p t h r e a d join(th3, (void )&d) ; return 0; Valore delle Variabili a b c d arg 14 unk unk 0 unk unk 9(inthread1) unk 3 9(inthread2) unk 4 9(inthread3) unk 5 20 unk unk 0 3 unk 21 unk unk 0 4 unk 22 unk unk 0 5 unk
53 Mutex & Deadlock I mutex (mutual exclusion) sono un procedimento di sincronizzazione fra processi o thread concorrenti, con il quale si impedisce che più task paralleli accedano contemporaneamente ai dati in memoria o ad altre risorse sogge;e a race condition (o corsa critica).! 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, a;raverso la quale si può avere una situazione di deadlock. 19
54 Esercizio 7 Trova il Deadlock Traccia dell esercizio: Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock. FATTO A LEZIONE 20
55 Esercizio 7 Trova il Deadlock Traccia dell esercizio: Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare la sequenza di istruzioni che porta alla situazione di deadlock. FATTO A LEZIONE Soluzione: thread1 blocca mutexa e contemporaneamente thread2 blocca mutexb; nessuno dei due thread potrà più procedere, in quanto thread1 aspeba che thread2 sblocchi mutexb e thread2 aspeba che thread1 sblocchi mutexa. 20
56 I rebangoli sono i threads Esercizio 7 Grafo di attesa FATTO A LEZIONE I cerchi sono le risorse Una freccia da un thread ad una risorsa indica che il thread è in abesa della risorsa (Fig. 1) Una freccia da una risorsa ad un thread indica che la risorsa è bloccata da un thread (Fig. 2) Thread Risorsa Thread Risorsa th1 mutexa NEL NOSTRO ESEMPIO mutexb th2 21
57 Esercizio 8 Trova il Deadlock (2) 22
58 Esercizio 8 Trova il Deadlock (2) Questo programma è stato chiaramente strutturato male, in quanto la funzione thread1 non libererà mai la risorsa mutexb nel caso l argomento val della funzione foo sia uguale a 2. In questo caso, se la funzione thread1 blocca mutexb prima che lo faccia la funzione thread2, quest ultima resterà bloccata in attesa che mutexb venga liberato, cosa che non accadrà mai. Il grafo di attesa è rappresentato in Figura 4. th1 mutexa 22 mutexb th2
59 Semafori Un semaforo è una variabile intera! 1. sem_init( ) inizializza il semaforo ad un valore 2. sem_wait( ) decrementa il valore del semaforo di 1 1. se il valore già 0 il thread viene bloccato 2. il valore del semaforo può essere negativo (quanti sono in a;esa) 3. sem_post( ) incrementa il valore del semaforo di 1 1. se ci sono thread in abesa sul semaforo, uno di questi viene sbloccato Il valore di un semaforo può essere interpretato nel modo seguente: 1. se il valore è positivo, rappresenta il numero di thread che lo possono decrementare senza andare in abesa 2. se è negativo, rappresenta il numero di thread che sono bloccati in abesa 3. se è 0 indica che non ci sono thread in abesa, ma il prossimo thread che eseguirà una wait andrà in abesa. 23
60 Esercizio 9 24
61 Esercizio 9 24
62 Esercizio 10 Trova il Deadlock (3)
63 Esercizio 10 Trova il Deadlock (3)
64 Esercizio 11 Valore delle variabili 26
65 Esercizio 11 Valore delle variabili 26
66 Esercizio 11 Valore delle variabili 26
67 Esercizio 11 Valore delle variabili 26
68 Esercizio 11 Valore delle variabili 26
69 Esercizio 11 Valore delle variabili 26
70 Esercizio 11 Valore delle variabili 26
71 Esercizio 12 Produttore/Consumatore Aspetta che sia vuoto Notifica che ora è pieno Aspetta che sia pieno Notifiche che ora è vuoto VERSIONE ERRATA 27
72 Esercizio 12 Barriera Si consideri il seguente problema (problema della barriera): un numero T di thread deve sincronizzarsi in un punto, cioè ogni thread deve arrivare a un punto (punto di sincronizzazione) dove deve attendere che tutti gli altri thread siano arrivati al loro punto di sincronizzazione. 28
73 Esercizio 12 Barriera Si consideri il seguente problema (problema della barriera): un numero T di thread deve sincronizzarsi in un punto, cioè ogni thread deve arrivare a un punto (punto di sincronizzazione) dove deve attendere che tutti gli altri thread siano arrivati al loro punto di sincronizzazione. Una prima soluzione (sbagliata) consiste nell uso di un semaforo A e un contatore, applicata da tutti i thread nel modo seguente: programma 1 (eseguito da ogni thread) 1 conta++; 2 if (conta==t) post A; 3 wait A; Questo programma contiene 2 errori gravi: individuarli e correggerli VERSIONE ERRATA 28
74 Esercizio 12 Barriera Il primo errore consiste nella mancanza di protezione del contatore durante l aggiornamento. Questo errore può essere corretto introducendo un mutex M. Il secondo errore è il deadlock. Supponiamo T = 10. Dopo l arrivo di 9 thread il valore di conta sarà 9 e quello del semaforo A sarà -9; a questo punto arriva l ultimo thread, conta diventa 10, viene eseguito un post, un thread in attesa viene sbloccato e il semaforo viene incrementato a -8. Tutti gl ialtri thread restano bloccati. Per correggere questi errori il programma deve diventare 1 mutex lock M; conta++; mutex_unlock M; 2 if (conta==t) post A; 3 wait A; 4 post A In questo modo i primi 9 thread vanno in attesa, l ultimo sblocca un thread, che parte ed esegue il post (riga 4), sbloccandone un altro, che esegue il post, e così via fino a sbloccare tutti i thread. 29
75 Esercizio 12 Barriera Tutti e T=10 i thread sono partiti. Quindi abbiamo, dopo linea 2, conta=10 e A = -9 THREAD 10 1 mutex lock M; conta++; mutex_unlock M; 2 if (conta==t) post A; 3 wait A; 4 post A RISVEGLIA THREAD 4 1 mutex lock M; conta++; mutex_unlock M; 2 if (conta==t) post A; 3 wait A; 4 post A THREAD 7 1 mutex lock M; conta++; mutex_unlock M; 2 if (conta==t) post A; RISVEGLIA 3 wait A; 4 post A 30 etc.
76 Esercizio 13 Il problema dei cinque filosofi Ci sono cinque filosofi seduti stabilmente ad un tavolo rotondo e ciascuno ha davanti un piabo di riso (che supponiamo inesauribile), oppure esiste un unico grande piabo al centro della tavola da cui ogni filosofo mangia (questo non cambia il problema). Tra un piabo ed un altro (o tra un filosofo ed un altro) però non vi sono due bastoncini come sarebbe opportuno, ma solo uno, per un totale di sole 5 bacchebe, contro le 10 che sarebbero richieste per permebere a tubi di mangiare contemporaneamente. Ciascun filosofo per tuba la sua vita non fa altro che tre cose: pensare quando e'ʹ sazio, mangiare e mebersi in abesa di mangiare quando ha fame. Un filosofo decide di mebersi a pensare a qualche problema filosofico per un certo intervallo di tempo (che possiamo ritenere casuale e finito), poi si siede a tavola (supponiamo ciascuno abbia assegnato un posto fisso, ma questo non è necessario) e decide di mangiare il riso. Impiega un certo tempo a mangiare (anche questo lo faremo variare casualmente, ma sarà sempre finito), poi decide di mebersi di nuovo a pensare, poi mangia di nuovo, ecc. Quando decide di mangiare, prima di poterlo fare, ha bisogno di prendere in mano due bacchebe. Un filosofo può prendere solo le due bacchebe che stanno alla sua destra e alla sua sinistra, una per volta, e solo se sono libere, ovvero non può sobrarre la risorsa baccheba ad un altro filosofo che l'ʹha già acquisita, cioè che sta mangiando (no preemption). Finché non riesce a prendere le bacchebe, il filosofo deve aspebare affamato. Quando invece, appena dopo aver mangiato, è sazio, posa le bacchebe al loro posto e si mebe a pensare per un certo tempo.! La situazione è tale che due filosofi vicini non possono mai mangiare contemporaneamente. Si chiede di trovare una soluzione, ossia una strategia tramite la quale i filosofi sono costrebi ad acquisire le risorse (le bacchebe) che soddisfi i seguenti due obiebivi: 1 non può accadere che tubi i filosofi rimangono indefinitamente bloccati in abesa reciproca che l'ʹaltro rilasci l'ʹulteriore baccheba di cui hanno bisogno per mangiare (no deadlock) 2 non accade mai che uno o più filosofi non riescano mai a mangiare e quindi muoiano di fame perché gli altri sono più svelti di loro a prendere le bacchebe (no starvation) 31
77 Esercizio 13 Il problema dei cinque filosofi PROVATE A CASA 32
78 Alla prossima lezione 33
Thread: sincronizzazione Esercitazioni del 16 Ottobre 2009
Thread: sincronizzazione Esercitazioni del 16 Ottobre 2009 Luca Fossati, Fabrizio Castro, Vittorio Zaccaria 19 ottobre 2009 Sequenze di esecuzione - 2 Sequenze di esecuzione - 2 Esercizio 1 Sequenze di
Programmazione di concorrente - Deadlock
Programmazione di concorrente - Deadlock Prof. Gerardo Pelosi & Ing. Michele Scandale 30 Ottobre 2014 Il materiale illustrato a lezione e in queste note contiene anche esempi di Fabrizio Castro, Luca Fossati,
Sistemi operativi. Corso di Laurea Triennale in Ingegneria Informatica. Lezione 7 Mutex Condition Esempi di utilizzo
Sistemi operativi ì Corso di Laurea Triennale in Ingegneria Informatica Lezione 7 Mutex Condition Esempi di utilizzo Domande sulle lezioni passate? Sommario ì Sincronizzazione ì Mutex ì Variabili condition
il tipo di parallelismo dipende dal grado di cooperazione
Thread Settembre 2009 programma e parallelismo il tipo di parallelismo dipende dal grado di cooperazione (scambio d informazione) necessario tra attività svolte in parallelo processo macchina virtuale
ACSO Programmazione di Sistema e Concorrente
ACSO Programmazione di Sistema e Concorrente P2 Modello Thread 2/12/2015 programma e parallelismo il tipo di parallelismo dipende dal grado di cooperazione (scambio di informazione) necessario tra attività
ACSO Programmazione di Sistema e Concorrente
ACSO Programmazione di Sistema e Concorrente P3 Programmazione concorrente 2/12/2015 programmazione concorrente 1 modello di esecuzione sequenziale istruzioni eseguite in ordine predeterminabile in base
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 19 febbraio 2013 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 17 febbraio 2015 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
istruzioni eseguite in ordine predeterminabile in base al codice del programma e dei valori dei dati in ingresso
Programmazione Concorrente sequenze critiche e mutua esclusione istruzioni atomiche deadlock sincronizzazione e semafori settembre 2009 programmazione concorrente 1 modello di esecuzione sequenziale istruzioni
Cosa sono i semafori?
Semafori Cosa sono i semafori? I semafori sono primitive fornite dal sistema operativo per permettere la sincronizzazione tra processi e/o thread. Semafori di mutua esclusione con i thread POSIX 2 Operazioni
= PTHREAD_MUTEX_INITIALIZER
MUTEX Prof.ssa Sara Michelangeli Quando si programma in modalità concorrente bisogna gestire le problematiche di accesso alle eventuali sezioni critiche. Una sezione critica è una sequenza di istruzioni
LinuxThreads: I thread nel sistema operativo LINUX: Linuxthreads. LinuxThreads. LinuxThreads
I thread nel sistema operativo LINUX: Linuxthreads : Caratteristiche Processi leggeri realizzati a livello kernel System call clone: int clone(int (*fn) (void *arg), void *child_stack, int flags, void
Corso di Laboratorio di Sistemi Operativi
Corso di Laboratorio di Sistemi Operativi Lezione 7 Alessandro Dal Palù email: alessandro.dalpalu@unipr.it web: www.unipr.it/~dalpalu Threads Un thread è l unità di base per l utilizzo della CPU. Composto
Libreria Linux Threads. Threads nel S.O. Linux. Primitive per la gestione dei thread. Portabilità: libreria pthreads (Posix).
Threads nel S.O. Linux Il thread è un processo leggero che può condividere uno spazio di indirizzi (o parte di esso) con il padre e gli altri processi della gerarchia cui appartiene. Realizzato a livello
LABORATORIO DI SISTEMI OPERATIVI
LABORATORIO DI SISTEMI OPERATIVI Corso di Laurea Triennale in Ingegneria Informatica A.A. 2018/2019 Guglielmo Cola Email: g.cola@iet.unipi.it Web: iet.unipi.it/g.cola Thread POSIX nel sistema Linux (parte
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 10 Martedì 7-11-2017 Thread a livello kernel Modello da uno a uno La
Architetture dei Calcolatori e Sistemi Operativi
Prof. Gerardo Pelosi & Ing. Michele Scandale 30 Ottobre 2014 Gerardo Pelosi 1 Esercizio 1 Indicare se nel seguente programma sono presenti deadlock e, in tal caso, identificare
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2016-17 Pietro Frasca Lezione 21 Martedì 10-01-2017 Sincronizzazione tra thread Per risolvere problemi
Creazione di thread. In Linux si utilizzano le librerie pthread (POSIX thread) per lavorare con i thread:
Thread Un thread o lightweight process (LWP) è un unità di utilizzo della CPU che consiste di: un program counter, un insieme di registri, uno stack space. Tale unità condivide con gli altri peer thread
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 4 luglio 2014 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare tutti
Sincronizzazione di thread POSIX
Sincronizzazione di thread POSIX Sincronizzazione I thread condividono la memoria Rischio di race condition Necessari meccanismi di sincronizzazione mutex (semaforo binario) condition variable I mutex
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 4 settembre 2015 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Informatica 3. LEZIONE 6: Il controllo dell esecuzione. Modulo 1: La gestione delle eccezioni Modulo 2: Programmazione concorrente
Informatica 3 LEZIONE 6: Il controllo dell esecuzione Modulo 1: La gestione delle eccezioni Modulo 2: Programmazione concorrente Informatica 3 Lezione 6 - Modulo 1 La gestione delle eccezioni Il controllo
Esercitazione n.1 24 Ottobre Obiettivi:
Esercitazione n.1 24 Ottobre 2013 Obiettivi: Gestione dei thread mediante libreria pthreads: creazione: pthread_create terminazione: pthread_exit join: pthread_join 1 Richiami sui thread 2 Processi Immagine
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 8 settembre 2017 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
LABORATORIO DI SISTEMI OPERATIVI
LABORATORIO DI SISTEMI OPERATIVI Corso di Laurea Triennale in Ingegneria Informatica A.A. 2018/2019 Guglielmo Cola Email: g.cola@iet.unipi.it Web: iet.unipi.it/g.cola Thread POSIX nel sistema Linux (parte
Esercitazione E9 Sincronizzazione
Esercitazione E9 Sincronizzazione Sistemi Operativi (9 CFU), CdL Informatica, A. A. 2013/2014 Dipartimento di Scienze Fisiche, Informatiche e Matematiche Università di Modena e Reggio Emilia http://weblab.ing.unimo.it/people/andreolini/didattica/sistemi-operativi
Thread thread lightweight process
Thread Un thread o lightweight process (LWP) è un unità di utilizzo della CPU che consiste di: un program counter, un insieme di registri, uno stack space. Tale unità condivide con gli altri peer thread
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 9 luglio 2012 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare tutti
Introduzione al Multithreading
Introduzione al Multithreading Claudia Calidonna Istituto di di Cibernetica C.N.R. Argomenti principali Parleremo di : Processi & Threads Operazioni sui threads ed eventuali confronti tra operazioni sui
Corso di Laboratorio di Sistemi Operativi A.A
Corso di Laboratorio di Sistemi Operativi A.A. 2016 2017 Lezione 17 Ivan Scagnetto ivan.scagnetto@uniud.it Nicola Gigante gigante.nicola@spes.uniud.it Dipartimento di Scienze Matematiche, Informatiche
Principles of Concurrent Programming
Principles of Giuseppe Anastasi g.anastasi@iet.unipi.it Pervasive Computing & Networking Lab. () Dept. of Information Engineering, University of Pisa Overview Concetti preliminari Interazione fra processi
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2018-2019 Pietro Frasca Lezione 9 Martedì 6-11-2018 I thread nello standard POSIX: la libreria pthreads
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 16 febbraio 2016 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Corso di Laboratorio di Sistemi Operativi A.A
Corso di Laboratorio di Sistemi Operativi A.A. 2016 2017 Lezione 18 Ivan Scagnetto ivan.scagnetto@uniud.it Nicola Gigante gigante.nicola@spes.uniud.it Dipartimento di Scienze Matematiche, Informatiche
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2016-17 Pietro Frasca Lezione 22 Giovedì 12-01-2017 1 Un esempio di sincronizzazione tra thread Risolviamo
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2016-17 Pietro Frasca Lezione 20 Giovedì 22-12-2016 Comunicazione: pipe In Unix, processi possono comunicare
System call per la gestione di processi
System call per la gestione di processi Chiamate di sistema per creazione di processi: fork() sostituzione di codice e dati: exec...() terminazione: exit() sospensione in attesa della terminazione di figli:
System call per la gestione di processi
System call per la gestione di processi Chiamate di sistema per creazione di processi: fork() sostituzione di codice e dati: exec...() terminazione: exit() sospensione in attesa della terminazione di figli:
LinuxThreads: I thread nel sistema operativo LINUX: Linuxthreads
I thread nel sistema operativo LINUX: Linuxthreads LinuxThreads: Caratteristiche Processi leggeri realizzati a livello kernel System call clone: int clone(int (*fn) (void *arg), void *child_stack, int
C: panoramica. Violetta Lonati
C: panoramica Violetta Lonati Università degli studi di Milano Dipartimento di Scienze dell Informazione Laboratorio di algoritmi e strutture dati Corso di laurea in Informatica AA 2009/2010 Violetta Lonati
Principles of Concurrent Programming
Principles of Concurrent Programming Alessio Vecchio alessio.vecchio@unipi.it Dip. di Ingegneria dell Informazione Università di Pisa Tratte da Principi e tecniche di progammazione concorrente, cap. 2
Obiettivi: Esercitazione n.1! 26 Ottobre Introduzione alla programmazione multithreaded Gestione dei thread mediante libreria pthreads:
Esercitazione n.1! 26 Ottobre 2016 Obiettivi: Introduzione alla programmazione multithreaded Gestione dei thread mediante libreria pthreads: creazione: pthread_create terminazione: pthread_exit join: pthread_join
Semafori. Semafori classici con i thread POSIX 2
Semafori classici Semafori I semafori sono primitive, implementate attraverso dei contatori, fornite dal sistema operativo per permettere la sincronizzazione tra processi e/o thread. Per queste primitive
Programmazione concorrente
Programmazione concorrente Prof. Gerardo Pelosi & Ing. Michele Scandale 16 Ottobre 2014 Il materiale illustrato a lezione e in queste note contiene anche esempi di Fabrizio Castro, Luca Fossati, Vittorio
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 19 settembre 2016 (Traccia A) Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine
Esercitazione 2! Mutex e semafori POSIX. 3 Novembre 2016
Esercitazione 2! Mutex e semafori POSIX 3 Novembre 2016 Strumenti di sincronizzazione nella libreria LinuxThread I semafori nelle librerie pthread e LinuxThreads La libreria pthread definisce soltanto
void char void char @param void int int int int
1 2 /** 3 * @ file definition_ thread. c 4 * contiene l' implementazioni delle diverse funzioni 5 */ 6 7 /** 8 * @ name elaborato Terzo 9 * @ author Nicola Milani VR360442 10 */ 11 12 13 # include " definition_
Esercitazione 2 Sincronizzazione con semafori. 31 Ottobre 2013
Esercitazione 2 Sincronizzazione con semafori 31 Ottobre 2013 Strumenti di sincronizzazione nella libreria LinuxThread e nel linguaggio Java I semafori nelle librerie pthread e LinuxThreads La libreria
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 9 Giovedì 2-11-2017 Comunicazione con pipe Oltre che con la memoria condivisa
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 13 Giovedì 16-11-2017 Variabili condizione (condition) La variabile condizione
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 13 febbraio 2017 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Architetture dei Calcolatori e Sistemi Operativi
Prof. Gerardo Pelosi & Ing. Michele Scandale 23 Ottobre 2014 Gerardo Pelosi 1 Esercizio 1 Quattro amici fanno una scommessa: il vincitore sceglie casualmente a chi tocca bere
Sistemi Operativi Prova scritta per coloro che non hanno svolto le esercitazioni con valutazione 27 Febbraio 2008
Matricola Nome Cognome Firma Punteggio Es. 1 Es. 2 Es. 3 Es. 4 Es. 5 Es. 6 Tot Sistemi Operativi Prova scritta per coloro che non hanno svolto le esercitazioni con valutazione 27 Febbraio 2008 Esercizio
Thread: sincronizzazione Esercitazioni del 09 Ottobre 2009
Thread: sincronizzazione Esercitazioni del 09 Ottobre 2009 Luca Fossati, Fabrizio Castro, Vittorio Zaccaria October 10, 2009 Sincronizzazione - 1 1 Esercizio 1: Sincronizzazione - 1 Qual è il problema
Le strutture /3. Riprendiamo ora la struttura definita alcune lezioni fa e completiamo il set di funzioni che servono per gestire un elenco di libri.
Le strutture /3 Riprendiamo ora la struttura definita alcune lezioni fa e completiamo il set di funzioni che servono per gestire un elenco di libri. typedef struct {char titolo[200]; char autore[100];
5 Thread. 5 Thread. 5 Thread. Ad un generico processo, sono associati, in maniera univoca, i seguenti dati e le seguenti informazioni:
1 Ad un generico processo, sono associati, in maniera univoca, i seguenti dati e le seguenti informazioni: codice del programma in esecuzione un area di memoria contenente le strutture dati dichiarate
Java Virtual Machine. Indipendenza di java dalla macchina ospite. I threads in Java
programmi sorgente: files.java compilatore Indipendenza di java dalla macchina ospite Programmi java Programmi java Programmi java files.class bytecode linker/loader bytecode bytecode Java API files.class
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 6 settembre 2013 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Esercitazione [2] Concorrenza
![Esercitazione [2] Concorrenza](/thumbs/102/153454969.jpg "Esercitazione [2] Concorrenza")
Esercitazione [2] Concorrenza Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo Multi-Nodo
Allocazione dinamica della memoria
Allocazione dinamica della memoria Allocazione statica: limiti Per quanto sappiamo finora, in C le variabili sono sempre dichiarate staticamente la loro esistenza deve essere prevista e dichiarata a priori
I thread nel sistema operativo LINUX: Linuxthreads
I thread nel sistema operativo LINUX: Linuxthreads LinuxThreads: Caratteristiche Processi leggeri realizzati a livello kernel System call clone: int clone(int (*fn) (void *arg), void *child_stack, int
Thread. Introduzione Creazione, distruzione Sincronizzazione
Thread Introduzione Creazione, distruzione Sincronizzazione Parallelismo Il tipo di meccanismo a supporto del parallelismo dipende dal grado di cooperazione tra le varie entità che costituiscono un'applicazione
Cosa sono i semafori?
Mutex Cosa sono i semafori? I semafori sono primitive fornite dal sistema operativo per permettere la sincronizzazione tra processi e/o thread. Semafori di mutua esclusione con i thread POSIX 2 Operazioni
Processi e Thread. Meccanismi di IPC (1)
Processi e Thread Meccanismi di IPC (1) 1 Comunicazioni fra processi/thread Processi/thread eseguiti concorrentemente hanno bisogno di interagire per comunicare e sincronizzarsi : scambiare dati utilizzare
Laboratorio di Informatica
Laboratorio di Informatica Ingegneria Meccanica Esercitazione 3, 23 ottobre 2007 versione 3 novembre 2007 Limiti per tipi int #include rende visibili le costanti simboliche SHRT_MIN, SHRT_MAX,
Controllo dei Processi 1
Controllo dei Processi 1 I processi Nei sistemi Unix/Linux ogni processo ne può generare altri. Il processo che li genera è detto processo padre (parent process), mentre i processi generati sono detti
Prof. Pagani Corrado PROGRAMMAZIONE CONCORRENTE
Prof. Pagani Corrado PROGRAMMAZIONE CONCORRENTE INTRODUZIONE La programmazione imperativa si basa su un modello di esecuzione sequenziale Tale modello si applica a un singolo programma eseguito da un singolo
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 6 Martedì 24-10-2017 1 Sostituzione del codice Tipicamente, dopo una
Thread. Contiene lucidi tratti da: Marco Faella, Clemente Galdi, Giovanni Schmid (Università di Napoli Federico II),
Thread Contiene lucidi tratti da: 2006-2007 Marco Faella, Clemente Galdi, Giovanni Schmid (Università di Napoli Federico II), 2005-2007 Thread processi leggeri un processo può avere diversi thread i thread
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 21 settembre 2017 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Principles of Concurrent Programming
Principles of Giuseppe Anastasi g.anastasi@iet.unipi.it Pervasive Computing & Networking Lab. () Dept. of Information Engineering, University of Pisa Overview Concetti preliminari Interazione fra processi
Linguaggio C: Variabili e assegnamento e semplici comandi di I/O
Linguaggio C: Variabili e assegnamento e semplici comandi di I/O Università degli Studi di Brescia Prof. Massimiliano Giacomin Elementi di Informatica e Programmazione Università di Brescia 1 Un programma
Lezione 9: Puntatori a funzioni. Tipi enumerativi e orientati ai bit
Lezione 9: Puntatori a funzioni. Tipi enumerativi e orientati ai bit Vittorio Scarano Laboratorio di Informatica I Corso di Laurea in Informatica Università degli Studi di Salerno Struttura della lezione
I Thread. I Thread. Se creiamo un nuovo processo con la fork, questo erediterà dal padre
I Thread 1 Ad un generico processo, sono associati i seguenti dati e le seguenti informazioni: codice del programma in esecuzione un area di memoria contenente le strutture dati dichiarate nel programma
Passare argomenti al programma
Passare argomenti al programma Quando si invoca un programma è possibile passare degli argomenti ad esso durante la chiamata. Gli argomenti ricevuti saranno stringhe (array di char) quindi l insieme di
SISTEMI OPERATIVI. Processi in Linux. Giorgio Giacinto Sistemi Operativi
SISTEMI OPERATIVI Processi in Linux 2 Creazione di processi concorrenti» La creazione di un processo figlio consente di far eseguire alcune funzionalità del programma in modo concorrente» Opzione 1 il
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2014-15 Pietro Frasca Lezione 20 Martedì 16-12-2014 1 System call per la gestione dei processi Creazione
I THREAD. thread 2. thread 1
I THREAD Un thread è un singolo flusso di istruzioni, all interno di un processo, che lo scheduler può fare eseguire separatamente e concorrentemente con il resto del processo. Per fare questo uno thread
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2018-2019 Pietro Frasca Lezione 5 Martedì 16-10-2018 Operazioni sui processi Nella maggior parte dei
Fondamenti di Programmazione
A.A. 08/09 Fondamenti di Programmazione (canale E-O) Docente: Prof.ssa Tiziana Calamoneri calamo@di.uniroma1.it Esercitatore: Dott. Roberto Petroccia petroccia@di.uniroma1.it Pagina del corso: http://twiki.di.uniroma1.it/twiki/view/programmazione1/eo/webhome
IEIM Esercitazione 1 Primi passi con la programmazione" Alessandro A. Nacci -
IEIM 2018-2019 Esercitazione 1 Primi passi con la programmazione" Alessandro A. Nacci alessandro.nacci@polimi.it - www.alessandronacci.it 1 Chi sono - Alessandro Nacci, PhD - Nato nel 1987 - Imprenditore
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 14 luglio 2017 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Thread. La libreria Pthread Stefano Quer Dipartimento di Automatica e Informatica Politecnico di Torino
Thread La libreria Pthread Stefano Quer Dipartimento di Automatica e Informatica Politecnico di Torino 2 Librerie di thread Fornisce l interfaccia per effettuare la gestione dei thread da parte del programmatore
Esercitazione 2: Java Thread
Esercitazione 2: Java Thread Thread Un thread è un singolo flusso sequenziale di controllo all interno di un processo Un thread (o processo leggero) è un unità di esecuzione che condivide codice e dati
Esercitazione 2: Java Thread. Java Thread. Java Thread. Un thread:
Esercitazione 2: Thread Un thread è un singolo flusso sequenziale di controllo all interno di un processo Un thread (o processo leggero) è un unità di esecuzione che condivide codice e dati con altri thread
Seminario: Thread POSIX Insegnamento di Sistemi di Elaborazione Corso di L.S. In Ing. Elettronica
Seminario: Thread POSIX Insegnamento di Sistemi di Elaborazione Corso di L.S. In Ing. Elettronica Ing. Francesco Restuccia E-mail: f.restuccia@studenti.unipi.it Pervasive Computing & Networking Lab (PerLab)
La funzione main() La funzione main(), presente in tutti i programmi C, è una funzione come tutte le altre
La funzione main() La funzione main(), presente in tutti i programmi C, è una funzione come tutte le altre Unica particolarità: viene chiamata dal Sistema Operativo, appena il programma viene avviato Non
I cicli. Iterazioni Calcolo della media Istruzioni break e continue
I cicli Iterazioni Calcolo della media Istruzioni break e continue Ciclo while p Vero A while() ; Falso Esegue una istruzione mentre una condizione è verificata Programmazione
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 13 luglio 2016 (Traccia A) Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine
Lezione 8: Stringhe ed array multidimensionali
Lezione 8: Stringhe ed array multidimensionali Vittorio Scarano Corso di Laurea in Informatica Università degli Studi di Salerno Struttura della lezione AVVISO: la lezione di laboratorio di 28/5 non si
Ogni variabile in C è una astrazione di una cella di memoria a cui corrisponde un nome, un contenuto e un indirizzo.
Ogni variabile in C è una astrazione di una cella di memoria a cui corrisponde un nome, un contenuto e un indirizzo. int a = 5; a 5 α=&a Esistono in C particolari variabili dette puntatori che possono
Laboratorio di informatica Ingegneria meccanica
C: costanti introdotte con #define Laboratorio di informatica Ingegneria meccanica Lezione 4 22 ottobre 2007 Forma: #define nome valore Effetto: ogni occorrenza successiva di nome sarà rimpiazzata con
GESTIONE DEI PROCESSI E DEI THREADS IN UN SISTEMA LINUX (PARTE 3) 1
Pietro Pino (pepy91) GESTIONE DEI PROCESSI E DEI THREADS IN UN SISTEMA LINUX (PARTE 3) 4 July 2013 I SEMAFORI La causa della maggior parte dei bugs che coinvolgono i threads è che i threads accedono agli
Laboratorio su Programmazione Concorrente in C. Problemi classici e derivati Dalla Ottava lezione di laboratorio in avanti
Laboratorio su Programmazione Concorrente in C Problemi classici e derivati Dalla Ottava lezione di laboratorio in avanti NOTA BENE: E INSISTO!!!!! Usare il comando man nomefunzionedilibreria per ottenere
Sistemi operativi. Lez. 9: primitive per la concorrenza i semafori
Sistemi operativi Lez. 9: primitive per la concorrenza i semafori Disabilitazione interrupt Due processi possono trovarsi in sezione critica simultaneamente solo perché chi vi è entrato per primo è stato