Network Simulator (NS)

Transcript

1 1 Introduzione a Network Simulator (NS) Ing. Anna Maria Vegni avegni@uniroma3.it Roma, 30/10/2008

2 Introduzione 2 NS2 Network Simulator è un software di simulazione di reti a pacchetto open source, sviluppato prevalentemente nelle università e realizzato grazie all unione di contributi diversi. Utilizzato spesso per simulare reti IP. Vantaggi: èdisponibile gratuitamente. C è una vasta comunità di utilizzatori che fornisce supporto e nuovi aggiornamenti di librerie e moduli. E un programma in continua evoluzione. Svantaggi: manca una documentazione rigorosa su come implementare 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 oggetti. OTcl realizza l interfaccia con l utente, permettendo una facile manipolazione degli oggetti in C++. NS è quindi un interprete Tcl (Tool Command Language) con estensione Object Oriented.

3 NS & NAM 3 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 interfaccia grafica per rappresentare gli scenari di rete. Visualizza i risultati generati da NS. Cosa simula NS? Modelli di traffico e applicazioni (Web, FTP, telnet, sensornetwork network, ecc.) Protocolli di trasporto, (TCP, UDP, broadcast, connessioni pto pto, p multi pto, ecc.) Routing & queueing Link layer (wired, wireless, satellite)

4 Installazione 4 È 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 ( build.html#allinone) Tutorial di Marc Greis NS by examples

5 Gli eventi in NS2 5 NS2 è un simulatore tempo discreto ad eventi. L istante t i in cui si presenta l evento i esimo attiva l esecuzione di azioni 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.

6 Il linguaggio Otcl 6 NS è strutturato in classi con ordinamento gerarchico. L utente simula il funzionamento di una rete di TLC mediante il linguaggio Otcl. UnoscriptOtclcreailpropriomodellodirete(numerodinodi, links, sorgentiditraffico traffico, ecc). Nello script Otcl si definiscono le istanze delle classi e di conseguenza si creano le istanze degli oggetti con le corrispondenti classi compilate in C++.

7 Alcuni comandi in Otcl 7 Per creare, inizializzare ed eliminare una variabile, vengono usate le seguenti istruzioni: set <nome_variabile> i <valore> l unset <nome_variabile> Ciclo FOR Ciclo WHILE Istruzione IF for {set i 0}{$i < 100}{incr i}{ set n($i) [new node] } while {$i < 100}{ set n($i) [new node] incr i } if {$i > 0} { puts i è un intero positivo }

8 Classi in Otcl 8 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 rete LINK genera un nuovo oggetto Link di rete AGENT genera un nuovo oggetto Agente TRACE genera un nuovo file di traccia ERRORMODEL genera sia errori a livello fisico, sia la perdita di interi pacchetti

9 La classe SIMULATOR 9 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 OTcl set ns [new simulator] I metodi didll della classe simulator permettono di configurare la simulazione schedulare glieventi configurare la topologia di rete (creazione dei nodi, dei link,...) monitorarel evoluzione levoluzione 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 $

10 La procedura FINISH e RUN 10 La procedura FINISH permette di chiudere la simulazione in un certo istante temporale: proc finish {} { global ns nf $ns flush-trace close $nf exec nam out.nam & exit 0 } $ns at 5.0 finish ovvero la procedura FINISH viene eseguita dopo 5s di tempo simulato. L istruzione finale dello script TCL è relativa all esecuzione della simulazione $ns run

11 La classe NODE 11 La classe NODE permette di creare un nodo di rete. Esistono due tipi di nodi: Unicast : per pacchetti htticon un solo mittente t ed un solo destinatario; t i Multicast : per pacchetti con un solo mittente e più destinatari. set nodo1 [$ns node] creazione di un oggetto 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 ] set nodo1 [ $ns node ] set nodo2 [ $ns node ] set nodo3 [ $ns node ] set nodo4 [ $ns node ] invocazione della classe Simulator creazione di 4 oggetti NODE

12 La classe LINK 12 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 d Delay Queue_type Nodo 1 Capacità = 10 Mb, ritardo = 1 ms Nodo 2 Nodo 3 Capacità = 100 Mb, ritardo = 50 ms Nodo 4 <bandwidht> 10Mb = 10 Mb/s, 1.2kb = 1.2 kb/s, 1.5e6 = 1.5 Mb/s <queue_type> DropTail ilindica una gestione FIFO (First In First Out) queue limit massima dimensione della coda, (numero di pacchetti) $ns queue-limit $nodo1 $nodo2 10 $link up attiva un collegamento $link down disabilita un collegamento $link up? interrogazione sullo stato di un link

13 La classe LINK 13 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 set rate_ 0.01 # variabile casuale per la generazione degli errori Tasso d errore sui pacchetti pari all 1% $errmod ranvar [new RandomVariable/Uniform] $errmod drop-target [new Agent/Null] N.B. l unità di errore è sempre espressa in pacchetti; la variabile aleatoria casuale è uniformemente distribuita nell intervallo [0, 1]. $ns link-lossmodel l l $errmod $nodo1 $nodo2

