Processi programma processo processo Stati di un processo Attesa di caricamento new Pronto ( ready ) Esecuzione running Waiting ( in Attesa )

Transcript

1 Processi Un processo è l insieme delle azioni compiute dal processore per eseguire un programma. Si può semplificare dicendo che "un processo è un programma in esecuzione". Per meglio definire un processo analizziamone la differenza con il programma. Un programma è costituito dalle istruzioni scritte dal programmatore e tradotte in linguaggio macchina e viene visto come un insieme di bit presenti sul disco rigido che non cambia nel tempo e non modifica lo stato della macchina. Un processo invece modifica lo stato della memoria e dei registri. In generale potremo dire che: Un processo è un entità dinamica il cui stato è determinato dai valori assunti dal registro Program Counter, dai registri generali, dallo stato della memoria, dallo stack e dall SR; Un processo ha una traccia d esecuzione, che può essere definita come la sequenza degli stati assunti dal processore durante l avanzamento dei processi. Ad un processo sono associati il codice, l area dati, i registri e le altre risorse ad esso assegnate. Stati di un processo Un processo, dopo la sua creazione ed attivazione, può trovarsi in diversi stati di avanzamento: Attesa di caricamento ( new ) è stata richiesta l esecuzione del programma memorizzato su disco e attende di essere caricato in memoria centrale; vi possono essere più processi in attesa di caricamento. Pronto ( ready ) il processo è in memoria centrale ed attende che gli venga assegnata la CPU; vi possono essere più processi in stato di pronto. Esecuzione ( running ) la CPU esegue il processo; vi è un solo processo in esecuzione Waiting ( in Attesa ) il processo ha richiesto una operazione di I/O e ne attende il completamento; più processi in attesa; spesso le operazioni di I/O vengono eseguite dai processori di I/O in parallelismo effettivo con la CPU Terminazione ( terminated ) il processo ha terminato l esecuzione può rilasciare le risorse utilizzate. Descrittore del processo Ogni processo ha associato un proprio descrittore di processo ( o PCB. Process Control Block) che viene creato in fase di "creazione" del processo e mantenuto in memoria centrale, in un area riservata al sistema operativo, per tutta la durata del processo. Tale descrittore contiene: PID ( Process Identification), un numero progressivo che identifica il processo, assegnato dal SO al momento della creazione del processo; PPID ( Parent Process Identification ) cioè il PID del processo padre cioè il processo che l ha generato;

2 puntatore alla lista dei processi figli ; stato del processo ; priorità; limiti della memoria centrale utilizzata; puntatore alla lista delle risorse in uso; copia del contesto del processo ( PC, IR, MAR, MDR, registri generali, ). Quando un processo rilascia la CPU nel suo PCB viene salvato il contesto. Quando a un processo viene assegnata la CPU la copia dei registri contenuta nel suo PCB viene copiata nei registri fisici della CPU. Ciò consente al processo di riprendere l esecuzione dal punto in cui era stata sospesa, dall istruzione puntata dal PC al momento della sospensione. Per Creare un processo occorre assegnare un area di memoria centrale, copiare il programma in tale area, creare il suo PCB, porre il processo in stato di "pronto". Per Terminare un processo occorre liberare la memoria centrale allocata, rilasciare tutte le risorse da esso utilizzate, aggiornare il PCB del processo che l ha creato. Thread Come abbiamo visto un processo è generato da un programma in esecuzione. Un programma eseguito su un processore può dare origine a più processi. Ogni processo è descritto da un PCB ( Process Control Block ) che viene generato in fase di "creazione" del processo e mantenuto in memoria centrale. I programmi tradizionali sono pensati per essere eseguiti in sequenza. Un thread ( o processo leggero ) è una sequenza di istruzioni di un programma in esecuzione, cioè il flusso di esecuzione di un processo viene scomposto in più flussi concorrenti. Per esemplificare un theread è una parte di programma che può eseguire operazioni in modo autonomo rispetto al resto. Esempi di thread sono: - Correttore ortografico di word che esegue il controllo contemporaneamente alla nostra scrittura; - Un client FTP che scarica più file contemporamneamente; - I giocatori di un gioco 3D che combattono con noi. Il thread designa un percorso di esecuzione parallela ( execution path ) ed è la minima unità di esecuzione che un S.O. può gestire in modo indipendente. Ogni thread condivide con altri thread :

