Inferno,
Limbo
e la Dis Virtual Machine
Lanciano Davide
Ferrara Simona
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.
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
Vantaggi per l’utilizzo di Inferno

Portabilità tra processori
VENDOR
Intel
Sun Microsystems
PROCESSOR
X86
Sparc
Silicon Graphics (MIPS)
Advanced RISC Machines
Hewlett Packard
MIPS
ARM
HP-PA
Amdahl
AMD
Vantaggi per l’utilizzo di Inferno

Portabilità tra ambienti
VENDOR
Various
Microsoft
PLATFORM
Standalone
Windows 95, Windows NT
Silicon Graphics
Sun Microsystems
Various
Irix
Solaris
Linux
IBM
Hewlett Packard
Lucent Technologies
AIX
HP/UX
Plan 9
Vantaggi per l’utilizzo di Inferno

Design distribuito

Portabilità delle applicazioni
Componenti principali

Linguaggio di programmazione: Limbo

Macchina virtuale: DIS

File Communications Protocol: Styx

Inferno API (application programming interface)
Esempio dell’utilizzo di Inferno
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.
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
Canali di comunicazione
Un canale il cui tipo e’ scritto
chan of data-type
- chan of int
- chan of (int, char)
c <= (123, “hello”);
Programma 1
1:
implement Timer2;
2:
3:
4:
include “sys.m”;
sys: Sys;
include “draw.m”;
5:
6:
7:
Timer: module {
init: fn (nil: ref Draw->Context, argv : list of string);
};
8: init (nil: ref Draw->Context, argv: list of string )
9: {
10: sys = load Sys Sys-> PATH;
11:
12:
n := len argv;
sys->print (“comand Line Parameters\n”);
13:
14:
15:
16:
17:
18:
for (i:= 0 ; i < n; I++ ) {
sys ->sleep (1000);
sys-> print (“%d: %s\n”, i, hd argv);
argv =tl argv;
}
}
Programma 2
1:
implement Timer2;
2:
3:
4:
include “sys.m”;
sys: Sys;
include “draw.m”;
5:
6:
7:
Timer2: module {
init: fn (nil: ref Draw->Context, argv : list of string);
};
8: init (nil: ref Draw->Context, argv: list of string )
9: {
10: sys = load Sys Sys-> PATH;
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26;
27: }
sync := chan of int;
n := len argv;
spawn timer (sync, n);
sys->print (“comand Line Parameters\n”);
for (i :=0; i < n; i++) {
<- sync;
sys-> print (“%d: %s\n”, i, hd argv);
argv =tl argv;
}
}
timer { syinc: chan of int, n: int)
{
for (i:= 0 ; i < n; I++ ) {
sys ->sleep (1000);
sync <-= 1;
}
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
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
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.
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.
Procedura d’esecuzione
di un programma
Application
(in Limbo)
Inferno
Kernel
Bytecode
Transformer
On-the-fly
compiler
Interpreter
CPU
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
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.
Elementi della symbol table

Header

Adt table

File table

Fn table

PC table

Data table
Dimensione degli operandi

byte = 8 bit

parola o puntatore = 32 bits

float = 64 bits

Big integer = 64 bits
Dimensione degli operandi
La dimensione ed il tipo dell’ operando sono
specificati dall’ultimo carattere dell’istruzione.
Esempio:
W
Word, 32-bit two’s complement
B
Byte, 8-bit unsigned
F
Float
L
Big, 64-bit two’s complement
P
Pointer
Instruction Set
Logical AND
Syntax:
andb src1, src2, dst
andw src1, src2, dst
andl src1, src2, dst
Function: dst = src1 & src2
Instruction Set
Branch equal
Syntax:
beqb src1, src2, dst
beqw src1, src2, dst
beqf src1, src2, dst
Function: if src1 == src2 then pc = dst
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
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)
DATI GLOBALI
DEI MODULI
MP 1
Modulo
1
FP 1
Stack
Thread 1
Codice
MP 2
Modulo
2
Dati statici
FP 2
Stack
Thread 2
Codice
MP 3
Modulo
3
Dati statici
DATI DEI THREADS
DEI MODULI
Dati statici
Codice
FP 3
Stack
Thread 3
Indirizzamento effettivo
Ogni istruzione puo’ indirizzare tre
operandi.
Gli operandi possono generare un
indirizzo effettivo in tre modi
differenti:



Indiretto
Immediato
Doppia indirettezza
Esempi di indirizzamento
10(fp)
indirect dal registro fp
20(mp)
indirect da mp
$0x123
immediate value
10(20(fp))
double indirect rispetto a fp
10(20(mp)) double indirect rispetto a mp
Instruction Set
Add
Syntax:
addf src1, src2, dst
Function: dst = src1 + src2
Instruction Set
Add (con operando intermedio omesso)
Syntax:
addf src1, dst
Function: dst = dst + src2
Garbage Collection
La macchina DIS fornisce 2 algoritmi di
garbage collection:


Reference Counted
Real Time mark-and-Sweep
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
La sintassi in assembler per un
descrittore di tipo è:
desc $10, 132, “001F”
dimensione
numero di
puntatore a map
descrittore
DIFFERENZA PRINCIPALE
RISPETTO ALLA JVM:
La DIS utilizza registri virtuali
La JVM utilizza lo stack
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
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
Riferimenti




www.vitanuova.com
contiene la versione scaricabile di
Inferno
www.hallogram.com/inferno
www.cynergy.com
www.infernolucent.com