alma mater studiorum universit`a di bologna il modello ad attori per la programmazione ...

127 Pages·2012·0.82 MB·Italian

ALMA MATER STUDIORUM
`
UNIVERSITA DI BOLOGNA
Seconda Facolta` di Ingegneria con sede a Cesena
Corso di Laurea in Ingegneria Informatica
IL MODELLO AD ATTORI PER LA
PROGRAMMAZIONE CONCORRENTE:
IL LINGUAGGIO AXUM SU .NET
COME CASO DI STUDIO
Elaborato in
SISTEMI OPERATIVI
TesidiLaureadi Relatore
ANGELO CROATTI Prof. ALESSANDRO RICCI
Anno Accademico 2011 – 2012
Ia Sessione di Laurea

PAROLE CHIAVE
Modello ad Attori
Programmazione Concorrente
Scambio Asincrono di Messaggi
AXUM
.NET Framework

alla mia famiglia

Indice
Introduzione xi
Sommario xv
1 Il Software e la Concorrenza 1
1.1 Aspetti generali . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Microprocessori multi-core . . . . . . . . . . . . . . . . . 2
1.3 Una nuova rivoluzione nel software . . . . . . . . . . . . 4
1.3.1 Vantaggi e Costi dell’approccio concorrente . . . . 5
1.4 Modelli per il parallelismo . . . . . . . . . . . . . . . . . 5
1.5 Concorrenza e Linguaggi . . . . . . . . . . . . . . . . . . 6
1.6 Tools per lo sviluppo . . . . . . . . . . . . . . . . . . . . 8
2 Programmazione Multithread 9
2.1 Il concetto di Thread . . . . . . . . . . . . . . . . . . . . 9
2.2 Lo spazio delle informazioni condivise . . . . . . . . . . . 10
2.2.1 Gestione delle corse critiche: i lock . . . . . . . . 10
2.2.2 Deadlock . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Sincronizzazione . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.1 Approccio mediante Semafori . . . . . . . . . . . 12
2.3.2 Monitor, alternativa ai semafori . . . . . . . . . . 13
2.4 Criticita` della programmazione multithread . . . . . . . 14
3 Il modello ad Attori 17
3.1 Definizione di Attore . . . . . . . . . . . . . . . . . . . . 17
3.2 Proprieta` semantiche . . . . . . . . . . . . . . . . . . . . 19
3.2.1 Incapsulamento . . . . . . . . . . . . . . . . . . . 19
3.2.2 Atomicit`a . . . . . . . . . . . . . . . . . . . . . . 20
3.2.3 Fairness . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.4 Location Transparency . . . . . . . . . . . . . . . 21
3.3 Sincronizzazione . . . . . . . . . . . . . . . . . . . . . . . 21
3.3.1 RPC-like Messaging . . . . . . . . . . . . . . . . 22
vii
viii INDICE
3.3.2 Local Synchronization Constraint . . . . . . . . . 23
3.4 Esecuzione di un programma ad attori . . . . . . . . . . 24
3.5 Vantaggi del modello ad attori . . . . . . . . . . . . . . . 25
3.5.1 Coordinazione . . . . . . . . . . . . . . . . . . . . 25
3.6 Problematiche e osservazioni . . . . . . . . . . . . . . . . 26
3.7 Applicazioni del modello ad attori . . . . . . . . . . . . . 27
3.7.1 Twitter: microblogging e social network . . . . . 28
3.7.2 Dart: linguaggio per applicazioni web strutturate 29
3.7.3 Orleans: piattaforma per il cloud computing . . . 30
4 Alcune implementazioni del modello 33
4.1 Linguaggio Erlang . . . . . . . . . . . . . . . . . . . . . 34
4.1.1 Attori in Erlang . . . . . . . . . . . . . . . . . . . 35
4.1.2 Scheduling . . . . . . . . . . . . . . . . . . . . . . 37
4.2 Linguaggio Scala . . . . . . . . . . . . . . . . . . . . . . 37
4.2.1 Attori in Scala . . . . . . . . . . . . . . . . . . . 38
4.2.2 Attori Thread-based e Attori Event-based . . . . 41
4.2.3 Messaggi Sincroni e relative problematiche . . . . 42
4.3 Erlang e Scala: breve confronto . . . . . . . . . . . . . . 44
4.4 Libreria ActorFoundry . . . . . . . . . . . . . . . . . . . 45
4.4.1 Esempio d’uso . . . . . . . . . . . . . . . . . . . . 46
4.4.2 Meccanismo per l’invio di messaggi . . . . . . . . 47
4.5 Analisi delle Performance . . . . . . . . . . . . . . . . . . 48
5 AXUM: linguaggio ad attori 51
5.1 Uno sguardo d’insieme . . . . . . . . . . . . . . . . . . . 52
5.2 Meccanismo di Asyncronous Message Passing . . . . . . 55
5.3 Elementi per la comunicazione . . . . . . . . . . . . . . . 57
5.3.1 Channel e Port . . . . . . . . . . . . . . . . . . . 57
5.3.2 Tipi non ammessi e Schema . . . . . . . . . . . . 59
5.3.3 Request Correlator e porte Request-Reply . . . . 62
5.3.4 Protocolli di comunicazione . . . . . . . . . . . . 64
5.4 Realizzazione di Agenti . . . . . . . . . . . . . . . . . . . 65
5.4.1 Domini . . . . . . . . . . . . . . . . . . . . . . . . 66
5.4.2 Creazione di agenti e Hosting . . . . . . . . . . . 66
5.4.3 Riferimento all’implementing end . . . . . . . . . 67
5.4.4 Ereditariet`a . . . . . . . . . . . . . . . . . . . . . 68
5.5 Condivisione di informazioni . . . . . . . . . . . . . . . . 69
5.5.1 Semantica Reader/Writer per Agenti . . . . . . . 71
5.6 Modificatori per dati locali . . . . . . . . . . . . . . . . . 72
5.7 Metodi asincroni . . . . . . . . . . . . . . . . . . . . . . 73
INDICE ix
5.7.1 Performance e regole d’uso . . . . . . . . . . . . . 74
5.8 DataFlow Network . . . . . . . . . . . . . . . . . . . . . 75
5.8.1 Nodi di interazione . . . . . . . . . . . . . . . . . 75
5.8.2 Operatori . . . . . . . . . . . . . . . . . . . . . . 78
5.9 Axum e il .NET Framework . . . . . . . . . . . . . . . . 82
5.9.1 Lo stato dell’arte . . . . . . . . . . . . . . . . . . 83
5.9.2 Integrazione con .NET Framework 4.5 . . . . . . 83
6 Analisi critica su AXUM 85
6.1 Axum e il Modello ad Attori . . . . . . . . . . . . . . . . 86
6.1.1 Agenti e mailbox . . . . . . . . . . . . . . . . . . 86
6.1.2 Canali e messaggi . . . . . . . . . . . . . . . . . . 87
6.1.3 Primitiva receive esplicita . . . . . . . . . . . . 88
6.1.4 L’approccio mediante DataFlow Network . . . . . 89
6.2 Flessibilita` nello scrivere applicazioni . . . . . . . . . . . 90
6.2.1 Implementazione orientata ai canali . . . . . . . . 91
6.2.2 Implementazione orientata al DataFlow . . . . . . 93
6.2.3 Implementazione orientata ai domini . . . . . . . 95
6.3 Integrazione tra Axum e C# . . . . . . . . . . . . . . . . 98
6.4 Applicazioni concorrenti distribuite . . . . . . . . . . . . 98
Conclusioni 101
Ringraziamenti 105
Bibliografia 107