Network Simulator: ns-2 Andrea Valletta Dipartimento INFOCOM Sapienza Università di Roma E-mail: valletta@net.infocom.uniroma1.it The work I am presenting has been written by Andrea Baiocchi and me, Alfredo Todini, at the INFOCOM department of the university of Roma “La Sapienza”. These are our email addresses.

Contenuti Introduzione Struttura del simulatore Oggetti e classi in ns-2 Linguaggio TCL e OTCL Creazione di uno scenario di simulazione Analisi dei risultati Riferimenti e documentazione disponibile

Introduzione Network simulator è nato con lo scopo di offrire un supporto per la ricerca in ambito networking Progettazione di nuovi protocolli, studio del traffico, etc Confronto tra varie versioni di un protocollo E’ un software open source Il codice è condiviso, visibile a tutti e liberamente modificabile per aggiungere nuovi protocolli, nuovi modelli, etc Questo incrementa l’affidabilità dei risultati Molte persone hanno testato i modelli in situazioni differenti I modelli sono stati sviluppati da esperti Ogni livello del simulatore è sviluppato con dettaglio. Unico simulatore che implementa l’intera pila protocollare di una rete complessa

Funzionalità incluse in ns Reti cablate Routing DV, LS, PIM-SM Trasporto: TCP, UDP, SCTP Sorgenti di traffico:web, ftp, telnet, cbr, stocastiche Discipline di coda:drop-tail, RED, FQ, SFQ, DRR QoS: IntServ and Diffserv Emulazione di reti reali Wireless Ad hoc routing e mobile IP Directed diffusion, sensor-MAC Reti satellitari (satelliti geostazionari e polari, con o senza elaborazione a bordo) Tracing, animazioni, utilities varie

Componenti di ns Ns, il simulatore vero e proprio Nam, il tool network animator Permette una visualizzazione grafica animata dei risultati forniti da ns Nam editor: interfaccia grafica per generare script per ns Pre-processing: Generatori di traffico e topologie Post-processing: Analisi delle tracce, solitamente mediante script in Awk, Perl, o Tcl

Modelli Modelli di traffico e applicazioni: Protocolli di trasporto: Web, FTP, telnet, constant-bit rate, real audio Protocolli di trasporto: unicast: TCP (Reno, Vegas, etc.), UDP, SCTP Multicast: SRM Routing e code: Wired routing, ad hoc routing e directed diffusion Protocolli di coda: RED, drop-tail, etc Physical media: Reti Cablate (point-to-point, LANs), wireless (multiple propagation models), reti satellitari

Parte I: Introduzione generale

Simulatore ad eventi Il simulatore vede una sequenza di eventi Viene gestita una lista di eventi Prendi un evento, elaboralo, poi passa all’evento successivo nella lista Ciascun evento si verifica in un istante di tempo simulato, ma impiega una quantità arbitraria di tempo reale E’ un modello molto semplice Singolo flusso di controllo Facile da gestire

Esempi di eventi discreti t=1, A pacchetto in coda t=1.01, il pacchetto viene prelevato dalla coda, parte l’evento B Semplice modello di coda: Due nodi su una LAN A B t=1.0: A invia un pacchetto all’interfaccia di rete (NIC) che inizia il carrier sensing (CS) t=1.005: il NIC di A termina il CS, inizia a trasmettere t=1.006: il NIC di B inizia a ricevere il pacchetto t=1.01: il NIC di B conclude la ricezione del pacchetto, e lo passa all’applicazione Modello dettagliato:

Struttura del software NS è orientato agli oggetti Un nodo, un link, uno strato dell’architettura protocollare costituiscono oggetti Ciò consente un notevole riuso del codice Alcuni oggetti importanti NsObject: aggiunge il metodo recv() Connector: aggiunge target() BiConnector: uptarget() e downtarget()