3 il codice eseguibile area dei dati globali area di memoria allocata dinamicamente tabella dei descrittori dei file Ogni thread ha non condivide con altri thread : dati propri stack ( variabili locali ) il contenuto del Program counter il set di registri Questi ultimi indispensabili per permettere una execution path indipendente per ogni thread. Con i thread si ottiene un miglioramento delle prestazioni complessive del sistema, ma esso deve avere più di una CPU o come nei sistemi moderni CPU multicore. Bisogna fare attenzione a parallelizzare l esecuzione, infatti se la mole dei dati da elaborare non è grande, vi è il concreto rischio che il tempo necessario al S.O. per creare e sincronizzare thread sia superiore a quello necessario all elaborazione sequenziali dei dati. Elaborazione sequenziale e concorrente Con elaborazione sequenziale si intende l esecuzione di un programma in cui le azioni eseguite sono totalemente ordinate. Con programmazione concorrente si indicano tecniche e strumenti impiegati per descrivere attività o processi che si intendono eseguire parallelamente in un sistema di calcolo ( processi paralleli ). Il parallelismo vero si ha soltanto nel caso di sistemei multipocessore o multicore. Nei sistemi monoprocessore il parallelismo è solo virtuale e il loro avanzamento parallelo dipende dal tempo che gli viene assegnato dalle politiche di schedulazione del S.O. Due processi si dicono concorrenti se la prima operazione di uno di essi ha inizio prima del completamento dell ultima operazione dell altro. La concorrenza Come abbiamo già detto l elaborazione non sequenziale o elaborazione parallela o concorrente si può ottenere in due modi Con elaboratori dotati di più CPU o multicore Con sistemi con un'unica CPU in multiprogrammazione Per poter codificare programmi non sequenziali è necessari avere linguaggi non sequenziali dotati cioè di particolari istruzioni adatte a trattare la programmazione parallela. Un programma concorrente si basa sulla scomposizione sequenziale, cioè il programmatore deve individuare le attività parallelizzabili e descriverle in termini di sequenze di istruzioni di un linguaggio concorrente. L istruzione fork è una istruzione concorrente che serve a generare un processo ( figlio ) che viene eseguito in parallelo al processo che lo ha generato ( processo padre ). L istruzione join viene eseguita quando il processo figlio è terminato e si sincronizza con il processo padre.

4 L istruzione cobegin e coend sono istruzioni che permettono di indicare il punto in cui N thread iniziano e finiscono contemporaneamente l esecuzione. Risorse e condivisione Una risorsa, sia essa hardware ( memoria, disco, cpu, ) o software ( file, PCB, ), è una qualche cosa necessaria al processo per avanzare verso lo stato di terminato. Una risorsa può essere assegnata: in modo statico per tutta la durata del processo; in modo dinamico viene assegnata, usata e rilasciata dopo l utilizzo da parte del processo; una risorsa è detta prerilasciabile se il S.O. può costringere il processo a rilasciarla. La CPU è un esempio di questo tipo di risorsa. Il nucleo (o Kernel) del sistema operativo si occupa, della gestione della CPU, scheduling della CPU e dell avanzamento dei processi. La gestione delle altre risorse è effettuata da appositi gestori delle risorse quali il gestore della memoria centrale, il gestore delle periferiche, e il gestore delle informazioni (o File System). Due processi si dicono disgiunti se sono completamente indipendenti l uno dall altro, interagenti se accedono a risorse comuni. L interazione fra processi può essere : cooperazione (diretta) due processi per avanzare si scambiano messaggi; competizione (indiretta) due processi competono per l accesso ad una stessa risorsa.

