1

Introduzione aIntroduzione a Network Simulator (NS)( )

Ing. Anna Maria VegniIng. Anna Maria Vegniavegni@uniroma3.it

Roma, 30/10/2008

2Introduzione

• NS2 Network Simulator è un software di simulazione di reti a pacchettoopen source, sviluppato prevalentemente nelle università e realizzatograzie all’unione di contributi diversi Utilizzato spesso per simulare retigrazie all unione di contributi diversi. Utilizzato spesso per simulare retiIP.

– Vantaggi: è disponibile gratuitamente. C’è una vasta comunità digg p gutilizzatori che fornisce supporto e nuovi aggiornamenti di librerie emoduli. E’ un programma in continua evoluzione.

S i d i i– Svantaggi: manca una documentazione rigorosa su comeimplementare e spesso il codice ha bug non segnalati.

• NS è basato su due linguaggi di programmazione, C++ e OTcl. 

– C++ è il linguaggio utilizzato come parte principale di NS, mediante la programmazione a oggettila programmazione a oggetti.

– OTcl realizza l’interfaccia con l’utente, permettendo una facile manipolazione degli oggetti in C++.p g gg

• NS è quindi un interprete Tcl (Tool Command Language) con estensione Object Oriented.

NS & NAM3

• Gli oggetti che compongono la rete e gli schedulatori di eventi sono implementati in C++.

• Il setup della rete ed il controllo dei parametri durante la simulazione utilizza il codice Otcl, più semplice e rapido da scrivere.

• NAM (Network AniMator) è un’interfacciagrafica per rappresentare gli scenarig p pp gdi rete. Visualizza i risultati generati da NS.

• Cosa simula NS?– Modelli di traffico e applicazioni

(Web FTP telnet sensor network ecc )(Web, FTP, telnet, sensor network, ecc.)– Protocolli di trasporto, (TCP, UDP,

broadcast, connessioni pto‐pto, multi‐pto, ecc.), p p , p , )– Routing & queueing– Link layer (wired, wireless, satellite)

4Installazione

• È possibile installare NS2

1. su Linux;

2. su Windows, utilizzando la piattaforma Cygwin che simula l’ambiente Linux, scaricabile liberamente da Internet.

• L’ultima versione di NS2 è ns‐allinone‐2.32(http://www.isi.edu/nsnam/ns/ns‐build.html#allinone)

• Tutorial di Marc Greis http://www.isi.edu/nsnam/ns/tutorial/

S b l• NS by examples http://nile.wpi.edu/NS/

5Gli eventi in NS2

• NS2 è un simulatore tempo‐discreto ad eventi.• L’istante ti in cui si presenta l’evento i‐esimo attiva l’esecuzione di 

azioni specificate nello scriptazioni specificate nello script.• Gli eventi sono descritti dall’istante di simulazione e sono inseriti in 

una lista  degli eventi.• Lo scheduler gestisce l’accesso alla lista.

6Il linguaggio Otcl

• NS è strutturato in classi con ordinamento gerarchico.

• L’utente simula il funzionamento di una rete di TLC mediante ill llinguaggio Otcl.

• Uno script Otcl crea il proprio modello di rete (numero di nodi,links sorgenti di traffico ecc)links, sorgenti di traffico, ecc).

• Nello script Otcl si definiscono le istanze delle classi e di conseguenzasi creano le istanze degli oggetti con le corrispondenti classicompilate in C++.

Alcuni comandi in Otcl7

• Per creare, inizializzare ed eliminare una variabile, vengono usate le seguenti istruzioni:

t < i bil > < l >set <nome_variabile> <valore>unset <nome_variabile>

• Ciclo FORfor {set i 0}{$i < 100}{incr i}{

set n($i) [new node]

while {$i < 100}{

}

• Ciclo WHILE set n($i) [new node]incr i

if {$i > 0} {• Istruzione IF

}

puts “i è un intero positivo”}

8Classi in Otcl