C++ e OTcl Ns usa due linguaggi C++ per l’elaborazione dei pacchetti Veloce, consente un controllo più fine OTcl per il controllo Preparazione e configurazione della simulazione Utile per introdurre rapidamente delle modifiche Maggiore flessibilità, ma occorre imparare due linguaggi di programmazione Stessa gerarchia delle classi La struttura generale del simulatore (in particolare, ciò che mette insieme le varie classi) è scritta in OTcl Il Tcl fornisce l’interfaccia di comando di ns

Oggetti “split” C++/OTcl C++ e OTcl Oggetti C++ puri Oggetti Tcl puri Oggetti “split” C++/OTcl C++ OTcl ns

Schema generale Il cuore del simulatore è scritto in C++ ( compilato, veloce) L’interfaccia per la gestione dei parametri di simulazione è scritta in OTcl (estensione di Tcl object oriented) ( interpretato, i parametri possono essere modificati senza dover ricompilare tutto il simulatore)

Linguaggio Tcl Tcl: Tool Command Language I programmi interattivi hanno bisogno di linguaggi adatti a gestire un’interfaccia di comando: Spesso viene creato un linguaggio “ad-hoc”, per ciascuna applicazione Soluzione debole, soggetta a problemi emacs e csh sono potenti, ma non riutilizzabili Soluzione: linguaggio di scripting riutilizzabile L’interprete è una libreria C Caratteristiche di base: variabili, procedure, ecc. Il linguaggio può venire esteso con caratteristiche aggiuntive (come avviene in NS)

Linguaggio Tcl Applicazioni complesse: Comandi interattivi, scripting: Importanza delle prestazioni Necessità di una struttura Comandi interattivi, scripting: Minore importanza delle prestazioni Struttura minimale: facile riutilizzo del codice Tcl Sintassi molto semplice, facile da imparare Struttura semplice Semplice interfaccia con il C/C++

Tcl nelle applicazioni Il Tcl può essere incluso nelle applicazioni Il Tcl interpreta gli script, e passa i parametri alle procedure dell’applicazione (scritte ad esempio in C) L’applicazione estende il set di comandi di Tcl In C vengono definiti nuovi tipi di dati Le primitive vengono implementate come nuovi comandi Tcl Operazioni complesse possono essere implementate come script Tcl

Sintassi del Tcl Sintassi molto semplice Valutazione di espressioni set a 47 47 Alla variabile a è stato assegnato il valore 47 Valutazione di espressioni set b [expr $a+10] 57 È stata eseguita l’istruzione expr $a+10 ed il suo risultato è stato assegnato alla variabile a Stringhe set b “a is $a” a is 47

Sintassi del Tcl Ricco insieme di istruzioni: Variabili, array associativi, liste Espressioni C-like Espressioni condizionali, loop: if "$x < 3" { puts "x is too small" } Procedure Accesso a socket TCP/IP, file, sottoprocessi Tutti i dati sono visti come stringhe Facile accesso dal C I programmi e i dati sono intercambiabili

Tcl: concetti di base Due parti principali da apprendere: Script Tcl Sintassi e regole di sostituzione Semplici, ma all’inizio possono causare confusione Comandi Si possono apprendere quando necessario Le strutture di controllo sono comandi, non fanno parte della sintassi del linguaggio! Script Tcl È una sequenza di comandi, separati da a capo o punto e virgola Comando Tcl Una o più parole separate da spazi bianchi La prima parola è il nome del comando, le altre sono gli argomenti

Tcl: concetti di base Tcl Parser Command procedure Suddivide il comando in una sequenza di parole Effettua le sostituzioni Non interpreta le parole Command procedure Interpreta le parole Fornisce i risultati Tcl Parser Word 1 Word 2 Word 3 Command procedure Result

Tcl: argomenti dei comandi Il parser non assegna alcun significato agli argomenti In C: x = 4; y = x + 10 Ad y è assegnato il valore 14 In Tcl: set x 4; set y x+10 Ad y è assegnata la stringa “x+10” Comandi diversi assegnano significati diversi ai loro argomenti set a 24/2 expr 24/2

Tcl: sostituzione di variabili Sintassi: $nomevariabile Esempi: set b 66 66 set a b b set a $b set a $b+$b+$b 66+66+66