5 Comunicazione fra processi Sappiamo che due processi possono interagire in cooperazione o concorrenza per utilizzare delle risorse che gli consentiranno di avanzare dallo stato di new a quello di terminated. A prescindere dall hardware vi sono due modi per realizzare l interazione modello a memoria comune ( utilizza l ambiente globale ) modello a scambio di messaggi ( utilizza l ambiente locale ) Il primo utilizzato in ambienti hardware in cui esiste un unica memoria, il secondo in ambienti di calcolo distribuito. Nel modello a memoria comune vi possono essere problemi per l accesso alla memoria da parte di due o più processi che ne potrebbero richiederne contemporaneamente l attribuzione. Mutua esclusione In genere una risorsa riusabile e non prerilasciabile può essere assegnata ad un solo processo per volta, in mutua esclusione cioè se un processo P ha la risorsa R, nessun altro può utilizzarla finché P non la rilascia, garantendo un tempo di attesa finito ed evitando situazioni di stallo ( o deadlock ). La mutua esclusione va garantita, pena il verificarsi di errori non controllabili. Stallo ( deadlock ) Lo stallo si ha quando due o più processi che posseggono risorse e, per avanzare necessitano di ulteriori risorse possedute da altri processi che non le possono rilasciare. L avere più programmi che competono per l uso delle risorse può causare situazioni di stallo (deadlock), situazioni nelle quali i processi non possono più avanzare. Le condizioni per le quali si può verificare lo stallo sono: necessità di garantire la mutua esclusione; attesa di risorse aggiuntive ( i processi richiedono le risorse una alla volta e non tutte insieme ); non prerilascio delle risorse ottenute; verificarsi di una situazione di "attesa circolare". Ad esempio il processo P1 ha in uso la risorsa R1che rilascerà solo dopo aver ottenuto la risorsar2; P2 ha in uso R2 che rilascerà solo dopo aver ottenuto R1: STALLO! Per ovviare allo stallo ci sono alcune diverse tecniche: la prevenzione dello stallo ( deadlock prevention ) consiste nell invalidare una o più condizioni di stallo (ad esempio si obbligano i processi a chiedere le risorse tutte insieme); in genere si previene l attesa circolare con l allocazione gerarchica delle risorse. la Fuga dallo stallo ( deadlock avoidance ) permette di rifiutare la richiesta di risorsa che causa (o potrebbe causare ) stallo; il Riconoscimento e recupero dello stallo ( deadlock detection and recovery ) non previene lo stallo, ma riconosce quando esso avviene (ad esempio esaminando

6 periodicamente il grafo di allocazione delle risorse ) e lo elimina ( ad esempio forzando uno dei processi a terminare ). Competizione tra processi ( interazione indiretta ) Primitive Lock e UnLock ( attesa attiva ) Per garantire la mutua esclusione ad una risorsa si associa un semaforo binario ( un bit ) che può valere 1 "semaforo verde", cioè risorsa libera 0 "semaforo rosso", risorsa occupata. La richiesta della risorsa viene fatta con la primitiva Lock che verifica il semaforo: se il semaforo è a 0 lo pone a 1 ed assegna la risorsa al processo, altrimenti resta in attesa che il semaforo diventi 0 ( verificandolo ad intervalli regolari ). Questo meccanismo, che prevede il test ripetuto del semaforo ( attesa attiva ) garantisce la mutua esclusione. Le primitive disable() e enable() servono rispettivamente a mascherare ( disabilitare ) e abilitare le interruzioni ( flag IF della PSW ) per evitare che il flusso dell esecuzione delle istruzioni delle primitive Lock() e Unlock() venga interrotto provocando così conseguenze imprevedibili. Nel processo P che utilizza la risorsa R a cui è associato il semaforo s avremo : Lock ( s ); // questa è la porzione di codice in cui viene usata la risorsa R // a cui è associato il semaforo s ( detta sezione critica ) UnLock ( s ); Cioè la lock() dovrà precedere la sezone critica alla fine della quale dovremo inserire la chiamata alla funzione unlock() che provvererà al rilascio della risorsa cioè a mettere a verde il semaforo. Questo sistema ha due gravi inconvenienti: 1. attesa attiva : la Lock() impegna inutilmente il processore a scapito di altri processi; 2. rinvio indefinito: un processo può attendere indefinitamente il semaforo verde anche se questo evento si è verificato infinite volte. Infatti se il semaforo diventa verde prima che venga riesaminato ed un altro processo chiede la risorsa, la ottiene, rimettendo il semaforo a rosso; quando si va a testare il semaforo lo si trova ancora rosso, ma nel frattempo la risorsa è stata data ad un alto processo; in teoria questo potrebbe verificarsi per un tempo indefinito. Le funzioni primitive P() e V() ( attesa passiva ) Con questo meccanismo a ciasuna risorsa viene associata semaforo s Q(s) una coda destinata a contenere i PID dei processi che l hanno richiesta.

