Studente: Diego BANOVAZ

Relatore: Prof. Luca BORTOLUSSI

Facoltà di Ingegneria

LAUREA SPECIALISTICA IN INGEGNERIA INFORMATICA

Prima analisi dell’obbiettivo

Si vuole ottenere un framework per la

simulazione di modelli

Il framework deve essere interfacciabile

con programmi esterni

Deve essere utilizzabile da utenti non

esperti in programmazione

Deve avere prestazioni accettabili

sCCP: Stochastic Concurrent

Constraint Programming

Evoluzione di CCP

Linguaggio per la descrizione di modelli

Modello ad agenti interagenti

Interazioni di tipo concorrente

Sistema ad evoluzione probabilistica

Lotka-Volterra

Lotka-Volterra: Codice SCCP

Predatore :-

[X > 0 -> Y = Y + 1; X = X - 1]@{Km * X * Y}.Predatore()

+ [Y > 0 -> Y = Y - 1]@{Kd * Y}.Predatore();

Preda:- [X > 0 -> X = X + 1]@{Kr * X}.Preda();

Lotka-Volterra: Codice SCCP

Predatore :-

[X > 0 -> Y = Y + 1; X = X - 1]@{Km * X * Y}.Predatore()

+ [Y > 0 -> Y = Y - 1]@{Kd * Y}.Predatore();

Preda:- [X > 0 -> X = X + 1]@{Kr * X}.Preda();

Nomi degli Agenti

Lotka-Volterra: Codice SCCP

Predatore :-

[X > 0 -> Y = Y + 1; X = X - 1]@{Km * X * Y}.Predatore()

+ [Y > 0 -> Y = Y - 1]@{Kd * Y}.Predatore();

Preda:- [X > 0 -> X = X + 1]@{Kr * X}.Preda();

Scelta

Nomi degli Agenti

Lotka-Volterra: Codice SCCP

Predatore :-

[X > 0 -> Y = Y + 1; X = X - 1]@{Km * X * Y}.Predatore()

+ [Y > 0 -> Y = Y - 1]@{Kd * Y}.Predatore();

Preda:- [X > 0 -> X = X + 1]@{Kr * X}.Preda();

Chiamate di AgentiScelta

Nomi degli Agenti

Lotka-Volterra: Codice SCCP

Predatore :-

[X > 0 -> Y = Y + 1; X = X - 1]@{Km * X * Y}.Predatore()

+ [Y > 0 -> Y = Y - 1]@{Kd * Y}.Predatore();

Preda:- [X > 0 -> X = X + 1]@{Kr * X}.Preda();

Chiamate di Agenti

Guardie

Scelta

Nomi degli Agenti

Lotka-Volterra: Codice SCCP

Predatore :-

[X > 0 -> Y = Y + 1; X = X - 1]@{Km * X * Y}.Predatore()

+ [Y > 0 -> Y = Y - 1]@{Kd * Y}.Predatore();

Preda:- [X > 0 -> X = X + 1]@{Kr * X}.Preda();

ask tell rate

Tra tutti gli agenti attivi, l’azione da eseguire vienescelta tramite una Race Condition tra le azioni con asktrue.La probabilità che un’azione venga eseguita èproporzionale al proprio rate.

if (ask) { tell }

Semantica per sCCP

Preda Predatore

X > 0 ->

X = X + 1

X > 0 -> Y = Y

+ 1; X = X - 1

Y > 0 ->

Y = Y - 1

sCCP istanzia dal sorgente un ambiente fatto da agenti.Il sistema è descritto completamente dagli agenti in vita edallo stato delle variabili.

Agenti

Azioni

Semantica per ITS