Tcl: sostituzione di comandi Sintassi: [script] Valuta uno script o un comando, restituisce il risultato Esempi: set b 8 8 set a [expr $b + 2] 10 set a “b - 3 is [expr $b - 3]” b - 3 is 5

Tcl: struttura delle parole Gli spazi e i punti e virgola sono separatori di parole I doppi apici (“) eliminano la separazione tra parole: set a “x is $x; y is $y” Le parentesi graffe {} eliminano i separatori e le sostituzioni: set a {[expr $b * $c]} Ad a è assegnata la stringa [expr $b * $c] senza sostituzioni di variabili o di comandi

Tcl: liste e strutture di controllo Zero o più elementi separati da spazi bianchi {,} per raggruppare elementi a b {c d e} f Comandi per la gestione di liste Esempio: lindex {a b {c d e} f} 2 restituisce c d e Strutture di controllo Simili al C, sono comandi che accettano come argomenti script Tcl Esempio: list reversal set b "" set i [expr [llength $a] - 1] while {$i >= 0} { lappend b [lindex $a $i] incr i -1 }

Tcl: procedure Il comando proc definisce una procedura: proc somma {x y} {expr $x + $y} Le procedure si comportano come le istruzioni incorporate: somma 7 3 10 Gli argomenti possono avere valori di default: proc decr {x {y 1}} {expr $x - $y} decr 8 restituisce 7 (y ha assunto il valore di default 1) Nome Lista degli argomenti Corpo della procedura

Tcl: sommario Procedure: Liste, array associativi, ecc. Variabili: set x 10 puts “x is $x” Funzioni ed espressioni: set y [pow x 2] set y [expr x*x] Controllo: if {$x > 0} { return $x } else { return [expr -$x] } while { $x > 0 } { puts $x incr x –1 } Procedure: proc pow {x n} { if {$n == 1} { return $x } set part [pow x [expr $n-1]] return [expr $x*$part] } Liste, array associativi, ecc. => Vero linguaggio di programmazione che può essere usato per costruire topologie di rete, modelli di traffico, ecc.

Otcl Versione orientata agli oggetti del Tcl La parola Class seguita dal nome della classe è usata per dichiarare una nuova classe I metodi (funzioni membro) della classe sono dichiarati usando la parola instproc preceduta dal nome della classe; per il resto la sintassi è la stessa di quella delle procedure Tcl Il metodo init è il costruttore della classe La variabile self è un puntatore all’oggetto stesso (analogamente a this in C++) Per dichiarare una variabile membro di una classe (instance variable) si usa la parola instvar La parola –superclass è usata per dichiarare che una classe eredita da un’altra

Otcl set a [new Person 45 Bill] set b [new Kid 15 Sam] Class Person # constructor: Person instproc init {age name} { $self instvar age_ $self instvar name_ set age_ $age set name_ $name } # method: Person instproc greet {} { puts “$age_ years old: How are you?” Person instproc name {} { puts “Name is $name_” # subclass: Class Kid -superclass Person Kid instproc greet {} { $self instvar age_ puts “$age_ years old kid: What’s up, dude?” } set a [new Person 45 Bill] set b [new Kid 15 Sam] $a greet  45 years old: How are you? $a name  Name is Bill $b greet  15 years old kid: What’s up, dude? $b name  Name is Sam La gerarchia tra le classi è utile per creare varianti di oggetti esistenti (TCP, TCP/Reno)

Creazione di uno script di simulazione

Script iniziale set ns [new Simulator] set nf [open out.nam w] $ns namtrace-all $nf proc finish {} { global ns nf $ns flush-trace close $nf exec nam out.nam & exit 0 } # Insert your own code for topology creation # and agent definitions, etc. here $ns at 5.0 "finish" $ns run Creazione dell’oggetto simulatore Apre il file out.nam in scrittura e assegna l’handle nf Scrive i dati della traccia nam nel file out.nam Crea una procedura con nome finish Chiude il file di traccia Esegue Network Animator per mostrare out.nam Termina Nell’istante t=5 s chiama la procedura finish Avvia la simulazione