7 La richiesta della risorsa viene fatta con la primitiva P() che testa il semaforo: se il semaforo è a 1 ( verde ) lo pone a 0 ( rosso ) ed assegna la risorsa al processo, altrimenti pone il PID del processo nella coda di attesa e pone in attesat il processo. Il rilascio della risorsa viene fatto con la primitiva V() che controlla se la coda di attesa è vuota: se si pone il semaforo a verde, altrimenti lo lascia a rosso ed assegna la risorsa al primo processo della coda. Questo meccanismo di attesa passiva garantisce sia la mutua esclusione che l attesa finita. Le primitive P() e V() sono conosciute anche come wait () e signal (). Cooperazione tra processi ( interazione diretta ) Nel modello ad ambiente locale un processo può accedere solo alla sua memoria ed essa non può essere modificata da altri processi. Non avendo memoria in comune l unico strumento di comunicazione e sincronizzazione fra i processi è lo scambio di messaggi. In questo modello ogni processo può accedere esclusivamente alle risorse allocate nella propria memoria locale e ogni risorsa del sistema è accessibile a un solo processo ( server ) che può operare su di essa, eseguire le operazioni richieste dai processi applicativi ( processi client ) che ne hanno bisogno. Client e server comunicano tramite lo scambio di messaggi. Client e server comunicano tramite un mezzo trasmissivo che da un punto di vista logico viene detto canale. Le principali caratterisstiche del canale sono : monodirezionale o bidirezionale comunicazione sincrona o asincrona Nella comunicazione asincrona il mittente dopo l invio del messaggio procede nell esecuzione senza attendere una risposta. Nella comunicazione sincrona mittente e destinatario sevono essere ambedue pronti a trasmettere / ricevere il messaggio cioè vi deve essere un randez-vous ( incontro ) fra i due. Il randez-vous può essere : randez-vous semplice Il mittente invia un messaggio e si sospende in attesa che il destinatario si a pronto ad eseguire l operazione richiesta randez-vous esteso Il destinatario una volta ricevuto il messaggio deve rispondere al mittente e quindi il mittente ricevuta la conferma, rimane in attesa che il destinatario esegua l operazione richiesta Per la comunicazione asincrona esistono delle funzioni primitive che sono send() e receive() ma prima di utilizzarle va definito il canale con l istruzione port <tipo> <identificatore>; ad esempio port int canale1; Per trasmettere send (<messaggio>) to <port>; ad esempio send ( 777 ) to canale1 Per ricevere

8 receive (<variabile>) from <port> ad esempio receive ( dato ) from canale1 Il problema del produttore-consumatore Il problema del produttore-consumatore è un esempio di sincronizzazione tra processi. Il problema descrive due processi, uno produttore ed uno consumatore, che condividono un buffer comune, di dimensione fissata. Compito del produttore è generare dati e depositarli nel buffer in continuo. Contemporaneamente, il consumatore utilizzerà i dati prodotti, rimuovendoli di volta in volta dal buffer. Il problema è assicurare che il produttore non depositi nuovi dati se il buffer è pieno, e che il consumatore prenda dati se il buffer è vuoto. Sincronizzare vuol dire che la "produzione" di un messaggio da parte del processo trasmittente deve avere sempre lo stesso tempo del "consumo" da parte del processo ricevente. La sincronizzazione viene fatta tramite : La funzione P ( semaforo ) che mette a rosso semaforo La funzione V ( semaforo ) che mette a verde semaforo Il semaforo prelevato inizializzato a verde, utilizzato dal consumatore per segnalare lo svuotamento del buffer; Il semaforo depositato inizializzato a rosso, utilizzato dal produttore per segnalare la presenza nel buffer di nuovi dati. Il produttore, dopo aver depositato un dato nel buffer, non può scrivere nel buffer sino a quando il consumatore non ha prelevato il dato e, analogamente, il consumatore non può usare più volte il dato inserito nel buffer. Per queste ragioni l accesso al buffer avviene in mutua esclusione.