• Otcl utilizza delle classi standard per implementare un modello di rete, quali:

– SIMULATOR genera un nuovo oggetto Simulatore

– NODE genera un nuovo oggetto Nodo di reteNODE genera un nuovo oggetto Nodo di rete

– LINK genera un nuovo oggetto Link di rete

– AGENT genera un nuovo oggetto Agenteg gg g

– TRACE genera un nuovo file di traccia

– ERRORMODEL genera sia errori a livello fisico, sia la perdita di interi pacchetti

9La classe SIMULATOR

• La classe SIMULATOR è la classe fondamentale di NS2. Permette di istanziare l’oggetto che simulerà la rete.

• E’ il primo oggetto creato da uno script OTclset ns [new simulator]

I t di d ll l i l t tt di• I metodi della classe simulator permettono di 

– configurare la simulazione 

schedulare gli eventi– schedulare gli eventi

– configurare la topologia di rete (creazione dei nodi, dei link,...)

– monitorare l’evoluzione temporale di oggetti (trace)monitorare l evoluzione temporale di oggetti (trace) 

• Per visualizzare le simulazioni, occorre scrivere le informazione per il NAM

set nf [open out.nam w]$ns namtrace-all $nf

quando si crea una variabile, essa viene utilizzata inserendo davanti al nome il simbolo $

10La procedura FINISH e RUN