Creazione di un link … set n0 [$ns node] set n1 [$ns node] $ns duplex-link $n0 $n1 1Mb 10ms DropTail Crea un nodo e assegna l’handle n0 Crea un nodo e assegna l’handle n1 Collega i due nodi n0 e n1: link bidirezionale Capacità 1Mb/s Ritardo di propagazione 10ms Coda a perdita

Topologia di rete: nodo Addr Classifier Port Classifier classifier_ dmux_ entry_ Node entry Multicast Classifier classifier_ dmux_ entry_ Node entry Nodo multicast multiclassifier_ 1 Nodo unicast set ns_ [new Simulator –multicast on] set n1 [ns_ node] set ns_ [new Simulator] set n0 [ns_ node]

Indirizzamento Due tipi di indirizzi: piatti (flat) e gerarchici Indirizzo piatto di default: 32 bit per l’id del nodo, 32 bit per l’id della porta Indirizzo gerarchico di default: 3 livelli di gerarchia 10 11 11 oppure 1 9 11 11 se multicast Sono possibili formati diversi Domain/cluster/nodes

Nodo gerarchico n2 Address classifier To Port demux Node entry Level 3 Domain, cluster. nodes Level 1 ns_ node-config –addressing hier

Topologia di rete: link duplex link enqT_ queue_ deqT_ drophead_ drpT_ link_ ttl_ n1 entry_ head_ tracing simplex link [ns_ duplex-link $n0 $n1 5Mb 2ms drop-tail]

Generazione del traffico … set udp0 [new Agent/UDP] $ns attach-agent $n0 $udp0 set cbr0 [new Application/Traffic/CBR] $cbr0 set packetSize_ 500 $cbr0 set interval_ 0.005 $cbr0 attach-agent $udp0 set null0 [new Agent/Null] $ns attach-agent $n1 $null0 $ns connect $udp0 $null0 $ns at 0.5 "$cbr0 start“ $ns at 4.5 "$cbr0 stop" Crea un agent UDP e assegna l’handle udp0 Collega l’agent udp0 al nodo n0 Crea un generatore costant bit rate cbr0 Dimensione del pacchetto 500 byte Intervallo di generazione 0.005 s Collega il generatore cbr0 a udp0 Crea un agent null e assegna l’handle null0 Collega l’agent null0 al nodo n1 Connette udp0 a null0 All’istante t=0.5s avvio generatore CBR cbr0 All’istante t=4.5s fine generazione dei pacchetti

Strato di trasporto n0 n1 1 set tcp [new Agent/TCP] Port Classifier Port Classifier dst_=1.0 dst_=0.0 Addr Classifier Agent/TCP agents_ Addr Classifier Agent/TCPSink agents_ 1 dmux_ dmux_ entry_ entry_ classifier_ classifier_ set tcp [new Agent/TCP] ns_ attach-agent $n0 $tcp set tcpsink [new Agent/TCPSink] ns_ attach-agent $n1 $tcpsink ns_ connect $tcp $tcpsink

Applicazione: generatore di traffico Port Classifier Application/FTP Port Classifier dst_=1.0 dst_=0.0 Addr Classifier Agent/TCP Addr Classifier Agent/TCPSink agents_ agents_ 1 dmux_ dmux_ entry_ entry_ classifier_ classifier_ set ftp [new Application/FTP] $ftp attach-agent $tcp $ns at 1.2 “$ftp start”

Flusso dei pacchetti n0 n1 1 1 Port Classifier Application/FTP dst_=1.0 dst_=0.0 Addr Classifier Agent/TCP Addr Classifier Agent/TCPSink 1 1 Link n0-n1 entry_ entry_ Link n1-n0

