Multithreading e programmazione funzionale in Cpp0X -C++11

Multithreading e programmazione funzionale in Cpp0X C++11 Vincenzo La Spesa 10 aprile 2012

Indice 1 Introduzione: Il C++ non `e ancora morto 1.1 Lo standard C++0X - C++11 . . . . . . . . . . . . . . . . . . . . . . . .

3 4

2 il C++ e le lambda 2.1 Il caso pi` u semplice, le funzioni void . . . . . . . . 2.2 Le funzioni che usano e restituiscono parametri . . 2.3 Le funzioni lambda e la visibilit` a . . . . . . . . . . 2.4 Funzioni che ricevono funzioni e funzioni anonime . 2.5 Qualche esempio funzionale ( che funziona) . . . .

4 5 5 6 7 7

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

3 Il C++ e il Multithreading 10 3.1 Allochiamo il nostro primo thread . . . . . . . . . . . . . . . . . . . . . . 10 3.2 Thread e condivisione dei dati . . . . . . . . . . . . . . . . . . . . . . . . . 12 3.3 Allocare un Thread senza creare un oggetto . . . . . . . . . . . . . . . . . 13 4 Sincronizzazione dei Thread e gestione delle risorse con i Mutex 14 4.1 I Mutex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 4.2 Mutex ed eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 5 Uso avanzato dei Mutex 5.1 Timed mutex e la prenotazione con timeout massimo . . . . . . . . . . . . 5.2 Accesso alle funzioni interne del mutex . . . . . . . . . . . . . . . . . . . . 5.2.1 Prenotazione multipla . . . . . . . . . . . . . . . . . . . . . . . . .

18 19 19 20

6 Il problema dei 5 filosofi 21 6.1 Vari approcci ingenui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 6.2 Una soluzione funzionante . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 7 Le Condition, implementazione delle code di attesa 24 7.1 Le Condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 7.2 Ma le cose non sono cos`ı semplici... . . . . . . . . . . . . . . . . . . . . . . 25 1

8 Il problema del barbiere addormentato 26 8.1 Il barbiere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 8.2 Il cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 8.3 Codice completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 A Ambiente di sviluppo e problemi di A.1 GNU Gcc - g++ . . . . . . . A.1.1 MinGw . . . . . . . . A.1.2 Multithreading . . . . A.2 Microsoft Visual Studio . . .

compilazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

Riferimenti bibliografici

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

31 31 31 31 31 31

v1.0.0 http://www.thedarshan.com/ [email protected] Quest’opera `e stata rilasciata sotto la licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia. Per leggere una copia della licenza visita il sito web http://creativecommons.org/licenses/by-nc-sa/2.5/it/ o spedisci una lettera a Creative Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.

Questo documento `e stato prodotto e impaginato con LATEX

2

1 Introduzione: Il C++ non `e ancora morto Uno dei linguaggi che ho visto pi` u maltrattare all’Universit` a e di conseguenza poi da molti (sedicenti e/o futuri) ingegneri del software che hanno fatto il grave errore di accettare acriticamente le illazioni dei professori `e il C++ (un mio professore ne aveva quasi terrore... ) Michele Sciabarr`a anni fa scrisse in un suo post 1 veramente geniale: C++ Livello di complessit` a: ESAGERATO. Per impararlo ci metti met` a della tua vita. E poi impieghi l’altra met`a a convincere gli altri a impararlo, perch´e devi giustificare a te stesso PERCHE’ hai perduto met`a della tua vita. Credi di fare una cosa, e invece ne fai un’altra. La stessa cosa, in un caso significa una cosa e in un altro significa un’altra. Senza contare che la stessa cosa per un compilatore significa una cosa, per un altro c’`e un bug che la fa diventare un’altra, e in un altro ancora non `e supportata. E non abbiamo ancora considerato i template. Ora, Sciabarr` a scherzava ma cpp si dicono molte cose cattive...la maggior parte delle quali secondo me derivano da un confronto inappropriato e stupido con Java, si dice prima di tutto che

Il C++ ` e troppo complicato! nessuno lo conosce per intero! Il cpp non `e complicato, `e vasto. L’idea che un linguaggio vada imparato e usato per intero `e tipica dei linguaggi di nuova generazione come il Java, ma non `e assolutamente una cosa necessaria in genere. Il cpp parte dal principio che se `e possibile fare una cosa il linguaggio deve permetterlo, se poi i 4 tipi di cast o l’ereditariet`a multipla ti fanno orrore o paura...non usarli! Resta il fatto che siano utili e comodi per fare workaround, e i workaround servono ( nel mondo reale almeno) e anche fare cose orribili come modificare le variabili dichiarate costanti pu` o tornare utile. un altra idea ancora pi` u stupida ma comunque abbastanza in voga e che: La libreria del C++ ` e scarna! Confondere la libreria di un linguaggio con il linguaggio `e veramente stupido! anche dare per assunto che un linguaggio necessiti di una libreria intrinseca lo `e, peraltro le stl e la libreria standard offrono un set di funzionalit`a che copre tutte le necessit`a di base, e per il resto se ne trovano a palate di librerie pronte. E adesso veniamo al vero motivo per cui sto scrivendo: 1

http://michele.sciabarra.com/page/NonUsateQuelLinguaggio

3

1.1 Lo standard C++0X - C++11 Dicevo che c++ non `e morto e si continua ad evolvere, il suo ultimo standard non `e quello del 1998 che tutti conoscono ( o dicono di conoscere) e nemmeno quello del 2003. Nel 2008 il ’C++ Standards Committee’ ha sviluppato un nuovo standard chiamato provvisoriamente Cpp0X, la bozza `e stata presentata con il nome di N3126 il 21 agosto 2010. Il 25 marzo 2011 l’ISO vota la bozza finale (targata N3290) che viene contrassegnata come FDIS (Final Draft International Standard). Il 1o settembre 2011 viene pubblicata la versione finale del C++11 da parte di ISO e IEC. La nuova versione introduce molte nuove funzionalit`a, sia nel linguaggio che nella sua libreria standard tra cui le pi` u importanti sono il supporto alla programmazione funzionale ( delegate e lambda function) e al multithreading con l’inclusione nelle stl di un interfaccia completa ai pthread ( e chi abbia mai lavorato con quei cosi sa quanto sia prolissa attualmente la loro gestione). Attualmente il nuovo standard `e supportato dalle ultime versioni di Microsoft Visual Studio e dagli ultimi Gcc utilizzando dei flag di compilazione, le procedure di compilazione sono esposte alla fine del tutorial.

2 il C++ e le lambda Un interessante funzione introdotta nello standard C++0X sono le lambda Le funzioni lambda sono tipiche dei linguaggi che applicano il paradigma della programmazione funzionale ( completamente o in maniera ibrida) e permettono di trattare le funzioni come se fossero oggetti, potendole quindi definire in qualunque punto del codice e assegnare a una variabile. Vediamo un esempio di come questo approccio sia stato implementato nel cpp

4

2.1 Il caso pi`u semplice, le funzioni void Listing 1: le funzioni void - void #include using namespace s t d ; auto lambda = [ ] ( ) { cout << ” Questa e ’ una lambda ” << e n d l ; }; i nt main ( ) { auto lambda2 = [ ] ( ) { cout << ”Una lambda puo ’ e s s e r e d e f i n i t a anche d e n t r o un a l t r a f u n z i o n e ” << e n d l ; }; cout << ” H e l l o wo r ld ! ” << e n d l ; lambda ( ) ; lambda2 ( ) ; return 0 ; }

