5f Esercizi Progr. Concorrente e Vari

Transcript

1 5f Esercizi Progr. Concorrente e Vari Contenuti: Esercizio 1 Programmazione concorrente, gestione coda FIFO (fornaio FIFO) Esercizio 2 - script, processi in background, pid, variabili. Esercizio 3 - script e stdout Esercizio 4 - script, stdout, e espressioni condizionali if Esercizio 5 - script, stdout, espressioni condizionali if e text utils ( sort etc etc ) Esercizio 6 - esecuzione comandi, precedenze operatori e raggruppamento comandi Esercizio 7 - espressioni condizionali Esempio soluzione semplice esercizio 1 Esempio soluzione piu' efficiente esercizio 1 Soluzioni esercizi 2, 3, 4, 5

2 Esercizio 1 - Fornaio FIFO (1/3) Un fornaio ha deciso di installare una macchinetta che distribuisce dei biglietti con un numero intero crescente per dirimere le liti tra i clienti in coda per essere serviti. Ciascun cliente che entra accede al distributore e prende un biglietto, poi aspetta il suo turno per essere servito. Il primo biglietto, di valore 0, lo prende il fornaio e lo posa sul bancone. Il biglietto sul bancone indica chi e' di turno. In particolare, chi possiede il biglietto di valore (1+bigliettoSulBancone) e' di turno non appena il fornaio ha finito di servire il cliente e dopo che questo ha poggiato il proprio biglietto sul bancone da qualche parte. Ogni volta che il fornaio finisce di servire un cliente, cambia il valore del bigliettosulbancone mettendo il valore del cliente appena servito, poi lancia un urlo per avvisare tutti che ha finito e che attende il prossimo cliente, poi aspetta che il cliente di turno arrivi al bancone. Quando il cliente di turno arriva al bancone, mette il suo biglietto sul bancone, avvisa il fornaio di essere arrivato, e aspetta di essere servito. Quando il fornaio finisce di servire il cliente al bancone, lo saluta e lo manda a casa, poi urla per avvisare il prossimo cliente di venire al bancone e aspetta. Dopo essere stato servito, il cliente se ne va. Ipotizziamo che: - il primo cliente prende il biglietto col numero 1. - nessun cliente va via dopo avere preso il biglietto; tutti restano in coda fino ad essere serviti. Modellare ed implementare il sistema descritto, utilizzando dei thread POSIX per ciascuna figura (il fornaio, i clienti) ed avvalendosi delle opportune strutture dati per la sincronizzazione. Utilizzare e completare i file (sorgenti e Makefile) disponibili al link:

3 Continuazione Esercizio 1 - Fornaio FIFO (2/3) L'archivio con la base per l'esercizio contiene un Makefile e alcuni moduli di utilita' che avete gia' usato (DBGpthread.h DBGpthread.c printerror.h) ed un modulo con il main del programma fornaiobasefifo.c. In questo modulo sono definite alcune variabili globali ed alcune funzioni: int64_t bigliettoglob=0; il contatore del distributore pthread_mutex_t mutexdistributorebiglietti; protegge il distributore questa var non deve essere usata per nesun altro motivo. int64_t bigliettosulbancone; biglietto su bancone che determina il turno Nel main viene inizializzata la mutex che protegge il distributore. Nel main vengono creati NUMCLIENTICONTEMPORANEAMENTE thread di tipo cliente, che vanno dal fornaio e terminano, Man mano che i thread terminano il main ne crea altri. La funzione clientechevuoleesseresalutato implementa il cliente. All'interno e' gia' presente il codice che prende il biglietto e lo mette in una variabile locale del cliente int64_t biglietto; Quando va al bancone, il cliente poggia il suo biglietto sul bancone. bigliettosulbancone=biglietto; La funzione fornaiochesaluta implementa la base per il fornaio. All'interno sono gia presenti due parti, che servono per fare un po' di output: - nella parte gestita in mutua esclusione, DOPO che il cliente e' arrivato al bancone ed ha posato il biglietto sul Bancone, viene essere salvato in yna variabile locale il valore del biglietto posato dal cliente. temp_bigliettosulbancone = bigliettosulbancone; Mentre il fornaio serve il cliente, FUORI DALLA MUTUA ESCLUSIONE, viene stampato il valore del biglietto del cliente, salvato nella variabile temp_bigliettosulbancone.

