Inferno, Limbo e la Dis Virtual Machine

1. Inferno, Limbo e la Dis Virtual Machine Lanciano Davide Ferrara Simona

2. Inferno E’ un nuovo Sistema Operativo per sistemi embedded sviluppato dai ricercatori Rob Pike e Phil Winterbottom del Computing Science Research of Bell Labs (Lucent Technologies). Nasce da un altro S.O. sviluppato presso gli stessi laboratori: Plan-9 . Il suo scopo è quello di facilitare la creazione ed il supporto di servizi distribuiti e di applicazioni di rete.

3. Caratteristiche principali di Inferno • Indipendente dall’architettura • Puo’ essere eseguito su dispositivi con poca memoria: serve soltanto 1 MB di RAM! • Supporta la compilazione Just-in-Time • Kernel e device driver sono scritti in C • Le applicazioni di Inferno sono scritte nel nuovo linguaggio Limbo

4. Vantaggi per l’utilizzo di Inferno • Portabilità tra processori

5. Vantaggi per l’utilizzo di Inferno • Portabilità tra ambienti

6. Vantaggi per l’utilizzo di Inferno • Design distribuito • Portabilità delle applicazioni

7. Componenti principali • Linguaggio di programmazione: Limbo • Macchina virtuale: DIS • File Communications Protocol: Styx • Inferno API (application programming interface)

8. Esempio dell’utilizzo di Inferno

9. Limbo Le sue caratteristiche principali: • sintatticamente simile al linguaggio C • inferno API • supporta la programmazione modulare • un forte type cheking a compile- e run-time • creazione di processi multipli (threads) e comunicazione tra loro attraverso dei tipi channel lo rendono semplice, sicuro, e molto potente, e meglio adatto per lo sviluppo di sistemi distribuiti e concorrenti.

10. Tipi di dato Limbo offre un’ampia scelta di tipi di dato primitivi: • Byte (8-bit unsigned) • Int (32-bit signed) • Big (64-bit unsigned) • Real (64-bit floating point) • List • Array • String • Tuple (ordered collection of types) • Channel (for inter-process communication) • Adt (C like struct) • Pick (discriminated union type) • Module

11. Canali di comunicazione Un canale il cui tipo e’ scritto chan of data-type - chan of int - chan of (int, char) c <= (123, “hello”);

12. Programma 1 1: implement Timer2; 2: include “sys.m”; 3: sys: Sys; 4: include “draw.m”; 5: Timer: module { 6: init: fn (nil: ref Draw->Context, argv : list of string); 7: }; 8: init (nil: ref Draw->Context, argv: list of string ) 9: { 10: sys = load Sys Sys-> PATH; 11: n := len argv; 12: sys->print (“comand Line Parameters\n”); 13: for (i:= 0 ; i < n; I++ ) { 14: sys ->sleep (1000); 15: sys-> print (“%d: %s\n”, i, hd argv); 16: argv =tl argv; 17: } 18: }

13. Programma 2 1: implement Timer2; 2: include “sys.m”; 3: sys: Sys; 4: include “draw.m”; 5: Timer2: module { 6: init: fn (nil: ref Draw->Context, argv : list of string); 7: }; 8: init (nil: ref Draw->Context, argv: list of string ) 9: { 10: sys = load Sys Sys-> PATH; 11: sync := chan of int; 12: n := len argv; 13: spawn timer (sync, n); 14: sys->print (“comand Line Parameters\n”); 15: for (i :=0; i < n; i++) { 16: <- sync; 17: sys-> print (“%d: %s\n”, i, hd argv); 18: argv =tl argv; 19: } 20: } 21: timer { syinc: chan of int, n: int) 22: { 23: for (i:= 0 ; i < n; I++ ) { 24: sys ->sleep (1000); 25: sync <-= 1; 26; } 27: }

14. Caratteristiche comuni con Java • Uso di una sintassi simile al C • Compilazione in codice macchina virtuale per un’ esecuzione portabile • Garbage collection automatico per la gestione della memoria • Uso di caratteri Unicode

15. Sostanziali differenze con Java • Limbo non e’ un linguaggio ad oggetti ma rispetto a Java ha piu’ tipi base (es: liste, stringhe, tuple) e piu’ concetti di programmazione (es: i thread sono implementati attraverso canali di comunicazione) • I programmi Limbo possono caricare e scaricare moduli come impone il suo ambiente

