il tipo di parallelismo dipende dal grado di cooperazione

Transcript

1 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 indipendente con meccanismi ad hoc per scambio d informazione tra processi (IPC) attività parallele indipendenti thread attività parallela che consente strutturalmente un grado di cooperazione elevato lo scambio d informazione è molto facilitato talvolta il thread è chiamato processo leggero la gestione del thread da parte del S.O. è meno onerosa rispetto alla gestione del processo (in termini di strutture dati e funzioni del S.O.) 2 Pag. 1 1

2 concetto di thread thread flusso di controllo che può essere svolto in parallelo con altri thread nell ambito di uno stesso processo flusso di controllo = esecuzione sequenziale di istruzioni (macchina) il flusso di controllo del thread è una funzione (sottoprogramma) che viene attivata alla creazione del thread dato che i thread sono attività parallele in uno stesso processo, condividono lo spazio d indirizzamento del processo (quasi tutto) questa è un implementazione efficiente dello scambio d informazioni scopo dello studio del thread: capirne il principio di funzionamento per comprendere/affrontare alcuni dei problemi principali che si incontrano nella programmazione concorrente thread POSIX pthread esistono svariati modelli implementativi di thread qui si considera lo standard POSIX Portable Operating System Interface for Computing Environment standard POSIX insieme di standard di interfacce applicative (API) di S.O. utilizzando le funzioni/servizi delle API di POSIX è garantita la portabilità dell applicazione su tutti i SO che adottano POSIX pthread = thread di POSIX 3 4 Pag. 2 2

3 pthread e processo 1 il thread è attivato nell ambito di un processo il processo può attivare uno, due o più thread quando il processo termina, terminano forzatamente anche tutti i suoi thread, qualunque sia il loro punto di esecuzione è necessario garantire la terminazione coerente dei thread pthread e processo 2 ogni thread ha un identificatore di thread, di tipo pthread_t l identificatore di thread identifica ill thread univocamente l identificatore di thread è diverso dall identificatore di processo (che è di tipo pid_t) la funzione getpid( ), eseguita all interno dei thread di un medesimo processo, restituisce sempre il PID del processo stesso ogni thread può essere posto in attesa di un evento pertanto l esecuzione del thread può essere sospesa per esempio per un operazione di ingresso/uscita in modo totalmente indipendente rispetto agli altri thread 5 6 Pag. 3 3

4 pthread creazione creazione del thread pthread_create ( ) pthread_create ( ) è simile a fork( ) ma il thread viene creato passandogli, con pthread_create, il nome della funzione che esso deve eseguire il thread inizia a eseguire il suo codice sempre dallo stesso punto (ossia dall inizio della funzione) qualunque sia il punto di esecuzione dove si trova il thread che lo crea pthread terminazione 1 attesa di terminazione tra thread pthread_join ( ) pthread_join ( ) è simile a waitpid ( ) si deve sempre specificare il thread di cui si vuole attendere la terminazione il suo uso è obbligato per garantire la terminazione coerente dei thread quando termina il processo che ha creati i thread 7 8 Pag. 4 4

5 pthread terminazione 2 dato che il thread esegue una funzione, termina quando esegue la return ( ) o al termine del codice eseguibile della funzione il thread che termina può passare, tramite la return ( ), un codice di terminazione al thread che lo ha creato il passaggio avviene se e quando il thread creatore esegue join il codice di terminazione è passato tramite il secondo parametro di join più propriamente, il codice di terminazione del thread è il valore restituito dalla funzione che il thread esegue 9 pthread esempio 1 #include <pthread.h> <stdio.h> // thread_function codice della funzione int main (void) { pthread_t tid1, tid2; pthread_create (&tid1, NULL, &tf1, (void ) 1); pthread_create (&tid2, NULL, &tf1, (void ) 2); pthread_join (tid1, NULL); pthread_join (tid2, NULL); return 0; } / main / // variabile locale int conta = 0; conta++; printf ( sono il thread n: %d; conta = %d \n, (int) tid, conta); return NULL; 10 Pag. 5 5

6 pthread_create e parametri parametri di pthread_create ( ) pthread_create (&tid1, NULL, &tf1, (void ) ) 1); 1) indirizzo di una variabile di tipo pthread_t per contenere l identificatore del thread 2) puntatore agli attributi del thread se NULL il thread avrà gli attributi di default 3) indirizzo della funzione eseguita dal thread (thread_function) 4) indirizzo dell argomento che si vuole passare alla thread_function si può passare un solo argomento che deve essere di tipo void se si vogliono passare più parametri, è necessario creare una struct e passarne l indirizzo 11 pthread_join e codice di terminazione parametri di pthread_join ( ) pthread _j join (tid1, (void ) &thread_ exit); 1) variabile di tipo pthread_t che contiene l identificatore del thread di cui si vuole attendere la terminazione 2) puntatore a una variabile che conterrà il codice terminazione passato dalla thread_function // thread_function void tf1 (void arg) { // codice della funzione return (void ) var } / tf1 / 12 Pag. 6 6