come si vede dal codice abbiamo definito due funzioni lambda assegnandole a variabili, adesso vediamo come comportarsi per definire funzioni che usano o producono valori (queste qui erano void− > void)

2.2 Le funzioni che usano e restituiscono parametri Listing 2: Le funzioni che usano e restituiscono parametri i nt main ( ) { auto somma = [ ] ( i nt a , i nt b ) { return ( a+b ) ; }; auto p r o d o t t o = [ ] ( i nt a , i nt b ) −> i nt { return ( a+b ) ; }; cout << ” 2+2 f a ” << somma ( 2 , 2 ) << e n d l ; cout << ” 2∗2 f a ” << p r o d o t t o ( 2 , 2 ) << e n d l ; return 0 ; }

5

la lista dei parametri in entrata viene dichiarata tra le parentesi tonde, il tipo del parametro in uscita pu`o essere definito esplicitamente con − > come nel caso di prodottoo lasciato implicito come nel caso di somma e in questo caso viene dedotto dal compilatore A questo punto vi starete chiedendo a che servano le parentesi quadre suppongo

2.3 Le funzioni lambda e la visibilit`a La programmazione a oggetti ci ha abituato al concetto di visibilit`a di una variabile, per esempio una funzione definita dentro una classe accede agli oggetti della classe, ma una lambda che pu`o essere definita in qualunque punto del codice a cosa pu` o accedere? la risposta `e: assolutamente a nulla se si vuole fare in modo che qualcosa venga visto dall’interno di una lambda bisogna passare il suo reference tra le quadre, vediamo un esempio Listing 3: un codice che non funziona i nt main ( ) { i nt c ; auto somma = [ ] ( i nt a , i nt b ) { c=a+b ; }; ...

la compilazione del pezzo di codice precedente ci dar`a un error: ’c’ is not captured per renderlo visibile dobbiamo fare questo Listing 4: Il modo giusto di procedere i nt main ( ) { i nt c ; auto somma=[&c ] ( i nt a , i nt b ) { c=a+b ; }; somma ( 2 , 2 ) ; cout << ” 2+2 f a ” << c << e n d l ; return 0 ; }

quindi passando un puntatore a this a una lambda rendiamo visibile l’intero oggetto. `e addirittura possibile passare l’intero contesto usando [&] e [=] dove la prima passa per reference e la seconda per valore

6

2.4 Funzioni che ricevono funzioni e funzioni anonime Una caratteristica fondamentale della programmazione funzionale `e la possibilit`a di passare funzioni ad altre funzioni, in questo caso per`o la sintassi del cpp `e un po sporca e siamo costretti ad usare la libreria functional perch´e non `e interamente possibile farlo direttamente usando solo il linguaggio e le sue keyword, ci servir` a la classe generica f unction < tipouscita(tipiingresso) > nell’esempio possiamo notare che `e anche possibile definire una funzione e passarla senza assegnarla a una variabile, la funzione resta quindi anonima Possiamo inoltre vedere come sia possibile modificare il comportamento di una fuzione dal suo esterno passandogli un altra funzione, infatti nel primo caso scrivisomma scrive sullo stdout mentre nel secondo su file Listing 5: funzioni che ricevono funzioni #include #include #include using namespace s t d ; i nt main ( ) { i nt c ; char∗ f i l e n a m e=” d a t i . t x t ” ; auto scr iviso mma =[&]( i nt a , i nt b , const f u n c t i o n & w r i t e r ) { c=a+b ; writer ( c ); }; auto s c r i t t o r e =[=]( i nt x ) { ofstream myfile ; m y f i l e . open ( f i l e n a m e ) ; m y f i l e << x << ” \n” ; myfile . close ( ) ; }; scr iviso mma ( 2 , 2 , s c r i t t o r e ) ; scr iviso mma ( 2 , 2 , [ ] ( i nt x ) { cout << x << e n d l ; } ) ; return 0 ; }

2.5 Qualche esempio funzionale ( che funziona) Adesso cerchiamo di inventarci qualcosa che sia comodo da realizzare con la programmazione funzionale e scomodo con quella procedurale... Abbiamo visto il caso precedente di una funzione che si aspetta un’altra funzione da utilizzare per scrivere i dati. Un

7

altro uso molto diffuso delle lambda ci permette di modificare il comportamento di un algoritmo passandogli un altro algoritmo, un semplice esempio `e una generica funzione di ordinamento a cui passiamo una funzione di confronto, questo ci permette sia di ordinare ogetti di tipi non conosciuti dalla funzione e non ordinabili a priori sia di modificare le relazioni di ordine.

8

Listing 6: un esempio completo #include #include #include #include #include #include #include

< s t d l i b . h>

using namespace s t d ; void s o r t ( void ∗ x [ ] , i nt n , const f u n c t i o n & co mpa r a to r ) { i nt i , j ; void ∗ app ; for ( i =1; i =0 && c o mpa r a to r ( x [ j ] , app) >0) { x [ j +1] = x [ j ] ; j −−; } x [ j +1] = app ; } return ; } i nt main ( ) { s r a n d ( time ( 0 ) ) ; i nt c ; char∗ c o s i [ ] = { ” p o l l o d i gomma” , ”ammaccabanane” , ” c o s o ” , ” c a n n u c c i a s b i r u l a ” } ; auto o r d i n a s t r = [ ] ( void ∗a , void ∗b)−>i nt { return s t r l e n ( ( const char ∗ ) a)− s t r l e n ( ( const char ∗ ) b ) ; }; auto d i s o r d i n a s t r = [ ] ( void ∗a , void ∗b)−>i nt { return rand ()%6 −3;}; s o r t ( ( void ∗ ∗ ) c o s i , 4 , o r d i n a s t r ) ; for ( i nt n=0;n<4;n++)co ut << c o s i [ n ] << e n d l ; cout<
9

3 Il C++ e il Multithreading Un’altra funzionalit`a molto interessante introdotta nel C++0X `e il supporto nativo al multithreading. Esistevano gi`a librerie che si occupavano di multithreading in cpp ma adesso `e integrato nel linguaggio e nella sua libreria standard anche se il backend che effettivamente alloca i thread `e l’onnipresente libreria pthread.

3.1 Allochiamo il nostro primo thread Un thread `e un qualcosa che viene eseguito in parallelo, e quindi si crea attraverso una funzione che `e quello che deve fare, non `e necessario creare una classe intorno al thread come si farebbe in Java, basta passare al costruttore di thread la funzione che deve eseguire il thread costruito o qualcosa di equivalente. Cpp `e un linguaggio marcatamente OOP e infatti non `e necessario passargli una procedura, basta qualunque ogetto supporti l’operatore (), possiamo anche creare una classe che definisce questo operatore e passarne un istanza.

10

Listing 7: Vari modi per allocare un thread #include #include #include using namespace s t d ; void c o s a d a f a r e ( ) { cout<<” Sono una p r o c e d u r a ! ”<
E’ interessante notare che quando si chiama un thread su un oggetto, come nel caso di std::thread t1(w), non gli viene passato il vero oggetto ma una sua copia, ma di questo ne parliamo dopo. Le join servono ad aspettare che i thread finiscono prima di terminare il programma,

11

infatti i thread sono concettualmente ’figli’ del processo padre ( il fatto che lo siano veramente dipende dall’implementazione) e se terminasse il processo padre i figli verrebbero terminati di conseguenza facendo generare a linux un allarmante messaggio di warning, per terminare un thread prima che abbia finito il suo lavoro si usa detach

3.2 Thread e condivisione dei dati Uno dei vantaggi dei thread rispetto ai processi `e che condividono lo spazio di memoria tra di loro, tutto quello che `e nello spazio di indirizzamento del processo padre pu`o essere passato ai figli. Quindi risulta molto conveniente piazzare dentro un oggetto la procedura del thread e i dati in cui dovr` a lavorare ma c’`e un inconveniente: come dicevamo sopra quando si chiama un thread su un oggetto, come nel caso di std::thread t1(w), non gli viene passato il vero oggetto ma una sua copia , questo `e irrilevante nel caso di oggetti che wrappano solo una procedura ma pu` o essere una fonte di bug subdoli nel caso essi contengano dati infatti modificando l’oggetto non modifichiamo niente all’interno del thread perch´e sono oggetti diversi se vogliamo evitare questo comportamento dobbiamo forzare un passaggio via reference e non abbiamo modo di farlo col linguaggio, dobbiamo affidarci alla magia nera delle stl,la soluzione `e: std::thread t1(std::ref(dw)); Vediamo un esempio

12

Listing 8: Oggetti clonati e oggetti linkati #include #include #include #include



using namespace s t d ; c l a s s Dummy { public : string testo ; s t r i n g nome ; void operator ( ) ( ) { for ( i nt a =0;a <15;a++){ cout<
Eseguendolo noterete che il comportamento del primo thread resta invariato, mentre possiamo agire sul secondo modificando i suoi dati dall’esterno.

3.3 Allocare un Thread senza creare un oggetto Malgrado la soluzione di un oggetto di wrapper pu` o tornare utile il passare dei parametri alla procedura chiamante, il che ci permette anche di non usare completamente un oggetto e di passare tutti i dati su cui deve lavorare il thread alla funzione che ne

13

costituisce il main, semplicemente accodiamo i parametri da passare alla funzione e ci affidiamo alle stl per la determinazione corretta del tipo 2 Listing 9: E se volessi passare parametri alla procedura e magari non usare un oggetto? #include #include #include #include



using namespace s t d ; void stampa ( s t r i n g co sa , s t r i n g a l t r a c o s a ) { for ( i nt a =0;a <10;a++){ cout<< c o s a << a l t r a c o s a << e n d l ; sleep (1); } } i nt main ( ) { s t d : : t h r e a d t 1 ( stampa , ” b l a b l a b l a ” , ” yada yada yada ” ) ; t1 . j o i n ( ) ; }; };

4 Sincronizzazione dei Thread e gestione delle risorse con i Mutex Come accennato nel capitolo precedente un applicazione che sfrutta il multithreading `e costituita da un insieme di processi sequenziali cooperanti, tutti in esecuzione asincrona che possono condividere dati e risorse. L’accesso concorrente ai dati o alle risorse pu` o provocare incoerenze nei dati o situazioni di deadlock nel caso di risorse che prevedono accesso esclusivo, in questo post cercher`o di analizzare gli strumenti che C++0X offre per la sincronizzazione. All’interno di un processo si possono separare le sezioni in cui lavora su dati interni da quelle in cui si accede a dati o risorse condivise, queste ultime vengono dette sezioni critiche e sono quelle di cui si deve curare la sincronizzazione. Non tratter`o in questo articolo le soluzioni ¨storiche¨e full-software per la gestione delle sezioni critiche (algoritmi di Dekker, di Peterson, algoritmo del banchiere e del panettiere di Lamport, semafori in spinlock) ma tratter`o l’uso di funzioni messe a disposizione dalla libreria che ci permettono di assicurare la mutua esclusione tra processi attraverso lo scheduler. 2

la sintassi per gli argomenti multipli esisteva gi` a, ma `e stata migliorata, se siete curiosi leggete qui http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf

14

Per prima cosa cerchiamo di definire cosa deve succedere su una sezione critica: una volta individuata e minimizzata una sezione critica dobbiamo fare in modo che 1. sia verificata la mutua esclusione ossia che soltanto un processo per volta possa trovarsi nella sezione critica 2. si eviti l’attesa indefinita da parte di un processo che tenta di accedere a una sezione critica occupata 3. un processo che si trova fuori dalla sezione critica non deve poter interferire con l’accesso alla sezione critica dei processi in attesa

4.1 I Mutex Lo strumento fondamentale per la sincronizzazione offerto dalle stl `e il Mutex, che `e la crasi di mutual exlusion e serve appunto ad evitare che pi` u processi del necessario possano accedere ad una sezione critica. Esistono 4 tipi di mutex: 1. semplice ( std::mutex ) 2. semplice con timeout ( std::timed mutex ) 3. ricorsivo ( std::recursive mutex ) 4. ricorsivo con timeout ( std::recursive timed mutex ) • un mutex `e semplice se il suo stato `e binario ( libero/occupato ) • `e invece ricorsivo se permette pi` u accessi prima di essere occupato • un mutex `e timed se `e possibile fare in modo che si liberi da solo dopo un certo tempo fondamentalmente un mutex dispone di almeno 3 funzioni: void lock(); che permette di occuparlo o di attenderlo se `e gi`a occupato void unlock(); che permette di liberarlo bool try lock(); che permette occuparlo se `e possibile senza per` o rimanere in attesa vediamo come usarli, per prima cosa costruiamo un programma che necessiti di essere sincronizzato

15

Listing 10: un codice che non funziona #include #include #include #include



using namespace s t d ; void stampa ( s t r i n g t e s t o ) { for ( i nt a =0;a
il codice ci far`a ottenere qualcosa del tipo: QHowu anmtuoc hl egwonodo rcooudelrd ebbae wuoond rocdhiutcokr cehuc ske uinf a r odiwtooroed chpuoctkes csouled rchoduecrek i l woloegdno??

16

La sincronizzazione si effettua creando un mutex globale e condividendolo tra i thread che vanno sincronizzati e racchiudendo la sezione critica dentro una lock e una unlock Listing 11: La versione sincronizzata del codice precedente ... c l a s s Worker { public : string testo ; mutex ∗m; Worker ( s t r i n g t , mutex ∗mtx ) { m=mtx ; t e s t o=t ; } void operator ( ) ( ) { m−>l o c k ( ) ; stampa ( t e s t o ) ; m−>u n l o c k ( ) ; } }; i nt main ( ) { mutex ∗m= new mutex ( ) ; t h r e a d t 1 ( Worker ( ” Quanto l e g n o r o d e r e b b e un r o d i t o r e s e un r o d i t o r e p o t e s s e r o d e r e i l l e g n o ? ” ,m) ) ; t h r e a d t 2 ( Worker ( ”How much wood c o u l d a woodchuck chuck i f a woodchuck c o u l d chuck wood? ” ,m) ) ; t1 . j o i n ( ) ; t2 . j o i n ( ) ; };

4.2 Mutex ed eccezioni Malgrado l’accesso diretto alle funzioni del mutex sia possibile `e un modo pericoloso di procedere. Infatti non gestisce le eccezioni, se un thread genera un errore all’interno della zona critica il thread viene terminato ma il mutex non viene sbloccato, quindi il modo corretto di gestire una sezione critica sarebbe usare un trycatch in questo modo:

17

Listing 12: Accesso diretto al mutex void operator ( ) ( ) { m−>l o c k ( ) ; try { stampa ( t e s t o ) ; m−>u n l o c k ( ) ; } catch ( . . . ) { m−>u n l o c k ( ) ; cout << ” Yikes ! ” << e n d l ; } }

Un modo pi` u compatto di usare in maniera sicura i mutex si pu`o ottenere usando gli ogetti lock guard delle stl, che permettono anche di rilasciare il mutex in maniera automatica quando si esce dal blocco in cui sono definite ( lo sbloccano nel loro distruttore per essere precisi), il codice precedente si pu`o riscrivere in questo modo: Listing 13: Uso di una guard void operator ( ) ( ) { l o c k g u a r d l o c k ( ∗m) ; stampa ( t e s t o ) ; }

Precisiamo una cosa per` o... Il fatto che la guard blocchi il mutex non implica che l’intero programma non venga terminato...infatti dopo aver sbloccato il mutex propaga l’eccezione generata a livello superiore e se non c’`e un catch a livello superiore questo equivale alla terminazione del processo padre Quindi se ci limitiamo a guardare questi snippet l’esempio con la gestione manuale funziona meglio di quello con la lock ma nel caso generale l’uso della lock `e comodo perch´e ci permette di scrivere codici per la gestione delle eccezioni che non tengono conto del mutex.

5 Uso avanzato dei Mutex Nell’articolo precedente ho parlato del mutex e del suo uso semplice con la lock guard. in questo tratter` o gli altri tipi di guard e l’uso avanzato dei mutex

18

unique lock u di quello che permette la lock guard Con unique lock un mutex pu`o fare molto di pi` • Si pu`o cercare di prenotarlo in maniera non bloccante ( se `e libero lo si occupa, se non `e libero non si attende) • Si pu`o cercare di prenotarlo fornendo un timeout massimo di attesa ( se si tratta di un timed mutex ovviamente) • Si pu`o accedere direttamente alle funzioni del mutex e un sacco di altre cose per le quali vi rimando a una reference

3

5.1 Timed mutex e la prenotazione con timeout massimo Disponendo di un timed mutex potremmo per esempio eseguire questo: Listing 14: Uso di un timed mutex s t d : : timed mutex m; s t d : : u n i q u e l o c k l k (m, s t d : : chr o no : : m i l l i s e c o n d s ( 5 ) ) ; i f ( l k ) work ( ) }

Questa funzione prova ad accedere al mutex aspettando massimo 5 millisecondi, il valore della lock si usa per determinare se l’accesso `e avvenuto o no

5.2 Accesso alle funzioni interne del mutex Attraverso la unique lock possiamo accedere alle funzioni del mutex, ma questa volta le eccezioni sono gestite. Listing 15: Accesso alle funzioni interne s t d : : mutex m; void z o n a c r i t i c a ( ) { s t d : : u n i q u e l o c k l k (m) ; // i n q u e s t o momento i l mutex `e o c c u p a t o lk . unlock ( ) ; // i n q u e s t o momento i l mutex `e l i b e r o lk . lock ( ) ; // i n q u e s t o momento i l mutex `e d i nuovo o c c u p a t o } 3

http://www.stdthread.co.uk/ ( lo so, non `e ufficiale... ma non ho trovato di meglio )

19

Listing 16: Costruttore non bloccante s t d : : mutex m; void z o n a c r i t i c a ( ) { s t d : : u n i q u e l o c k l k (m, s t d : : d e f e r l o c k t ( ) ) ; // i n q u e s t o momento i l mutex `e l i b e r o lk . lock ( ) ; // i n q u e s t o momento i l mutex `e o c c u p a t o lk . unlock ( ) ; // i n q u e s t o momento i l mutex `e d i nuovo l i b e r o }

5.2.1

Prenotazione multipla

Un problema molto comune nella programmazione concorrente `e la necessita da parte di un processo di accedere in maniera esclusiva a pi` u risorse, `e un problema che se gestito male pu`o causare facilmente deadlock o starvation in quanto se un processo che ha acquisito parte delle risorse necessarie attende altre risorse per continuare e queste risorse sono bloccate da altri processi anche loro in attesa tutti i processi restano bloccati in attesa l’uno dell’altro, in questo caso le stl ci vengono in aiuto dandoci un costrutto che permette di bloccare n mutex restando in attesa ma non bloccandoli Listing 17: Prenotazione multipla void p r e n o t a ( s t d : : mutex ∗ a , s t d : : mutex ∗ a ) { s t d : : u n i q u e l o c k l o c k a ( ∗ a , s t d : : d e f e r l o c k ) ; s t d : : u n i q u e l o c k l o c k b ( ∗ b , s t d : : d e f e r l o c k ) ; std : : lock ( lock a , lock b ) ; // f a i q u a l c o s a d i c r i t i c o }

20

6 Il problema dei 5 filosofi Un problema molto interessante che illustra la potenzialit`a di questo costrutto `e il problema dei 5 filosofi a cena, esso `e stato formulato da Dijkstra intorno al 1965, per mettere alla prova le primitive di sincronizzazione dell’epoca ( i semafori fondamentalmente) il problema `e questo (cito dal testo di Silberschatz) : Si considerino cinque filosofi che passano la vita pensando e mangiando. I filosofi condividono un tavolo rotondo circondato da cinque sedie, una per ciascun filosofo. Al centro del tavolo si trova una zuppiera colma di riso, e la tavola `e apparecchiata con cinque bacchette. Quando un filosofo pensa, non interagisce con i colleghi; quando gli viene fame, tenta di prendere le bacchette pi` u vicine: quelle che si trovano tra lui e i commensali alla sua destra e alla sua sinistra. Un filosofo pu`o prendere una bacchetta alla volta e non pu`o prendere una bacchetta che si trova gi`a nelle mani di un suo vicino. Quando un filosofo affamato tiene in mano due bacchette contemporaneamente, mangia senza lasciare le bacchette. Terminato il pasto, le posa e riprende a pensare. ”Il problema dei cinque filosofi `e considerato un classico problema di sincronizzazione, non certo per la sua importanza pratica, e neanche per antipatia verso i filosofi da parte degli informatici, ma perch´e rappresenta una vasta classe di problemi di controllo della concorrenza, in particolare i problemi caratterizzati dalla necessit` a di assegnare varie risorse a diversi processi evitando situazioni di stallo e d’attesa indefinita.”4 la parola starvation deriva proprio da questo problema... se non si riesce a gestire la cosa i filosofi muoiono di fame ( to starve in inglese)

6.1 Vari approcci ingenui Una semplice soluzione consiste nel rappresentare ogni bacchetta con un mutex: un filosofo tenta di afferrare ciascuna bacchetta eseguendo un’operazione lock su quel mutex e la posa eseguendo una unlock. 4

Parola di Silberschatz, che non me ne vogliano gli amici filosofi

21

Partendo da questo modello possiamo cominciare a cercare una soluzione, quella pi` u immediata potrebbe esere: un filosofo prende la bacchetta a destra, poi quella a sinistra e poi mangia. ma cosa succede se tutti prendono contemporaneamente la forchetta di destra? un deadlock, muoiono di fame aspettando che qualcuno liberi qualcosa ma nessuno liberer` a mai niente. un’altra soluzione potrebbe essere: Un filosofo di numero pari prende prima la forchetta di destra e poi quella di sinistra, un filosofo dispari il contrario Ma questo `e barare,scartiamola Ci rendiamo conto che un filosofo deve rilasciare la bacchetta se non pu`o prendere la seconda, qualcosa del tipo Un filosofo prende la bacchetta di destra, poi cerca di prendere quella di sinistra (trylock) e se non pu` o le posa entrambe e riprova in seguito ma che succede se i filosofi partono insieme? l’algoritmo va in loop: tutti prendono quella di destra, nessuno pu` o prendere quella a sinistra, tutti posano tutto e si ricomincia, le operazioni necessitano di essere eseguite in maniera atomica

6.2 Una soluzione funzionante Un filosofo cerca di prendere entrambe le bacchette contemporaneamente, se non pu` o aspetta Questo comportamento non pu`o essere costruito direttamente usando i singoli mutex, ma possiamo farlo con il nostro std::lock(lock a,lock b) La soluzione tradizionale necessita della costruzione di un Monitor, ma non me ne occuper`o qui, sfruttiamo a pieno le stl e riduciamo il problema a una cosa banale, con buona pace di Dijkstra5

5

Se siete interessati alla versione originale del problema di Dijkstra ,risolta interamente con i semafori, potete dare un occhiata a questo testo su google docs http://goo.gl/96ZaX , se poi avete anche interessi archeologici c’`e la scansione della versione originale dattiloscritta qui http://www.cs.utexas.edu/~ EWD/ewd03xx/EWD310.PDF

22

Listing 18: Il problema dei 5 filosofi di Dijkstra ... class F i l o s o f o { public : i nt i d ; mutex ∗ d e s t r a ; mutex ∗ s i n i s t r a ; F i l o s o f o ( i nt n , mutex ∗d , mutex ∗ s ) { i d=n ; d e s t r a=d ; s i n i s t r a=s ; } void pensa ( ) { s t r i n g a r g o me nti [ 5 ] = { ” A l l a fame n e l mondo” , ” Al punto G” , ” All o r i g i n e d e l l Universo ” , ” Al s e n s o d e l l a v i t a ” , ” A l l a domanda l a c u i r i s p o s t a e ’ 42 ” }; cout << i d << ” : Sto pensando . . . ” << a r g o me nti [ i d ] << e n d l ; u s l e e p ( 10000 ∗ ( rand ( ) % 90 + 10 ) ) ; }; void mangia ( ) { p r i n t f ( ”%d : Cerco l e b a c c h e t t e . . . \ n” , i d ) ; s t d : : u n i q u e l o c k l o c k a ( ∗ d e s t r a , s t d : : d e f e r l o c k ) ; s t d : : u n i q u e l o c k l o c k b ( ∗ s i n i s t r a , s t d : : d e f e r l o c k ) ; std : : lock ( lock a , lock b ) ; p r i n t f ( ”%d : Sto mangiando . . . \ n” , i d ) ; u s l e e p ( 30000 ∗ ( rand ( ) % 90 + 10 ) ) ; p r i n t f ( ”%d : Poso l e b a c c h e t t e , s a z i o \n” , i d ) ; };

}; ...

void operator ( ) ( ) { p r i n t f ( ”%d : Penso q u i n d i sono \n” , i d ) ; u s l e e p ( 30000 ∗ ( rand ( ) % 90 + 10 ) ) ; for ( i nt a =0; a <5; a++) { pensa ( ) ; mangia ( ) ; } }

23

7 Le Condition, implementazione delle code di attesa 7.1 Le Condition Le Condition sono un meccanismo di sincronizzazione che permette ai thread di sospendersi in attesa che avvenga un evento e di essere risvegliati quando l’evento accade, permettono quindi di creare delle code di attesa. Nelle STL le condition sono oggetti della classe std::condition variable. I metodi fondamentali per usarle sono tre: wait() permette di accodarsi alla condition notify one() notify all() permettono di risvegliare uno o tutti i thread in attesa sulla coda (nell’implementazione tradizionale dei pthread si chiamavano signal e broadcast) A una Condition `e sempre associato un mutex per evitare race condition che potrebbe creare un thread che si sta preparando a una wait mentre un altro thread esegue una signal, la signal potrebbe infatti avvenire contemporaneamente alla wait e venire quindi persa creando un deadlock, pu` o essere usato un mutex qualunque o si pu` o creare un mutex proprio della condition Vediamone il funzionamento con un semplice codice: Listing 19: 10 thread si mettono in coda su una condition e un altro thread li sveglia uno per volta #include #include #include #include #include



using namespace s t d ; c l a s s Worker { public : i nt numero ; s t d : : c o n d i t i o n v a r i a b l e ∗ coda ; mutex ∗m; Worker ( i nt n , s t d : : c o n d i t i o n v a r i a b l e ∗ cond , mutex ∗mtx ) { coda=cond ; numero=n ; m=mtx ; }

24

};

void operator ( ) ( ) { cout << ” Thread ”<< numero << ” a l l o c a t o , mi metto i n coda ” << e n d l ; s t d : : u n i q u e l o c k l k ( ∗m) ; coda−>wa it ( l k ) ; cout << ” Thread ”<< numero << ” r i s v e g l i a t o d a l l a coda ” << e n d l ; }

i nt main ( ) { s t d : : c o n d i t i o n v a r i a b l e ∗ coda= new c o n d i t i o n v a r i a b l e ( ) ; mutex ∗m= new mutex ( ) ; i nt a ; std : : thread ∗ threads [ 1 0 ] ;

};

for ( a =0;a <10;a++){// c r e o t h r e a d s [ a ]= new s t d : : t h r e a d ( Worker ( a +1 , coda ,m) ) ; u s l e e p ( 100000 ) ; } for ( a =0;a <10;a++){// s v e g l i o u s l e e p ( 1000 ∗ ( rand ( ) % 9 0 0 ) ) ; coda−>n o t i f y o n e ( ) ; } for ( a =0;a <10;a++)// a s p e t t o t e r m i n e { t h r e a d s [ a]−> j o i n ( ) ; delete ( t h r e a d s [ a ] ) ; }

7.2 Ma le cose non sono cos`ı semplici... • Malgrado di solito non succeda le specifiche dei pthread non garantiscono che l’ordine in cui i thread si sveglino sia uguale a quello in cui si addormentano, quindi in caso di applicazioni dove l’ordine degli accessi `e importante questo va verificato esplicitamente. • Un altra cosa che potrebbe succedere ( e questa `e pi` u grave ) `e che pi` u di un thread venga liberato dalla coda, quindi i thread appena svegliati devono di nuovo verificare che la condizione che li ha fatti accodare sia stata soddisfatta ed eventualmente rimettersi in coda.

25

8 Il problema del barbiere addormentato Vediamo un applicazione delle condition a un problema pi` u complesso, il problema del barbiere addormentato di Dijkstra. il problema `e definito in questo modo: Un negozio di barbiere `e costituito da una sala con una sola poltrona sulla quale si accomoda il cliente che viene servito e da una sala d’attesa con n sedie. Se non ci sono clienti da servire il barbiere va a dormire. Se arriva un cliente e tutte le sedie della sala d’attesa sono occupate, il cliente va via, mentre, se c’`e una sedia libera e il barbiere `e occupato, il cliente attender` a, seduto, il proprio turno. Se il barbiere sta dormendo (cio`e `e libero, senza clienti in attesa), il cliente lo sveglia e viene servito subito. La soluzione `e pi` u prolissa di quello che potrebbe sembrare a prima vista, tralaltro nell’implementarlo ho istintivamente usato un monitor anche se non ho accennato a questo tipo di costrutti, ne do soltanto una breve definizione OOP Un monitor ` e un oggetto che incapsula la risorsa ed espone i metodi per accedervi in maniera sicura In questo caso, come si vede nel sorgente sottostante, il contatore delle sedie occupate `e nascosto dentro la classe Stanza che mette a disposizione i metodi per occupare e liberare una sedia mantenendoli sincronizzati attraverso un semaforo proprio della classe. L’approccio che ho utilizzato `e questo:

8.1 Il barbiere 1. Controlla se ci sono clienti in attesa (attraverso i metodi del Monitor) 2. se non ce ne sono si addormenta ( svegliandosi al punto 3) 3. se ce ne sono li rade e torna al punto 1 la rasatura consiste in: • liberare un Cliente dalla coda della sala di attesa (attesa.notify one) , il cliente liberato occupa la coda della poltrona • radere il Cliente, liberarlo dalla coda della poltrona (poltrona.notify one())

8.2 Il cliente 1. Entra nella sala, cerca di sedersi (a) Se pu`o sedersi: i. Se `e l’unica persona seduta sveglia il barbiere (letto.notify one()) ii. va al punto 2 (b) Se non pu`o sedersi esce dalla sala e va al punto 5 26

2. Si mette in attesa nella coda della sala (attesa.wait(lk)) 3. una volta svegliato occupa il barbiere (barbiere− > lock()) e si mette in attesa sulla sedia della poltrona (poltrona.wait(∗barbiere)). il mutex sul barbiere evita il problema di una possibile signal non voluta ( vedi sopra il paragrafo 7.2) una volta svegliato libera il barbiere ed esce dalla sala 4. va in giro a bighellonare e poi torna al punto 1 In questa implementazione sono possibili delle signal superflue su un barbiere gi`a sveglio, ma sono irrilevanti

8.3 Codice completo Listing 20: Problema del barbiere addormentato #include #include #include #include #include



using namespace s t d ; i nt dormi ( f l o a t base , f l o a t v a r i a b i l e ) { i nt k =1000∗1000; i nt b a s e i =( i nt ) ba se ∗k ; i nt v a r i a b i l e i =0; i f ( v a r i a b i l e >0) v a r i a b i l e i=rand ( ) % ( i nt ) ( v a r i a b i l e ∗k ) ; u s l e e p ( b a s e i+v a r i a b i l e i ) ; return b a s e i+v a r i a b i l e i ; }; c l a s s Sta nza { private : i nt o c c u p a t e ; s t d : : mutex monitor m ; public : std : : c o n d i t i o n v a r i a b l e attesa ; std std std std i nt

: : mutex a t t e s a m ; : : c o n d i t i o n v a r i a b l e poltrona ; : : condition variable letto ; : : mutex b a r b i e r e ; sedie ;

27

i nt p r e n o t a ( ) { s t d : : u n i q u e l o c k l k ( monitor m ) ; i f ( o ccupa te>=s e d i e ) return −1; o c c u p a t e++; cout << o c c u p a t e << ” s e d i e o c c u p a t e ”< l k ( monitor m ) ; return o c c u p a t e ; } i nt l i b e r a ( ) { s t d : : u n i q u e l o c k l k ( monitor m ) ; o ccupa te −−; cout << o c c u p a t e << ” s e d i e o c c u p a t e ”<
};

Sta nza ( i nt n s e d i e ) { this −>s e d i e=n s e d i e ; o c c u p a t e =0; }

class Barbiere { public :

i nt numero ; i nt a z i o n i ; Sta nza ∗ s t a n z a ; s t d : : u n i q u e l o c k ∗ b a r b i e r e ; B a r b i e r e ( Sta nza ∗ s t ) { a z i o n i =0; this −>s t a n z a=s t ; b a r b i e r e= new s t d : : u n i q u e l o c k ( sta nza −>b a r b i e r e , s t d : : d e f e r l o c k t ( ) ) } void operator ( ) ( ) {

28

while ( true ) { cout << ” B a r b i e r e c o n t r o l l a s e c i sono c l i e n t i i n a t t e s a ”<guarda ()==0) { cout << ” B a r b i e r e s i addormenta”< l k ( sta nza −>b a r b i e r e ) ; stanza −>l e t t o . wa it ( l k ) ; }

};

}

}

cout << ++a z i o n i <<” B a r b i e r e s e r v e un c l i e n t e ”<a t t e s a . n o t i f y o n e ( ) ; dormi ( 2 , 2 ) ; stanza −>p o l t r o n a . n o t i f y o n e ( ) ;

class Cliente { public :

i nt numero ; Sta nza ∗ s t a n z a ; s t d : : u n i q u e l o c k ∗ b a r b i e r e ; C l i e n t e ( Sta nza ∗ s t , i nt n ) { s t a n z a=s t ; numero=n ; b a r b i e r e= new s t d : : u n i q u e l o c k ( sta nza −>b a r b i e r e , s t d : : d e f e r l o c k t ( ) ) } void work ( ) { cout << ” Thread ”<< numero << ” a l l o c a t o , e n t r a d a l b a r b i e r e ” << e n d l ; i nt s=sta nza −>p r e n o t a ( ) ; i f ( s <0) { cout << ” Thread ”<< numero << ” t u t t e l e s e d i e sono o ccupa te , e s c e ” << e n d l ; return ; } else { i f ( s >0) { cout << ” Thread”<< numero << ” s i s i e d e e a s p e t t a ” << e n d l ; i f ( s==1)

29

{ cout << ” Thread ”<< numero << ” s v e g l i a i l b a r b i e r e ” << e n d l ; dormi ( 1 , 0 ) ; stanza −>l e t t o . n o t i f y o n e ( ) ;

}

} s t d : : u n i q u e l o c k l k ( sta nza −>a t t e s a m ) ; stanza −>a t t e s a . wa it ( l k ) ; cout << ” Thread”<< numero << ” s i a l z a ” << e n d l ; stanza −>l i b e r a ( ) ;

b a r b i e r e −>l o c k ( ) ; cout << ” Thread ”<< numero << ” s i s i e t e e s i f a r a s a r e ” << e n d l ; stanza −>p o l t r o n a . wa it ( ∗ b a r b i e r e ) ; b a r b i e r e −>u n l o c k ( ) ; cout << ” Thread ”<< numero << ” e s c e ” << e n d l ; }

};

} void operator ( ) ( ) { for ( i nt a =0; a <2; a++) { work ( ) ; cout << ” Thread ”<< numero << ” va i n g i r o a b i g h e l l o n a r e ” << e n d l ; dormi ( 3 0 , 3 0 ) ; } cout << ” Thread ”<< numero << ” muore” << e n d l ; }

i nt main ( i nt a r g c , char ∗∗ a r g v ) { Sta nza s t a n z a ( 5 ) ; i nt a ; std : : thread ∗ threads [ 1 5 ] ; s t d : : t h r e a d ∗ b a r b i e r e=new s t d : : t h r e a d ( B a r b i e r e (& s t a n z a ) ) ; for ( a =0; a <15; a++) // c r e o { dormi ( 0 , a ) ; t h r e a d s [ a ]= new s t d : : t h r e a d ( C l i e n t e (& sta nza , a + 1 ) ) ; } for ( a =0; a <15; a++) // a s p e t t o t e r m i n e { t h r e a d s [ a]−> j o i n ( ) ; delete ( t h r e a d s [ a ] ) ;

30

}

};

A Ambiente di sviluppo e problemi di compilazione Questa `e la parte pi` u ’instabile’ del tutorial: come si compila il codice Cpp0X. Quando ho incominciato a scrivere la serie di articoli la bozza del progetto era ancora in fase di approvazione da parte dell’ISO, adesso che sto finendo di creare un tutorial dai miei post sul blog `e uno standard approvato ma ancora in fase di diffusione. Le cose sono cambiate e continuano a cambiare.

A.1 GNU Gcc - g++ Il compilatore che ho usato in tutti i codici, supporta il nuovo standard attraverso il flag -std=c++0x ( da g++ ovviamente) Le funzioni sono incluse nei compilatori GNU a partire dalla 4.5 A.1.1

MinGw

E’ possibile compilare parte dei sorgenti usando MinGw6 che `e un porting windows di gcc, il supporto di compilazione `e completo mentre non lo `e il supporto alle librerie, in particolare quelle riguardanti i thread visto che i pthread non hanno un corrispettivo windows ( non open source quantomeno7 ) A.1.2

Multithreading

Il supporto ai thread della stl usa la libreria pthread per creare e gestire i thread, per attivarla ci si serve del flag -lpthread ed `e necessario che gcc includa gcc-multilib (disponibile come pacchetto in molte distribuzioni di linux) se non funziona e in particolare se da errori del tipo ’fatal error: asm/errno.h’ bisogna applicare una patch alla libreria andate su /usr/include/ e controllate che esista la cartella asm-generic, se esiste fatene un link software su /usr/include/asm (NON rinominatela, non si sa mai che pu`o succedere con un aggiornamento di pacchetti ). Questo dovrebbe risolvere il problema, e possibilmente mentre sto scrivendo non `e pi` u una cosa necessaria.

A.2 Microsoft Visual Studio Fonti bene informate8 mi dicono che il supporto a Cpp0X `e completo in Visual Studio 2010 6

http://www.mingw.org/ http://www.justsoftwaresolutions.co.uk/ 8 http://www.romeoxbm.tk/it/ Francesco Guastella, un mio collega in diverse cose universitarie e non 7

31

Riferimenti bibliografici [1] http://www.thedarshan.com/informatica/2011/02/il-c-non-e-ancora-morto/ [2] http://www.thedarshan.com/informatica/2011/03/il-cp-e-le-lambda-c0x/ [3] http://www.thedarshan.com/informatica/2011/10/il-c-e-il-multithreading-c0x/ [4] http://www.thedarshan.com/informatica/2011/10/sincronizzazione-dei-thread-egestione-delle-risorse-con-i-mutex-c0x/ [5] http://www.thedarshan.com/informatica/2011/11/uso-avanzato-dei-mutex-i-5filosofi-c0x/ [6] http://www.thedarshan.com/informatica/2011/11/le-condition-implementazionedelle-code-di-attesa-il-problema-del-barbiere-addormentato-c0x/

32