9 Esercitazioni Per poter lavorare con i thread con il Wxdev C++ dovremo installare la libreria Pthreads ( POSIX Threads ) costituita da 60 funzioni suddivise in tre classi : Funzioni per gestire thread ( creare, distruggere, aspettare un thread ) Funzioni per la gestione della mutua esclusione ( Mutex ) : init, destroy, lock, unlock,... Condition variable: costrutti e funzioni per la comunicazione tra thread che condividono un mutex per aspettare o segnalare il verificarsi di eventi: init, destroy, wait, timed wait,... Pthreads: convenzioni Nomi tipi: pthread_object_t Nomi funzioni: pthread_object_action Costanti/Macro: PTHREAD_PURPOSE Se le funzioni portano ha termine con successo il proprio compito generalmente ritornano il valore 0, 1 in caso contrario. Pthreads: installazione Se in Strumenti Package Manager del Wxdev C++ è presente l icona : vuol dire che la libreria dei thread è installata per cui le istruzioni che seguono sono inutili. Scarica da La libreria per la gestione dei thread pacchettizzata per WxDev C++. Se hai installato WxDev C++ fai direttamente Aprilo con.. come mostrato in figura Viene così richiamato direttamente il Package Manager del WxDev C++

10 Per verificare la corretta installazione in WxDev C++ Strumenti - Package Manager E viene visualizzata la finestra seguente : Controllare la presenza di Pthreads-w32. Dopo aver installato la libreria Creare un nuovo progetto in Dev C++

11 Scegliere dal menù Progetto Opzioni del Progetto Opzioni addizionali riga comando Aggiungi libreria selezionare C:/Program Files (x86)/dev-cpp/lib/libpthreadgc2.a OK NOTA Verificare in quale cartellla sono stati inseriti i tre Header: pthread.h sched.h semaphore.h ed eventualmente aggiungerne in Strumenti Opzioni di compilazione Cartelle Include C++ il path. Ora siamo pronti per la compilazione del progetto Identificatore di un thread Come un processo, anche un thread ha un proprio ID ( tid ), ma a differenza del pid, il tid ha senso solo all interno del processo a cui il thread appartiene. pthread_t pthread_self ( void ); // per conoscere il proprio tid pthread_t pthread_equal ( pthread_t tid1, pthread_t tid2 ); // per confrontare due tid Creazione di un thread int pthread_create ( pthread_t *tid, pthread_attr_t *attr, void *(*funzione)(void *), void *arg ); // per creare un thread I parametri sono: tid : il tid del thread creato attr: per impostare gli attributi del thread ( NULL di default ) funzione: funzione eseguita dal thread creato arg: argomento di ingresso per funzione Una volta creato, un thread può creare altri thread; non c è gerarchia o dipendenza implicita tra thread. Esempio: #include <pthread.h> #include <iostream> #include <windows.h> using namespace std; void * thread1( void *arg ) { // primo thread int i; cout << "x"; Sleep ( 500 ); // ritardo per rallentare l'esecuzione cout << "y"; Sleep ( 500 ); cout << "z"; Sleep ( 500 ); return NULL;

