Giuseppe Cutuli, Enzo Mumolo, Marco Tessarotto

Presentazione sul tema: "Giuseppe Cutuli, Enzo Mumolo, Marco Tessarotto"— Transcript della presentazione:

1 An XML-based virtual machine for distributed computing in a Fork/Join framework
Giuseppe Cutuli, Enzo Mumolo, Marco Tessarotto DEEI, Universita’ di Trieste, Italy Dipartimento di Elettrotecnica, Elettronica , Speech, Multimedia and Robotics Informatica, Universita' di Trieste Technologies Lab

2 Introduction “GRID Computing”: a High Performance Computing
1/39 Introduction “GRID Computing”: a High Performance Computing paradigm based on sharing computing resources in internet Complex problems in theoretical physics, medicine, genetics, astronomy, financial, whether analysis … Some requirement of GRID: multi-platform nodes  Java Virtual Machine dynamic environment: hardware and software moving A typical GRID monolytic architecture: p2p node Byte code + data results Dynamic linking Security Verification Optimization

3 Introduction (cont.) some problems of the monolythic architecture:
2/39 Introduction (cont.) some problems of the monolythic architecture: performance – security - scalability The point of view used in this work: p2p node Algorithm described in XML + data results XML Interpretation Why using XML to describe algorithms in GRID? efficient algorithms distribution (HTTP’s Post ) efficient XML interpretation

4 Motivations of this work
To increase computing power on a mobile robot Image – demining applications Distributed environment Radio LAN LAN