14 La classe AGENT & APPLICATION 14 La gestione del traffico di pacchetti è associata agli Agent e Application gli Agent sono le entità che rappresentano il livello di trasporto; le Application sono le entità che generano il traffico. Generatore di traffico Application 1 Application 2 Livello di trasporto Agent 1 Agent 2 Nodo 1 LINK Nodo 2 La classe Application emula le applicazioni più comuni e le caratteristiche di traffico noti, (es. FTP, Telnet, WEB). La classe Application genera unità dati che vengono passate all oggetto AGENT.

15 La classe AGENT 15 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). N. B. L agent non riceve i dati dall applicazione ma solo la dimensione dell unità informativa (bytes) 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)

16 La classe AGENT 16 set udp1 [new Agent / UDP] # crea l agente udp1 set null2 [new Agent / Null] # crea l agente null2 $ns attach-agent $nodo1 $udp1 # attacca udp1 al nodo1 $ns attach-agent $nodo2 $null2 # attacca null2 al nodo2 $ns connect $udp1 $null2 # connette i due agent $udp1 set fid_ 1 # associa i pacchetti al flusso 1, tramite la variabile flow indicator udp1 Nodo Link Nodo 2 null2

17 La classe APPLICATION 17 Generatori di Traffico: 1. Exponential: generazione di traffico On/Off con distribuzione exp dei tempi di permanenza in ogni stato. Durante i periodi di OFF non viene generato alcun pacchetto; nei periodidi ON solo pacchetti a ritmo costante. 2. POO_Traffic: tempi di permanenza in ciascuno stato distribuiti secondo una distribuzione di Pareto (bursty); 3. CBR_Traffic: generazione di traffico a rate costante, con pacchetti di dimensione fissa; 4. TrafficTrace: generazioneditraffico effettivo ottenuto da misurazioni sulla rete. set ExpOnOff [new Application/Traffic/Exponential] set cbr1 [new Application/Traffic/CBR]

18 Application/Traffic/CBR 18 Si consideri che l agent1 UDP sia alimentato da una sorgente di traffico CBR. set cbr1 [new Application/Traffic/CBR] i / $cbr1 set packetsize_ 500 $cbr1 set rate_ 128Kb $cbr1 attach-agent agent $udp1 $ns at 2.0 $cbr1 start $ns at 5.5 $cbr1 stop Crea un applicazione a bit rate costante, b cbr1 La dimensione massima del pacchetto è 500 bytes La sorgente cbr1 trasmette a 128 Kbyte La sorgente cbr1 è collegata all agent1 cbr1 agent 1 (Agent/UDP) Nodo Link Nodo 2 agent 2 (Agent/Null)

19 Application/FTP 19 Il nodo 3 è una sorgente di traffico FTP. set udp3 [new Agent / UDP] # crea l agent3 UDP set null4 [new Agent / Null] # crea l agent4 Null $ns attach-agent $nodo3 $udp3 $ns attach-agent $nodo4 $null4 $ns connect $udp3 $null4 $udp3 set fid_ 2 # Crea l applicazione ftp3 e l attacca all agent3 set ftp3 [ new Application/FTP ] $ftp3 attach-agent $udp3 $ns at 0.0 $ftp3 start # ftp3 inizia a 0.0 s $ns at 4.5 $ftp3 stop # ftp3 termina a 4.5 s ftp udp3 Nodo 3 LINK Nodo 4 null4

20 La classe TRACE 20 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 trasmessidurante la simulazione. set trace_file [open traccia.tr w] apertura in scrittura del file di trace traccia.tr $ns trace-queue $nodo1 $nodo2 $trace_file... close $trace_file set trace_file [open traccia.tr r] creazione del file traccia.tr t con trace queue chiusura del file al termine della simulazione apertura del file traccia.tr in lettura per leggere i risultati

21 Il file traccia.tr 21 event time from node to node Pkt type Pkt size flags fid Src addr Dst addr Seq num Pkt id Parametro event time from/to node Pkt type Pkt size fd fid src_addr dst_addr Descrizione Evento associato al pacchetto (es. ricevuto, accodato, fuori coda, perso, ecc.) Istante temporale dell evento associato al pacchetto Identificativo dell interfaccia di trasmissione e ricezione Tipo di pacchetto (es. ack, tcp, cbr, ecc.) Dimensione del pacchetto (es. 40 bytes, 1000 bytes, ecc.) Identificativo di flusso a cui appartiene il pacchetto Identificativo del nodo sorgente 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)

22 Script_1 22 set ns [new Simulator] set nf [open out.nam w] $ns namtrace-all $nf set trace_file [open traccia.tr w] # Crea un oggetto simulator # Apre in scrittura il file nam proc finish {} { } global l ns nf trace_file $ns flush-trace close $nf $trace_file exec nam out.nam & exit 0 # Definisce una procedura finish # Esegue nam for {set i 1} {$i < 5} {incr i} {set nodo$i [$ns node]} $ns simplex-link link $nodo1 $nodo2 10Mb 1ms DropTail $ns duplex-link $nodo3 $nodo4 100Mb 50ms DropTail $ns queue-limit $nodo1 $nodo2 10 $ns trace_q queue $nodo1 $nodo2 $trace_ file # Crea 4 nodi # Crea i link