12 void * thread2( void *arg ) { // secondo thread int i; cout << "a"; Sleep ( 500 ); cout << "b"; Sleep ( 500 ); cout << "c"; Sleep ( 500 ); return NULL; int main ( void ) { // programma principale che richiama i due thread pthread_t tid1; pthread_t tid2; while(1) // ciclo infinito che esegue in continuazione i due thread { pthread_create ( &tid1, NULL, &thread1, NULL ); // creazione del primo thread pthread_create ( &tid2, NULL, &thread2, NULL ); // creazione del secondo thread pthread_join ( tid1, NULL ); // attende il termine del 1^ thread pthread_join ( tid2, NULL ); // attende il termine del 2^ thread cout << "\n"; return 0; Terminazione di un thread Un thread può terminare perché: L intero processo viene terminato con una chiamata alle funzioni exit() o exec() Il thread termina l esecuzione della sua routine Il thread chiama pthread_exit() La funzione int pthread_exit( void * rval_ptr ); viene usata per terminare thread e non causa la chiusura di file aperti dal thread che la chiama. Un thread può esser cancellato da un altro thread tramite pthread_cancel(). Sincronizzazione dei processi mediante semafori Come abbiamo già visto per evitare che due processi usino la stessa risorsa contemporaneamente è necessario implementare il meccanismo della mutua esclusione attraverso l utilizzo : di un semaforo ( variabile binaria ) associato alla risorsa delle due funzioni lock() e unlock() ( meglio la P()e la V() ) le cui chiamate vengono inserite rispettivamente prima e dopo la sezione critica ( frazione di codice in cui viene utilizzata la risorsa a cui è assiciato il semaforo ) del codice. In sostanza dobbiamo fare in modo che le due sezioni critiche dei due processi non vengano eseguite contemporaneamente. Nella libreria pthread il semaforo è detto mutex e che naturalmente presenta due stati: aperto o verde o 1 ( unlocked ) o chiuso o rosso o 0 ( locked ) E evidente che solo un thread alla volta può possedere il mutex cioè ottiene il lock. Per definire un mutex utilizzeremo: pthread_mutex_t nomesemaforo = PTHREAD_MUTEX_INITIALIZER;

13 Per bloccare la sezione critica del processo che usa la risorsa a cui è associato il mutex, cioè la funzione che abbiamo chiamato P() dovremo usare: int pthread_mutex_lock ( pthread_mutex_t * nomesemaforo ); int pthread_mutex_trylock ( pthread_mutex_t * nomesemaforo ); La prima è bloccante la seconda no ( utile per evitare lo stallo ) Il parametro della funzione è il puntatore al mutex da bloccare Il valore di ritorno è un intero che se uguale a 0 indica il successo. La trylock() restituisce EBUSY se il mutex è occupato. Per mettere a verde il mutex utilizzeremo int pthread_mutex_unlock ( pthread_mutex_t * nomesemaforo ); int pthread_mutex_destroy ( pthread_mutex_t * nomesemaforo ); La prima funzione sbolocca il mutex soltanto, la seconda lo distrugge. Il parametro della funzione è il puntatore al mutex da sbloccare / distruggere Il valore di ritorno è un intero che se uguale a 0 indica il successo. Esempio Prendiamo in considerazione l esempio precedente l output si presentava così: xabyzc xaybzc cioè l output del 1^ thread si mescolava con quello del secondo. L uso di un semaforo ( mutex ) associato alla risorsa monitor, come mostrato di seguito, elimina l inconveniente.. pthread_mutex_t monitor =PTHREAD_MUTEX_INITIALIZER; // definisco semaforo di nome monitor void * thread1( void *arg ) { // primo thread int i; pthread_mutex_lock ( &monitor ); // semaforo occupato quindi risorsa ad uso esclusivo del thread cout << "x"; cout << "y"; cout << "z"; Sleep ( 500 ); pthread_mutex_unlock ( &monitor ); // semaforo libero return NULL; void * thread2( void *arg ) { // secondo thread int i; pthread_mutex_lock ( &monitor ); // semaforo occupato quindi risorsa ad uso esclusivo del thread cout << "a"; cout << "b"; cout << "c"; Sleep ( 500 ); pthread_mutex_unlock ( &monitor ); // semaforo libero return NULL;

14 Esempio del problema del produttore consumatore #include <pthread.h> #include <iostream> #include <windows.h> using namespace std; int m; pthread_mutex_t prelevato, depositato; // variabile condivisa // dichiaro semafori void *produttore ( void * ) { int conta = 0; while ( conta < 10 ) { pthread_mutex_lock( &prelevato ); // P(prelevato) m = ++conta; // produci un numero progressivo cout << "Prodotto " << m << '\n'; pthread_mutex_unlock(&depositato); // V(depositato) per il consumatore pthread_exit(0); void *consumatore ( void *) { int conta = 0; while ( conta < 10 ) { pthread_mutex_lock( &depositato ); conta = m; cout << "Consumato: " << conta << '\n'; pthread_mutex_unlock( &prelevato ); pthread_exit(0); // P(depositato) aspetta il dato // consuma il numero progressivo // V(prelevato) per il produttore int main() { pthread_t produci, consuma; //dichiaro le variabili relative ai thread pthread_mutex_init ( &prelevato, NULL ); // semaforo prelevato a verde pthread_mutex_init ( &depositato, 0 ); // semaforo depositato a rosso pthread_create ( &produci, NULL, produttore, NULL ); // creo il produttore pthread_create ( &consuma, NULL, consumatore,null ); // creo il consumatore pthread_join ( produci, NULL ); pthread_join ( consuma, NULL ); pthread_mutex_destroy ( &prelevato ); pthread_mutex_destroy ( &depositato ); system ( "PAUSE"); return 0; // attesa del termine dei figli // distruzione dei semafori