4 Continuazione Esercizio 1 - Fornaio FIFO (3/3) Completare il codice con la parte necessaria a realizzare la sincronizzazione. NB: Una soluzione efficiente e' sintetizzata alla fine delle slide. La soluzione efficiente, completa, e' scaricabile all'indirizzo

5 Esercizio 2 - script, processi, background e pid. Realizzare uno script bash aspetta.sh che prende come argomento un numero intero. Lo script deve attendere un numero di secondi pari al numero passato come argomento allo script, e poi terminare restituendo 0. Scrivere poi uno script principale, lanciaekilla.sh che lancia 10 volte direttamente in background lo script aspetta.sh, passando come argomento Lo script lanciaekilla.sh, ogni volta che lancia lo script aspetta.sh, deve prendere il pid del processo messo in background. Man mano che crea figli, lo script lanciaekilla.sh memorizza i pid dei figli creati in una variabile PIDFIGLI che contiene uno dopo l'altro, separati da uno spazio bianco, i pid dei diversi figli. Ad esempio, dopo la creazione di 10 figli, il contenuto della variabile PIDFIGLI potrebbe essere Dopo avere creato i 10 figli, il processo padre lancia un ultimo script, killa.sh. Lo script killa.sh, al proprio interno, legge la variabile PIDFIGLI, separa i pid dei diversi processi, e usa uno per uno quei pid per eliminare uno per uno i processi, mediante il comando kill -9 pidprocessodaeliminare

6 Esercizio 3 - script e stdout Realizzare uno script bash che considera tutti i file con estensione.h contenuti direttamente nella directory /usr/include/ (non nelle sottodirectory). Lo script deve stampare sullo standard output il numero intero dato dalla somma del numero delle righe di ciascuno dei file considerati. Suggerimento: utilizzare il comando wc per ottenere il numero di righe di cui e' formato ciascun file. Esercizio 4 - script, stdout, e espressioni condizionali if Realizzare uno script bash che considera i file con estensione.h contenuti direttamente nella directory /usr/include/ (non nelle sottodirectory) e che abbiano al loro interno almeno 100 righe. Lo script deve stampare sullo standard output il numero intero dato dalla somma del numero delle righe di ciascuno dei file considerati. Suggerimento: utilizzare il comando wc per ottenere il numero di righe di cui e' formato ciascun file. Esercizio 5 - script, stdout, espressioni condizionali if e text utils ( sort etc etc ). Realizzare uno script bash che considera i file con estensione.h contenuti direttamente nella directory /usr/include/ (non nelle sottodirectory) e che al loro interno abbiano almeno 10 righe contenenti la parola ifdef. Da questi file prendere le prime 5 righe che contengono la parola ifdef. Creare un primo file che contiene tutte le righe cosi' selezionate. Usando il comando sort, creare un secondo file, chiamandolo FINALE.txt, che contiene le righe del primo file ma ordinate secondo l'ordine lessicografico crescente.

7 Esercizio 6 - esecuzione comandi, precedenze operatori e raggruppamento comandi Realizzare uno script bash che: esegue il comando echo ciao se tale comando va a buon fine esegue il comando cat /usr/include/stdlib.h se tale comando va a buon fine esegue il comando sleep 1 se tale comando va a buon fine esegue il comando false niente se tale comando NON va a buon fine esegue echo puzzola Se uno dei 5 comandi specificati non ha ottenuto il risultato indicato, allora occorre eseguire il comando cat /usr/include/stdio.h tutto lo standard output prodotto dai comandi precedenti deve essere processato dal comando grep -i -v int Esercizio 7 - espressioni condizionali realizzare uno script che mette in output il numero di directory contenute nella directory /usr/include (non considerare le directory contenute nelle sottodirectory).