23 Script_1 23 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] $cbr1 set packetsize_ 500 $cbr1 set rate_ 128Kb $cbr1 attach-agent $udp0 # Crea una sorgente CBR

24 Script_1 24 set udp3 [new Agent / UDP] $ns attach-agent $nodo3 $udp3 # Crea l agent udp3 e lo attacca a nodo3 set null4 [new Agent / Null] # Crea l agent null4 e lo attacca a nodo4 $ns attach-agent $nodo4 $null4 $ns connect $udp3 $null4 $udp3 set fid_ 2 # Collega l agent udp3 con null4 set ftp3 [ new Application/FTP ] # Crea una sorgente FTP $ftp3 attach-agent $udp3 $ns at 0.0 $cbr1 start $ns at 1.0 $ftp3 start $ns at 3.5 $cbr1 stop $ns at 4.5 $ftp3 stop $ns at 5.0 finish # Eventi della simulazione # Richiama la procedura finish $ns run # Parte la simulazione i

25 Esempio di topologia di rete composta da 5 nodi e 3 link set ns [ new Simulator ] Script_2 25 set f0 [open out0.tr w] # Apre i files di uscita set f1 [open out1.tr w] set f2 [open out2.tr w] for {set k 0} {$k < 4} {incr k} { set n($k) [$ns node] } set 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 $ns duplex-link li $n(2) $n(3) 1Mb 100ms DropTail $ns duplex-link $n(3) $n(4) 1Mb 100ms DropTail n0 n3 n4 n1 n2

26 La procedura finish 26 proc finish {} { # Procedura di chiusura global f0 f1 f2 close $f0 # Chiude i file di uscita close $f1 close $f2 # Invoca xgraph per visualizzare i risultati exec xgraph out0.tr tr out1.tr tr out2.tr tr geometry 800x400 & exit 0 }

27 La procedura attach expoo traffic 27 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] $ns attach-agent $node $source # crea un agente Expoo traffic e i suoi parametri set traffic [new Application/Traffic/Exponential] $traffic set packetsize_ $size $traffic set burst_time_ ti $burst $traffic set idle_time_ $idle $traffic set rate_ $rate $traffic attach-agent $source $ns connect $source $sink return $traffic }

28 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 f2 set ns [Simulator instance] # dopo 0.5s verrà richiamata questa procedura set time 0.5 # quanti bytes sono arrivati ad ogni sink set bw0 [$sink0 set bytes_] set bw1 [$sink1 set bytes_] set bw2 [$sink2 set bytes _] # registra il tempo attuale set now [$ns now]

29 La procedura record (2/2) 29 # Calcola la banda istantanea (in MBit/s) e la scrive nei file di output put $f0 $now [expr $bw0/($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 $sink1 set bytes_ 0 $sink2 set bytes_ 0 } # Ri-schedula la procedura di record $ns at [expr $now+$time] record

30 Agenti Loss Monitor 30 # Creo tre sink agenti di monitor, attaccati a n4 set sink0 [new Agent/LossMonitor] set sink1 [new Agent/LossMonitor] set sink2 [new Agent/LossMonitor] $ns attach-agent t $n4 $sink0 $ns attach-agent $n4 $sink1 $ns attach-agent agent $n4 $sink2 # Creo tre sorgenti di traffico Expoo set source0 [attach-expoo-traffic $n0 $sink s 1s 100k] set source1 [attach-expoo-traffic $n1 $sink s 1s 200k] set source2 [attach-expoo-traffic $n2 $sink s 1s 300k]

31 Gli eventi della simulazione 31 # La registrazione inizia all istante 0.0 s $ns at 0.0 "record" # Le sorgenti iniziano i i a trasmettere tt a 10.0s0 $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 $ns at 50.0 "$source0 stop" $ns at 50.0 "$source1 stop" $ns at 50.0 "$source2 stop" # A 60s la simulazione termina $ns at 60.0 "finish" # Parte la simulazione $ns run

32 NS su Linux 32 Per lanciare una simulazione in ambiente Linux, occorre aprire una shell e lanciare la seguente istruzione: ns <nome del file.tcl>

33 Grafici dei risultati tramite Xgraph 33

34 Esercizio 34 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). 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 t 1 = 1 s e finisce dopo Δt 1 = 5 s. Inoltre, il link tra A e B sia affetto da errori sui pacchetti, con un rate pari al 10% e variabile ibil random uniforme. Il nodo B riceve i pacchetti senza inviare riscontri. La simulazione termina dopo 3 s da quando A ha interrotto la trasmissione dati. Visualizzare il file di traccia per il collegamento A B.