• La procedura FINISH permette di chiudere la simulazione in un certo istante temporale:proc finish {} {proc finish {} {

global ns nf$ns flush-traceclose $nfexec nam out.nam &exit 0exit 0

}

$ns at 5.0 “finish”ovvero la procedura FINISH viene eseguita dopo 5s di tempo simulatosimulato.

• L’istruzione finale dello script TCL è relativa all’esecuzione della simulazione$ns run

La classe NODE11

• La classe NODE permette di creare un nodo di rete. Esistono due tipi di nodi:

U i t h tti l itt t d l d ti t i– Unicast : per pacchetti con un solo mittente ed un solo destinatario;

– Multicast : per pacchetti con un solo mittente e più destinatari.

creazione di un oggetto NODEset nodo1 [$ns node]• Creazione di N oggetti NODE mediante il ciclo FOR

for {set i 0} {$i < N} {incr i}{set node$i [$ns node]}

• Esempio :set ns [ new Simulator ]

$invocazione della classe Simulator

set nodo1 [ $ns node ]set nodo2 [ $ns node ]set nodo3 [ $ns node ]

creazione di 4 oggetti NODE [ $ ]

set nodo4 [ $ns node ]

La classe LINK12

• Creazione di 2 collegamenti fra i nodi 1‐2 e 3‐4$ns simplex-link $nodo1 $nodo2 10Mb 1ms DropTail$ns duplex-link $nodo3 $nodo4 100Mb 50ms DropTail

Tipo di link Bandwidht Delay Queue typeNodo

1Nodo

2

Nodo Nodo

Capacità = 10 Mb, ritardo = 1 ms

C ità 100 Mb it d 50

Tipo di link a d d Delay Queue_type

Nodo3

Nodo4Capacità = 100 Mb, ritardo = 50 ms

<bandwidht> 10Mb = 10 Mb/s, 1.2kb = 1.2 kb/s, 1.5e6 = 1.5 Mb/s

D T il i di i FIFO (Fi I Fi O )

• queue‐limit massima dimensione della coda, (numero di pacchetti)$ns queue limit $nodo1 $nodo2 10

<queue_type> DropTail indica una gestione FIFO (First In First Out)

$ns queue-limit $nodo1 $nodo2 10

• $link up attiva un collegamento• $link down disabilita un collegamento• $link up? interrogazione sullo stato di un link

La classe LINK13

• Si consideri un link affetto da errori. Occorre creare un modello di errore (Error Model),

set errmod [new ErrorModel]$errmod unit pkt # unità di errore desiderata$errmod unit pkt # unità di errore desiderata

$errmod set rate_ 0.01 # variabile casuale per la generazione degli errori

Tasso d’errore sui pacchetti pari all’1%g g

$errmod ranvar [new RandomVariable/Uniform]$errmod drop-target [new Agent/Null]

l’ à d è h l b l• N.B. l’unità di errore è sempre espressa in pacchetti; la variabile aleatoria casuale è uniformemente distribuita nell’intervallo [0, 1].

$ li k l d l $ d $ d 1 $ d 2$ns link-lossmodel $errmod $nodo1 $nodo2

La classe AGENT & APPLICATION14

• La gestione del traffico di pacchetti è associata agli Agent e Application

– gli Agent sono le entità che rappresentano il livello di trasporto;

A li ti 1 A li ti 2G t di t ffi

– le Application sono le entità che generano il traffico.

Application 1

A 1

Application 2Generatore di traffico

Li ll di Agent 1 Agent 2Livello di trasporto

Nodo2LINKNodo

1

• La classe Application emula le applicazioni più comuni e lecaratteristiche di traffico noti, (es. FTP , Telnet, WEB).L l A li ti ità d ti h t ll’ tt• La classe Application genera unità dati che vengono passate all’oggettoAGENT.

La classe AGENT15

• Gli agent sono elementi che permettono di: 

– generare a livello di rete le unità informative da trasmettere, (es. applicazione che invia dati);

– rimuovere le unità informative dopo averle ricevute, (es applicazione che riceve i dati)(es. applicazione che riceve i dati).

• N. B. L’agent non riceve i dati dall’applicazione ma solo la dimensione dell’unità informativa (bytes)f ( y )

• Per ogni protocollo di trasporto, viene definito:

– un agent trasmettitore

– un agent ricevitore

• Al nodo ricevitore, i pacchetti vengono “scartati” dall’agent ricevitore

– Agent NULL (riceve i pacchetti e li scarta)

– Agent TCPSink (scarta +ACK)

– Agent/LossMonitor (raccoglie statistiche sui pacchetti ricevuti)

La classe AGENT16

set udp1 [new Agent / UDP] # crea l’agente udp1set null2 [new Agent / Null] # crea l’agente null2[ g / ] # g$ns attach-agent $nodo1 $udp1 # attacca udp1

al nodo1$ns attach-agent $nodo2 $null2 # attacca null2

al nodo2$ t $ d 1 $ ll2 # tt i d t$ns connect $udp1 $null2 # connette i due agent$udp1 set fid_ 1 # associa i pacchetti al

flusso 1, tramite la variabileflusso 1, tramite la variabile “flow indicator”

udp1 Nodo2LinkNodo

1

1 11null2

La classe APPLICATION17

• Generatori di Traffico:

1. Exponential: generazione di traffico “On/Off ” con distribuzioneexp dei tempi di permanenza in ogni stato. Durante iperiodi di OFF non viene generato alcun pacchetto;nei periodi di ON solo pacchetti a ritmo costante.nei periodi di ON solo pacchetti a ritmo costante.

2. POO_Traffic: tempi di permanenza in ciascuno stato distribuitisecondo una distribuzione di Pareto (bursty);

3. CBR_Traffic: generazione di traffico a rate costante, conpacchetti di dimensione fissa;

ff d ff ff d4. TrafficTrace: generazione di traffico effettivo ottenuto damisurazioni sulla rete.

set ExpOnOff [new Application/Traffic/Exponential]

set cbr1 [new Application/Traffic/CBR]set cbr1 [new Application/Traffic/CBR]

Application/Traffic/CBR18

• Si consideri che l’agent1 UDP sia alimentato da una sorgente di traffico CBR.

b 1 [ li i / ffi / ]set cbr1 [new Application/Traffic/CBR]

$cbr1 set packetSize 500Crea un’applicazione a bit 

“ b ”$cbr1 set packetSize_ 500

$cbr1 set rate 128KbLa dimensione massima del pacchetto è 500 bytes

rate costante, “cbr1”

$cbr1 set rate_ 128Kb

$cbr1 attach-agent $udp1

p y

La sorgente “cbr1” trasmette a 128 Kbyte

$cbr1 attach agent $udp1

$ns at 2.0 “$cbr1 start”

La sorgente “cbr1” è collegata all’agent1

$ns at 5.5 “$cbr1 stop”

1 11cbr1

agent 1(Agent/UDP)

Nodo2LinkNodo

1

1 11agent 2

(Agent/Null)

Application/FTP19

• Il nodo 3 è una sorgente di traffico FTP.

set udp3 [new Agent / UDP] # crea l’agent3 UDPset null4 [new Agent / Null] # crea l’agent4 Null$ns attach-agent $nodo3 $udp3$ $ $$ns attach-agent $nodo4 $null4$ns connect $udp3 $null4$ d 3 t fid 2$udp3 set fid_ 2# Crea l’applicazione ftp3 e l’attacca all’agent3set ftp3 [ new Application/FTP ]set ftp3 [ new Application/FTP ]$ftp3 attach-agent $udp3$ns at 0.0 “$ftp3 start” # ftp3 inizia a 0.0 s$ns at 0.0 $ftp3 start # ftp3 inizia a 0.0 s $ns at 4.5 “$ftp3 stop” # ftp3 termina a 4.5 s

ftp3

Nodo3

Nodo4LINKudp3

2 22ftp3

null4

La classe TRACE20

• La classe TRACE raccoglie i risultati della simulazione di NS.• L’oggetto trace è inserito tra due nodi e genera un report su tutti gli eventi 

che hanno interessato i pacchetti trasmessi durante la simulazioneche hanno interessato i pacchetti trasmessi durante la simulazione.

set trace_file [open traccia.tr w]

$ t $ d 1 $ d 2 $t fil

apertura in scrittura del file di trace traccia.tr

$ns trace-queue $nodo1 $nodo2 $trace_file....close $trace file

creazione del file t i t tclose $trace_file

set trace_file [open traccia.tr r]traccia.tr con trace‐queue

apertura del file traccia.tr in 

chiusura del file al termine della simulazione

lettura per leggere i risultati

Il file traccia.tr21

event time to node Pkt type Pkt size flags Src addr Dst addr Seq num Pkt idfrom node fid

Parametro Descrizione

event Evento associato al pacchetto (es. ricevuto, accodato , fuori coda, perso, ecc.)

time Istante temporale dell’evento associato al pacchetto 

from/to node Identificativo dell’interfaccia di trasmissione e ricezionefrom/to node Identificativo dell interfaccia di trasmissione e ricezione

Pkt type Tipo di pacchetto (es. ack, tcp, cbr, ecc.)

Pkt size Dimensione del pacchetto (es. 40 bytes, 1000 bytes, ecc.)

f dfid Identificativo di flusso a cui appartiene il pacchetto

src_addr Identificativo del nodo sorgente

dst_addr Identificativo del nodo destinazione

Seq_num Identificativo del numero di sequenza a cui appartiene il pacchetto

Pkt id Identificativo unico del pacchetto (es. pacchetto numero 201)

Script_122

set ns [new Simulator] # Crea un oggetto simulatorset nf [open out.nam w] # Apre in scrittura il file nam$ns namtrace-all $nfset trace_file [open traccia.tr w]

proc finish {} { # Definisce una procedura “finish” l b l f filglobal ns nf trace_file$ns flush-traceclose $nf $trace_file exec nam out nam & # Esegue namexec nam out.nam & # Esegue namexit 0

}

for {set i 1} {$i < 5} {incr i} # Crea 4 nodi{set nodo$i [$ns node]}

$ns simplex-link $nodo1 $nodo2 10Mb 1ms DropTail # Crea i link$ns simplex link $nodo1 $nodo2 10Mb 1ms DropTail # Crea i link$ns duplex-link $nodo3 $nodo4 100Mb 50ms DropTail$ns queue-limit $nodo1 $nodo2 10$ns trace queue $nodo1 $nodo2 $trace file _q _

Script_123

set errmod [new ErrorModel] # Crea l’ErrorModel$errmod unit pkt$errmod set rate 0.01_$errmod ranvar [new RandomVariable/Uniform]$errmod drop-target [new Agent/Null]

$ns link-lossmodel $errmod $nodo1 $nodo2

set udp1 [new Agent/UDP] # Crea l’agent udp1 e lo attacca a nodo1$ns attach-agent $nodo1 $udp1

set null2 [new Agent/Null] # Crea l’agent null2 e lo attacca a nodo2$ns attach-agent $nodo2 $null2

$ns connect $udp1 $null2 # Collega l’agent udp1 con null2$udp1 set fid_1

set cbr1 [new Application/Traffic/CBR] # Crea una sorgente CBR$cbr1 set packetSize_ 500$cbr1 set rate 128Kb$cbr1 set rate_ 128Kb$cbr1 attach-agent $udp0

Script_124

set udp3 [new Agent / UDP] # Crea l’agent udp3 e lo attacca a nodo3$ns attach-agent $nodo3 $udp3

set null4 [new Agent / Null] # Crea l’agent null4 e lo attacca a nodo4$ns attach-agent $nodo4 $null4

$ns connect $udp3 $null4 # Collega l’agent udp3 con null4$udp3 set fid_ 2

set ftp3 [ new Application/FTP ] # Crea una sorgente FTP$ftp3 attach-agent $udp3

$ns at 0.0 “$cbr1 start” # Eventi della simulazione$ns at 1.0 “$ftp3 start”$ns at 3.5 “$cbr1 stop”$ $$ns at 4.5 “$ftp3 stop”$ns at 5.0 “finish” # Richiama la procedura finish

$ # P t l i l i$ns run # Parte la simulazione

Script_225

• Esempio di topologia di rete composta da 5 nodi e 3 linkset ns [ new Simulator ]

set f0 [open out0.tr w] # Apre i files di uscitaset f1 [open out1.tr w]set f2 [open out2.tr w]set f2 [open out2.tr w]

for {set k 0} {$k < 4} {incr k} {set n($k) [$ns node] # Crea i nodi di reteset n($k) [$ns node] # Crea i nodi di rete

}

# Creazione dei link tra i nodi di rete#$ns duplex-link $n(0) $n(3) 1Mb 100ms DropTail$ns duplex-link $n(1) $n(3) 1Mb 100ms DropTail$ d l li k $ (2) $ (3) 1Mb 100 D T il$ns duplex-link $n(2) $n(3) 1Mb 100ms DropTail$ns duplex-link $n(3) $n(4) 1Mb 100ms DropTail

n0 n3 n4

n1 n2

La procedura finish26

proc finish {} { # Procedura di chiusuraglobal f0 f1 f2gclose $f0 # Chiude i file di uscitaclose $f1 close $f2# Invoca xgraph per visualizzare i risultatiexec xgraph out0 tr out1 tr out2 tr –geometryexec xgraph out0.tr out1.tr out2.tr –geometry 800x400 & exit 0

}

La procedura attach‐expoo‐traffic27

proc attach-expoo-traffic {node sink size burst idle rate} {

set ns [Simulator instance]# crea un agente UDP e lo attacca al nodo

set source [new Agent/UDP]set source [new Agent/UDP]$ns attach-agent $node $source

# crea un agente Expoo traffic e i suoi parametriset traffic [new Application/Traffic/Exponential]

$traffic set packetSize_ $size$t ffi t b t ti $b t$traffic set burst_time_ $burst$traffic set idle_time_ $idle$traffic set rate $rate$traffic set rate_ $rate$traffic attach-agent $source$ns connect $source $sinkreturn $traffic

}

La procedura record (1/2)28

# Procedura che periodicamente registra nei file la banda occupata dalle sorgenti di traffico

proc record {} {global sink0 sink1 sink2 f0 f1 f2t [Si l t i t ]set ns [Simulator instance]

# dopo 0.5s verrà richiamata questa proceduraset time 0 5set time 0.5# quanti bytes sono arrivati ad ogni sinkset bw0 [$sink0 set bytes ]set bw0 [$sink0 set bytes_]set bw1 [$sink1 set bytes_]set bw2 [$sink2 set bytes ][$ y _]# registra il tempo attualeset now [$ns now]… … … … … … … … … … … …

La procedura record (2/2)29

… … … … … … … … … … … …# Calcola la banda istantanea (in MBit/s) e la scrive nei file di outputla scrive nei file di outputput $f0 “$now [expr $bw0/($time*8/10^6)]”put $f1 “$now [expr $bw1/($time*8/10^6)]”put $f1 $now [expr $bw1/($time 8/10 6)]put $f2 “$now [expr $bw2/($time*8/10^6)]”

# Resetta la variabile “bytes_” nei sink$sink0 set bytes_ 0$ i k1 t b t 0$sink1 set bytes_ 0$sink2 set bytes_ 0

# Ri-schedula la procedura di record$ns at [expr $now+$time] “record”

}

Agenti Loss‐Monitor30

# Creo tre sink agenti di monitor, attaccati a n4set sink0 [new Agent/LossMonitor] set sink1 [new Agent/LossMonitor]set sink2 [new Agent/LossMonitor]$ tt h t $ 4 $ i k0$ns attach-agent $n4 $sink0$ns attach-agent $n4 $sink1$ns attach agent $n4 $sink2$ns attach-agent $n4 $sink2

# Creo tre sorgenti di traffico Expoo# Creo tre sorgenti di traffico Expooset source0 [attach-expoo-traffic $n0 $sink0 200

2s 1s 100k]set source1 [attach-expoo-traffic $n1 $sink1 200

2s 1s 200k]set source2 [attach-expoo-traffic $n2 $sink2 200

2s 1s 300k]

