Il simulatore NS-2

Il simulatore NS-2
Paolo Campegiani
paolo@paolocampegiani.it

http://www.paolocampegiani.it

– p.

Network Simulator - versione 2 (NS-2)
É un simulatore di reti orientato al livello network sviluppato
da UC Berkeley, USC/ISI, Xerox Parc e disponibile
gratuitamente in formato sorgente (ma non è GPL).
simulatore scritto in C++
linguaggio di scripting OTcl
ha un tool di analisi graﬁca: nam
sviluppato per Unix/Linux, può essere compilato anche
per Windows
E’ disponibile sia il solo sorgente del simulatore che tutte le
librerie di cui ha bisogno, nella versione allinone (circa
60MB)

– p.

Installare NS-2 (1)
Faremo riferimento alla versione presente a partire da
www.ce.uniroma2.it nel materiale per questo corso. Il sito di
NS-2 é www.isi.edu/nsnam. Prelevato il ﬁle sorgente
questo può essere scompattato ad esempio in /usr/local.
Come root:
cd /usr/local
tar tfvj ns-2-allinone...tar.bz2
ln -s /usr/local/ns-allinone-2.27 ns-2

– p.

Installare NS-2 (2)
Quindi si procede alla compilazione del programma ns-2 e
degli altri a corredo:

cd /usr/local/ns-2
./install

Intenderemo nel seguito NS_2_BASE_DIR come la
directory /usr/local/ns-2/, o qualsiasi altra in cui si sono
stati scompattati i sorgenti della versione allinone.

– p.

Installare NS-2 (3)
Al termine dell’esecuzione del programma di installazione,
vengono riportate le modiﬁche da effettuare sulle variabili di
ambiente. Tipicamente si ha:
export PATH=NS BASE DIR/bin:NS BASE DIR/tcl8.4.5/unix
:NS BASE DIR/tk8.4.5/unix:$PATH
export TCL LIBRARY=NS BASE DIR/tcl8.4.5/library
export LD LIBRARY PATH=NS BASE DIR/otcl-1.8:NS BASE DIR/lib
Inﬁne occorre validare il simulatore:
./validate

– p.

Installare NS-2 (4)
Se tutto é andato a buon ﬁne il simulatore é eseguibile
lanciando il comando ns, e si puó veriﬁcare che versione é
in esecuzione:

$ ns
% ns-version
2.27 (NSWEB/0.2)
% quit

– p.

Installare NS-2 (5)
Oltre ad ns sono installati altri programmi (nella directory
NS_BASE_DIR/bin):
nam il network animator
tclsh8.4 l’interprete tcl
Il simulatore viene solitamente invocato con il nome di uno
script da eseguire come parametro, ma può operare anche
in modo interattivo.

– p.

Il linguaggio Tcl
Il linguaggio Tcl (Tool Command Language) é un linguaggio
di scripting. Ha a disposizione un toolkit grafico (Tk) ed é
stato spesso usato per realizzare programmi di
configurazione (ad esempio printtool). Anche expect si
basa su Tcl.
Siti su Tcl:
http://www.tcl.tk
http://www.msen.com/˜clif/TclTutor.html
Per accedere alle pagine di manuale relative a Tcl conviene
specificare la sezione n: man n puts.

– p.

Tcl: variabili - 1
Le variabili in Tcl non hanno tipo, e vengono istanziate
assegnando loro un valore con il comando set:

set x 10
set nome Riccardo
set soprannome “Cuor di Leone”

Il valore di una variabile viene acceduto premettendo al
nome il simbolo $.

– p.

Tcl: Il comando puts
Il comando puts visualizza il contenuto di una stringa sullo
standard output:

puts “Oggi sto imparando il Tcl.”
puts -nonewline “Questo e’ l’inizio di una
riga”
puts “ e questa e’ la fine”
puts “Il soprannome di Riccardo era:
$soprannome”

– p. 1

Tcl: Il risultato di un comando
Il risultato dell’esecuzione di un comando (o della
invocazione di una funzione) viene espresso con le
parentesi quadre [ ]:

set a [comando]
set a [funzione $variabile1 $variabile2]

– p. 1

Tcl: il comando expr e il comando incr
Il comando expr permette di valutare una espressione
numerica, in cui possono comparire anche variabili.

set a 5
set b 10
puts “La somma vale [expr $a+$b]”
set c [expr $a*$b]
puts “Il valore di c e’ $c”