16. Dis virtual machine Fornisce l’ambiente di esecuzione per i programmi che vengono eseguiti sul sistema operativo Inferno. Ogni macchina che ha la DIS può eseguire ogni applicazione scritta in Limbo. Fornisce perciò una rappresentazione architettura-indipendente del codice eseguibile.

17. Caratteristiche principali della Dis • Modella un’architettura di tipo CISC • E’ una macchina a tre operandi OP src1, src2, dst • Ha un’architettura memory-to-memory • Supporta un grande insieme di tipi di alto livello, ad esempio stringhe, liste e array.

18. Procedura d’esecuzione di un programma Application (in Limbo) Inferno Kernel Bytecode Transformer Interpreter On-the-fly compiler CPU

19. Procedura d’esecuzione di un programma • Quando il codice e’ caricato in memoria per l’esecuzione il bytecode viene convertito in un formato piu’ efficente per l’esecuzione • Un compilatore JIT puo’ trasformare l’insieme di istruzioni Dis nel codice nativo dell’hardware sottostante

20. Symbol table Un file .sbl fornisce le informazioni sui tipi utilizzati in un file eseguibile Dis e puo' essere usato dai debuggers. Viene costruita dal compilatore. Il file .sbl è formato da un header seguito da 5 tabelle. Ogni tabella inizia con 1 linea che contiene il numero di elementi di quella tabella.

21. Header File table PC table Adt table Fn table Data table Elementi della symbol table

22. Dimensione degli operandi • byte = 8 bit • parola o puntatore = 32 bits • float = 64 bits • Big integer = 64 bits

23. Dimensione degli operandi La dimensione ed il tipo dell’ operando sono specificati dall’ultimo carattere dell’istruzione. Esempio:

24. Instruction Set Logical AND Syntax: andb src1, src2, dst andw src1, src2, dst andl src1, src2, dst Function: dst = src1 & src2

25. Instruction Set Branch equal Syntax: beqb src1, src2, dst beqw src1, src2, dst beqf src1, src2, dst Function: if src1 == src2 then pc = dst

26. Organizzazione della memoria IL SEGMENTO DI CODICE CONTIENE: • istruzioni decodificate in linguaggio Dis disponibili per essere eseguite dall’interprete (istruction set) • codice macchina compilato on-the-fly per la CPU che si sta utilizzando

27. Indirizzamento Un thread in esecuzione ha accesso a due regioni di memoria dati indirizzabile: • una regione dei dati globali di un particolare modulo, puntata dal registro MP (module pointer) • il record di attivazione, o frame, per il thread, puntato dal registro FP (frame pointer)

28. DATI GLOBALI DEI MODULI DATI DEI THREADS DEI MODULI MP 1 Dati statici FP 1 Stack Thread 1 Modulo 1 Codice MP 2 FP 2 Stack Thread 2 Dati statici Modulo 2 Codice FP 3 Stack Thread 3 MP 3 Dati statici Modulo 3 Codice

29. Indirizzamento effettivo Ogni istruzione puo’ indirizzare tre operandi. Gli operandi possono generare un indirizzo effettivo in tre modi differenti: • Indiretto • Immediato • Doppia indirettezza

30. Esempi di indirizzamento

31. Instruction Set Add Syntax: addf src1, src2, dst Function: dst = src1 + src2

32. Instruction Set Add (con operando intermedio omesso) Syntax: addf src1, dst Function: dst = dst + src2

33. Garbage Collection La macchina DIS fornisce 2 algoritmi di garbage collection: • Reference Counted • Real Time mark-and-Sweep

34. Questo approccio ibrido permette al codice di essere generato in diversi stili: • Reference Counted puro • Real Time mark-and-Sweep • Approccio intermedio tra le due strategie

35. La sintassi in assembler per un descrittore di tipo è: desc $10, 132, “001F” dimensione numero di descrittore puntatore a map

36. DIFFERENZA PRINCIPALE RISPETTO ALLA JVM: La DIS utilizza registri virtuali La JVM utilizza lo stack

37. cio’ comporta: • maggiore semplicita’ di interpretazione per la SM rispetto alla MM • maggiore traffico di memoria per la SM, mascherato dal tempo risparmiato a non decodificare i campi degli operandi

38. consideriamo il codice per eseguire la seguente istruzione: c = a + b sequenza di istruzioni per una SM: push a #LS push b #LS add #LLS store c #LS il corrispondente in MM: add a, b, c #LLS

39. Riferimenti • www.vitanuova.com contiene la versione scaricabile di Inferno • www.hallogram.com/inferno • www.cynergy.com • www.infernolucent.com