8 soluzione SEMPLICE Esercizio 1 - fornaio FIFO 1/3 #define NUMCLIENTICONTEMPORANEAMENTE 50 /* variabili da proteggere */ int64_t bigliettoglob=0; int64_t bigliettosulbancone, previousbigliettosulbancone; /* variabili per la sincronizzazione */ pthread_mutex_t mutexdistributorebiglietti; pthread_mutex_t mutex; pthread_cond_t condattendiprossimoturno; pthread_cond_t condsaluto; /* aggiunta per salutare */ int main ( void) { pthread_t th, vth[numclienticontemporaneamente]; int rc, i, itot, *intptr; rc = pthread_cond_init( &condsaluto, NULL); rc = pthread_cond_init( &condattendiprossimoturno, NULL); rc = pthread_mutex_init( &mutex, NULL); rc = pthread_mutex_init( &mutexdistributorebiglietti, NULL); bigliettoglob=1; previousbigliettosulbancone=0; rc=pthread_create( &th, NULL, fornaiochesaluta,(void*)null); for(i=0;i<numclienticontemporaneamente;i++) { intptr=malloc(sizeof(int)); *intptr=i; rc=pthread_create( &(vth[i]),null,clientechevuoleesseresalutato,(void*)intptr); itot=i-1; i=0; while(1) { /* aspetto la fine di un thread e ne lancio un altro */ void *ptr; rc=pthread_join( vth[i], &ptr ); intptr=malloc(sizeof(int)); *intptr=itot; itot++; rc=pthread_create( &(vth[i]),null,clientechevuoleesseresalutato,(void*)intptr); i++; i = i%numclienticontemporaneamente;