Gli eventi della simulazione31

# La registrazione inizia all’istante 0.0 s$ns at 0.0 "record"# L ti i i i t tt 10 0# Le sorgenti iniziano a trasmettere a 10.0s$ns at 10.0 "$source0 start"$ns at 10.0 "$source1 start"$ns at 10.0 "$source2 start"

# A 50s le sorgenti terminano la trasmissione# A 50s le sorgenti terminano la trasmissione$ns at 50.0 "$source0 stop"$ns at 50.0 "$source1 stop"$ns at 50.0 "$source2 stop"

# A 60s la simulazione termina# A 60s la simulazione termina$ns at 60.0 "finish"

# Parte la simulazione$ns run

NS su Linux32

Per lanciare una simulazionein ambiente Linux, 

occorre aprire una shell eoccorre aprire una shell e lanciare la seguente

istruzione:

ns <nome del file.tcl>

Grafici dei risultati tramite Xgraph33

Esercizio34

• Scrivere lo script OTcl per il seguente scenario di rete:

– Due nodi, A e B, sono connessi tramite un link unidirezionale (capacità 10 Mb/s, ritardo di propagazione 10 ms e politica di coda DropTail)DropTail). 

– La trasmissione dati avviene in modalità UDP, da A verso B, essendo A una sorgente di traffico CBR (pacchetti 100 bytes, rate di 1 Mbs). A inizia a trasmettere all’istante t1 = 1 s e finisce dopo Δt1 = 5 s.

– Inoltre, il link tra A e B sia affetto da errori sui pacchetti, con un rate i l 10% i bil d ifpari al 10% e variabile random uniforme.

– Il nodo B riceve i pacchetti senza inviare riscontri.

La simulazione termina dopo 3 s da quando A ha interrotto la– La simulazione termina dopo 3 s da quando A ha interrotto la trasmissione dati. 

– Visualizzare il file di traccia per il collegamento A‐B.p g