5 Il Meta-linguaggio XML
8/39 Il Meta-linguaggio XML L’XML (eXtensible Markup Language) è un linguaggio di meta – markup, specifica una sintassi per altri linguaggi di markup semantici <?xml version="1.0"?> <!DOCTYPE nome descrittivo del documento [ <!ELEMENT elemento 1 (second1.1, ..,> <!ELEMENT second1.1 tipo> …. <!ELEMENT elemento N> <!ATTLIST elementoN Attributo1 tipo Valore ]> <!ENTITY nome “definizione”> <elemento 1>Contenuti e funzionalità </elemento 1> Struttura Logica: Prologo Elemento Document o Document Type Definition (DTD) Fisica: Contenuti e Funzionalità Sintassi Documenti validi e ben formati

6 XML-RPC: chiamata a procedure remote
9/39 XML-RPC: chiamata a procedure remote Header HTTP per i parametri di comunicazione Corpo XML per passare la richiesta coi parametri d’esecuzione Richiesta URI al codice di gestione richieste HTTP User-Agent Host Content-Type Content-length <?xml version="1.0"?> <methodCall> <methodName> nome procedura richiamata </methodName> <params> <param> Parametro 1 </param> …. </params> </methodCall> Risposta Verifica Trasmissione Chiusura connessione Content-Type Content-lengthDate GMTServer: agente di collegamento del server <?xml version="1.0"?> <methodResponse> <methodResponse> <params> <fault> parametri di ritorno <value> </params> struttura che segnala </methodResponse> l’errore </value> </fault> </methodResponse>

7 XML-RPC: chiamata a procedure remote
10/39 XML-RPC: chiamata a procedure remote Schema che descrive una comunicazione RPC

8 Architettura del sistema
12/39 Architettura del sistema Esempio di rete Peer – to - peer Chiamata tra i Nodi Peer – to – peer (nostra realizzazione) Chiamata tra i Nodi Peer – to – peer (teorico) Schema con restituzione dei risultati

9 Architettura software
13/39 Architettura software Non esiste una precompilazione del documento sorgente Il documento viene analizzato (Parsing)  eventi Eventi  interprete scritto in Java (esecuzione) Lettura Parsing Esecuzione *** ** *** ** * ** * *** * ** * ** *** ** * ** ** * ** ** ** * ** ** ** * ********** *** ** *** ** * ** * *** * ** * ** *** ** * ** ** * ** ** ** * ** ** ** * ********** *** ** *** ** * ** * *** * ** * ** *** ** * ** ** * ** ** ** * ** ** ** * ********** *** ** *** ** * ** * *** * ** * ** *** ** * ** ** * ** ** ** * ** ** ** * ********** Interprete Scritto in Java

10 Il Meta-linguaggio XML-VM
14/39 Il Meta-linguaggio XML-VM Permette di descrivere un algoritmo con XML I Tag XML diventano le istruzioni del nuovo linguaggio Il linguaggio si può vedere come un tipo semplificato di Assembler Si è deciso di non sviluppare una DTD del linguaggio per non appesantire la fase d’interpretazione Il controllo della sintassi è affidato allo stesso compilatore Java

11 Il Meta-linguaggio XML-VM (continua)
15/39 Il Meta-linguaggio XML-VM (continua) Caratteristiche principali del linguaggio: Attributi come parametri Strutture dati Registro Disco Virtuale I dati sono immagazzinati nel Disco Virtuale I dati possono essere elaborati solo nel Registro Abbiamo introdotto il tipo di dato Index

12 Le istruzioni Matematiche
16/39 Le istruzioni Matematiche Istruzioni: Esempio <OPER target=“0” op1=“13” op2=“11” op3=“9” command=“*+”/> <ADD target=“2” first=“3” second=“9”/> ADD ADD ADD CONV r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r0 Registro 1 m3 6 2 12 DIV ELEV MUL 30 m9 OPER OPER SUB

13 Le istruzioni di Spostamento Dati
17/39 Le istruzioni di Spostamento Dati Esempio Istruzioni: <LOAD register=“4” index=“10”/> <STORE topointed=“5” from=“4”/> <LOAD regpointed=“4” index=“3”/> r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r0 Registro Disco Virtuale m0 m1 m2 m3 m4 m5 m6 m7 m8 m9 m10 m11 m12 m13 m14 m15 m16 m19 m20 m21 m22 m23 m24 m25 m26 m27 m28 m29 m17 m18 1 12 7 LOAD LOAD LOAD MOVE r5 m3 STORE STORE r5

14 Le istruzioni Logiche Istruzioni: CMP CMP JEQ JGR JNEQ JNGR LABEL QUIT
18/39 Le istruzioni Logiche Esempio Istruzioni: <CMP first=“6” second=“9”/> <CMP first=“6” second=“11”/> CMP CMP JEQ r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r0 Registro 1 m3 2 6 12 Flag = “ ” Flag = “ 2 ” Flag = “ 3 ” JGR JNEQ JNGR LABEL QUIT START STRUCT

15 Le istruzioni di Chiamata
19/39 Le istruzioni di Chiamata Esempio Istruzioni: <JOIN to=“m15-m19”/> <FORK id=“N00” file=“pippo.xml” name=“via” to=“m15-m19” clone=“m5-m9”/> r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r0 Registro Disco Virtuale m0 m1 m2 m3 m4 m5 m6 m7 m8 m9 m10 m11 m12 m13 m14 m15 m16 m19 m20 m21 m22 m23 m24 m25 m26 m27 m28 m29 m17 m18 1 8 12 7 5 15 CALL FORK FORK FORK JOIN JOIN LOCALCALL RETURN 5 7 8 12 15 *RESERVED*

16 Fork/Join L’istruzione Fork è simile ad una chiamata a procedura
20/39 Fork/Join L’istruzione Fork è simile ad una chiamata a procedura classica, solo che lancia due processi in parallelo Il compito di raccordo è svolto dall’istruzione Join, che sincronizza i flussi di programma separati col Fork

17 Fork/Join Si può usare un contatore delle chiamate Fork
21/39 Fork/Join Esistono diverse sintassi per descrivere il Fork/Join Si può usare un contatore delle chiamate Fork Si possono associare le istruzioni a delle variabili

18 Fork/Join Esempio di chiamata Fork/Join in XML-VM 22/39 … …
<FORK id=“N00” file=“pippo.xml” name=“via” to=“m3-m5” clone=“m7-m9”/> <JOIN to=“m3-m5”/> <QUIT/> *** ** *** ** ** * ** <LABEL name=“via”/> ** * ** ** * ** *** ** * ** ** * * ************ ** * ** ** ** <RETURN from=“r6-r8”/>

19 <RANDOM to=“m15-m25” type=“int” mul=“10”/>
23/39 Le istruzioni Varie Esempio Istruzioni: <RANDOM to=“m15-m25” type=“int” mul=“10”/> r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r0 Registro Disco Virtuale m0 m1 m2 m3 m4 m5 m6 m7 m8 m9 m10 m11 m12 m13 m14 m15 m16 m19 m20 m21 m22 m23 m24 m25 m26 m27 m28 m29 m17 m18 1 12 7 RANDOM RANDOM SHOW 3 2 5 9 8 6 1 7

20 24/39 Il Parser Java È un traduttore in grado d’interpretare un documento XML Permette al linguaggio Java di trattare le informazioni contenute nel documento come eventi concatenati Esistono due tipi di specifiche per il Parser Sax 1.0 (contenuto dei Tag ed attributi) Sax 2.0 (anche analisi DTD, fogli di stile ed altro…) Prima realizzazione: Xerces dell’Apache (Sax 2.0) Realizzazione definitiva: MinML (Sax 1.0)

21 L’interprete di XML-VM
25/39 L’interprete di XML-VM È scritto in Java per potersi adattare ad ogni piattaforma È strutturato nei seguenti 14 file File che implementano la Macchina Virtuale Index.java xmlvm.java xmlvmcontext.java XmlvmException.java xmlvmcontenthandler.java xmlvmgeneric.java xmlvmStack.java File che contengono procedure main() saxtest.java xmlvmCall.java xmlvmnamres.java File con compiti vari Methods.java PseudXmlRpc.java xmlvmMachine.java xmlvmMachineTable.java

22 L’interprete di XML-VM (continua)
26/39 L’interprete di XML-VM (continua) public Object startExecution(Object[] arg, xmlvmMachine Machine) throws Exception{ Inizializzazioni; Scansione rapida del documento per la ricerca dei Tag Label; Verifica che l’intestazione del documento sia corretta; Cerca nel documento il Tag <START/> o quello <STRUCT/>, e inizializza la variabile i con la posizione del Tag appena trovato; try { FOR(i < tag.getChildrenCount(); i++) { SE (il Tag[i] è uno tra ADD LOAD MOV STORE SUB …) Allora lancia la procedura associata; Altrimenti { Per START e LABEL non fare niente; Per STRUCT ripristina le informazioni presenti nell’array Arg[]; Per JEQ, JNEQ, JGR, JNGR lancia le procedure associate ed aggiorna i; Per RETURN esegui la procedura Return(tag); Per SHOW mostra il contenuto del registro indicato; Per QUIT esci dal ciclo; }  } catch(Exception e) SE (non termina con QUIT) Lancia un errore e scrivi “non termina con Quit”;

23 L’interprete di XML-VM (continua)
27/39 L’interprete di XML-VM (continua) xmlvmCall public class xmlvmCall implements XmlRpcHandler { public Object execute (String method, Vector v) throws Exception { Vector vResult = Methods.execute(method,v); return (vResult); } public static void main(String args []) throws Exception { WebServer webserver = new WebServer (...porta...); webserver.addHandler ("$default", new xmlvmCall()); xmlvmnamres class nameres implements XmlRpcHandler { Inizializzo la xmlvmMachineTable, inserendo tutti i Nodi a disposizione: nameres() { } public class xmlvmnamres { public static void main(String args []) throws Exception {  WebServer webserver = new WebServer (10000); //attivo il Server XML-RPC webserver.addHandler ("$default", new nameres()); public Object execute (String method, Vector v) throws Exception { Riconosci che la chiamata è per una vera a propria risoluzione del nome; Confronta l’identificativo che ti è stato passato con quelli disponibili; Se l’identificativo è “N00”, allora restituisci i dati di uno dei Nodi disponibili a caso; Altrimenti restituisci quello specificato; public class saxtest { public static void main(String[] arg) throws Exception { Definisci l’oggetto “xmlvmMachine” con l’ip e la porta del risolutore dei nomi, e chiamalo “table”; xmlvmcontext ct = new xmlvmcontext(); ct.init(); Object[] args = new Object[2]; args[0] = " xml"; //nome del documento XML-VM da elaborare ct.parseXmlvmDoc(args[0].toString()); //Esegui il Parsing del documento Object o = ct.startExecution(args, table); //Lancia l’esecuzione del } Saxtest.java

24 L’interprete di XML-VM (continua)
28/39 L’interprete di XML-VM (continua) Sistema distribuito completo

25 L’interprete di XML-VM (continua)
29/39 L’interprete di XML-VM (continua) Esempio d’istruzione Logica Esempio d’istruzione per le Chiamate Esempio d’istruzione per Spostamento dati Esempio di codice d’istruzione Matematica public void LocalCall(xmlvm tag) throws Exception { Estrai gli attributi TO, NAME; Aggiungi un elemento all’XML-VMStack, dove sono memorizzati il registro al momento della chiamata ed i parametri inviati; Metti nelle celle del disco virtuale dalla 1 in poi i parametri annidati nell’ordine in cui appaiono; Salta all’etichetta definita dal nome NAME; Raccogli i risultati della chiamata; Memorizza nelle celle di memoria indicate dall’attributo TO; } public void Div(xmlvm tag) throws Exception { Estrai gli attributi RESULT, REST, FIRST e SECOND; Se R[FIRST] e R[SECOND] sono numeri, allora Se (RESULT.compareTo(“”) == 0), allora metti il risultato della divisione in R[FIRST] rispettando il tipo di dato del risultato; Altrimenti mettilo in R[RESULT]; Se (REST.compareTo(“”) != 0), allora metti il resto della divisione in R[REST]; } public void Store(xmlvm tag) throws Exception { Estrai gli attributi TO, TYPE, FROM e TOPOINTED; Se (FROM.compareTo(“”) != 0), carica il valore della cella R[FROM]; altrimenti cairca il valore contenuto all’interno del TAG; Se (TO.compareTo(“”) != 0), metti il valore caricato in DV[TO]; altrimenti mettilo nella locazione di memoria del disco virtuale puntato da R[TOPOINTED]; } public void Cmp(xmlvm tag) throws Exception { Estrai gli attributi FIRST e SECOND; Se (FIRST>SECOND), aggiorna la variabile di flag a 1; Altrimenti Se (FIRST<SECOND), aggiorna la variabile di flag a 2; Altrimenti Se (FIRST==SECOND), aggiorna la variabile di flag a 3; }

26 L’interprete di XML-VM (continua)
30/39 L’interprete di XML-VM (continua) Pseudo-codice istruzione Join Pseudo-codice istruzione Fork public void Fork(xmlvm tag) throws Exception { Estrai gli attributi TO, IP, FILE, NAME e CLONE; Effettua una chiamata RPC al risolutore dei nomi e aggiorna l’IP; Prepara nel vettore args tutti i parametri necessari per l’invio della richiesta remota, ovvero il registro per intero e la sezione del disco virtuale indicata dall’attributo CLONE; Inizializza le celle del disco virtuale descritte da “TO” al valore “*RESERVED*”; ForkThread remoteCall = new ForkThread(); RemoteCall.start();  }  protected class ForkThread extends Thread {  Definizione delle Variabili locali; public void run() { Effettua la richiesta remota direttamente verso la macchina corrispondente all’IP; Digli di eseguire il documento XML-VM indicato nell’attributo FILE a partire dalla procedura etichettata col nome NAME; Raccogli i risultati della chiamata; Memorizza nelle celle di memoria indicate dall’attributo TO; } public void Join(xmlvm tag) throws Exception { Estrai gli attributi TO e TOPOINTED; SE(TO.compareTo(“”) != 0) verifica che le celle individuate dall’attributo TO non siano ancora *RESERVED*; se sono ancora *RESERVED*, esegui un ciclo che continui a monitorare le celle; Altrimenti { verifica che le celle contigue a partire dalla cella puntata dalla prima parte dell’attributo TOPOINTED per una lunghezza pari alla seconda parte dello stesso attributo non siano ancora *RESERVED*; }

27 Accorgimenti presi per gli esperimenti
31/39 Accorgimenti presi per gli esperimenti Risolutore dei nomi per raccogliere le misurazioni Procedure di rilevazione dei tempi Procedure di rilevazione del flusso di dati XML-RPC Strumenti a disposizione per gli esperimenti 16 computer eterogenei 8 Pentium III 800MHz, Windows2000, 128 MB RAM 8 Celeron 400MHz, WindowsNT 4.0, 64 MB RAM Impostazioni adottate negli esperimenti Nodo centrale escluso dalla computazione (Pentium III) Misurazioni in funzione del numero di macchine coinvolte Carico doppio sui Pentium III I Pentium III sono le prime macchine introdotte

28 Risultati Sperimentali
32/39 Risultati Sperimentali Tre tipi di esperimenti Una Sommatoria Un Integrale Un Ordinamento Quick Sort f(x) x

29 Esempio di sorgente XML-VM
33/39 Esempio di sorgente XML-VM Codice XML-VM per la Sommatoria <?xml version='1.0'?> <XMLVM> <START/> <STORE to="12" type="int"> 1 </STORE> <STORE to="0" type="index"> m1 <STORE to="13" type="int"> <STORE to="14" type="int"> 2 <STORE to="15" type="index"> m0 <STORE to="16" type="int"> 20 <LOAD register="15" index="15"/> <LOAD register="16" index="16"/> <ADD first="15" second="16"/> <STORE to="15" from="15"/> <LOAD register="29" index="14"/> <LOAD register="30" index="13"/> <LOAD register="31" index="12"/> <MOVE target="15" source="30"/> <STORE to="10" type="int"> </STORE> <STORE to="11" type="int"> 100000 <LOAD register="0" index="10"/> <LOAD register="1" index="11"/> <DIV result="2" first="0" second="1"/> <CONV register="2" to="int"/> <MOVE target="3" source="30"/> <LABEL name="For1"/> <CMP first="2" second="3"/> <JNGR to="EndFor1"/> <MUL target="4" first="3" second="1"/> <ADD target="5" first="4" second="1"/> <STORE to="1" from="4"/> <STORE to="2" from="5"/> <FORK id="N00" file=" name="Somma" to="m15[m12]" clone="m0[m14]"/> <LOAD register="15" index="15"/> <ADD first="15" second="31"/> <STORE to="15" from="15"/> <ADD first="3" second="31"/> <JGR to="For1"/> <LABEL name="EndFor1"/> <STORE to="17" type="index"> m0 </STORE> <LOAD register="17" index="17"/> <LOAD register="16" index="16"/> <ADD first="17" second="16"/> <STORE to="17" from="17"/> <MOVE target="17" source="30"/> <STORE to="9" from="2"/> <JOIN topointed="m17[m9]"/> <MOVE target="3" source="30"/> <LOAD register="6" index="13"/> <LOAD register="8" index="17"/> <LABEL name="For2"/> <CMP first="2" second="3"/> <JNGR to="EndFor2"/> <LOAD register="7" pointer="8"/> <ADD first="8" second="31"/> <ADD first="3" second="31"/> <ADD first="6" second="7"/> <JGR to="For2"/>  <LABEL name="EndFor2"/> <QUIT/> </XMLVM>

30 Risultati Sperimentali (Sommatoria)
34/39 Risultati Sperimentali (Sommatoria) Grafico dei Tempi per numero di macchine Grafico degli Speedups

31 Risultati Sperimentali (Integrale)
35/39 Risultati Sperimentali (Integrale) Grafico degli Speedups Grafico dei Tempi per Pentium e Celeron Grafico dei Tempi per numero di macchine Grafico stimato per Pentium e Celeron

32 Risultati Sperimentali (Quick Sort)
36/39 Risultati Sperimentali (Quick Sort) Grafico degli Speedups riscalato (Pentium) Grafico dei Tempi per numero di macchine Volume dati trasferiti via XML-RPC Grafico degli Speedups

33 Risultati Sperimentali (Parsing)
37/39 Risultati Sperimentali (Parsing) Il Tempo di Parsing comprende il download e l’analisi del documento XML Si effettua il Parsing dei documenti XML-VM ad ogni chiamata remota Tabella dei tempi di Parsing

34 Conclusioni Trasferimento dei metodi in Java
38/39 Conclusioni Metodi variabili: Trasferimento dei metodi in Java Nodo Sorgente Nodo Remoto Compilazione Esecuzione Java Trasferimento dei metodi con XML-VM Nodo Sorgente Nodo Remoto Parsing Esecuzione XML Nel Nodo remoto ci sono: Parser MinML Codice eseguibile (~100KB)

35 Conclusioni Si è progettato e sviluppato un sistema per Grid Computing
39/39 Conclusioni Si è progettato e sviluppato un sistema per Grid Computing Si è utilizzato XML per descrivere algoritmi Si è utilizzato Java per implementare la macchina virtuale I risultati raccolti hanno risposto adeguatamente alle attese I grafici delle prestazioni dimostrano efficienza di calcolo I Tempi di download e d’analisi dei metodi sono leggerissimi Non è stato affrontato il problema della distribuzione del Carico e della tolleranza ai guasti Non sono stati affrontati i problemi di sicurezza e programmazione complessa