Creazione di una semplice topologia … set n0 [$ns node] set n1 [$ns node] set n2 [$ns node] set n3 [$ns node] $ns duplex-link $n0 $n2 1Mb 10ms DropTail $ns duplex-link $n1 $n2 1Mb 10ms DropTail $ns duplex-link $n3 $n2 1Mb 10ms DropTail $ns duplex-link-op $n0 $n2 orient right-down $ns duplex-link-op $n1 $n2 orient right-up $ns duplex-link-op $n2 $n3 orient right Crea 4 nodi n0, n1, n2, n3 Crea 3 link bidirezionali Orienta i link

Generazione del traffico set udp0 [new Agent/UDP] $ns attach-agent $n0 $udp0 set cbr0 [new Application/Traffic/CBR] $cbr0 set packetSize_ 500 $cbr0 set interval_ 0.005 $cbr0 attach-agent $udp0 set udp1 [new Agent/UDP] $ns attach-agent $n1 $udp1 set cbr1 [new Application/Traffic/CBR] $cbr1 set packetSize_ 500 $cbr1 set interval_ 0.005 $cbr1 attach-agent $udp1 set null0 [new Agent/Null] $ns attach-agent $n3 $null0 $ns connect $udp0 $null0 $ns connect $udp1 $null0 $ns at 0.5 "$cbr0 start“ $ns at 1.0 "$cbr1 start“ $ns at 4.0 "$cbr1 stop“ $ns at 4.5 "$cbr0 stop“ $ns duplex-link-op $n2 $n3 queuePos 0.5 $udp0 set class_ 1 $udp1 set class_ 2 $ns color 1 Blue $ns color 2 Red

Creazione di topologie complesse. for {set i 0} {$i < 7} {incr i} { set n($i) [$ns node] } $ns duplex-link $n($i) $n([expr ($i+1)%7]) 1Mb 10ms DropTail set udp0 [new Agent/UDP] $ns attach-agent $n(0) $udp0 set cbr0 [new Application/Traffic/CBR] $cbr0 set packetSize_ 500 $cbr0 set interval_ 0.005 $cbr0 attach-agent $udp0 set null0 [new Agent/Null] $ns attach-agent $n(3) $null0 $ns connect $udp0 $null0 $ns at 0.5 "$cbr0 start“ $ns at 4.5 "$cbr0 stop" Ciclo i da 0 a 6 Crea 7 nodi n(0) n(1)…n(6) Crea link da n(0) a n(1) a n(2)… a n(6) a n(0)

Guasto di un link, routing dinamico … $ns rtmodel-at 1.0 down $n(1) $n(2) $ns rtmodel-at 2.0 up $n(1) $n(2) $ns rtproto DV All’istante t=1s il link tra n(1) e n(2) si guasta All’istante t=2s il link riprende a funzionare Si usa routing dinamico (Distance Vector)

Visualizzazione delle prestazioni (1/3) set n0 [$ns node] set n1 [$ns node] $ns duplex-link $n0 $n1 1Mb 100ms DropTail set source [new Agent/UDP] $ns attach-agent $n0 $source set traffic [new Application/Traffic/Exponential] $traffic set packetSize_ 200 $traffic set burst_time_ 2s $traffic set idle_time_ 1s $traffic set rate_ 100k $traffic attach-agent $source set sink0 [new Agent/LossMonitor] $ns attach-agent $n1 $sink0 $ns connect $source $sink Traffico con distribuzione esponenziale Dimensione del pacchetto 200 byte Tempo medio di attività 2s Tempo medio di inattività 1s Rate quando la sorgente è attiva 100kb/s Scarta e conta i pacchetti