9 continua soluzione SEMPLICE Esercizio 1 - fornaio FIFO 2/3 void *fornaiochesaluta (void *arg) { while(1) { pthread_mutex_lock(&mutex,flabel); /* dico chi e' il prossimo ad essere */ previousbigliettosulbancone=bigliettosulbancone; /* libero gli eventuali clienti che non erano di turno */ pthread_cond_broadcast ( &condattendiprossimoturno); /* aspetto che il cliente arrivi al bancone */ pthread_cond_wait ( &condsaluto, &mutex ); /* ORA il cliente ha appoggiato il suo biglietto al bancone */ /* rilascio mutua esclusione */ pthread_mutex_unlock(&mutex ); /* fornaio serve il cliente */ printf("fornaio serve cliente \n" ); fflush(stdout); /* il fornaio serve il cliente per 1/2 di sec piu o meno */ nanosleep( ); /* fornaio finisce di servire il cliente */ /* prendo la mutua esclusione */ pthread_mutex_lock(&mutex ); /* fornaio saluta per far uscire fuori il cliente */ pthread_cond_signal( &condsaluto ); printf("fornaio ha salutato cliente \n" );fflush(stdout); /* rilascio mutua esclusione */ pthread_mutex_unlock(&mutex); pthread_exit(null);

10 continua soluzione SEMPLICE Esercizio 1 - fornaio FIFO 3/3 void *clientechevuoleesseresalutato (void *arg) { int64_t biglietto; pthread_mutex_lock(&mutexdistributorebiglietti ); biglietto=bigliettoglob; /* cliente prende il biglietto */ bigliettoglob++; pthread_mutex_unlock(&mutexdistributorebiglietti ); /* cliente controlla il biglietto sul Bancone per vedere se e' il suo turno oppure no. Se non e' il suo turno aspetta che il fornaio lo risvegli. Al risveglio, il cliente controlla di nuovo se e' il suo turno. Se non e' il suo turno si blocca in attesa del prossimo turno.*/ pthread_mutex_lock(&mutex ); while( (previousbigliettosulbancone+1)!= biglietto ) { /* non sono di turno, aspetto */ pthread_cond_wait( &condattendiprossimoturno, &mutex ); /* io cliente esco dalla coda e vado al bancone del fornaio */ bigliettosulbancone=biglietto; pthread_cond_signal ( &condsaluto ); /*ok, sono al banco, ora il fornaio mi serve */ /* il cliente aspetta mentre il fornaio lo serve */ pthread_cond_wait( &condsaluto, &mutex ); /* aspetto il saluto del fornaio per andare via dal banco */ pthread_mutex_unlock(&mutex ); /* rilascio mutua esclusione */ /* e il cliente se ne va */ pthread_exit(null);

11 soluzione piu' EFFICIENTE Esercizio 1 - fornaio FIFO 0/3 UNA SOLUZIONE PIU' EFFICIENTE IMPEDISCE CHE, IN UNO STESSO TURNO, UNO STESSO CLIENTE VENGA SVEGLIATO PIU' VOLTE PER CONTROLLARE SE E' IL SUO TURNO vedi qui di seguito. La soluzione piu' efficiente e' pero' abbastanza complicata/

12 soluzione piu' EFFICIENTE Esercizio 1 - fornaio FIFO 1/3 #define NUMCLIENTICONTEMPORANEAMENTE 50 /* variabili da proteggere */ int64_t bigliettoglob=0; int64_t bigliettosulbancone, previousbigliettosulbancone; /* variabili per la sincronizzazione */ pthread_mutex_t mutexdistributorebiglietti; pthread_mutex_t mutex; pthread_cond_t condfornaiolibero; pthread_cond_t condattendiprossimoturno; pthread_cond_t condsaluto; /* aggiunta per salutare */ int main ( void) { pthread_t th, vth[numclienticontemporaneamente]; int rc, i, itot, *intptr; rc = pthread_cond_init( &condfornaiolibero, NULL); rc = pthread_cond_init( &condsaluto, NULL); rc = pthread_cond_init( &condattendiprossimoturno, NULL); rc = pthread_mutex_init( &mutex, NULL); rc = pthread_mutex_init( &mutexdistributorebiglietti, NULL); bigliettoglob=1; previousbigliettosulbancone=0; rc=pthread_create( &th, NULL, fornaiochesaluta,(void*)null); for(i=0;i<numclienticontemporaneamente;i++) { intptr=malloc(sizeof(int)); *intptr=i; rc=pthread_create( &(vth[i]),null,clientechevuoleesseresalutato,(void*)intptr); itot=i-1; i=0; while(1) { /* aspetto la fine di un thread e ne lancio un altro */ void *ptr; rc=pthread_join( vth[i], &ptr ); intptr=malloc(sizeof(int)); *intptr=itot; itot++; rc=pthread_create( &(vth[i]),null,clientechevuoleesseresalutato,(void*)intptr); i++; i = i%numclienticontemporaneamente;

13 continua soluzione piu' EFFICIENTE Esercizio 1 - fornaio FIFO 2/3 void *fornaiochesaluta (void *arg) { while(1) { pthread_mutex_lock(&mutex,flabel); /* dico chi e' il prossimo ad essere */ previousbigliettosulbancone=bigliettosulbancone; /* libero gli eventuali clienti che non erano di turno */ pthread_cond_broadcast ( &condattendiprossimoturno); /* se il prossimo cliente e' gia' in coda, ne risveglio 1 */ pthread_cond_signal ( &condfornaiolibero ); /* aspetto che il cliente arrivi al bancone */ pthread_cond_wait ( &condsaluto, &mutex ); /* ORA il cliente ha appoggiato il suo biglietto al bancone */ /* rilascio mutua esclusione */ pthread_mutex_unlock(&mutex ); /* fornaio serve il cliente */ printf("fornaio serve cliente \n" ); fflush(stdout); /* il fornaio serve il cliente per 1/2 di sec piu o meno */ nanosleep( ); /* fornaio finisce di servire il cliente */ /* prendo la mutua esclusione */ pthread_mutex_lock(&mutex ); /* fornaio saluta per far uscire fuori il cliente */ pthread_cond_signal( &condsaluto ); printf("fornaio ha salutato cliente \n" );fflush(stdout); /* rilascio mutua esclusione */ pthread_mutex_unlock(&mutex); pthread_exit(null);

14 continua soluzione piu' EFFICIENTE Esercizio 1 - fornaio FIFO 3/3 void *clientechevuoleesseresalutato (void *arg) { int64_t biglietto; pthread_mutex_lock(&mutexdistributorebiglietti ); biglietto=bigliettoglob; /* cliente prende il biglietto */ bigliettoglob++; pthread_mutex_unlock(&mutexdistributorebiglietti ); /* cliente controlla il biglietto sul Bancone per vedere se e' il suo turno oppure no. Se non e' il suo turno aspetta che qualcuno lo risvegli. Se qualcuno lo sveglia, il cliente controlla di nuovo se e' il suo turno. Se non e' il suo turno si blocca in attesa del prossimo turno.*/ pthread_mutex_lock(&mutex ); while( (previousbigliettosulbancone+1)!= biglietto ) { /* non sono di turno, aspetto */ pthread_cond_wait( &condfornaiolibero, &mutex ); if( (previousbigliettosulbancone+1)!= biglietto ) { /* prima di aspettare risveglio un altro cliente in coda */ pthread_cond_signal( &condfornaiolibero ); pthread_cond_wait( &condattendiprossimoturno, &mutex ); /* rifaccio il controllo sul loop, in attesa del fornaio libero */ else { /* e' il mio turno, esco dal loop */ break; /* io cliente esco dalla coda e vado al bancone del fornaio */ bigliettosulbancone=biglietto; pthread_cond_signal ( &condsaluto ); /*ok, sono al banco, ora il fornaio mi serve */ /* il cliente aspetta mentre il fornaio lo serve */ pthread_cond_wait( &condsaluto, &mutex ); /* aspetto il saluto del fornaio per andare via dal banco */ pthread_mutex_unlock(&mutex ); /* rilascio mutua esclusione */ /* e il cliente se ne va */ pthread_exit(null);

15 soluzione Esercizio 2 aspetta.sh #/bin/bash if (( "$#"!= 1 )) ; then echo "num arg errato" ; exit 1 ; fi sleep $1 exit 0 killa.sh #/bin/bash for pidfiglio in ${PIDFIGLI ; do kill -9 ${pidfiglio done exit 0 lanciaekilla.sh #/bin/bash for (( num=0; ${num<10; num=${num+1 )) ; do./aspetta.sh 1000 & PIDFIGLI="${PIDFIGLI $!" ; done export PIDFIGLI./killa.sh exit 0 NB: for pid in `ps aux grep sleep cut --bytes=3-10 ` ; do kill -9 $pid ; done

16 soluzione Esercizio 3 somma_h.sh #/bin/bash SOMMA= for nomefile in `ls /usr/include/*.h` ; do OUT=`wc -l ${nomefile` (( SOMMA=${SOMMA+${OUT%% * )) done echo "SOMMA=${SOMMA" exit 0 soluzione Esercizio 4 somma_h_minori100.sh #/bin/bash SOMMA= for nomefile in `ls /usr/include/*.h` ; do OUT=`wc -l ${nomefile` LINES=${OUT%% * if (( "${LINES" >= "100" )) ; then (( SOMMA=${SOMMA+${LINES )) fi done echo "SOMMA=${SOMMA" exit 0 NB: for pid in `ps aux grep sleep cut --bytes=3-10 ` ; do kill -9 $pid ; done

17 soluzione Esercizio 5 somma_h_ifdef10.sh #/bin/bash if [[ -e PARZIALE.txt ]] ; then rm -f PARZIALE.txt fi for nomefile in `ls /usr/include/*.h` ; do OUT=`cat ${nomefile grep ifdef wc -l ` LINES=${OUT%% * if (( "${LINES" >= "10" )) ; then cat ${nomefile grep ifdef head -n 5 >> PARZIALE.txt fi done sort PARZIALE.txt > FINALE.txt exit 0 soluzione Esercizio 7 find /usr/include/ -maxdepth 1 -mindepth 1 -type d wc -l NB: for pid in `ps aux grep sleep cut --bytes=3-10 ` ; do kill -9 $pid ; done