– p. 1

Tcl: il comando incr
Il comando incr permette di incrementare il valore di una
variabile di una quantitá che puó essere speciﬁcata e che di
default vale 1.

incr c ;# ora c vale 51

Si possono scrivere piú comandi sulla stessa riga
separandoli con il carattere ;. I commenti sono indicati dal
carattere #. La stessa riga puó essere spezzata in piú righe
utilizzando il carattere .

– p. 1

Tcl: il comando switch
Il comando switch é un comando di branching che opera
con confronti di tipo testuale.

switch $x
“ONE” : puts “You’re english.”
“UNO” : puts “Sei italiano.”
“default” : puts “Ich weiss nicht.”

– p. 1

Tcl: il comando if
L’esecuzione condizionale si deﬁnisce con il comando if.

if {$x == 100} {
puts “Il valore e’ accettabile.”
} else { ;# SULLA STESSA RIGA!
puts “Il valore non va bene.”
}

– p. 1

Tcl: for e while
Il comando for ha questa sintassi:
for {condizione iniziale} {test}
{incremento} {corpo del ciclo}
for {set i 0} {$i<10} {incr i} {
puts “Valore di i: $i”}

Il comando while ha questa sintassi:
while {test} {corpo del ciclo}

– p. 1

Tcl: array associativi (1)
Gli array in Tcl hanno come indice un valore di qualsiasi
tipo:

set eta(gianni) 5
set eta(mario) 10
set eta(luigi) 15
puts “Mario ha $eta(mario) anni”

– p. 1

Tcl: array associativi (2)
array exists a ritorna 1 se l’array a esiste.
array names a ritorna una lista contenente i valori
degli indici dell’array a.
array size a ritorna la dimensione dell’array a.
array get a ritorna una lista i cui elementi dispari
sono i valori dell’indice e i cui elementi pari sono i valori
dell’array a.
array set a lista effettua l’operazione inversa
(dalla lista ad un array). La lista é nel formato prodotto
da array get.

– p. 1

Tcl: Liste: Creazione
Le liste sono la struttura dati base in Tcl. Sono collezioni
ordinate di elementi.
Possono essere create in diversi modi:
Esplicitamente: set lista { {1} {2} {3} {4}
{5}}
Con il comando list: set lista [list 1 2 3 4 5]
Con il comando split: set lista [split “Da una
frase le singole parole” “ ,:“]

– p. 1

Tcl: Liste: accesso
llindex lista posizione ritorna l’elemento di
posizione posizione dalla lista lista. Il primo elemento
ha posizione 0
llength lista ritorna la lunghezza della lista lista

E’ possibile compiere operazioni su tutti gli elementi di una
lista con il comando foreach:
foreach el $lista { ;# NON $el
puts “Nella lista c’e’ l’elemento $el”
}

– p. 2

Tcl: Liste: modiﬁche
concat l1 l2 l3 ritorna la concatenazione delle
liste l1, l2, l3:
set result [concat a b c { 1 2 3} {q { r
s } } ]
La lista result é: a b c 1 2 3 q { r s }
lappend l1 a1 a2 aggiunge alla lista l1 gli
argomenti a1, a2.
linsert lista indice a1 a2 aggiunge alla lista
lista gli elementi a1 a2 subito dopo la posizione indice.
lreplace lista inizio fine a1 a2 sostituisce
gli elementi compresi tra inizio e ﬁne della lista lista con
gli elementi a1 a2.

– p. 2

Tcl: Liste: ricerche
lsearch lista pattern ritorna l’indice del
elemento di lista che combacia con il pattern (o -1 se
non c’é elemento).
set elenco [list A B C AAA DG EE FR]
set indice [lsearch $elenco AA*] ==> indice
vale 3
lsort lista ordina una lista. Per default in modo
alfabetico, per ulteriori informazioni si veda la pagina di
manuale.
lrange lista inizio fine ritorna una lista i cui
elementi sono quelli di lista di posizione compresa tra
inizio e ﬁne.

– p. 2

Tcl: stringhe
Una stringa in Tcl é una lista i cui componenti sono singoli
caratteri.
set stringa “Mi sto appassionando al TCL
sempre piu’ ”
string length $s ritorna la lunghezza della stringa.
string index $s pos ritorna il carattere di
posizione pos della stringa s.
string range $s inizio fine ritorna la
sottostringa costituita dai caratteri di posizione
compresa tra inizio e ﬁne della stringa s.