Visualizzazione delle prestazioni (2/3) set f0 [open out0.tr w] proc record {} { global sink0 f0 set ns [Simulator instance] set time 0.5 set bw0 [$sink0 set bytes_] set now [$ns now] puts $f0 "$now [expr $bw0/$time*8/1000000]“ $sink0 set bytes_ 0 $ns at [expr $now+$time] "record” } proc finish {} { global f0 close $f0 exec xgraph out0.tr -geometry 800x400 & exit 0 Crea il file out0.tr Procedura chiamata ogni 0.5s Variabili globali sink0 e f0 Contatore bytes ricevuti Istante attuale Scrive nel file di traccia Resetta contatore Schedula la procedura record Variabile globale f0 Chiude il file Esegue xgraph per visualizzare la traccia termina

Visualizzazione delle prestazioni (3/3)

Scenari wireless: struttura del nodo mobile Classifier:Forwarding Node Agent: Protocol Entity Node Entry Routing ARP LL MAC LL:Link layer object IFQ:Interface queue MAC:Mac object PHY PHY:Net interface LL MAC PHY Radio Propagation Model MobileNode CHANNEL

Scenari wireless: caratterizzazione del nodo mobile Stack protocollare LL ARP Interface Queue Strato MAC Interfaccia di rete Modello di propagazione radio Friss-space attenuation(1/r2) per piccole distanze Two ray Ground (1/r4) per distanze maggiori Posizione coordinate (x,y,z=0) Movimenti velocità, direzione, ...

Scenari wireless configurazione di un nodo mobile # $ns_ node-config -addressingType flat or hierarchical # -adhocRouting DSDV or DSR or TORA # -llType LL # -macType Mac/802_11 # -propType "Propagation/TwoRayGround“ # -ifqType "Queue/DropTail/PriQueue“ # -ifqLen 50 # -phyType "Phy/WirelessPhy“ # -antType "Antenna/OmniAntenna“ # -channelType "Channel/WirelessChannel“ # -topoInstance $topo # -energyModel "EnergyModel“ # -initialEnergy (in Joules) # -rxPower (in W) # -txPower (in W) # -agentTrace ON or OFF # -routerTrace ON or OFF # -macTrace ON or OFF # -movementTrace ON or OFF

Script iniziale (1/4) # variabili set val(chan) Channel/WirelessChannel set val(prop) Propagation/TwoRayGround set val(ant) Antenna/OmniAntenna set val(ll) LL set val(ifq) Queue/DropTail/PriQueue set val(ifqlen) 50 set val(netif) Phy/WirelessPhy set val(mac) Mac/802_11 set val(rp) DSDV set val(nn) 2 #inizio set ns_ [new Simulator] set tracefd [open traccia.tr w] $ns_ trace-all $tracefd set topo [new Topography] $topo load_flatgrid 500 500 create-god $val(nn) channel type radio-propagation model Antenna type Link layer type Interface queue type max packet in ifq network interface type MAC type ad-hoc routing protocol number of mobilenodes Crea l’oggetto simulatore Apre il file traccia.tr in scrittura Scrive traccia in traccia.tr Crea un oggetto topografia Nodi in un’area di 500x500m Crea il General Operations Director

Script iniziale (2/4) $ns_ node-config -adhocRouting $val(rp) \ -llType $val(ll) \ -macType $val(mac) \ -ifqType $val(ifq) \ -ifqLen $val(ifqlen) \ -antType $val(ant) \ -propType $val(prop) \ -phyType $val(netif) \ -topoInstance $topo \ -channelType $val(chan) \ -agentTrace ON \ -routerTrace ON \ -macTrace OFF \ -movementTrace OFF for {set i 0} {$i < $val(nn) } {incr i} { set node_($i) [$ns_ node ] $node_($i) random-motion 0 } Configura i nodi mobili utilizzando le variabili precedentemente definite Configura vari parametri, gli altri assumono valori di default Crea nn nodi mobili Disattiva il movimento random

Script iniziale (3/4) $node_(0) set X_ 5.0 $node_(0) set Y_ 2.0 $node_(0) set Z_ 0.0 $node_(1) set X_ 390.0 $node_(1) set Y_ 385.0 $node_(1) set Z_ 0.0 $ns_ at 10.0 "$node_(0) setdest 20.0 18.0 1.0“ $ns_ at 50.0 "$node_(1) setdest 25.0 20.0 15.0“ $ns_ at 100.0 "$node_(1) setdest 490.0 480.0 15.0" Posizione iniziale nodo node_(0) Posizione iniziale nodo node_(1) All’istante t=10s il nodo node(0) si sposta verso (20,18) con velocità 1m/s All’istante t=50s il nodo node_(1) si sposta verso (25,20) con velocità 15m/s All’istante t=100s il nodo si sposta verso (490,480) con velocità 15m/s

Script iniziale (4/4) set tcp [new Agent/TCP] set sink [new Agent/TCPSink] $ns_ attach-agent $node_(0) $tcp $ns_ attach-agent $node_(1) $sink $ns_ connect $tcp $sink set ftp [new Application/FTP] $ftp attach-agent $tcp $ns_ at 10.0 "$ftp start" for {set i 0} {$i < $val(nn) } {incr i} { $ns_ at 150.0 "$node_($i) reset"; } $ns_ at 150.0001 "stop“ $ns_ at 150.0002 "$ns_ halt“ proc stop {} { global ns_ tracefd close $tracefd $ns_ run Crea agent TCP Crea agent TCPSink (invia riscontri TCP) Attach sorgente TCP al nodo node_(0) Attach sink TCP al nodo node_(1) Connessione TCP tra node_(0) e node_(1) Crea applicazione ftp Attach ftp sopra TCP All’istante t=10s avvia generatore ftp Alla fine simulazione reset dei terminali Chiama procedura stop Termina Chiude il file di traccia Avvia simulazione

Animazione simulazione wireless

File di traccia + 1.84375 0 2 cbr 210 ------- 0 0.0 3.1 225 610 Inserimento in coda + 1.84375 0 2 cbr 210 ------- 0 0.0 3.1 225 610 - 1.84375 0 2 cbr 210 ------- 0 0.0 3.1 225 610 r 1.84471 2 1 cbr 210 ------- 1 3.0 1.0 195 600 r 1.84566 2 0 ack 40 ------- 2 3.2 0.1 82 602 + 1.84566 0 2 tcp 1000 ------- 2 0.1 3.2 102 611 - 1.84566 0 2 tcp 1000 ------- 2 0.1 3.2 102 611 r 1.84609 0 2 cbr 210 ------- 0 0.0 3.1 225 610 + 1.84609 2 3 cbr 210 ------- 0 0.0 3.1 225 610 d 1.84609 2 3 cbr 210 ------- 0 0.0 3.1 225 610 - 1.8461 2 3 cbr 210 ------- 0 0.0 3.1 192 511 r 1.84612 3 2 cbr 210 ------- 1 3.0 1.0 196 603 + 1.84612 2 1 cbr 210 ------- 1 3.0 1.0 196 603 - 1.84612 2 1 cbr 210 ------- 1 3.0 1.0 196 603 + 1.84625 3 2 cbr 210 ------- 1 3.0 1.0 199 612 Istante in cui è avvenuto l’evento Nodi coinvolti Tipo Dimensione Flags Numero di sequenza Identificativo univoco del pacchetto Flusso Sorgente Destinazione Rimozione dalla coda Ricezione Pacchetto scartato

Riferimenti e documentazione

Dove si trova ns-2? E’ possibile scaricare direttamente la versione all-in-one (include uno script per l’installazione automatica di tutto il software necessario al funzionamento di ns). http://www.isi.edu/nsnam/ns/ In alternativa, è possibile scaricare separatamente i singoli software richiesti da ns: Tcl/TK 8.x: http://resource.tcl.tk/resource/software/tcltk/ Otcl and TclCL: http://otcl-tclcl.sourceforge.net ns-2 and nam-1: http://www.isi.edu/nsnam/dist Other utilities http://www.isi.edu/nsnam/ns/ns-build.html Tcl-debug, GT-ITM, xgraph, …

Documentazione Per problemi legati alla compilazione http://www.isi.edu/nsnam/ns/ns-build.html Ns mailing list: ns-users@isi.edu Manuale e tutorial su ns (nella distribuzione e sul sito di ns) TCL: http://dev.scriptics.com/scripting Otcl tutorial (nella distribuzione e sul sito di ns): ftp://ftp.tns.lcs.mit.edu/pub/otcl/doc/tutorial.html