SVsAgenteRateSVRate )(*

X > 0Guardia

X = X + 1

Kr * X

Update

Rate

SVPreda > 0

&& X > 0

X = X + 1;

SVPreda--;

SVPreda++

SVPreda * Kr *

X

Lo stato del sistema è dato dalle definizioni degli

Agenti, dalle variabili globali e dalle State Variables. Le

State Variables vengono associate ad ogni agente e

rappresentano il Numero di agenti attivi di quel

particolare tipo.

Semantica per ODE

0e'SVPredator

0'SVPreda

Y*Kd*eSVPredatorY*X*Km*eSVPredator Y'

Y * X * Km*eSVPredator - X *Kr *SVPreda'X

•La modifica alle variabili avviene proporzionalmente

alla state variables dell’agente e al rate dell’azione

stessa.

•Questa simulazione completamente deterministica.

•Le equazioni e cui si arriva sono le stesse equazioni

matematiche che definiscono il sistema.

Risultati Semantiche

SCCP

ITS

ODE

Analisi

Derivare dal codice SCCP le tre

semantiche

Fornire un’interfaccia utente

Input standardizzato

Output standardizzato

Output grafico

Custom Memory Semantic

Performance

Progettazione

SCCP

XML

Compiler

Simulator

Graph CSV

Other SW

Input

Computazione

Output

Schema Macro Classi

Conversione tra sCCP e XML

InterfacciaProgrammazione

Interfaccia Simulazione

Compilatore e Simulatore

Conversione tra sCCP e XML

Conversione tra sCCP e XML

InterfacciaProgrammazione

Interfaccia Simulazione

Compilatore e Simulatore

•Utilizzato un compilatore di compilatori (COCO)

•In grado di generare documenti XML che

rispettino un determinato DTD

•Efficace segnalazione degli errori di Parsing

Interfaccia Programmazione

Conversione tra sCCP e XML

InterfacciaProgrammazione

Interfaccia Simulazione

Compilatore e Simulatore

•Scrivere codice sCCP

•Commons Functions (Save, Load..)

•Compilazione

•Selezione Compilatore

•Selezione Constraint Store

•Start Graphic Simulation

•Start Batch Simulation

Interfaccia Simulazione

Conversione tra SCCP e XML

InterfacciaProgrammazione

Interfaccia Simulazione

Compilatori e Simulatori

Graphic:

•Interfaccia completa, funzionalità avanzate

•Possibilità di salvare e continuare le simulazioni

•Modalità continua / modalità per passi

•Traccia il grafico

Batch:

•Stato avanzamento del sistema

•Interfaccia leggera, funzionalità di base

Compilatori e Simulatori

Conversione tra SCCP e XML

InterfacciaProgrammazione

Interfaccia Simulazione

Compilatori e Simulatori

•Interscambiabili

•Interfacciabili con programmi esterni

•In grado di comprendere codice XML-sCCP

•Semantica matematica programmabile

Compilatori e Simulatori(2)

Parser AMParser CS

Constraint Store Definition Manager

Runtime Manager

Parser Results Parser Results

Operazioni sulle Variabili

Operazioni sulle Definizioni

Parse CSXML Parse AMXMLInput Output

Constraint Store

Constraint Store

Math Parser

From Parser

Declarations

Results

Queries

From/To Runtime Manager

Nuova Variabile

Nuova Funzione

Nuovo Constraint

Nuovo Operatore

Nuovo Parametro

Nuova Costante

Il Math Parser è un modulo

esterno che permette la

risoluzione di equazioni. Il

framework mette a disposizione

due Constraint Store, uno basato

su muParser e uno basato su

Flee.

Il Constraint Store si interfaccia al

Math Parser facendo da Wrapper

intelligiente.

Ask: richiede la validità

di una formula

Tell: impone un nuovo

vincolo al sistema

GetRate: ottiene il

valore di una formula

GetVariables: ottiene

lo stato delle variabili.

Definition Manager

Definition ManagerDefinitions Instances

Nuova Definizione

Definition Manager contiene e

gestisce tutte le definizioni. Ne

esiste uno per ogni semantica, in

modo che questi possa modellare

il suo prodotto a seconda delle

richieste.

A seconda della sua

implementazione

ritorna Agenti oppure

Transizioni

From Parser To Runtime Manager

Runtime Manager

Runtime ManagerCommands Results

Start

Stop

Step

Runtime Manager è l’esecutore.

Utilizza il Constraint Store e

l’Definition Manager per simulare

il modello.

Loop:

Scegli Azione

Esegui Azione

Incrementa il tempo trascorso

Stato del sistema

Valori delle variabili

Agenti Attivi

To User InterfaceFrom User Interface

Interfaccia Programmazione

Definizione

Agenti e Stato

Iniziale

Definizione

Constraint Store

Menu

Compilazione

Scelta

Semantica

Scelta

Constraint Store

Inizia

Simulazione

Interfaccia Simulazione

Stato Variabili

Stato Agenti

Scelta

SimulazioniSystem Status

Options

Grafico

TestSistema semplificato

Client Server

Lotka-Volterra

Sintesi di Glucosio da

Lattosio in E-Coli

Performances

Client Server – Peso del grafico e confronto Constraint Store

Lotka Volterra – Differenza tra i compilatori

Lactose – Differenza tra i compilatori

Il grafico rallenta di molto la simulazioneIl Constraint Store muParser è molto più

lento di Flee

ITS è più veloce di SCCP

ODE è più veloce di entrambi

In questo caso ODE è molto più lento di

SCCP ed ITS

Analisi Performance

Flee molto più veloce di muParser (circa 50 volte)

Tracciare il grafico influenza pesantemente la velocità di simulazione (circa 50 volte)

ITS risulta più efficiente di sCCP, più agenti in gioco ci sono e più risulta efficiente

ODE risulta più efficiente in alcuni esempi rispetto ad altri

Conclusioni

6 mesi di lavoro

Oltre 250 classi scritte

Oltre 20.000 righe di codice

Progetto funzionante al 100%

Migliorie necessarie per incrementarne

l’usabilità