– p. 2

Tcl: procedure - 1
Le procedure in Tcl si deﬁniscono con il comando proc:
proc sum {n1 n2} {
set totale [expr $n1 + $n2
return $totale
}

– p. 2

Tcl: procedure - 2
Una procedura puó avere un numero variabile di argomenti:
proc p {param1 {param2 “”} } {...}
Il parametro param2 é facoltativo. Nel codice della
procedura si pu’øvedere se é stato impostato
controllando se vale o meno “”.
proc p {param1 param2 args} {...}
I parametri param1 e param2 sono obbligatori. Ulteriori
parametri sono facoltativi e sono nel caso presenti in
args (come sequenza di valori che puó essere tradotta
in una lista con split).
Lo scoping delle variabili é quello usuale: per accedere ad
una variabile globale si usa il comando global: global i.

– p. 2

Tcl: I/O su file
File esterni possono essere aperti in lettura o scrittura:

set file [open outfile w] ;# Apre in scrittura
set file [open outfile r] ;# Apre in lettura
puts $file “Ci abbiamo anche l’I/O in Tcl!!”
gets $file $valore ;# legge la riga e la memorizza in valore

– p. 2

Il linguaggio OTcl
OTcl é una estensione object oriented (o quasi...) di Tcl.
L’estensione si ottiene con alcuni nuovi comandi, tra cui:
class
instproc
instvar
$self
next
$class
new
Gli altri comandi (in particolare info) sono riportati in
NS_BASE_DIR/otcl-<versione>/doc.

– p. 2

OTcl: class
Il comando class permette di definire una nuova classe.

Class WebClient
Class Proxy -superclass WebServer

Questa definizione precede la definizione dei metodi e degli
attributi della classe.

– p. 2

OTcl: instproc,instvar, $self
Il comando instproc permette di definire un metodo di
una classe.
Il metodo init é il costruttore di una classe. Il metodo
destroy é il distruttore.
Il comando instvar permette di definire gli attributi di una
classe.
Con $self si intende l’instanza in cui quelle definizioni
hanno luogo, ed é quindi analogo al this del C++, anche
se risulta indispensabile e non opzionale.

– p. 2

OTcl: instproc, instvar, $self (2)
Ad esempio per dichiarare un costruttore per la classe
WebClient si potrebbe avere:
WebClient instproc init {modalita_} {
$self instvar num_page_read modalita
set num_page_read 0
set modalita $modalita_
}
In questo modo si deﬁnisce un costruttore con due
parametri e due attributi della classe (NON gli unici due!).

– p. 3

OTcl: note su instvar
Non occorre deﬁnire tutti gli attributi in tutti i metodi, é
sufﬁciente riportare quelli usati in ogni metodo.

WebClient instproc choose-page {} {
$self instvar modalita num_page_asked
... }
Quindi la classe WebClient ha anche l’attributo
num_page_asked.

– p. 3

OTcl: next
Il comando next permette di far riferimento alla
superclasse della classe corrente, e quindi di eseguire dei
metodi altrimenti rideﬁniti.
Il tipico uso é in un costruttore:
Proxy instproc init { param... } {
eval $self next $param
... }
In questo modo viene invocato il costruttore della classe da
cui deriva la classe Proxy.

– p. 3

OTcl: $class
Con $class si fa riferimento alla classe corrente, e quindi
si puó utilizzare per deﬁnire delle variabili globali a tutte le
istanze di una classe.

Webclient instproc init { ... } {
$class instvar num_of_clients
incr num_of_clients
}

– p. 3

OTcl: new
Il comando new istanzia un oggetto per una data classe.
set myproxy [new Proxy]
set myspecproxy [new Proxy/Transcoding]
Quindi i metodi vengono richiamati in modo analogo alle
procedure:
$myproxy add-handler p1 p2 p3
$myproxy show-stats

– p. 3

NS-2: Architettura
Il simulatore NS-2 é scritto in C++, ed é accessibile in OTcl.
Le piú importanti classi disponibili in OTcl sono:
Simulator Il simulatore
Node I nodi
Link I collegamenti tra nodi
Queue Le code dei pacchetti (router)
Agent Entitá livello Transport
LanNode Reti Locali (Ethernet)
Inoltre esistono varie classi di supporto.

– p. 3

NS-2: un esempio (1)
Vogliamo simulare un trafﬁco di tipo CBR (Constant Bit
Rate) tra due nodi collegati direttamente tra di loro.

set ns [new Simulator] ;# Istanzia un simulatore
set f [open out.tr w]
$ns trace-all $f ;# Trace ﬁle
set n0 [$ns node] ;# 1o nodo
set n1 [$ns node] ;# 2o nodo
$ns duplex-link $n0 $n1 1Mb 5ms DropTail ;# link tra i nodi

– p. 3

NS-2: un esempio (2)
set udpsource [new Agent/UDP]
$ns attach-agent $n0 $udp0 ;# traffico di tipo UDP
set cbrsource [new Application/Traffic/CBR]
$cbrsource attach-agent $udp0 ;# a bitrate costante
set sink [new Agent/Null]
$ns attach-agent $n1 $sink ;# Destinatario traffico
$ns connect $udpsource $sink
$ns at 1.0 “$cbrsource start”
$ns at 10.0 “close $f; $ns halt”
$ns run ;# Inizio simulazione

– p. 3

NS-2: la classe Simulator (1)
In ogni simulazione é presente una istanza della classe
Simulator che sostanzialmente é lo scheduler degli
eventi.
set ns [new Simulator] istanzia un simulatore
[$ns now] riporta l’ora della simulazione
[$ns at time event] Esegue l’evento ad un dato
orario.

– p. 3

Quindi questa é una procedura che una volta richiamata
viene poi eseguita ogni 5 secondi:

proc schedule {} {
global ns
set now [$ns now]
puts “Schedule invocata ad $now”
set later [expr $now + 5.00]
$ns at $later “schedule”
}

– p. 3

$ns cancel event cancella un dato evento (at
ritorna il numero assegnato all’evento)
$ns run fa partire lo scheduler (che é quindi stato
caricato prima con le invocazioni di at)
$ns halt Termina la simulazione

– p. 4

NS-2: trace file (1)
Un trace file é un file di log le cui riportano gli eventi
accaduti ai pacchetti. Sono presenti in piú formati, quello
standard per nodi fissi é il seguente:

O Time S D Type Size flags FlowID SourceAddr
DestAddr SeqNo PktID

dove:
O vale:
+: aggiunta di un pacchetto in coda
-: rimozione di un pacchetto dalla coda
r: ricezione di un pacchetto
d: drop di un pacchetto

– p. 4

Time é il momento in cui l’evento é avvenuto
S e D sono i due nodi coinvolti
Type é il tipo del pacchetto
Size é la dimensione in byte del pacchetto (determinata
dall’header IP)
Flags sono i ﬂag eventualmente presenti (trace.cc):
E Congestion Experienced
N ECN Capable
C ECN Echo
A Congestion Window Reduced (!)
P Priority
F TCP Fast Start

– p. 4

FlowID é il flow identifier (come IPv6)
SourceAddr e DestAddr sono gli indirizzi dei nodi
coinvolti
SeqNo é il numero di sequenza (se l’Agente lo genera)
PktId é un identificatore univoco del pacchetto

– p. 4

NS-2: esempio di trace ﬁle
O Time S D Type Size ﬂags FlowID SourceAddr DestAddr SeqNo PktID
+ 1.0000 0 2 cbr 400 - - - - - - - 0 0.0 3.1 225 610
- 1.0005 0 2 cbr 400 - - - - - - - 0 0.0 3.1 225 610
r 1.0011 0 2 cbr 400 - - - - - - - 1 0.0 3.1 225 610
r 1.0012 2 0 ack 40 ------- 2 3.2 0.1 82 602
d 1.1111 2 3 tcp 1000 - - - - - - - 2 0.1 3.2 102 611

– p. 4

NS-2: comandi per trace file (1)
$ns trace-all file Imposta il file di trace
$ns namtrace-all file Imposta il file di trace per
nam
$ns flush-trace Svuota i buffer dei trace file
$ns monitor-queue param Monitor sulla lunghezza
di una coda
$ns create-trace param Traccia tra due nodi
specifici

Il tracing é una operazione molto costosa, ed allunga
notevolmente i tempi della simulazione.

– p. 4

NS-2: comandi per trace file (2)
Occorre sempre specificare un file di trace!
Tuttavia si può ridurre la quantità di dati tracciati:

$ns node-config -agentTrace ON -routerTrace
OFF -macTrace OFF

In questo modo si ha un tracing solo a livello applicativo e
senza il livello network e il livello MAC.

– p. 4

NS-2: Tipi dei pacchetti
In NS-s sono presenti diversi tipi di pacchetti, come ad
esempio:
PT_TCP
PT_UDP
PT_CBR
PT_ACK
PT_REQUEST, PT_ACCEPT, PT_CONFIRM,
PT_TEARDOWN

– p. 4

NS-2: unicast routing
É possibile speciﬁcare che tipo di routing avere:
$ns rtproto static routing statico, tabelle
calcolate all’inizio della simulazione con Dijkstra
$ns rtproto session come sopra, ma ricalcolato
se la topologia cambia
$ns rtproto DV $n0 $n1 $n2 i nodi n0, n1, n2
usano Distance Vector.
$ns rtproto LS $n0 $n1 i nodi n0, n1 usano Link
state.
$n0 rtproto Manual i percorsi di routing sono
codiﬁcati esplicitamente con
add-route-to-adj-node.

– p. 4

NS-2: routing gerarchico (1)
I nodi possono essere indirizzati in modo gerarchico, e
questo riduce anche la dimensione delle tabelle di routing.
Sono possibili ﬁno a 3 livelli gerarchici. Per avere routing
gerarchico occorre innanzitutto utilizzare node-config:

$ns node-config -addressType hierarchical

Quindi bisogna speciﬁcare il numero di domini, il numero di
cluster per dominio, e il numero di nodi per cluster.

– p. 4

AddrParams set domain_num 2 ;#due domini
lappend cluster_num 2 2
AddrParams set cluster_num_
$cluster_num ;#ogni dominio ha due cluster
lappend nodes 5 10 20 20
AddrParams set nodes_num_ $nodes ;#il primo
cluster ha 5 nodi, il secondo 10, e i due cluster del secondo
dominio hanno venti nodi l’uno

– p. 5

Quindi quando si creano i nodi si specifica anche il loro
indirizzo:

set client [$ns node 1.0.10]

1. Ci si assicuri di avere un numero di nodi sufficienti in
ogni cluster
2. Il nodo x.y.z ha un numero identificativo dato da
x ∗ 20482 + y ∗ 2048 + z

– p. 5

NS-2: nodi
Un nodo ha un identiﬁcativo univoco, un indirizzo
(progressivo o gerarchico), un insieme di agenti che ci
girano sopra, ed un oggetto di tipo Classifier che
indirizza i pacchetti in arrivo all’opportuno agente. Alcuni
comandi sono:
$node id ritorna l’id del nodo;
$node-addr ritorna l’indirizzo del nodo;
$node attach agent (port) aggiunge un agente
al nodo, opzionalmente speciﬁcando la porta
$node detach agent (null_agent) rimuove un
agente, opzionalmente indirizzando pacchetti in arrivo
per il vecchio agente ad un null_agent.

– p. 5

NS-2: link (1)
Un link é un collegamento tra due nodi, e modella sia la
capacitá di un collegamento che il ritardo che la politica di
scheduling dei pacchetti (tramite degli oggetti di classe
Queue). Un link monodirezionale viene creato con:
$ns simplex-link $n0 $n1 bw delay tipo-coda
Mentre un link bidirezionale viene creato con:
$ns duplex-link $n0 $n1 bw delay tipo-coda
e consiste in una coppia di link monodirezionali.

– p. 5

NS-2: link (2)
Nella deﬁnizione di un link viene esplicitato il tipo di coda,
ovvero la politica di gestione dei pacchetti, ma
l’istanziazione viene effettuata dalla procedura
simplex-link, e quindi l’oggetto creato risulta nascosto.
Se si vuole avere un accesso diretto all’oggetto occorre
creare il link direttamente tramite una instproc di
Simulator:
set Q1 [new Queue/MyQueue]
set Q2 [new Queue/MyQueue]
$Q1 my-command my-param
$Q2 my-command my-param

$ns my-set-link

– p. 5

NS-2: link(3)
Simulator instproc my-set-link {} {
global node Q1 Q2
$self instvar link_
set sid [$node(0) id]
set did [$node(1) id]
set link_($sid:$did) [new SimpleLink
$node(0) $node(1) $OPT(CAP) 2ms $Q1]
set link_($did:$sid) [new SimpleLink
$node(1) $node(0) 200Kbit 2ms $Q2]
}

– p. 5

NS-2: link (4)
Le code presenti in NS-2 sono di tipo:
DropTail Coda FIFO (dimensione standard 50
pacchetti)
FQ Fair Queueing
SFQ Stochastic Fair Queueing
DRR Deﬁcit Round Robin
RED Random Early Detection
CBQ Class Based Queueing
CBQ/WRR CBQ con Weighted Round Robin

– p. 5

NS-2: Agenti
Gli agenti sono i punti terminali in cui si creano o
consumano i pacchetti che transitano al livello network. In
NS-2 gli agenti modellano sia il livello Transport che quello
Application. Alcuni agenti disponibili sono:
Agent/TCP Mittente TCP
Agent/TCP/Reno Mittente TCP con fast recovery
Agent/TCP/Sack1 Mittente TCP con SACK (RFC
2018)
Agent/TCP/FullTcp TCP due vie
Agent/TCPSink destinatario per TCP, TCPReno (non
FullTcp)
UDP mittente e destinatario UDP
Null agente nullo (scarta tutti i pacchetti)
– p. 5

NS-2: Agenti: Creazione
set newtcp [new Agent/TCP]
$newtcp set window_ 20 ﬁnestra pari a 20
$newtcp set fid_ 2 Flow ID pari a 2

Gli agenti si agganciano a dei nodi:
$ns attach-agent $node(0) $newtcp
$ns attach-agent $node(1) $sink

Inﬁne gli agenti si collegano tra di loro:
$ns connect $newtcp $sink

– p. 5

NS-2: Agenti: avvio e fermo
Gli agenti vengono attivati con l’instproc start:
$ns at $time “$newtcp start”

Gli agenti possono essere arrestati con l’instproc stop:
$ns at $time “$newtcp stop”

– p. 5

NS-2: Agenti livello applicativo (1)
Questi agenti si appoggiano su agenti di tipo trasporto.
Alcuni esempi sono:
Application/FTP Trafﬁco FTP. Simula trasferimenti
bulk di dati.
Application/Telnet Trafﬁco di tipo telnet (distribuito
esponenzialmente o secondo tcplib-telnet.cc)
Application/Traffic/Exponential un oggetto
On/Off distribuito esponenzialmente
Application/Traffic/Pareto un oggetto On/Off
distribuito con una Pareto
Application/Traffic/CBR Un constant bit rate

– p. 6

NS-2: Agenti livello applicativo (2)
Questo esempio configura un traffico CBR su un agente
UDP:
set src [new Agent/UDP]
set sink [new Agent/UDP]
$ns attach-agent $node(0) $src
$ns attach-agent $node(1) $sink
$ns connect $src $sink
set c [new Application/Traffic/CBR]; $c set packetSize 1500
$c set interval 0.1; $c set maxpkts 200
$c attach-agent $src

– p. 6

NS-2: LAN
Una LAN puó essere creata con l’instproc make-lan della
classe Simulator:
$ns make_lan nodi banda delay LL TipoDiCoda
TipoDiMac

Ad esempio per creare una rete Ethernet si ha:

$ns make_lan “$n(0) $n(1) ...” 10Mbit 2ms
LL Queue/DropTail Mac/Csma/CD

– p. 6

NS-2: LAN e routing gerarchico
In NS_BASE_DIR/ns-(versione)
/tcl/ex/vlantest-hier.tcl é riportato un esempio di
utilizzo di LAN quando c’é un routing gerarchico, utilizzando
l’instproc newLan:

set lan [$ns newLan $nodelist $opt(bw)
$opt(delay) -llType $opt(ll) -ifqType
$opt(ifq)
-macType $opt(mac) -chanType $opt(chan)
-address "0.0.0’’

– p. 6

NS-2: Generazione numeri casuali (1)
La classe RNG modella istanze di un generatore di numeri
casuali. Il seme di ogni generatore puó essere impostato
euristicamente (sconsigliato) oppure con un valore scelto.

set rng [new RNG] ;# Istanzia un nuovo generatore
$rng seed 0 ;# Seme euristico
$rng seed 123 ;# Seme pari a 123
$rng seed predef n ;# Usa uno dei 64 semi predeﬁniti
(stream da 33 milioni di elementi)

– p. 6

$rng next-random ;# ritorna il prossimo numero
$rng uniform a b ;# uniforme in [a..b]
$rng integer k ;# intero uniforme in [0..k-1]
$rng exponential ;# esponenziale di media 1

– p. 6

Le manipolazioni necessarie per passare da una
distribuzione uniforme ad una data possono essere
ottenute tramite delle classi aggiuntive:
RandomVariable/UniformRandomVariable min_, max_

RandomVariable/ExponentialRandomVariable avg_

RandomVariable/ParetoRandomVariable avg_, shape_

RandomVariable/HyperExponentialRandomVariable avg_, cov_

RandomVariable/ConstantRandomVariable val_

– p. 6

Il collegamento viene effettuato tramite use-rng:

set e [new RandomVariable/Exponential]
$e use-rng $rng
Si impostano quindi i parametri e si ottengono i valori con
value:

$e set avg_ 10
set interarrivo [$e value]

– p. 6

NS-2: NSWEB (1)
NSWEB é una estensione di NS-2 che consente di
modellare facilmente del trafﬁco di tipo Web. É possibile
inserire in un server delle pagine aventi dimensioni, numero
di oggetti e dimensione degli oggetti modellati secondo
delle variabili casuali, ed avere dei client che richiedono le
pagine e gli oggetti in esse presenti. Supporta HTTP/1.1
(pipelining e persistenza) e genera un log a livello
applicativo evidenziando il trafﬁco dovuto agli header e ai
body.
Directory di riferimento: NS_BASE_DIR/ns-2.27/nsweb

– p. 6

NS-2: NSWEB: Esempio (1)
NSWEB deﬁnisce dei client e dei server, che condividono
l’insieme delle pagine che possono essere richieste e
fornite.
Discuteremo il ﬁle example.tcl fornito con NSWEB.
set ns [new Simulator]
set trace [open "session.tr" w]
$ns trace-all $trace

– p. 6

set log [open "session.log" w]
set web [new GPool]
$web log $log
set se1 [$ns node]
set cl1 [$ns node]
$ns duplex-link $se1 $cl1 100mb 2ms DropTail

– p. 7

set s1 [$web server $se1 $CONN_PIPELINED 5
15] ;# max 5 connessioni e 15 secondi di
inattivita’ per connessioni persistenti
set c1 [$web client $cl1 3 $CONN_PIPELINED]
# Dimensione delle pagine HTML
set pagesize_gen [new
RandomVariable/UdSPareto]
$pagesize_gen set scale_ 13300
$pagesize_gen set alpha_ 1.2

– p. 7

# Numero di oggetti per pagina
set embcount_gen [new
$embcount_gen set scale_ 2
$embcount_gen set alpha_ 1.5
# Dimensione degli oggetti
set embsize_gen [new
$embsize_gen set scale_ 133000
$embsize_gen set alpha_ 1.05

– p. 7

# Popolamento del server
$web populate-server $s1 100 $pagesize_gen
$embcount_gen $embsize_gen ;# Attenzione,
example.tcl usa due volte pagesize_gen!
set dump [open "demo.dump" w]
$web dump-scenario $dump ; close $dump
# Meccanismo di selezione delle pagine
set page_gen [new AccessGenerator/Uniform
0.0 1.0]
$web set-page-generator $page_gen

– p. 7

# Imposta l’interarrivo delle richieste
delle pagine
set inter_request [new
$inter_request set scale_ 10
$inter_request set alpha_ 1.5
#10 richieste per questa sessione
set u 10
$ns at 1.0 "session_handler $c1"
$ns run

– p. 7

proc session_handler { client } {
global ns length web u log inter_request
puts stderr "Call to session handler: [$ns
now]"
if { $u > 0 } {
set page [$web select-page]
set nextpage [$page getID]
set wait [$inter_request value]
set nt [expr [$ns now] + $wait]

– p. 7

$ns at $nt "$client request-page $page
"session_handler $client"
set u [expr $u - 1]
} else { ;# u vale 0
# Termina la simulazione tra 30 secondi
$ns at [ expr [$ns now] + 30.0 ] "finish"
} ;#chiusura if
} ;#chiusura proc

– p. 7

Binding C++/OTcl

– p. 7

Estendere ns-2

– p. 7

Il simulatore NS-2

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Il simulatore NS-2

Similar to Il simulatore NS-2 (15)

Il simulatore NS-2