7 thread principale e creato 1 il thread viene creato nell ambito di un processo che ha un suo flusso di controllo: main ( ) si prende main come thread principale o di default quando un codice eseguibile viene lanciato, nel processo viene creato un solo thread, chiamato thread principale il thread principale (ossia il modulo main del codice del processo) può creare altri thread tramite pthread_create a sua volta un thead qualunque può creare altri thread quando un nuovo thread viene creato, si ha esecuzione concorrente dei due flussi di controllo 13 thread principale e creato 2 il thread viene eseguito nello spazio d indirizzamento del processo che lo ha creato tutti i thread di un processo condividono la stessa memoria dati ciascun thread in un processo ha pila propria, indipendente da quella degli altri thread e allocata ad un indirizzo differente dello stesso spazio d indirizzamento del processo pertanto le variabili locali della funzione eseguita dal thread appartengono solo a quel thread, poiché sono allocate in pila pertanto sia le variabili statiche sia quelle globali, non allocate in pila, sono condivise tra tutti i thread è proprio questa condivisione che rende facile (immediato) lo scambio d informazione tra thread ma che rende più difficile garantire la correttezza del programma multithreading 14 Pag. 7 7

8 ancora esempio 1 variabile locale #include <pthread.h> <stdio.h> // thread_function codice della funzione int main (void) { pthread_t tid1, tid2; pthread_create (&tid1, NULL, &tf1, (void ) 1); pthread_create (&tid2, NULL, &tf1, (void ) 2); pthread_join (tid1, NULL); pthread_join (tid2, NULL); return 0; } / main / // variabile locale int conta = 0; conta++; printf ( sono il thread n: %d; conta = %d \n, (int) tid, conta); return NULL; 15 esempio 1 possibile sequenza di esecuzione sono thread n: 1; conta = 1 sono thread n: 2; conta = 1 oppure sono thread n: 2; conta = 1 sono thread n: 1; conta = 1 16 Pag. 8 8

9 ancora esempio 1 variabile statica #include <pthread.h> <stdio.h> // thread_function codice della funzione int main (void) { pthread_t tid1, tid2; pthread_create (&tid1, NULL, &tf1, (void ) 1); pthread_create (&tid2, NULL, &tf1, (void ) 2); pthread_join (tid1, NULL); pthread_join (tid2, NULL); return 0; } / main / // variabile locale static int conta = 0; conta++; printf ( sono il thread n: %d; conta = %d \n, (int) tid, conta); return NULL; 17 variabile statica sequenza di esecuzione sono thread n: 1; conta = 1 sono thread n: 2; conta = 2 oppure sono thread n: 2; conta = 1 sono thread n: 1; conta = 2 18 Pag. 9 9

10 ancora esempio 1 variabile globale #include <pthread.h> <stdio.h> // conta è variabile globale int conta = 0; // thread_function codice della funzione // variabile locale conta++; printf ( sono il thread n: %d; conta = %d \n, (int) tid, conta); return NULL; int main (void) { pthread_t tid1, tid2; pthread_create (&tid1, NULL, &tf1, (void ) 1); pthread_create (&tid2, NULL, &tf1, (void ) 2); pthread_join (tid1, NULL); pthread_join (tid2, NULL); return 0; } / main / 19 thread_function parametri e codice di terminazione #include <pthread.h> <stdio.h> void tf1 (void *arg) { // codice thread_function int main (void) { int argomento = 10; int thread_exit; pthread_t tid1; pthread_create (&tid1, NULL, &tf1, &argomento); pthread_join (tid1, (void ) &thread_exit); printf ( sono il main; thread_exit = %d\n, thread_exit); return 0; } / main / void tf1 (void arg) { int i = ((int ) arg); printf ( sono thread_function: ti valore argomento = %d \n, i); i++; return (void ) i; 20 Pag

11 thread_function parametri e codice di terminazione sono thread_function: valore argomento = 10 sono il main; thread_exit = thread e processo considerazioni di uso efficienza: la copia di memoria per un nuovo processo richiede tecniche di gestione e risorse più onerose rispetto a un thread. in generale il thread è più efficiente del processo protezione: un thread con errori può danneggiare altri thread nello stesso processo; invece un processo non può danneggiarne un altro (hanno spazi d indirizzamento disgiunti) i processi sono più protetti uno dall altro cambiamento di eseguibile: è possibile solo con il processo; il thread può eseguire solamente il codice della funzione associata, già presente nel codice del processo un processo figlio può, tramite exec, sostituire l intero programma eseguibile (flessibilità) condivisione dei dati: la condivisione di dati tra thread è molto semplice, mentre tra processi è complicata (richiede l impiego di meccanismi di comunicazione tra processi IPC) 22 Pag