Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.
UNIVERSITÀ DEGLI STUDI DI TRIESTE                FACOLTÀ DI INGEGNERIA     CORSO DI LAUREA SPECIALISTICA IN INGEGNERIA    ...
RingraziamentiScrivere i ringraziamenti di questa tesi è un passo importante, nel fare ilquale spero di non dimenticare ne...
letti di spritz!A m3kka, per aver implementato una List in Java e per le mille altre stupi-daggini che ci hanno portato a ...
Vale, Xander, Biz, Ushti, la ragazza di Ushti, Scano, Jessica, Marta, Mono,i ba di Mono.Come da consuetudine i ringraziame...
IndiceRingraziamenti                                                                       iIntroduzione                  ...
2.2.4   Runtime Manager . . . . . . . . . . . . . . . . . . . . .          24         2.2.5   Constraint Store       . . ....
5.3.2   Modello sCCP . . . . . . . . . . . . . . . . . . . . . . .      71        5.3.3   Analisi delle Prestazioni   . . ...
IntroduzioneLa costruzione di modelli di alcuni aspetti della realtà è sempre stata untassello fondamentale del metodo di ...
mework: si partirà dalle basi teoriche esposte nel primo capitolo per proget-tare la visione funzionale dei moduli del pro...
1    1
Capitolo 1Nozioni TeoricheIn questo capitolo verranno presentate sintetizzate le nozioni teoriche per lacomprensione dei c...
1. Composizione in parallelo   2. Indicazione del canale per il trasferimento dati   3. Composizione sequenziale delle azi...
di output.Generalmente si indica il usso di input come      x(v) e il usso di output comexy(supponendo   x il nome del can...
Chiamate RicorsiveUna chiamata ricorsiva prevede la possibilità di far si che un processo ese-gua sé stesso (o un altro pr...
•   Constraint: deriva dallutilizzo di una rappresentazione della memoria       a vincoli come il Constraint Store;   •   ...
Azioni       Le azioni che permettono di eettuare degli update condizionatidel Constraint Store. Lagente eettua gli Ask e ...
[   → t = 10]Scelta     La scelta permette di associare più azioni ad un solo agente.La scelta prevede, come si vede in gr...
1.2 Algebre di Processo StocasticheNel corso delle prossime sottosezioni verrà analizzato un ambiente in cui,dato lo stato...
Rate(a)P (A) =   RateT otaleIn queste formule:                        +   • λπ : CS →              è il Rate dellazione è ...
[true - x=x+1]Questa farà riferimento allaggiunta del valore sulla destra nella lista denitadal nome che compare sulla sin...
STEP   X    RATE     AZIONE                          0      0    5        X   =X   +1                          1      1   ...
S   : lettera    S   |Ed essendo un innito numerabile posso associare a ciascuna variabile chegenero un numero intero che ...
Quindi, avendo vericato questo possiamo asserire che :Eseguendo sCCP tutte le azioni della macchina URM può, co-me CCP, pe...
2. Ogni Agente del tipo A è uguale ad ogni altro Agente del tipo A.   3. Ogni passaggio di variabili è fatto per riferimen...
A1 : − [ X  0 → X = X + 1]@{k}.A2diventa:[ X  0 → X = X + 1; SV 1 = SV − 1; SV 2 = SV + 1]@{k}Incrementare una variabile d...
Questo sistema, viene convertito in:t1 = [SV 1  0 ∧ X  0−  X = X − 1; SV 1 = SV 1 − 1; SV 2 =SV 2 + 1]@{k1}t2 = [SV 1  0 ∧...
laggiornamento delle variabili di stato:      ki   ∈ R,   se i è aggiornata esplicitamentek=      0,          altrimenti  ...
Capitolo 2Analisi e ProgettazioneIn questo capitolo verranno analizzate le fasi di Analisi e di Progettazionesvolte per cr...
inoltre di permettere allutente di poter simulare passo passo per compren-dere landamento non solo in chiave temporale, ma...
•   Utente      •   Altri SoftwareDa quanto visto sopra, possiamo riassumere le attività che lutente può farein:      •   ...
Use Cases Diagram2.2.1 Standardizzazione di Input ed OutputSi è fortemente cercata lindipendenza delle parti su tutti i fr...
les DTD apposta. Lutilizzo di questo sistema ha portato ad una sempli-cazione anche nella creazione dei compilatori stessi...
Figura 2.1: Primo Approccio Progettuale2.2.3 Il CompilatoreIl Compilatore in questo progetto non è unico e non perchè si è...
correttamente il proprio lavoro.ParserAM conosce in questo modo i dati per la denizione del nuovo Con-straint Store; oltre...
2.2.5 Constraint StoreIl Constraint Store (CS) sarà la memoria del nostro sistema.          In esso cisaranno le variabili...
Agente :- [X  0 - X = X-1]@{1}.Agente  + [X == 0 - X = 10]@{1}.([ - Y= Y + 1]@{1}.Agente || Agente + Agente);Questa strutt...
Figura 2.2: Rappresentazione concettuale delle classiParser GUIQuesta WPF Window è stata progettata per essere il più semp...
completamente dedicata al graco. Si sono volute mostrare anche le variabilicon i loro valori e gli agenti in vita, ma la m...
Capitolo 3InterfacciaIn questo capitolo tratteremo lutilizzo del framework in oggetto di questoelaborato.Nella prima parte...
Nel menù     Engine   è possibile scegliere il simulatore tra i tre visti nelleprecedenti sezioni:   •   sCCP   •   ITS   ...
Per la compatibilità delle istruzioni assegnate in Ask, Tell o Rate si rimandaal Capitolo 4.   Un Tell può esser costituit...
3.2.2 Il Codice SourceCSIn questa sezione si vedrà come scrivere il SourceCS per modellare il Con-straint Store con il qua...
3.3 La SimulazioneIn questa sezione si analizzeranno sCCP-GraphicSimulator e sCCP-BatchSimulator.Entrambi possono venir es...
Seconda SchermataNella seconda schermata lutente può impostare le impostazioni riguardanti ilgraco. Nella lista superiore ...
•   Save Status - Salva una simulazione   •   Save CSV - Salva i dati su disco in Comma Separated Values   •   Close - Chi...
che rimane allinterno di un intervallo.Il numero di simulazioni sarà proporzionale al numero di combinazioni pos-sibili. S...
Capitolo 4ImplementazioneDopo aver esposto le nozioni teoriche nel capitolo 1, lanalisi e la progettazio-ne nel capitolo 2...
inseriti nelle liste di punti opportune.Nel gestire simulazioni parellele contemporanee, onde evitare problemi concalcoli ...
•   GetVariablesÈ stato necessario appoggiarsi ad un parser di espressioni matematiche pergestire il Constraint Store. La ...
Name    ARC    Explanationsin     1      sine functioncos     1      cosine functiontan     1      tangens functionasin   ...
Operator    Meaning                     Priority                =           assignement                 -1                ...
prevede un metodo Solve che accetta come parametri un array di double e unintero contenente il numero di parametri. Questa...
È facile comprendere il caos che si può creare durante questa conversione.È stato necessario convertire le stringe in mani...
FLEEFLEE(Fast Lightweight Expression Evaluator) è un valutatore di espressionimolto veloce dalle funzionalità ridotte. La ...
Constraint Store riceve un Tell, verica se la stringa è formata da nome va-riabile seguita dal simbolo =. Se così è allora...
•   Boolean - true o false   •   Real - Ogni numero con un punto decimale.            Con d ed f  si può       specicare l...
di semplicità di scrittura tramite Constraint si consiglia muParser.Per una descrizione più approfondita di Flee, si riman...
Le AzioniLe azioni (come visto nel capitolo 2.2.6) vengono raccolte in ActionManagerche a loro volta vengono contenuti da ...
•    ForceRefresh: forza il refresh   •    GetActionData: ritorna un oggetto con i dettagli dellazioneLutilizzo di funzion...
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Banovaz Diego - Tesi
Upcoming SlideShare
Loading in …5
×

Banovaz Diego - Tesi

884 views

Published on

Diego Banovaz - Prelaurea

Published in: Technology
  • Be the first to comment

  • Be the first to like this

Banovaz Diego - Tesi

  1. 1. UNIVERSITÀ DEGLI STUDI DI TRIESTE FACOLTÀ DI INGEGNERIA CORSO DI LAUREA SPECIALISTICA IN INGEGNERIA INFORMATICAIMPLEMENTAZIONE IN .NET DI UN FRAMEWORK PER LANALISI DI SISTEMI BIOLOGICI BASATO SULLAPROGRAMMAZIONE CONCORRENTE CON VINCOLI.Laureando RelatoreDiego Banovaz prof. Luca Bortolussi ANNO ACCADEMICO 2009 - 2010
  2. 2. RingraziamentiScrivere i ringraziamenti di questa tesi è un passo importante, nel fare ilquale spero di non dimenticare nessuno.In primis vorrei ringraziare il mio relatore, Luca Bortolussi, per avermi ac-compagnato in questo viaggio verso la follia della durata di sei mesi. In molteoccasioni ha saputo spronarmi o fustigarmi per spingermi ad andare avanticon il lavoro. In particolar modo è a lui che si deve la stesura corretta delle-laborato; senza il suo intervento infatti non sempre avrei trovato la forza diriordinare quella che era una matassa intricata di idee `gettate su un foglio.Voglio ringraziare poi la mia famiglia: mia madre Silvia, in arte Iena, laquale ha saputo insegnarmi con dolcezza e pugno di ferro che cosa signichiprendersi un impegno; mio padre Loris, meglio noto come Bao, che non hamai lesinato un gesto aettuoso o un incoraggiamento. Spero possano trarreda questa occasione almeno una parte dellentusiasmo e della graticazioneche loro hanno sempre saputo darmi.Ringrazio poi mio fratello Daniele, o Menion, per avermi trasmesso innume-revoli passioni e ben pochi sani principi. Devo sicuramente a questa `guerradei venticinque anni buona parte della mia formazione caratteriale. Azzar-dando che almeno un lettore su due abbia pensato `purtroppo, non possofare altro che far ricadere sul fratello malvagio la colpa.Il mio pensiero va poi ai miei Nonni, Alda, Cornelio, Danira e Giordano pergli insegnamenti che hanno saputo darmi nel corso degli anni e per quantodi buono mi hanno trasmesso.Un grande grazie va a Giordana, per avermi reso (e rendermi) ogni giornopiù felice. Un grazie per essere sempre al mio anco, nei momenti belli e inquelli brutti.Fine della pseudo-serietà.Un grazie di proporzioni bibliche va al Sig. Federico Morsut (quel de Gra-do!), per avermi accompagnato in tutto questo percorso di studi e non solo;per esser stato sempre ad ascoltare e sempre disponibile. Unico!Al Dott. Mr.P per lamicizia di mille mila anni, dalla sabbionaia agli stiva- i
  3. 3. letti di spritz!A m3kka, per aver implementato una List in Java e per le mille altre stupi-daggini che ci hanno portato a sghignazzare insieme.Al buon lelìn per le mille avventure arontate insieme (quando torniamo aNovalia?)A PoL, perchè i motivi da elencare sarebbero troppi.A ZaK, per essere una delle persone migliori che conosco.Grazie a tutti i fenomeni del DMI: dal furlanissimo Ghise, al karate-kid-spartano Alex, alla New Entry Luka, al buon vecchio Peo, al PortaNOT tr3,ad Alice e a tutti quelli che mi odieranno per essermeli dimenticati!Un grazie va anche a tutti i compagni di LAN della Tana: a kapa per ilfalsetto potente, a Spruss per le cene di Bio, a Spino per essere un camper,a Conza per la risata suina, a Defy per i rosik trascendentali, a Max perla fede nel Dark Cocumber, a Iccio per la perdita dellolfatto, a Jack per itormentoni immancabili, a 0rka per lArroganza, a minivap per larroganza,a jockey per nominarmi tra le due e le trecento volte a LAN, a Diu per lusoscorretto di qualunque Zombie a Left, a Kane per essersi beccato con gioiai miei Commando in CnC, a Baz per avermi fornito una scena alla Porkysche dicilmente dimenticherò, a Turbo per lo Strip CnC con la corriera disvedesi, a Tora per le sponte in ET, a Fil per la corretta fede nel sacro UTserale, a Sick perchè tutto è un GdR, a Pislner Urquel per lUT in esecuzioneautomatica, a Angel per i quintali di gamberetti in salsa rosa, a Gandalf perlutilizzo corretto della parole Bollione, a Pietro per aver involontariamenteassaggiato, a Toom per la risata contagiosa e letale, a Gibo per il wood rivelascritte idiote, a bubez per esser sempre più sfalcià, al Wolf per le Storie delLupo e alla sk0d3 per essere la prova vivente che una donna non può essereforte ad UT, per quanto ci provi.Ai miei cuginetti condividi-pasto/cartoni-inutili del pranzo dalla nonna, An-gelica e Davide (e ovviamente anche a Fede e Roby). A tutta la musica, inparticolar modo agli Opeth.Grazie anche agli Insanity Fair (Jo, Tati, Alf, Mauro) e agli Overtures (Meek,Dani, Luka, Cum, Guitty) per le tournè/viaggi e per le incredibili serate vis-sute insieme.Al Gippo (alias el Bomber) per le innumerevoli volte che mi ha lasciato vince-re a PES adducendo innumerevoli scuse improbabili, alla pazientissima Sarae al suo acerrimo nemico Rudy.A Niha, Maru, m3kka e Diu per la GdR experience in montagna.A butra, per i racconti dei Mig Russi e del cemento per el controllo climatico.A Nebbia, el Folpo, el Guru, Patachini e a tutti i compagni di carretto dellaSagra.Un grazie anche ai Bodri per tutte le Bodrate insieme: Hale, Ophy, Sara, ii
  4. 4. Vale, Xander, Biz, Ushti, la ragazza di Ushti, Scano, Jessica, Marta, Mono,i ba di Mono.Come da consuetudine i ringraziamenti son stati scritti 10 minuti prima dimandare in stampa la tesi, quindi saranno sicuramente carichi di mancanzee lacune. iii
  5. 5. IndiceRingraziamenti iIntroduzione vii1 Nozioni Teoriche 1 1.1 Algebre di Processo . . . . . . . . . . . . . . . . . . . . . . . . 1 1.1.1 Operazioni dei processi . . . . . . . . . . . . . . . . . . 1 1.1.2 CCP: Concurrent Constraint Programming . . . . . . . 4 1.2 Algebre di Processo Stocastiche . . . . . . . . . . . . . . . . . 8 1.3 sCCP: Stocastic Concurrent Constraint Programming . . . . . 8 1.3.1 Rate . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 1.3.2 Constraint Store . . . . . . . . . . . . . . . . . . . . . 9 1.3.3 Grammatica . . . . . . . . . . . . . . . . . . . . . . . . 10 1.3.4 Le potenzialità del sCCP . . . . . . . . . . . . . . . . 11 1.4 ITS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.4.1 Limitazioni del linguaggio . . . . . . . . . . . . . . . . 13 1.4.2 Modello ITS . . . . . . . . . . . . . . . . . . . . . . . . 14 1.4.3 Le Variabili di Stato . . . . . . . . . . . . . . . . . . . 14 1.4.4 Transizioni . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.5 ODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.5.1 Deterministicità del Linguaggio . . . . . . . . . . . . . 16 1.5.2 La denizione di ODE . . . . . . . . . . . . . . . . . . 162 Analisi e Progettazione 18 2.1 Analisi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.1.1 Analisi dei Requisiti . . . . . . . . . . . . . . . . . . . 18 2.1.2 Studio dei Casi dUso . . . . . . . . . . . . . . . . . . . 19 2.2 Progettazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.2.1 Standardizzazione di Input ed Output . . . . . . . . . 21 2.2.2 I Macro Moduli . . . . . . . . . . . . . . . . . . . . . . 22 2.2.3 Il Compilatore . . . . . . . . . . . . . . . . . . . . . . . 23 iv
  6. 6. 2.2.4 Runtime Manager . . . . . . . . . . . . . . . . . . . . . 24 2.2.5 Constraint Store . . . . . . . . . . . . . . . . . . . . . 25 2.2.6 Denition Store . . . . . . . . . . . . . . . . . . . . . . 25 2.2.7 Interfaccia Graca . . . . . . . . . . . . . . . . . . . . 263 Interfaccia 29 3.1 Installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.2 Il Codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.2.1 Il Codice SourceAM . . . . . . . . . . . . . . . . . . . 30 3.2.2 Il Codice SourceCS . . . . . . . . . . . . . . . . . . . . 32 3.3 La Simulazione . . . . . . . . . . . . . . . . . . . . . . . . . . 33 3.3.1 Graphic Simulator . . . . . . . . . . . . . . . . . . . . 33 3.3.2 Batch Simulator . . . . . . . . . . . . . . . . . . . . . . 354 Implementazione 37 4.1 Dettagli dellInterfaccia Graca . . . . . . . . . . . . . . . . . 37 4.2 SCCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 4.2.1 Il Constraint Store . . . . . . . . . . . . . . . . . . . . 38 4.2.2 Denition Store . . . . . . . . . . . . . . . . . . . . . . 47 4.2.3 Runtime Manager . . . . . . . . . . . . . . . . . . . . . 50 4.2.4 ParserCS . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.2.5 ParserAM . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.3 ITS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 4.3.1 Constraint Store e Denition Store . . . . . . . . . . . 55 4.3.2 Runtime Manager . . . . . . . . . . . . . . . . . . . . . 56 4.3.3 ParserCS e ParserAM . . . . . . . . . . . . . . . . . . 59 4.4 ODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 4.4.1 ParserAM e ParserCS . . . . . . . . . . . . . . . . . . 60 4.4.2 Transition System . . . . . . . . . . . . . . . . . . . . . 605 Test 63 5.1 Esempio #1: client server . . . . . . . . . . . . . . . . . . . . 63 5.1.1 Analisi del problema . . . . . . . . . . . . . . . . . . . 63 5.1.2 Modello sCCP . . . . . . . . . . . . . . . . . . . . . . . 65 5.1.3 Analisi delle prestazioni . . . . . . . . . . . . . . . . . 66 5.2 Esempio #2: Lotka-Volterra . . . . . . . . . . . . . . . . . . . 67 5.2.1 Analisi del Sistema . . . . . . . . . . . . . . . . . . . . 67 5.2.2 Modello sCCP . . . . . . . . . . . . . . . . . . . . . . . 68 5.2.3 Analisi delle Prestazioni . . . . . . . . . . . . . . . . . 69 5.3 Esempio #3: Sintesi di Glucosio da Lattosio in E-Coli . . . . . 70 5.3.1 Analisi del Sistema . . . . . . . . . . . . . . . . . . . . 70 v
  7. 7. 5.3.2 Modello sCCP . . . . . . . . . . . . . . . . . . . . . . . 71 5.3.3 Analisi delle Prestazioni . . . . . . . . . . . . . . . . . 73 5.4 Esempio 4: Numero elevato di Agenti . . . . . . . . . . . . . . 736 Conclusioni 75Bibliograa 76 vi
  8. 8. IntroduzioneLa costruzione di modelli di alcuni aspetti della realtà è sempre stata untassello fondamentale del metodo di indagine scientico.Le tecniche di modellizzazione dei giorni nostri permettono di descrivere e ra-gionare su aspetti sempre più complessi del mondo. In questo la matematicae linformatica hanno un ruolo fondamentale: la prima fornisce una corniceformale entro cui costruire dei modelli, la seconda mette a disposizione po-tenti strumenti computazionali per lanalisi.Laumento della potenza computazionale e il miglioramento delle tecniche dianalisi non sono tuttavia sucienti a rendere la modellizzazione matematicapervasiva anche nelle discipline scientiche storicamente più descrittive (acausa della loro complessità), come la biologia.Costruire modelli formali e analizzarli a calcolatore sono attività complicateche richiedono nozioni approfondite di matematica ed informatica, oltre chenellambito specico del modello.Per queste ragioni oggigiorno cè la tendenza a creare degli ambienti di svi-luppo integrato per la creazione ed analisi di modelli, che rendano questaattività accessibile anche a non specialisti. Sullonda di questa evoluzionesi è deciso di arontare largomento di questa tesi: creare un ambiente disviluppo per SCCP, un linguaggio per la creazione di modelli ad agenti con-correnti ad evoluzione stocastica.Nel corso del progetto sono stati svolte le fasi di analisi, progettazione erealizzazione dello stesso e sono state portate tutte a termine: il frameworkadesso esiste e rispetta tutte le speciche preventivate.Lo stesso è composto da uninterfaccia graca che si interfaccia tramite XMLe CSV e tre compilatori diversi che sono stati scritti appositamente per ri-spondere a tre diverse esigenze.Nel primo capitolo tratteremo le nozioni teoriche che sono le fondamenta ne-cessarie per arontare il problema: si parlerà infatti di Algebre di Processo,Algebre di Processo Stocastiche e si daranno alcuni tratti sul lavoro svoltodai tre compilatori che sono stati creati.Nel secondo capitolo si aronteranno lAnalisi e la Progettazione del fra- vii
  9. 9. mework: si partirà dalle basi teoriche esposte nel primo capitolo per proget-tare la visione funzionale dei moduli del progetto.Nel terzo capitolo si darà una visione esterna del progetto, si tratterà lin-stallazione e lutilizzo delle diverse componenti che formano il progetto.Nel quarto capitolo si guarderà più da vicino al progetto: si analizzeranno leclassi più importanti, si vedranno i punti di forza e di debolezza delle scelteoperate, e si vedranno a livello pratico la dierenza tra i diversi compilatori.Il quinto capitolo sarà unanalisi prestazionale e funzionale del framework:si studieranno le prestazioni rispetto a diversi programmi SCCP, si confron-teranno le tempistiche e le performance dei diversi compilatori cercando ditrovare dei punti nei quali approfondire gli sforzi per migliorare il frameworkstesso.Inne, nel sesto capitolo, si trarranno le conclusioni su quanto è stato fatto.Lintero codice è stato scritto dal tesista, eccezzion fatta per alcuni mo-duli di supporto esterno che verranno segnalati per la corretta valutazionedelloperato. viii
  10. 10. 1 1
  11. 11. Capitolo 1Nozioni TeoricheIn questo capitolo verranno presentate sintetizzate le nozioni teoriche per lacomprensione dei capitoli successivi.Dapprima verranno presentate le algebre di processo come formalismo perla denizione di programmi ad agenti concorrenti. In seguito verrà espostoCCP, come esempio di linguaggio concorrente.Nelle sezioni seguenti si scenderà in dettaglio su sCCP e gli argomenti neces-sari per capire le tre semantiche a disposizione del framework.1.1 Algebre di ProcessoLe algebre di processo (in inglese, Process Algebras) sono un linguaggio for-male che permette di descrivere levoluzione parallela di più processi con leconseguenti modiche del sistema stesso. Il formalismo prevede che levolu-zione segua tre regole principali: 1. I processi (chiamati anche Agenti) comunicano tra loro tramite mes- saggi (attraverso memoria condivisa) 2. La descrizione dei processi avviene tramite lutilizzo di semplici primi- tive, composte per formare della azioni più complesse. 3. Viene denita unalgebra che imponga delle regole per gli operatori dei processi.1.1.1 Operazioni dei processiSecondo la teoria, ogni processo è composto dalla concatenazione di più azioniatomiche; nello specico queste sono: 1
  12. 12. 1. Composizione in parallelo 2. Indicazione del canale per il trasferimento dati 3. Composizione sequenziale delle azioni atomiche 4. Restrizione di dati e comunicazioni 5. Scelta tra più possibili azioni 6. Chiamata ricorsiva ad un processo 7. Azione nullaNelle sottosezioni successive verrà spiegato il signicato di ognuna di questeoperazioni.Composizione in ParalleloPer indicare una composizione in parallelo viene utilizzato loperatore || .Un esempio può essere il seguente:Agente1||Agente2La semantica di questa azione è traducibile nellistanziazione ed esecuzio-ne parallela degli agenti (equivalente a processo) indicati come Agente1 edAgente2. Sebbene possa sembrare limitante il parallelo denito in questomodo, basti pensare che uno dei due agenti composto da un altro paralleloper vedere che il numero di Agenti da istanziare in parallelo con una singolaazione è illimitato.ComunicazioneLa comunicazione è un azione atomica che permette a degli agenti di comuni-care tra loro. Si capisce subito come dei processi paralleli privi di possibilitàdi comunicare risultino di scarso interesse e per questo motivo quesazione ècosì importante; solitamente vi sono due modi per due processi di comunicare: • Tramite lausilio di variabili o aree di memoria condivise; • Tramite il passaggio diretto di dati;Il primo punto è autoesplicativo: basta dare libero accesso ad opportune areedi memoria ed il gioco è fatto.Per il secondo punto vanno invece deniti il canale, il usso di input e quello 2
  13. 13. di output.Generalmente si indica il usso di input come x(v) e il usso di output comexy(supponendo x il nome del canale, v il vettore di dati da ricevere e y il vettoreda spedire)A livello semantico lelemento di input specica che il processo è in attesa didati in arrivo, mentre lelemento di output specica che il processo è prontoa inviare sul canale i dati.Composizione in sequenzaLa composizione in sequenza permette di collegare nellesecuzione un numeroindenito di azioni. Vediamo un semplice esempio della composizione delleazioni che abbiamo nora visto.Supponiamo di voler descrivere un agente che attenda un parametro di in-gresso per poi istanziare due agenti (A1 e A3) in parallelo: Questo processopotrebbe venir descritto come:x(v).(A1(v)||A3(v))Focalizzare dati / comunicazioniUn processo può voler limitare il numero di connessioni che gli altri agentipossono aprire con lui: lhiding gli permette di nascondere il canale di comu-nicazione (o variabile) ad altri agenti. In pratica lagente fa il wrapper disé stesso e nasconde allesterno parte dei suoi canali.SceltaLa scelta permette ad un agente di scegliere in maniera non deterministicalazione da eseguire.Loperatore per la scelta è il +, unesempio di utilizzo potrebbe essere:P0 :- P1 + P2;In questo caso, al momento dellesecuzione di P0, questi sceglierà quale azioneinvocare. 3
  14. 14. Chiamate RicorsiveUna chiamata ricorsiva prevede la possibilità di far si che un processo ese-gua sé stesso (o un altro processo), permettendo la costruzione di cicli e diesecuzioni illimitate/innite.Azione nullaLazione nulla (indicata in innumerevoli modi, come nil, null, 0) fa terminareil processo che la invoca. Questa capacità viene utilizzata per terminareselettivamente un agente in determinate situazioni (sicchè non rimanga inmemoria ultimata la sua esecuzione).1.1.2 CCP: Concurrent Constraint ProgrammingCCP è un linguaggio di programmazione a processi concorrenti basato suivincoli che sta alla base di sCCP. La dierenza principale tra i due sta nellanon-deterministicità di CCP che si contrappone alla stocasticità di sCCP.Nelle prossime sezioni verranno presentate le componenti che contraddistin-guono il linguaggio.Constraint StoreIl Constraint Store è la rappresentazione che CCP ha della memoria. In essole variabili non assumono un semplice valore, ma rappresentano un insiemedi valori che la variabile stessa può assumere.Questa denizione è più estesa rispetto quella di Von Neumann: permetteinfatti di associare alle variabili insiemi di valori, ma anche insiemi con unsolo elemento e quindi sono evidenti le maggiori potenzialità.È possibile accedere al Constraint Store attraverso due funzioni: Ask e Tell.Ask è una chiamata che pone una domanda al gestore della memoria, nellospecico gli chiede la validità di una formula.Tell invece impone un nuovo vincolo al sistema espresso come formula logicaal primo ordine.Si noti come i diversi Tell vadano ad inserire nuovi vincoli, senza in alcunmodo toccare quelli esistenti: questa condizione può portare facilmente al-linconsistenza del sistema, ma utilizzata nel modo corretto porta le variabiliad appartenere a dei domini di accettazione sempre più ristretti.È comprensibile allora il nome di questo linguaggio: • Concurrent: deriva dalla presenza di Agenti in un ambiente conccoren- te; 4
  15. 15. • Constraint: deriva dallutilizzo di una rappresentazione della memoria a vincoli come il Constraint Store; • Programming: indica che si tratta di un linguaggio di programmazione;Identicate le componenti di base, si può procedere alla denizione dellagrammatica del linguaggio.La Grammatica di CCPDi seguito viene esposto la sintassi del linguaggio nella conveniente forma digrammatica. P rogram ::= Declaration.Agente Declaration ::= ε | Declaration.Declaration | p(x): −Agente Azioni ::= ask(c) → tell(c) Scelta ::= Azione.Agente | Scelta + Scelta Agente ::= 0 | Agente.Agente | Scelta | Agente Agente | ∃x Agente | p(x) Tabella 1.1: La sintassi di CCP.Programma Programma è il punto di partenza della grammatica, in CCPquesti è costituito dalle dichiarazioni degli agenti e dallagente iniziale.Declaration Le dichiarazioni possono essere una, più di una o anche nes-suna; si indicano con la forma:N omeAgente (v ) : − AgenteUna dichiarazione rappresenta il prototipo di un Agente; contiene le diverseazioni che fanno parte del comportamento del processo stesso e le variabililocali che gli appartengono. 5
  16. 16. Azioni Le azioni che permettono di eettuare degli update condizionatidel Constraint Store. Lagente eettua gli Ask e i Tell al Constaint Store.Ricordiamo brevemente quali sono le azioni compiute da ask e tell: • Ask(condizione) permette allagente di domandare al Constraint Store la validità della condizione; • Tell(condizione) permette allagente di aggiungere al Constraint Store il vincolo espresso in condizione;Si veda lesempio quì riportato per capire lutilizzo delle guardie stesse.if (x 5) y = 9;diventa:ask(x 5).tell(y = 9)Si è deciso, sempre prendendo spunto da unidea trovata in [1], di adot-tare la seguente scrittura per le guardie:[ condizione → condizione ]La semantica scelta impone di interpretare come Ask tutte el condizioneche stanno a destra delloperatore → , mentre ciò che sta dopo viene inter-pretato come Tell.La condizione prima esposta:ask(x 5).tell(y = 9)diventa:[ x5→y=9 ]Questa forma contratta non impone lutilizzo di entrambe le azioni (Aske Tell), in quanto basta omettere le condizioni od utilizzare dei vincoli sem-pre veri:[ true → t = 10 ]Contratto per comodità in: 6
  17. 17. [ → t = 10]Scelta La scelta permette di associare più azioni ad un solo agente.La scelta prevede, come si vede in grammatica, la distinzione tra le varieazioni separate da il segno +. Ogni elemento che forma una somma è costi-tuito da una guardia seguita da unAgente.Agente1 : − [x 0 → y = 0].Agente1()+ [x == 0 → (x = 10) (y = 0)].Agente1();Questo è la denizione di unAgente, operante sulle variabili globali x edy che compie le seguenti azioni:Se x 0, impongo un nuovo vincolo per cui y debba essere positiva;Se x == 0, impongo un nuovo vincolo per cui x debba essere minore ugualea 10.Quando viene chiesto di eseguire ad un agente, questi sà quali sono le guardiesono vere (con Ask true) e quali no: eseguirà solo le azioni corrispondentialle prime.Si noti come in questo particolare esempio lagente ha sempre e solo una solaazione da eseguire: non è possibile infatti che entrambi le azioni superino leguardie perchè presupporrebbe che nello stesso istante x sia maggiore a 0 eanche uguale a 0. Nel caso più guardie siano attive contemporaneamente, lascelta viene eettuata in modo non-deterministico.Agente Lagente è la parte centrale non solo della grammatica, ma dellinguaggio in generale: formato da azioni e variabili locale è lelemento sottoosservazione da parte della simulazione. UnAgente è formalmente compostoda agenti, guardie e scelte che a loro volta vengono composte per ottenere laforma dello stesso da noi voluta. Un esempio di Declaration potrebbe essere:P (x = 0) : − [true → x = 0].( P 2() || P 3() ) + P 4();Questa viene interpretata come:Declaration - Scelta tra (Guardia seguita da parallelo e chiamata P4) 7
  18. 18. 1.2 Algebre di Processo StocasticheNel corso delle prossime sottosezioni verrà analizzato un ambiente in cui,dato lo stato della memoria e lindice dellistruzione non è possibile sapere ilrisultato che questa avrà, ma al massimo si potrà fare delle stime su questovalore.1.3 sCCP: Stocastic Concurrent Constraint Pro- grammingsCCP è un linguaggio per la descrizione di modelli in cui agenti interagisconotra loro e con lambiente in modo concorrente; inoltre questa interazione ègovernata da leggi probabilistiche.sCCP è unestensione stocastica di CCP e da esso eredita le peculiarità fon-damentali: il Constraint Store e gli Agenti. Questo linguaggio prevede lacomunicazione tra agenti come asincrona, ottenuta tramite lutilizzo di va-riabili globali condivise. sCCP è strutturato in modo da avere tutte le azioniviste prima: scelta non deterministica, composizione in parallelo, chiamataricorsiva e in più la dichiarazione di variabili locali.Levoluzione temporale di sCCP è profondamente legata alle catene di Mar-kov Tempo Continue, come spiegato in [1]. In questa sezione analizzeremo illinguaggio e ne studieremo le dierenze con CCP.1.3.1 RateAd ogni azione interagente con il Constraint Store, viene associato un valore∈ + che rappresenta il Rate. Il Rate è il prametro di una distribuzione diprobabilità esponenziale che descrive il tempo che lazione impiega a venireeseguita. Ad ogni passo si verica una Race Condition tra le diverse azioniattive: verrà eseguita quella che impiega il tempo minore. Questa evoluzionesi può descrivere (dal punto di vista matematico) equivalentemente tramitela scelta di un azione con probabilità proporzionale al rate, aumentando iltempo secondo una distribuzione di probabilità esponenziale con Rate Tota-le. Questultimo si può calcolare come: Rate(A) = π∈Actions Gπ (i) ∗ λπ RateT otale = A∈ActiveAgents Rate(A)Si evince che la probabilità di esecuzione di un Agente è: 8
  19. 19. Rate(a)P (A) = RateT otaleIn queste formule: + • λπ : CS → è il Rate dellazione è dipendente dallo stato corrente del Constraint Store. • G(i) : CS → 0, 1 rappresenta un valore booleano associato alla guardia: 1 se la condizione in Ask è vera, 0 se non lo è.Lo scorrere del tempo, viene quindi calcolato come:Tempo = Tempo + ∆T∆T = −1/T ∗ log U (con U distribuzione uniforme di probabilità tra 0 e 1)Azioni a Rate InnitosCCP prevede la possibilità di avere delle azioni con Rate innito. Questeazioni vengono chiamate Azioni Istantanee ed hanno le seguenti peculiarità: • Non incrementano il tempo. (∆T = 0) • Vengono eseguite prima di ogni azione stocastica.1.3.2 Constraint StoreEssendo un derivato diretto di CCP, anche sCCP ha un suo Constraint Sto-re. Per aggiungere potenzialità al linguaggio, sono state aggiunte le StreamVariables, come denite in [1]. In applicazioni di biologia o chimica, spessole variabili devono poter cambiare il loro valore, non solo linsieme dei valoriche vi si possono attribuire.Nel sequente esempio si capisce i limiti imposti da una struttura senza StreamVariables:[true- X=5][true- X=X+1]Questa istruzione porta ad uno stato inconsistente. Per questo motivo è statopensato il sistema delle Stream Variables: associando ad ogni variabile unalista (in particolare con variabile in coda non istanziata) possiamo aggiungerein coda i nuovi valori. Nel momento in cui ci si trovi a volere il valore di quelladata variabile, basterà guardare il valore in coda, ma la presenza allinternodi essa di tutta la sua storia non viola il resto della teoria. In tutto il restodellelaborato, nelle situazioni in cui si trova una scrittura del tipo: 9
  20. 20. [true - x=x+1]Questa farà riferimento allaggiunta del valore sulla destra nella lista denitadal nome che compare sulla sinistra. Nellapprofondimento pratico vedremocome questa gestione teorica può essere implementata con un sistema divariabile standard a singolo valore.1.3.3 Grammatica P rogram = Declaration.Agente Declaration = ε | Declaration.Declaration | p(x) : −Agente Agente = 0 | [→ U]@∞.Agente | Scelta | ∃x Agente | Agente Agente Scelta = π.Guardia | Scelta + Scelta π = [G → U]@λ | [G → U]@∞ Guardia = 0 | tell∞ (c).Guardia | p(y) | Scelta | ∃x Guardia | Guardia Guardia Tabella 1.2: Sintassi del sCCP. LsCCP ha una diversa grammatica per descriverlo, in cui la dierenzaprincipale sta nellassegnazione dei valori di Rate. Oltre a ciò si vede comeogni azione debba avere un peso e, essendo questo vincolato alle guardie, ogniazione deve iniziare con una guardia. Un possibile esempio potrebbe essereil seguente (dove @ è seguito dal Rate):Agente1 : - [X=0-X=X+1]@{5}.Agente1() +[X3-X=X-5]@{3}.Agente1();Agente2 : - [X0 -X=X*2]@{1/X}.Agente2();Agente1 || Agente2Analizziamo brevemente questo esempio, supponendo il valore iniziale di Xsia 0. 10
  21. 21. STEP X RATE AZIONE 0 0 5 X =X +1 1 1 1 X =X ∗2 2 2 0.5 X =X ∗2 3 4 3.25 X =X −5 4 -1 5 X =X +1 5 0 5 X =X +1Per quanto quasi tutti i punti siano deterministici (in questo esempio ad hoc)al punto 3 è stata eettuata una scelta. Nello specico le azioni attive erano:a)[X 3-X =X -5]@{3}b)[X 0 -X =X *2]@{1/X}Nello specico è stata fatta una scelta a favore della prima azione per motivistatistici: 3 0.25p(a)= p(b)= 3.25 3.25Ovviamente poteva anche accadere il contrario e avremmo raggiunto unoSTEP 4 con X pari a 8 e Rate totale pari a 3.125. A questo punto nuova-mente si sarebbe eettuata una scelta, aggiornata con i nuovi valori di Rate. 3 0.125p(a)= p(b)= 3.125 3.125Questo banalissimo esempio mostra unoscillazione controllata del valore diX.1.3.4 Le potenzialità del sCCPDa questo esempio si desume la versatilità del sistema e la possibilità di im-plementare praticamente ogni tipo di algoritmo: si pensi per un attimo allamacchina URM, gemella di quella Turing, e alle 4 operazioni da essa imple-mentate.sCCP ha tutte le potenzialità della macchina URM, e quindi diquella di Turing.Dimostrazione: Per prima cosa lenumerabilità dei registri: nella mac-china URM questi sono inniti ma, lo sono anche in questo caso, in quantole variabili sono le produzioni ottenibili da una grammatica del tipo: 11
  22. 22. S : lettera S |Ed essendo un innito numerabile posso associare a ciascuna variabile chegenero un numero intero che diventerà il numero del registro della macchinaURM.Le operazioni della macchina teorica URM sono: 1. Z(n), n=1, 2, 3, ... . In risposta a questa istruzione la URM azzera il registro n, lasciando gli altri registri inalterati: rn := 0. 2. S(n), n=1, 2, 3, ... . In risposta a questa istruzione la URM aumen- ta il contenuto del registro n di una unità, lasciando gli altri registri inalterati, rn := rn + 1. 3. T (m, n), m,n=1, 2, 3, ... . In risposta a questa istruzione la URM trasferisce il contenuto del registro m nel registro n, tutti gli altri registri compreso Rm rimangono inalterati, rn := rm . 4. J(m, n, q), m,n,q=1, 2, 3, ... .In risposta a questa istruzione la URM confronta il contenuto dei registri rm ed rn se: rm = rn allora con- tinua con listruzione successiva nel programma, rm = rn allora salta allistruzione q nel programma. Si vede subito allora che (supponendo x = rn e y = rm ) 1. Z(n) Azzeramento → [true - x = 0] 2. S(n) Incremento → [true - x = x + 1] 3. T(m,n) Scambio → [true - x = y] 4. J(m,n,q) Salto Condizionato → [x == y - true].IstrQ + [x! =y - true]Per aiutare a capire la dimostrazione in altro modo, è possibile esaminare unalgoritmo scritto in questo modo:Agente1:- [x == 0 - x = x + 1]@1 . Istruzione + [x == 1 - x = x + 1]@1.IstruzioneAgente2:- [x == 2 - x = x + 1]@1 . Istruzione + . . .In questo caso il valore di x determina in maniera deterministica quale azio-ne verrà eseguita: lunica azione con la guardia attiva, infatti, sarà quellaeseguibile. Si può fare un paragone tra la variabile x di questo esempio elIstruction Pointer di un normale calcolatore: agendo su questa otterremodei salti verso altre azioni. 12
  23. 23. Quindi, avendo vericato questo possiamo asserire che :Eseguendo sCCP tutte le azioni della macchina URM può, co-me CCP, per la Tesi di Church-Turing computare ogni funzionecomputabile.1.4 ITSITS è la seconda semantica di sCCP che è stata implementata. In questasezione ne analizzeremo le qualità e i limiti che, dal punto di vista teorico,ci han permesso di crearla. Dapprima vedremo le limitazioni del linguaggio,analizzando poi variabili di stato, transizioni e inne un esempio. È neces-sario ricordare che si vuole giungere ad una simulazione di tipo stocastico.Dellargomento viene data una trattazione superciale, per approfondimentisi rimanda a [5].Il procedimento che si è arontato prevede la creazione di una nuova seman-tica per il nostro sorgente sCCP, in modo da descrivere in un altro modo ilmodello descritto nel sorgente stesso. In questo caso si tratta di una visioneche passa dalla visione ad agenti ad una visione a transizioni. Le tran-sizioni, denite formalmente nella sezione specica, rappresentano in suntoun passo eseguibile dal sistema per andare da uno stato ad un altro stato.Nello specico possiamo creare una transizione partendo da qualunque dellenostre azioni. Va ricordato che, non essendoci le variabili locali, ogni agenteè uguale a qualunque altro agente che implementi la stessa denizione. Perdescrivere ecientemente il sistema, si introducono le State Variables.1.4.1 Limitazioni del linguaggioPer poter funzionare il sistema a Transizioni il codice deve sottostare aiseguenti vincoli: • Non può essere utilizzata la composizione in parallelo nelle denizioni, ma solo per denire lo stato iniziale. • Non esistono azioni istantanee (con Rate innito). • Ogni azione è nella forma [Ask− T ell]@{Rate}.Agente. • Gli Agenti non posseggono variabili locali.Queste condizioni portano a: 1. Il numero di Agenti è costante. 13
  24. 24. 2. Ogni Agente del tipo A è uguale ad ogni altro Agente del tipo A. 3. Ogni passaggio di variabili è fatto per riferimento.Queste due asserzioni sono fondamentali ai ni pratici. Alla prima vi si arrivatramite un procedimento molto semplice ed intuitivo. Siamo nella situazionein cui: • Ho N Agenti iniziali dati dallo stato iniziale. • Non ho composizione parallela allinterno della denizione degli agen- ti(N non può crescere). • Ogni azione è della forma [ Ask → T ell]@{Rate}.Agente, quindi il numero di Agenti non può calare.In generale, queste proprietà, specie lassenza di variabili locali, garantisconoche le variabili di stato siano una descrizione corretta dello stato del modellosCCP.1.4.2 Modello ITSUn modello ITS viene dato da una tupla ITS = (X, S, T )Dove: • X è linsieme costituito dalle variabili globali • S è linsieme delle variabili di stato • T è linsieme delle transizioniLe Variabili Globali sono le stesse viste per sCCP.1.4.3 Le Variabili di StatoIndicate con la lettera S nella denizione del sistema, le variabili di statopermettono di descrivere e di gestire in maniera eciente lo stato delle tran-sizioni del sistema. Ogni variabile di stato è associata ad una denizione diun agente, e descrive il numero di agenti di quel tipo attualmente attivi nelsistema. Di questa denizione, rappresenta il numero di agenti attivi che larappresentano. Il valore di una State Variable è dunque sempre un numeronaturale.Ogni update delle transizioni sCCP dovrà essere modicato per descrivereanche laggiornamento delle variabili di stato. Ad esempio: 14
  25. 25. A1 : − [ X 0 → X = X + 1]@{k}.A2diventa:[ X 0 → X = X + 1; SV 1 = SV − 1; SV 2 = SV + 1]@{k}Incrementare una variabile di stato equivale dunque ad aggiungere un agentedel tipo associato al sistema stesso. Decrementarla equivale ad eliminarneuno.Supponiamo di avere il seguente agente A1 precedentemente descritto. Laguardia sarà passabile se:X 0 ∧ SV 1 0E il rate dato dagli agenti dello stesso tipo sarà:A1λ = SV 1 ∗ kIn altri termini, la prima formula impone che se il numero di Agenti è pari a0, nessuna azione è eseguibile. La seconda fa si che il Rate dato da tutti gliagenti di un tipo sia pari al numero di essi moltiplicato per il rate del singolo.1.4.4 TransizioniDeniamo ora le transizioni:T = (nome, guardia, update, rate)πi := [guardia(X)− update(X)]@λguardia(X) è passabile ⇔SVi 0 ∧ Ask(G(X)) == trueupdate(X) = update(X)s CCP, SVi = SVi − 1, SVj = SVj + 1In altri termini:La guardia è espressa come la guardia di sCCP solo che presenta un vincolodi positività sulla variabile di stato associata.Lupdate è uguale allupdate visto in sCCP ma aggiorna anche lo stato delleState Variables. Vedendo un esempio:A1 : −[X 0 → X = X − 1]@{k1}.A2 + [X 10 → X = 0]@{k2}.A1;A2 : −[true → X = X + 1]@{k1}.A1;SI : A1 15
  26. 26. Questo sistema, viene convertito in:t1 = [SV 1 0 ∧ X 0− X = X − 1; SV 1 = SV 1 − 1; SV 2 =SV 2 + 1]@{k1}t2 = [SV 1 0 ∧ X 10− X = 0; ]@{k2}t3 = [SV 2 0∧true− X = X +1; SV 2 = SV 2−1; SV 1 = SV 1+1]@{k1}Nellesempio t2 non tocca le SV perchè incrementerebbe e decrementereb-be la stessa variable.È evidente come una tale forma racchiude tutte le informazioni necessarieper un algoritmo che voglia simulare landamento del sistema descritto dalsorgente sCCP ridotto.1.5 ODECon ODE si indicano le Equazioni Dierenziali Ordinarie ed è proprio daqueste che prende il nome il compilatore di tipo ODE. In questa sezione siesporrà brevemente il collegamento tra ITS ed ODE. Verrà esposto come,sotto opportune ipotesi, sia possibile passare da un sistema di tipo ITS adun sistema di equazioni dierenziali. Un approfondito studio dellargomentosi può trovare in [5].1.5.1 Deterministicità del LinguaggioQuesta semantica per sCCP non presenta evoluzione stocastica: levoluzionetemporale è determinata solo dalle equazioni dierenziali associate al sistemascritto in forma di sCCP ridotto. Questo è un ulteriore vincolo sul sistemastesso.1.5.2 La denizione di ODECome visto per sCCP e per ITS, si è dovuto denire in termini formali ilsistema. Nello specico, assumiamo che le transizioni del sistema siano dellaseguente forma:τ ∈ T , τ = (guardτ (x, s), X = X + k, S = S + h, fτ (X, S))k rappresenta laggiornamento delle variabili globali, il vettore h rappresenta 16
  27. 27. laggiornamento delle variabili di stato: ki ∈ R, se i è aggiornata esplicitamentek= 0, altrimenti hi ∈ R, se i è aggiornata esplicitamenteh= 0, altrimentiSi noti come richiediamo che gli update siano di una forma particolare, ov-verro incrementi/decrementi delle variabili con quantità costanti. Da questadenizione si ottiene il seguente sistema di ODE: ˙ X= τ ∈T kτ gτ (X, S)fτ (X, S) ˙ S= τ ∈T hτ gτ (X, Sfτ (X, S)Dove X, S, h e k sono vettori.In pratica, dal sorgente si deriva una denizione sintattica del sistema diequazioni dierenziali. Questo ha delle relazioni con il sistema stocasticoassociabile allo stesso sorgente, per una discussione su questa relazione sirimanda a [5]. Un programma sCCP che soddis i vincoli di cui sopra, puòessere visto come una descrizione di alto livello di un sistema di ODE. 17
  28. 28. Capitolo 2Analisi e ProgettazioneIn questo capitolo verranno analizzate le fasi di Analisi e di Progettazionesvolte per creare il progetto oggetto di questa tesi.Nella prima sezione è stato analizzato il problema, partendo dai requisitifunzionali.Nella seconda sezione sono state progettate le componenti per rispondere airequisiti.2.1 AnalisiNel Capitolo 1 si sono viste le nozioni teoriche riguardanti sCCP e le duevarianti ITS e ODE.Il progetto che si vuole creare, per lappunto, consiste nellimplementazionedi sCCP nella maniera più versatile e più completa possibile, con un occhiorivolto allecienza.Il progetto è stato sviluppato in ambiente .NET, in particolare è stata uti-lizzata la versione 4.0 del framework Microsoft. Le interfacce grache sonostate sviluppate in Windows Presentation Foundation (WPF).2.1.1 Analisi dei RequisitiÈ stato necessario interpellarsi sulle funzionalità necessarie al ne di creareil framework. È facile immaginare che il requisito fondamentale sia quello dicomprendere codice di tipo sCCP: oltre a ciò è necessario che ne permettala simulazione in maniera integrata. Dato un codice, quindi, vogliamo ave-re come riscontro dei dati sotto forma di graco o memorizzati in manieracompatibile con la maggior parte dei sistemi di analisi dati. È stato deciso 18
  29. 29. inoltre di permettere allutente di poter simulare passo passo per compren-dere landamento non solo in chiave temporale, ma anche in chiave di stepesecutivi.Si è voluto fornire anche uninterfaccia per la stesura del codice ma, nel con-tempo, si è voluto far in modo che non fosse lunica interfaccia possibile inmodo da permettere di accedere alle funzionalità del codice anche da altreGUI scritte in futuro.Un requisito fondamentale che è stato scelto è la creazione del ConstraintStore on demand: partendo da un sorgente contenente le informazioni perindicare le proprie speciche, il framework dovrà essere in grado di modellareun oggetto che le implementi nella maniera migliore.Linterfaccia graca deve permettere di salvare e riprendere in seguito il la-voro che si sta arontando. Oltre a questo deve permettere di impostare deicriteri di arresto dellesecuzione (raggiungimento temporale o raggiugimentoin passi).Deve esistere uninterfaccia simulativa di tipo batch che può gestire grandicarichi di lavoro in maniera eciente e gestire la simulazione con variazionedei parametri iniziali automatica.Oltre a ciò è necessario rendere il sistema in grado di utilizzare diversi tipidi compilatori in modo da dare allutente la possibilità di utilizzare sia ITSche ODE.Quanto detto si può riassumere nei seguenti punti: • Il framework deve tradurre del codice scritto in sCCP, comprenderlo e simularlo. • Il framework deve fornire uninterfaccia allutente in maniera da met- tere a disposizione tutte le sue funzionalità. • Il framework deve fornire uninterfaccia ad altri programmi in maniera da mettere a disposizione tutte le sue funzionalità. • Il framework deve generare unoutput graco o numerico compatibile con gli altri standard. • Il framework deve essere capace di creare un Constraint Store specico che risponda alle esigenze di ogni applicazione. • Il framework deve poter gestire anche codice ITS e ODE.2.1.2 Studio dei Casi dUsoUna volta analizzato il problema è stato denito il diagramma degli Use Case.Si è visto, da quanto scritto sopra, che gli unici attori presenti sono: 19
  30. 30. • Utente • Altri SoftwareDa quanto visto sopra, possiamo riassumere le attività che lutente può farein: • Scrivere il sorgente (salvare, caricare, compilarlo) • Scegliere il compilatore • Avviare la simulazione (graca o batch) • Raccogliere i risultatiMentre gli eventuali altri software dovranno poter: • Scegliere il compilatore • Avviare la simulazione (graca o batch) • Raccogliere i risultatiDa questa prima analisi si arriva al graco in gura nella pagina successiva.2.2 ProgettazioneUltimata la fase di analisi si è passati a quella di progettazione. In primis,come illustrato nelle successivo sezioni, si è progettata la parte simulativa.Nellarontare largomento si è dovuto tener conto della possibilità di volerscrivere altre IDE per i compilatori e di poter avere più compilatori per lastessa IDE. Oltre a questo è stato necessario utilizzare un sistema standardper loutput dei dati.Per riuscire a mantenere il massimo distacco tra le componenti, si è decisodi utilizzare delle interfacce per sottolineare i punti di contatto. In questomodo se qualcuno dovesse volere riscrivere una parte del programma, nondeve far altro che reimplementare linterfaccia associata.È stato fondamentale dividere il codice sorgente dellutente in due blocchi di-stinti: una parte va a denire la congurazione degli agenti (compresi agentiiniziali, denizioni agenti, ecc.) detta SourceAM, mentre laltra serve a mo-dellare il Constraint Store come lutente desidera (variabili globali, funzioni,constraints, parametri, operatori ... ) detta SourceCS. 20
  31. 31. Use Cases Diagram2.2.1 Standardizzazione di Input ed OutputSi è fortemente cercata lindipendenza delle parti su tutti i fronti, per questosi è deciso di utilizzare degli standard già aermati per gestire input ed out-put. Principalmente si doveva rendere compatibile con future espansioni evarianti linput (rappresentato per la maggior parte dai sorgenti) e loutput(i dati di risposta della simulazione).Per modellare linput serviva un linguaggio in grado di esser modellato per lenostre esigenze e che fosse di semplice lettura: per questo motivo si è sceltoXML. Essendo molto utilizzato, un domani chiunque potrebbe creare unin-terfaccia graca diversa che generi il codice XML da fornire al compilatoresenza grossi sforzi. Un domani uno sviluppatore potrebbe voler creare unaIDE completamente graca in cui lutente non debba scrivere una sola lineadi codice: grazie allutilizzo di XML non necessiterà di alcun parser o vali-datore se non il DTD stesso dei le XML utilizzati.Per la verica della correttezza sintattica dei le XML sono stati creati dei 21
  32. 32. les DTD apposta. Lutilizzo di questo sistema ha portato ad una sempli-cazione anche nella creazione dei compilatori stessi: ogni compilatore avràun suo DTD per analizzare il codice così creato.Per quanto concerne loutput si è scelto per un formato molto leggero eduniversale: il CSV (comma separated values). Questo formato è compatibilecon moltissimi programmi di analisi dati (come Mathlab o Excell) ed è prati-camente un plain text e quindi leggibile anche con un qualunque text editor(esattamente come XML).2.2.2 I Macro ModuliPer creare questo progetto è stato necessario utilizzare un approccio di tipoTop-Down in cui si è iniziato immaginando dei macro blocchi che poi sonoandati a denirsi mano a mano che si scendeva nel dettaglio. Fin dal prin-cipio si sapeva che dovevano esistere delle classi che assolvessero ai seguenticompiti: • Interfaccia Graca di Scrittura del Codice (Parser GUI) • Parser da linguaggio a XML per il SourceCS • Parser da linguaggio a XML per il SourceAM • Interfaccia Graca per la simulazione graca in tempo reale • Interfaccia Graca per la simulazione Batch • Classi di scambio parametri di compilazione • CompilatoreCon la congurazione esposta in gura un utente può utilizzare il progettoin più modi: • Utilizzare tutto il progetto, dal Parser GUI per la stesura al compilatore per simulare • Utilizzare un proprio Editor e passare il codice per la simulazione Graca / Batch alle due classi predisposte • Utilizzare solo il compilatore lasciando poi il proprio software a gestire i dati in input e output 22
  33. 33. Figura 2.1: Primo Approccio Progettuale2.2.3 Il CompilatoreIl Compilatore in questo progetto non è unico e non perchè si è scelto dicrearne più del dovuto, ma perchè ogni Compilatore deve comprendere unparticolare tipo di codice.Avendo di base due tipi di codice, uno scritto per la denizione degli agentie laltro per la denizione del Constraint Store, è evidente che ci dovrannoessere un modulo per comprendere luno e un per comprendere laltro. Avre-mo quindi, in generale, una suddivisione tra Parser per SourceAM e uno perSourceCS.È comprensibile come un codice scritto per il Parser X non necessariamentedebba funzionare per il Parser Y, ma la divisione in queste due categorieserve per avere dei risultati comuni.Ad esempio da un Parser per il SourceCS (ParserCS) ritornerà sempre uncontenitore con variabili, funzioni, constraint e quantaltro; allo stesso modoun Parser per il SourceAM (ParserAM) ritornerà sempre un elenco di deni-zioni di Agenti ed uno stato iniziale.Avendo scelto di utilizzare in ingresso dei codici XML, i Parser non hannobisogno di librerie particolari per produrre il risultato ma gli basta saperanalizzare un le XML.Va rispettato un vincolo: ParserCS deve eseguire sempre prima di Parse-rAM. La motivazione è molto semplice: ParserAM ha bisogno di sapere chisono le variabili, chi i constraint, chi le funzioni e quantaltro per poter fare 23
  34. 34. correttamente il proprio lavoro.ParserAM conosce in questo modo i dati per la denizione del nuovo Con-straint Store; oltre a questo gli vengono forniti gli indirizzi dei RuntimeMa-nager appena istanziati in modo da dare loro i risultati da esso prodotti.2.2.4 Runtime ManagerCome ParserAM e ParserCS svolgono le funzioni di comprensione del sor-gente, il Runtime Manager svolge quelle di simulatore. Esso infatti conosce,grazie a ParserAM, tutte le denizioni sia in termini di Agenti che del Con-straint Store.Viene istanziato fornendogli semplicemente i criteri di arresto (durata tem-porale λ o numero di passi). Un Runtime Manager espone (principalmente)le seguenti funzioni: • Start - Inizia la simulazione • Stop - Interrompe la simulazione • Step - Eettua un passo della simulazione • GetGraphData - Fornisce tutti i dati relativi alle variabili ed al loro andamento temporale • GetGlobalVars - Fornisce il valore attuale della variabili globali • GetStatus - Fornisce un riassunto di Agenti Attivi, ultime azioni ese- guite, rate, ecc.Come è evidente il Runtime Manager è in tutto e per tutto il cuore del pro-getto: tutte le altre parti non sono che moduli che permettono linterazionecon esso.Una volta dato il comando Start, questo simulerà nchè non gli viene datolo Stop o soddisfa le condizioni di terminazione.Analizzando il linguaggio sCCP ci si è resi conto che un simulatore benstrutturato deve esser dotato di due elementi: • Il Constraint Store • Il Denition Store 24
  35. 35. 2.2.5 Constraint StoreIl Constraint Store (CS) sarà la memoria del nostro sistema. In esso cisaranno le variabili e vi si accederà tramite gli Ask e i Tell. Oltre a ciòdobbiamo poter richiedere al CS di ritornare il risultato di una formula:questo viene usato per il calcolo dei Rate. Unaltra funzionalità è quella diritornare lo stato di tutte le variabili in un operazione sola. Al CS viene datoanche il compito di modicare, se necessario, le formule lette dai Parser.Ricapitolando: • Ask • Tell • GetRate • GetVariables • Parse2.2.6 Denition StoreIl Denition Store è il gestore delle denizioni di agenti. Deve aiutare lafase di Parsing del SourceAM e deve fornire al RuntimeManager gli agentirichiesti. È unico per ogni Runtime Manager. I requisiti che deve soddisfaresono: • Creare una denizione • Creare unazione per una denizione • Fornire le istanze delle denizioniVista la denizione degli agenti, si è deciso di progettare la singola denizionepartendo dalle seguenti considerazioni: • Ogni Agente ha più scelte • Ogni scelta ha una o più azioni • Ogni azione può essere composta da una o più azioni atomichePer gestire questa condizione si è pensato al seguente sistema. Ogni Agenteha una scelta tra le possibili azioni. Ogni serie di azioni composte in sequenzasono gestite da un Action Manager. Le azioni implementano tutte la stessainterfaccia che espone molti metodi, tra cui quello per lesecuzione dellazionee quello per ricevere il Rate dellazione stessa.Vediamo ora un esempio sulla gestione dellazione: 25
  36. 36. Agente :- [X 0 - X = X-1]@{1}.Agente + [X == 0 - X = 10]@{1}.([ - Y= Y + 1]@{1}.Agente || Agente + Agente);Questa struttura viene dapprima spezzata in due:[X 0 - X = X-1]@{1}.Agente[X == 0 - X = 10]@{1}.([ - Y= Y + 1]@{1}. Agente || Agente + Agente);La prima azione ora diventa:ActionManager - [Guardia][Call]La seconda invece diventa:ActionManager - [Guardia][Scelta][Scelta] - ActionManager - [Guardia][Parallelo([Call][Call]) - ActionManager - [Call]In pratica un ActionManager è una lista di Azioni collegate dalla Composi-zione in Sequenza: quando il Parser individua una scelta aggiunge in codaunelemento Scelta, il quale avrà i suoi ActionManager per gestire le biforca-zioni.In questo modo si gestiscono le azioni come fossero un albero, in manieraeciente e assolutamente non rigida.In gura un diagramma approssimato ma riassuntivo.2.2.7 Interfaccia GracaÈ stato fondamentale progettare da subito anche linterfaccia graca: graziead unapprofondita analisi delle funzionalità che si volevano esporre si è riu-sciti ad apportare modiche anche ai diagrammi delle classi che formano ilCore.Per prima cosa è il caso di dividere linterfaccia graca in tre blocchi distinti: • GUI per la scrittura del codice • GUI per la simulazione in tempo reale • GUI per la simulazione Batch 26
  37. 37. Figura 2.2: Rappresentazione concettuale delle classiParser GUIQuesta WPF Window è stata progettata per essere il più semplice possibile.Divisa in due parti in cui scrivere il SourceAM e il SourceCS, ore le funzionidi base (salva, carica, nuovo, esci) aancate dalla possibilità di compilare(AM, CS, Entrambi), di scegliere il compilatore (sCCP, ITS, ODE) e innela possibilità di lanciare la simulazione (Graca o Batch).Nel capitolo 3 vedremo un esempio pratico con tanto di immagini prese dalprogramma.Graphic Simulation GUIQuesta interfaccia si compone di tre nestre distinte che vengono mostrateuna di seguito allaltra.Nella prima si è progettato che venga data la possibilità di scegliere i para-metri di arresto, i le XML da caricare (SourceAM e SourceCS, impostatidal Parser GUI con i giusti valori), la precisione del graco e il numero disimulazioni parallele.Nella seconda nestra è stata data la possibilità di scegliere i dettagli delgraco: si possono scegliere le variabili da analizzare mostrandole tracciate,di quali variabili mostrare la media, di quali la varianza. Per ogni linea datracciare si può scegliere il colore e la didascalia.Avendo concentrato le scelte prima dellesecuzione, lultima nestra è quasi 27
  38. 38. completamente dedicata al graco. Si sono volute mostrare anche le variabilicon i loro valori e gli agenti in vita, ma la maggior parte dello schermo è presadal graco. Questa nestra si è pensato debba avere funzionalità interattive(permettndo di iniziare o fermare la simulazione o di fare un singolo passo),permettendo di salvare e ricaricare lo stato ed anche di esportare un le .CSVcontente i dati raccolti.Batch Simulation GUILa simulazione batch deve raccogliere i seguenti dati: • Scelta criteri di arresto • Scelta numero di esecuzioni • Scelta le da eseguire • Scelta le da salvare • Scelta delle variazioni delle variabili in ingressoCome nel caso precedente si è pensato di procedere con tre schemate perpoter scegliere le opzioni. Nella prima si possono così concentrare le infor-mazioni in merito ai criteri di arresto, le di eseguire, le da salvare e numerodi esecuzioni.Nella seconda così ci si può concentrare sulle variazioni dello stato iniziale:per ogni variabile ed ogni stato si devono poter impostare dei possibili valoriiniziali e il sistema deve poi valutare le esecuzioni sugli opportuni valori ini-ziali.A questo punto nella terza videata basta predisporre un indicatore di com-pletamento e qualche controllo sulla durata delle operazioni (per evitareloop). 28
  39. 39. Capitolo 3InterfacciaIn questo capitolo tratteremo lutilizzo del framework in oggetto di questoelaborato.Nella prima parte analizzeremo le procedure per linstallazione.Nella seconda discuteremo in merito alla stesura del codice, analizzando indettaglio come stendere un semplice codice desempio.Nella terza sezione vedremo come simulare in forma graca e non.3.1 InstallazioneLinstallazione del progetto risulta molto semplice. Una volta scaricato ille compresso del progetto, basta scompattare la cartella. A questo punto èpossibile eseguire il le sCCP-GUI.exe ed utilizzare il programma.Se il programma non dovesse funzionare, è probabile che il computer sul qua-le si sta lavorando non disponga del .NET Framework 4.0.Per linstazzazione di questultimo, basta visitare il sito di Microsoft e scari-care il software in questione.3.2 Il CodiceUna volta lanciato leseguibile sCCP-GUI.exe, apparirà uninterfaccia gra-ca per la stesura del codice. Oltre ai soliti comandi che si trovano in unausuale IDE (salva, carica, esci, nuovo, compila) ne sono stati aggiunti altriper lanciare la simulazione di tipo Batch e di tipo Graco.Il corpo della nestra principale è diviso in due aree di testo: in quella disinistra verrà scritto il Source AM, mentre in quella di destra il SourceCS.Il menù Compile permette di scegliere di compilare il SourceAM, il Sour-ceCS o entrambi. 29
  40. 40. Nel menù Engine è possibile scegliere il simulatore tra i tre visti nelleprecedenti sezioni: • sCCP • ITS • ODESe si dovesse scegliere ODE, verrà data la possibilità di scegliere quale meto-do utilizzare per risolvere il problema (Implicit Runge Kutta...). Oltre a ciòè possibile scegliere la precisione del solver. Nel menù Constraint Store èpossibile scegliere se utilizzare il Constraint Store basato su muParser oppurequello basato su Flee.Se si volesse scavalcare la linterfaccia graca per la stesura del codice, è possi-bile lanciare i simulatori direttamente. Questi si trovano nella stessa cartella,con il nome sCCP-GraphicSimulator.exe e sCCP-BatchSimulator.exe. Nel-lultima sezione di questo capitolo verrà spiegato lutilizzo di questi e comeinterfacciarli ad eventuali altre IDE.3.2.1 Il Codice SourceAMIn questa sezione si daranno alcune informazioni sul come scrivere il codiceSourceAM. Per prima cosa dobbiamo ricordare che a seconda del compila-tore il linguaggio subisce delle restrizioni dovute alle limitazioni teoriche. Inquesta sezione parleremo, in modo del tutto generale del codice sCCP.Il SourceAM è costruito in questo modo:Agent_Definitions/* Definitions */End_Agent_DefinitionsInitial_State/* Initial State */End_Initial_StateAllinterno dello spazio dedicato alle denizioni, possono venir scritti agentiin questo modo:NomeAgente(Variabili) :- Azione (.Azione)+Variabili = Nome | Nome = ValoreAzione = Guardia | Chiamata | Parallelo | SceltaGuardia = [Ask - Tell]@{Rate}Chiamata = NomeAgente(Variabili)Parallelo = Azione || Azione ...Scelta = Azione + Azione ... 30
  41. 41. Per la compatibilità delle istruzioni assegnate in Ask, Tell o Rate si rimandaal Capitolo 4. Un Tell può esser costituito da più chiamate al ConstraintStore; queste devono essere separate da un ;. Se il codice viene compila-to da sCCP è possibile assegnare dei valori iniziali alle variabili locali cosìdenite, altrimenti rimangono dei semplici segnaposto: nel momento in cuiverrà chiamato lAgente fornendogli dei riferimenti in ingresso, questo verràmodicato per inserire la nuova variabile al posto del segnaposto.In sCCP è previsto loperatore di dereferenziazione, come in C.Ad ogni assegnazione, se viene passata una variabile in una chiamata ricor-siva, questa viene passata per riferimento, mentre se si vuole passare solo ilvalore si deve utilizzare loperatore *.Esemplicando:Agente(X):- [X 0 - X = X-1]@{k1}.Agente(X);Agente2 :- Agente(Y);Nel momento in cui viene invocato Agente(Y), il segnaposto viene sostituito:Agente(Y):- [Y 0 - Y = Y-1]@{k1}.Agente(Y);Se invece listruzione fosse stata:Agente2 :- Agente(*Y);Agente(X) sarebbe rimasto uguale ma sarebbe stato assegnato ad X il valoredelle variabile attuale della variabile Y.Questo meccanismo è utilissimo per specicare lo Stato Iniziale, in quantopermette di modellare degli agenti con lo stesso comportamento su variabilidiverse.Lo Stato Iniziale è così composto.Initial_State/* Agenti */End_Initial_StateAgenti = Numero * Chiamata || ChiamataChiamata = NomiAgente || NomiAgente(Variabili)Un esempio di inizializzazione, facendo riferimento ad Agente(X) visto primapuò essere il seguente:Initial_StateAgente || Agente(Y) || 2 * Agente(Z)End_Initial_State 31
  42. 42. 3.2.2 Il Codice SourceCSIn questa sezione si vedrà come scrivere il SourceCS per modellare il Con-straint Store con il quale interagiranno gli agenti del SourceAM.Il sorgente deve dar la possibilità di denire: • Variabili • Parametri • Costanti • Operatori • Funzioni • ConstraintsPer ogni elemento esiste una sintassi per la sue generazione. Il SourceCS haquesta forma:Global_Var/* Var Defs */End_Global_VarParams/* Param Defs */End_ParamsFunctions_Def/*Function Defs */End_Functions_DefConstraints_Def/* Constraint Defs */End_Constraints_DefVar Defs := NomeVariabile = Valore ;Param Defs := param NomeParametro Valore ;Function Defs := Constant OR Function OR OperatorConstant := CONST costante valore ;Function := Nome(Vars) = Semantica ;Operator := operat Simbolo/i Semantica ;Constraint Defs := Nome(Vars) = (Var = Semantica; Var = Semantica ...);Ogni elemento dichiarato allinterno del SourceCS è richiamabile negli Ask,nei Tell e nei Rate del SourceAM. Nel capitolo 5 sono illustrati alcuni esempicompleti di programmi funzionanti. Si rimanda il lettore a quella sezione pervedere in pratica le denizioni viste in questa e nella precedente sezione. 32
  43. 43. 3.3 La SimulazioneIn questa sezione si analizzeranno sCCP-GraphicSimulator e sCCP-BatchSimulator.Entrambi possono venir eseguiti come programmi stand alone e vengono ese-guiti dalla stessa sCCP-GUI quando si inviano i comandi di simulazione. Persimulare dalla sCCP-GUI si deve utilizzare il Menu Run, il quale permettedi scegliere tra Graphic Simulation e Batch Simulation.Una volta mandata in esecuzione da sCCP-GUI, è come se questa non esi-stesse più e ci si trova a contatto diretto con il simulatore.3.3.1 Graphic SimulatorIl Graphic Simulator è composto da tre videate, ognuna con uno specicoutilizzo. Queste vengono mostrate in ordine e lultima è quella che mostra lasimulazione vera e propria. Queste servono a: 1. Scelta dei criteri di arresto, scelta sorgenti e numero di simulazioni 2. Scelta delle variabili da monitorare, dei colori delle linee etc 3. Simulazione e graciPrima SchermataNella prima schermata sono impostabili i criteri di arresto. Questi possonoessere di due tipi: sul numero di passi o sul tempo di sistema. Una volta sceltoil criterio di arresto si può passare alla scelta della precisione dellanalisi. Sesi è scelto di concludere a un dato tempo, si può scegliere di campionare Npunti (decretanto così la precisione delloutput) oppure si può scegliere unpasso temporale di campionamento ed utilizzare direttamente quello.Nel caso la scelta ricada su un criterio di terminazione legato al numero dipassi, si può scegliere ogni quanti passi campionare.Oltre a questo si possono scegliere altre cose: • Il numero di simulazioni • Il le XML che descrive il Constraint Store • Il le XML che descrive lAgent Manager • Se mostrare il graco durante la simulazione o alla neNel caso il simulatore venga caricato dalla sCCP-GUI, i campi contenenti ipercorsi dei les vengono già assegnati con i nomi corretti. 33
  44. 44. Seconda SchermataNella seconda schermata lutente può impostare le impostazioni riguardanti ilgraco. Nella lista superiore vengono indicate le variabili globali del progetto.Una volta selezionata, lutente può scegliere se: • Stampare i singoli valori della variabile delle diverse simulazioni • Stampare la media dei valori della variabile derivanti dalle diverse simulazioni • Stampare la varianza dei valori della variabile derivanti delle diverse simulazioniUna volta cliccato su uno dei tre pulsanti, viene aggiunta una nuova riganella lista dei valori da stampare. In questa lista è possibile congurare piùparametri: • Il nome da mostrare nella legenda del graco • Il colore della linea • La sorgente dei datiLa sorgente dei dati serve per selezionare di quale simulazione si vuole tenertraccia. Ad esempio è possibile calcolare la media tutte le simulazioni eccettouna e di questa mostrare il valore singolo. In questo modo si può comparare,per ni landamento medio con landamento di una singola simulazione.Una volta selezionati i valori, si può premere sul tasto OK per passare allaterza schermata.Terza SchermataLa terza schemata è stata progettata per interfacciarsi con il RuntimeMa-nager dando allutente tutte le informazioni di cui ha bisogno. Buona partedello schermo è coperto dal graco. Sulla destra vengono riportati i valoridelle variabili e gli agenti vivi. In basso a sinistra una label riassume lo sta-to del Runtime Manager (ultima azione eseguita se si va per step, rate delsistema etc).I Menù permettono di di interagire con il sistema:File: • New - Crea una nuova simulazione copia di quella in esecuzione • Load Status - Carica una simulazione precedentemente salvata 34
  45. 45. • Save Status - Salva una simulazione • Save CSV - Salva i dati su disco in Comma Separated Values • Close - Chiude la simulazioneRun: • Single Step - Esegue un passo nella simulazione • Start/Stop - Avvia/Interrompe la simulazione3.3.2 Batch SimulatorIl Batch Simulator è strutturato in 3 parti, come il Graphic Simulator. Letre nestre hanno scopi diversi rispetto a quanto precedentemente visto: 1. Scelta criteri di arresto e precisione dei dati, scelta della locazione dei CSV con i risultati e dei le XML da compilare 2. Scelta delle diverse congurazioni di valori iniziali e parametri nelle diverse simulazioni 3. Semplice indicatore dellavanzamento del lavoroPrima SchermataLa prima nestra è stata impostata allo stesso modo della prima del GraphicSimulator. I criteri di arresto vengono introdotti nello stesso modo. Nel-linterfaccia è sostituita la CheckBox che prima serviva la visualizzazione delgraco a run-time o alla ne della simulazione; questa ora serve per stabilirese lutente vuole il risultato salvato in un unico le o in uno diverso per ognisimulazione. Oltre a questo una TextBox ore la possibilità di scegliere dovesalvare loutput prodotto.Seconda SchermataLa seconda schermata permette allutente di scegliere diverse congurazionidi valori delle variabili e dei parametri. Questa schermata serve, ad esempio,a vedere come varia il comportamento del sistema mano a mano che un pa-rametro cresce. Da una ComboBox si può scegliere il valore da modicare,una volta aggiunto si può scegliere come farlo variare. È possibile scegliereche la variabile acquisica N valori uniformemente distribuiti su unintervallo,oppure che il valore di questa venga incrementato / decrementato ntanto 35
  46. 46. che rimane allinterno di un intervallo.Il numero di simulazioni sarà proporzionale al numero di combinazioni pos-sibili. Se ad esempio si fa variare la prima variabile su 3 valori e unaltra su2, ci saranno 6 simulazioni.Terza SchermataLa terza schermata è assolutamente stringata: presenta solo una barra diavanzamento dei processi. Quando le simulazioni vengono completate, que-sta avanza. Quando la simulazione è conclusa, viene riportato il tempoimpiegato, listante di inizio elaborazione e di ne elaborazione. 36
  47. 47. Capitolo 4ImplementazioneDopo aver esposto le nozioni teoriche nel capitolo 1, lanalisi e la progettazio-ne nel capitolo 2 e aver mostrato linterfaccia nel capitolo 3, in questo quartocapitolo si presenterà limplementazione.Nella prima sezione verranno analizzate velocemente le schermate. Nellesuccessive si analizzeranno a turno i diversi compilatori.4.1 Dettagli dellInterfaccia GracaPer la programmazione dellinterfaccia graca sono stati utilizzate delle com-ponenti esterne, non scritte dal candidato. Nello specico si sono usate leseguenti librerie: • ColorPicker • DynamicDataDisplayLa prima consentiva di prelevare un colore da una tavolozza ed è stata inseri-ta nella scelta dei colori nella simulazione graca. Sempre nella simulazionegraca si è utilizzato il DynamicDataDisplay. Questi altro non è se non uncontrollo WPF che gestisce dei graci a linea.Quando viene istanziato la nestra con il graco vengono letti i parametri edesunte le linee da disegnare. A questo punto vengono memorizzate in undizionario, per ogni linea, una lista di ObservablePoint. Ogni volta che verràaggiunto un punto in una di queste liste, questo verrà tracciato nella correttalinea.Quando viene lanciata una simulazione, viene anche attivato un thread cheva a controllare ogni 500ms se vi sono nuovi dati disponibili dal Runtime-Manager. Questi vengono convertiti in modo da essere utilizzabili e vengono 37
  48. 48. inseriti nelle liste di punti opportune.Nel gestire simulazioni parellele contemporanee, onde evitare problemi concalcoli della media e inconsistenza dei dati, si è deciso di disegnare i punti noallistante temporale del RuntimeManager di tempo minimo. Ad esempio, siconsiderino 4 simulazioni che dopo 500ms si trovano nel seguente stato:Sim1 : T = 35 Sim2 : T = 50 Sim3 : T = 80 Sim4 : T = 12A questo punto il simulatore vede che Sim4 è la simulazione più in ritardo edisegna sul graco tutti i punti richiesti no al tempo 12.Nel caso una delle simulazioni dovesse incontrare un blocco dovuto al codice(rate pari a 0), non sarà possibile continuare la tracciatura del graco.Linterfaccia graca si appoggia su un OutputManager che gli permette dimemorizzare su disco lo stato corrente, i risultati delle elaborazioni e diricaricarli alloccorrenza.4.2 SCCPSCCP è il primo compilatore e simulatore che è stato scritto per questo pro-getto. È quello che presenta maggiori requisiti da implementare in quantodeve poter simulare tutte le caratteristiche del linguaggio SCCP. Nelle pros-sime sezioni vedremo nel dettaglio come sono state implementate le diversecomponenti che lo formano.Inizieremo esaminando il Constraint Store, parleremo poi del Denition Sto-re, del Runtime Manager e inne dei Parser (ParserCS a ParserAM).4.2.1 Il Constraint StoreNella sezione 1 abbiamo appreso come il Constraint Store debba risponderead Ask e Tell, mentre nella fase di progettazione ci si è resi conti che lefunzionalità andavano ampliate. Nello specico si è giunti a: • Ask • Tell • GetRate • Parse • Metodi per istanziare variabili, parametri, funzioni, operatori, con- straint e quantaltro. 38
  49. 49. • GetVariablesÈ stato necessario appoggiarsi ad un parser di espressioni matematiche pergestire il Constraint Store. La scelta è ricaduta su muParser (modulo esternonon scritto dal tesista).muParserMuParser è reperibile allindirizzo muparser.sourceforge.net.È gratuito e disponibile in forma nativa per C++ e Wrappato per ambiente.NET.Questa libreria permette di calcolare il valore di espressioni contenenti nu-merosi operatori e dà anche la possibilità di espandere le proprie potenzialitàtramite opportuni metodi. Oltre a ciò permette di memorizzare al propriointerno parametri e variabili. È uno dei migliori parser matematici gratuitia livello di performances.In questa prima tabella vengono esposte le funzioni built-in in muParser. 39
  50. 50. Name ARC Explanationsin 1 sine functioncos 1 cosine functiontan 1 tangens functionasin 1 arcus sine functionacos 1 arcus cosine functionatan 1 arcus tangens functionsinh 1 hyperbolic sine functioncosh 1 hyperbolic cosinetanh 1 hyperbolic tangens functionasinh 1 hyperbolic arcus sine functionacosh 1 hyperbolic arcus tangens functionatanh 1 hyperbolic arcur tangens functionlog2 1 logarithm to the base 2log10 1 logarithm to the base 10log 1 logarithm to the base 10ln 1 logarithm to base e (2.71828...)exp 1 e raised to the power of xsqrt 1 square root of a valuesign 1 sign function -1 if x0; 1 if x0rint 1 round to nearest integerabs 1 absolute valuemin var. min of all argumentsmax var. max of all argumentssum var. sum of all argumentsavg var. mean value of all arguments 40
  51. 51. Operator Meaning Priority = assignement -1 and logical and 1 or logical or 1 xor logical xor 1 = less or equal 4 = greater or equal 4 != not equal 4 == equal 4 greater than 4 less than 4 + addition 5 - subtraction 5 multiplication 6 / division 6 ^ raise x to the power of y 7 ?: if then else operator 1In questa tabella vengono esposti gli operatori built-in in muParser.Interfacciamento con muParserCome visto, muParser ha delle peculiarità molto importanti per quanto ri-guarda la denizione di funzioni, variabili e quantaltro. Per quanto riguardaAsk, Tell e GetRate la loro denizione diventa banale: basta che il ConstraintStore faccia da Wrapper, facendo attenzione a casi particolari. Ad esempioil parsing di unistruzione vuota genera uneccezione, ma si è deciso inveceche lAsk di una tale istruzione sia sempre valido, quindi si è dovuta gestireleccezione e ritornare il valore true.La denizioni di variabili e parametri è molto semplice, così come lottenereil valore delle variabili in muParser; basta anche in questo caso fare poco piùche un Wrapper. Gli argomenti più spinosi rimangono: la denizione di UserDened Funcion (UDF) e il Parsing delle stringhe per i Parser.Per risolvere il problema delle UDF è stato escogitato un metodo molto mal-leabile che permette di gestire funzioni molto complicate e con molti para-metri. Per denire una nuova funzione in muParser, questo non si aspettaaltro se non un delegato da invocare passando i parametri quando la incontradurante il parsing.Per creare a runtime una funzione che risolva questo problema si sono usateopportune classi neutre. Viene denita una classe Function che si aspetta iningresso una lista parametri e la semantica della stessa. I parametri non han-no un valore, ma solo il nome del segnaposto nella semantica. Questa classe 41
  52. 52. prevede un metodo Solve che accetta come parametri un array di double e unintero contenente il numero di parametri. Questa rma è esattamente quellache si aspetta muParser per creare una nuova funzione.Associato il nome alla funzione Solve della classe appena generata, il Parserla invocherà al momento opportuno.Quando questa viene invocata, va a sostituire tutti i parametri che ricevein ingresso (dei double) ai segnaposti indicati prima come parametri (dellestring). A questo punto la stringa può venir risolta da muParser in manieraricorsiva risolvendo il problema.Vediamo ora un semplice esempio:F(X,Y,Z) = (X + Y) / Z;Il Parser la spezza in modo da ottenere una lista di stringhe contente [X,Y,Z]e la semantica (X+Y) / Z. A questo punto crea la Function passando i valori.Nel momento della chiamata:F(1,3,5)Invoke Solve([1,3,5],3)Sostituzione Parametri ai segnaposto: (X + Y) / Z ⇒ (1 + 3) / 5return Parser.Solve((1 + 3) / 5);Da questo pseudocodice si comprende subito la linearità dei passaggi e lacorrettezza degli stessi.Un problema altrettando spinoso da trattare per il Constraint Store è il Par-sing per il ParserAM. Questo serve per rendere compatibili le stringhe chepoi verranno passate a muParser.Un esempio banale è dato dalla gestione delle variabili globali: per distingue-re le une dalle altre, alle variabili globali viene applicato il presso GLOBAL.Se non viene fatto un parsing corretto, un Agente che avesse un Ask del tipo[X 0] creerebbe uneccezione per variabile non trovata. Il Constraint Storedeve, per lappunto, controllare le formule e modicarle:[X 0] ⇒ [GLOBALX 0]Il Constraint è una particolare UDF che serve ad eettuare molteplici opera-zioni parametrizzate. Un esempio di Constraint potrebbe essere il seguente:CS(ix, ipsilon) = ( X = ix/2; ipsilon = Y+2;);Il seguente constraint pone ad X il valore di ix /2 (qualunque sia il valore diix) e modica il valore di ipsilon ponendolo a Y + 2. 42
  53. 53. È facile comprendere il caos che si può creare durante questa conversione.È stato necessario convertire le stringe in maniera che ogni chiamata diven-tasse diversa dalle altre: è da ricordare infatti che le funzioni denite inmuParser accettano solo parametri double e non stringhe.La soluzione che si è adottata prevede di parsare le stringhe associando undiverso constraint per ogni sua invocazione, così da poter modicare la se-mantica a seconda della chiamata.Si consideri ad esempio il constraint CS prima denito e si analizzi la chia-mata:[ - CS(K,MyCount)]@{...È necessario creare il constraint partendo dalla denizione e tenendo contodi: • Variabili Globali (se X è globale diventa GLOBALX) • Nome del Constraint Store (deve essere diverso per ogni invocazione) • Sostituire in tutte le istruzioni il nome della variabile presente nella chiamata.Tenendo conto di queste particolari condizioni, il Constraint Store produrràin risposta alla richiesta di parsing:CS1(GLOBALK, MyCount)Dove in muParser è denita una funzione che esegue:GLOBALX = GLOBALK / 2MyCount = GLOBALY + 2Per quanto concerne la creazione degli operatori deniti dallutente, muParsergestisce il tutto in maniera simile.La sintassi denita è come:operat SIMBOLO (elemento1, elemento2, precedenza)Ad esempio:operat ^= (p1, p2 ,1) = (p1 - p2) /2;Questo operatore, ad esempio fa la media dei due elementi. La gestione inmuParser è simile, lunica dierenza è la precedenza delloperatore, indicatadal terzo parametro. È possibile capirne il signicato guardando la tabellacon i built-in operators. Dopo aver costruito il Constraint Store basato sumuParser si è riscontrata una mancanza di performance dovuta alla noncompilazione delle formule. Per questo motivo si è creato un altro ConstraintStore basato su un altra libreria: FLEE. 43
  54. 54. FLEEFLEE(Fast Lightweight Expression Evaluator) è un valutatore di espressionimolto veloce dalle funzionalità ridotte. La libreria è gratuita e disponibile suee.codeplex.com.Vediamo ora i vantaggi di questa libreria: • Compila le formule, fornendo delle prestazioni molto maggiori • Si interfaccia facilmente con altre librerie per aggiungere funzionalità • Supporta la chiamata di funzioni di sistema e codice ILFlee presenta anche dei notevoli svantaggi: • Non permette lassegnazione come elemento delle formule (X = X+1 risponde false) • Non permette la creazione di parametri o costanti • Non permette di creare degli operatori customA questo punto si è deciso di creare un Constraint Store limitato ma decisa-mente più veloce. In questo non sarà possibile: • Denire Constraints • Denire Operatori customSe per un particolare programma non servono queste due funzionalità è pos-sibile utilizzare questo Constraint Store che, come sarà esposto nel quintocapitolo, ha delle performance di gran lunga superiori. La denizione del-le funzioni è stata implementata in una maniera simile a quanto visto permuParser. In questo caso si è creato un Function Manager che espone unafunzione F che accetta come parametro una stringa. Il Constraint Store mo-dicherà tutte le chiamate alle funzioni che trova in questo modo:miaF(X,2,K) → F(miaF,X,2,K)Quando FLEE incontrerà F, invocherà la funzione del Function Manager.Questi spezzerà la stringa usando come divisore le virgole. Al primo postotrova il nome della funzione da evocare e la evocherà dallelendo di funzionidenite.I Tell sarebbero inutili se impossibilitati a modicare il sistema. Si è quin-di intervenuti per rendere possibile la modica delle variabili. Quando il 44
  55. 55. Constraint Store riceve un Tell, verica se la stringa è formata da nome va-riabile seguita dal simbolo =. Se così è allora viene risolta la parte successivaalluguale e il risultato viene assegnato alla variabile. Nel caso la variabileappartenga alla lista di parametri fornita dal SourceCS, lassegnazione nonviene fatta, trattando di fatto la variabile come una costante.Ora verranno brevemente esposte le funzionalità di Flee:Operazioni Aritmetiche Flee permette di eseguire tutte le operazioniaritmetiche come somme, prodotti, elevamenti a potenza e moduli.ES: X * 2 + B ^ 100 % 10Operazioni di Confronto Le operazioni di confronto ammesse sono tuttele più comuni. Per indicare il diverso si utilizza loperatore , mentre pervericare luguaglianza di due oggetti si può usare semplicemente luguale.ES: (X Y)Operazioni di And/Or/Xor/Not Essendo ogni operazione in Flee for-temente tipizzata, lutilizzo di questi operatori varia a seconda del contesto.In alcuni casi Flee utilizzerà lAnd logico, mentre in altri farà quello Bit aBit per esempio.ES (logico): a 100 And Not b = 100ES (bit a bit): (100 or 2) and 1Operazioni di Shift Grazie agli operatori e è possibile fare degli Shiftdei valori.ES: 100 2Operatori di Contatenazione Come in molti liguaggi di programmazio-ne moderni, il + in Flee sta ad indicare la concatenazione tra stringhe.ES: abc + def ES: the number is: + 100Operatori di Indicizzazione Con Flee si possono modellare ed utilizzareArray dentro le formule. ES: arr[i + 1] + 100Scrittura dei Simboli In Flee ogni valore viene interpretato in un parti-colar modo per tipizzarlo nella maniera corretta: • Char - Un carattere tra singoli apici a 45
  56. 56. • Boolean - true o false • Real - Ogni numero con un punto decimale. Con d ed f si può specicare la precisione (oat, double) • Integral - Ogni numero intero. Con U lo si specica Unsigned, mentre con L lo si considera a 64 bit • Hex - Numero esadecimale, espresso nella notazione: 0xFF12 • String - Insieme di caratteri racchiuso tra due doppi apici • Null - Alla variabile viene assegnato il valore null • DateTime - Una data scritta come: #08/06/2008#Casting Essendo tutte le variabili fortemente tipizzate (e non tutte doublecome in muParser), la conversione si fa tramite cast.ES: 100 + cast(obj, int)Operatori Condizionali Come visto in muParser, anche quì è presenteun operatore condizionale.ES: If(a 100 and b 10, both greater, less)Operatore In Questo operatore è un operatore booleano che ritorna lap-partenenza di un valore o meno ad un insieme. Lo si può utilizzare con unvalore ed una lista di valori dello stesso tipo.ES (List): If(100 in (100, 200, 300, -1), in, not in)ES (Collection): if(100 in collection, in, not in)Le funzioni messe a disposizione da Flee sono le stesse disponibili nella libreriaMath di .NET. Grazie alla sua essibilità, infatti, tramite questa istruzionesi può fargli utilizzare lintero pacchetto:context.Imports.AddType(typeof(Math));Questa si può utilizzare con qualunque namespace o classe, di questa impor-terà tutte le funzioni publiche e statiche.Nonostante tutte queste funzionalità di Flee non è stato possibile implemen-tare degli operatori custom come fatto in muParser. Non è stato altresìpossibile permettere la gestione dei Constraint.Allutente verrà data la possibilità di scegliere tra i due Constraint Store aseconda delle sue esigienze: in caso di performance si consiglia Flee, in caso 46
  57. 57. di semplicità di scrittura tramite Constraint si consiglia muParser.Per una descrizione più approfondita di Flee, si rimanda al sito del progetto.4.2.2 Denition StoreCome è stato denito il Constraint Store per la gestione dei vincoli, ora verràanalizzato il lavoro che è stato svolto per il Denition Store. Dalla teoria edalle fasi di analisi e progettazione è emerso che il Denition Store deve: • Gestire la creazione di una denizione • Gestire la modica delle denizioni • Fornire uninterfaccia al ParserAM per aiutarlo nella creazione delle denizioni • Istanziare su richiesta le denizioniOltre a fornire le funzioni sopra esposte, il Denition Store deve creare deglioggetti utilizzabili dal Runtime Manager, ossia Agenti pronti ad eseguire leproprio azioni.Si è subito deciso che il Denition Store dovesse, in primis, contenere unalista di denizioni. Il passo successivo è stato decidere che, al momento dellacreazione di una nuova denizione, questa venisse fornita al chiamante.In questo modo il chiamante, utilizzando i metodi della denizione può mo-dicarla aggiungendoci azioni e variabili locali.Questo è possibile grazie allimplementazione di interfacce contenute nel Pro-getto Commons, in comune allintera soluzione.Il Denition Store contiene tutte le classi che deniscono le azioni viste inteoria. Queste sono intercambiabili in quanto tutte implementano la classeIAction (presente anchessa in Commons).Avremo quindi le seguenti azioni: • Guard: gestisce unazione di tipo guardia • Choose: gestisce una scelta • Parallel: gestisce un parallelo • Call: gestisce la chiamata • Tell: gestisce un Tell a rate innito (allinterno dei Parallel) • Ask: gestisce un Ask a rate innito (allinterno dei Parallel)Oltre alle azioni e le denizioni, il Denition Manager deve fornire anche gliAgenti. 47
  58. 58. Le AzioniLe azioni (come visto nel capitolo 2.2.6) vengono raccolte in ActionManagerche a loro volta vengono contenuti da Actions. Actions gestisce più Action-Manager (come fosse una scelta), mentre un ActionManager gestisce una listadi Azioni nchè si trova il bivio dato da una scelta.È ora riportato un esempio che aiuterà a spiegare lutilizzo di Actions eActionManager.Ag :- [- X=X+1]@{1} . Ag . [X 0 - ]@{X}.Ag + [ - ]@{1}.Ag2 + [ X5 - X=0]@{1} . Ag || Tell(Y=X);Questo agente avrà come azioni un oggetto costituito come quello in gura: Le azioni implementano linterfaccia IAction, che garantisce la loro esposi-zione dei seguenti metodi: • Execute: fa eseguire lazione • ReceiveLocalVariables: permette di impostare le variabili locali alla- zione • GetRate: ritorna il rate dellazione • GetAskVars: ritorna le variabili che inuiscono sulleseguibilità della- zione • GetTellVars: ritorna le variabili che vengono modicate dallazione • Refresh: aggiorna lazione se sono state modicate variabili che la interessano • IsRateInnite: permette di sapere se lazione ha rate innito 48
  59. 59. • ForceRefresh: forza il refresh • GetActionData: ritorna un oggetto con i dettagli dellazioneLutilizzo di funzioni come Refresh, GetAskVas e GetTellVars sono indispen-sabili al ne di ottenere un miglioramento delle performance. Nella sezionededicata al Constraint Store, vedremo come queste verranno utilizzate.Agent e AgentDenitionAgentDenition è una classe che contiene tutte i dati utili per la creazionedi un agente e i metodi per far si che il parser possa crearla.Agent viene creato dalla AgentDenition ed è loggetto centrale di sCCP.Dalla teoria si evince che un agente è costituito dalle Variabili Locali e dal-lelenco delle proprie azioni. Questo è importante anche perchè ci fa capireche inizialmente tutti gli agenti dello stesso tipo sono uguali.Da questo si può desumere che listanziazione di un Agent da un AgentDe-nition sia alquanto semplice in quanto consta della crezione dello stesso e delpassaggio delle proprie azioni e delle proprie variabili locali. Nello specicoogni Agent implementerà linterfaccia IAgent. Per le speciche dellinterfac-cia IAgent e delle altre, si rimanda ai sorgenti del codice, dove i commentispiegano lutilizzo di ogni funzione.Verrà ora spiegato velocemente cosa succede quando viene invocato lExcecu-te a un Agente. Assieme allExecute viene passato un valore è Reale: questogenerato dal Runtime Manager e serve nella scelta dellazione.Vediamo ora uno pseudo codice:Execute(RATE)i := 0while(RATE 0) RATE = RATE - RateAzione[i] if (RATE 0) Esegui Azione[i] else i ++Nello specico tale azione viene compiuta dalloggetto Actions che ogni Agentha. Azione[i] è un ActionManager e come tale inizierà lesecuzione eseguen-do ogni IAction che ha in lista. Se dovessimo incontrare unazione di tipoChoose, questa gestirà autonomamente (con il rate residuo) la scelta che devefare. 49

×