BE 3ème année : Introduction au simulateur réseau NS-2

(Network Simulator)
Hervé THALMENSY
[email protected]

Objectif : Se familiariser avec le simulateur ns. Dans un premier temps, être capable de
réaliser une simulation réseau filaire. Puis des simulations de réseau sans fils.

Présentation du simulateur : ns-2 est un simulateur réseau à évènements discrets orienté objet
développé dans le cadre du projet VINT de l’Université de Berkeley en Californie. Ce projet a
été fondé par DARPA en collaboration avec le XEROX Palo Alto Research Center (PARC) et
le Lawrence Berkeley National Laboratory (LBNL).

Le développement de ns suit une approche orientée objet où deux langages de programmation

sont utilisés: C++ et tcl. Les modules de base du simulateur et les protocoles sont implantés
en C++ avec une couche tcl au-dessus, qui fournit une interface flexible et facile à utiliser.

Pour les travaux pratiques, il ne sera pas nécessaire de programmer en C++ directement,
puisqu'on ne prévoit pas la création de nouveaux protocoles. Cependant une connaissance
moyenne de tcl pourrait être nécessaire.

Voici quelques liens utiles:

http://www.isi.edu/nsnam/ns/
http://www.isi.edu/nsnam/vint/
http://www.darpa.mil/
http://www.scriptics.com/software/tcltk/

Documentation disponible à l’adresse :

http://www.isi.edu/nsnam/ns/ns-documentation.html
http://www.isi.edu/nsnam/ns/tutorial/index.html
http://www2.univ-reunion.fr/~panelli/enseignement/TRA/TP/Enonce/IntroNS.pdf

Travail à réaliser :

I. Prise en main
Vous pouvez écrire vos scripts dans n’importe quel éditeur de texte (kedit, kwrite, vi où
emacs).

Le célèbre « «Hello World » ;-)

set ns [new Simulator]
$ns at 1 “puts \“Hello World!\””
$ns at 1.5 “exit”
$ns run
Enregistrer le fichier sous hello.tcl. Puis exécuter :
% ns hello.tcl

Nous allons définir un modèle à utiliser pour tous les premiers scripts Tcl: (à récupérer ici)

Tout d’abord, il faut créer un objet simulator.

set ns [new Simulator]

Maintenant il va falloir définir un fichier dans lequel les données (résultats) vont être
écrites. Ces données seront utilisées par nam pour afficher les résultats. On en
reparlera dans la suite.
set nf [open out.nam w]
$ns namtrace-all $nf

La première ligne ouvre le fichier out.nam en écriture et donne à ce fichier le

descripteur nf. La seconde ligne indique à l’objet simulateur créé précédemment
d’écrire tous les résultats relatifs à nam dans ce fichier.

La procédure suivante permet de fermer le fichier de traces et lance l’outil nam.

proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}

La ligne suivante indique à l’objet simulateur d’exécuter la procédure finish après 5

secondes de simulation.
$ns at 5.0 "finish"

La dernière ligne lance la simulation.

$ns run

Après avoir enregistré, vous pouvez exécuter votre fichier en tapant : ns exemple.tcl

Question :
1. Que remarquez vous lorsque vous lancez la simulation ?
II. Premiers scripts

a. Exercice 1 : Topologie basée sur 3 nœuds.

L’objectif est de réaliser une topologie avec 3 nœuds et 2 liens semblable à :

Les liens sont full duplex et ont un temps de propagation de 5ms. Entre n1 et n2 le débit est de
5Mbits/s et entre n2 et n3 de 1Mbit/s.

Vous aurez besoin de :

Pour créer un nœud : set n0 [$ns node]

Pour créer un lien avec un débit de 1Mbit/s et d’un délai de 10ms et une queue FIFO entre n0
et n1 : $ns duplex-link $n0 $n1 1Mb 10ms DropTail

Utiliser les options de positionnement spatial de nam pour obtenir une représentation
identique à celle proposée.

Exemple : si on veut que le lien entre n0 et n1 soit horizontal de gauche à droite on écrira :
$ns duplex-link-op $n0 $n1 orient right

On peut également demander la représentation de la file d’attente du nœud n2 vers n3

$ns duplex-link-op $n2 $n3 queuePos 0.5
Ici 0.5 est l’angle de la pile de paquets avec l’horizontale.

Il est également possible de choisir différentes couleurs pour les paquets

$ns color 1 red
$ns color 2 blue

b. Exercice 2 : Ajout de flux FTP.

Pour cela, il faut introduire la notion d’agent. Un agent peut être considéré comme une entité
de la couche Transport (modèle OSI). Dans ns les données sont toujours échangées d’un agent
à un autre.

Pour créer un agent TCP standard :

set transport [new Agent/TCP]

Pour créer un agent qui va absorber les paquets qui lui parviennent
set trounoir [new Agent/TCPSink]

Tout agent doit être attaché à un nœud. La connexion logicielle entre 2 agents peut alors être
établie.
$ns attach-agent $n0 $transport
$ns attach-agent $n1 $trounoir
$ns connect $transport $trounoir

Les paquets émis par l’agent transport peuvent être coloré en rouge (nous avons définit 1
comme étant la couleur rouge)
$transport set class_ 1

La classe Source permet de décrire le niveau applicatif, elle ne comporte que les applications
telnet et ftp.
set transfert [new Source/FTP]
$transfert set agent_ $transport
Ceci permet d’associer la couche transport et l’application ftp.

Pour lancer le ftp :

$ns at 0.1 "$transfert start"

Remarques :
- de la même façon, il est possible de définir un [Agent/CBR] : agent CBR (constant bit rate)
qui permet de reproduire un trafic constant. Il est associé à un [Agent/Null]

- certains agents (Agent/CBR par exemple) n’ont pas besoin d’être commandés par une
application.

Questions :
1. Reprendre la topologie précédente et créer un flux FTP entre n1 et n3.
2. Modifier les paramètres des liens.
3. Que remarquez-vous ?
4. Ajouter un 2ème flux FTP grâce à un 4ème nœud
5. Comment se comportent les 2 flux FTP ?

III. Mise en concurrence de flux TCP et UDP

UDP est un protocole qui ne dispose pas de mécanisme d’adaptation à la congestion du
réseau. Dans cette partie on verra les résultats de la mise en concurrence de flux TCP et UDP.

Pour créer un agent UDP :

set udp0 [new Agent/UDP]

Pour créer un CBR connecté à l’agent udp0 :

set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp0

Ici, la taille des paquets est de 500 octets et un paquet sera envoyé toutes les 0.005 secondes
(ce qui est équivalent à 200 paquets/s).

Pour démarrer et arrêter le CBR :

$ns at 0.5 "$cbr0 start"
$ns at 4.5 "$cbr0 stop"
Prenons la topologie suivante :
Flux TCP Flux TCP
S1 D1

1.3 Mbit/s R1 R2 1.3 Mbit/s

100 ms 100 ms

500 kbit/s
50 ms
S2 D2

Flux UDP Flux UDP

On dispose d’une source de trafic CBR de débit équivalent au goulot d’étranglement c'est-à-
dire 500kbit/s. Les paquets émis ont une taille fixe de 1000 octets.

Questions
1. Reproduire cette expérience avec ns
2. Comment se comportent les 2 flux ?
3. Modifier les paramètres pour mettre en évidence le comportement lorsqu’ils doivent
se partager de la bande passante.

IV. Le format de traces et visualisation des résultats

Ns fournit un outil permettant de tracer des courbes : xgraph

Pour tracer un flux UDP, utiliser un agent monitor: set sink [new Agent/LossMonitor]

Voici un exemple de procédure pour enregistrer les traces :

proc record {} {
global sink0 f0
#On instancie le simulateur
set ns [Simulator instance]

#Intervalle de mesure (qd la procédure va être rapellée)

set time 0.5

#Combien d’octets ont été recus par le traffic sink?

set bw0 [$sink0 set bytes_]

#Instant courant
set now [$ns now]

#Calcul de bande passante (en MBit/s) et écriture dans le fichier

puts $f0 "$now [expr $bw0/$time*8/1000000]"

#Reset de la variable bytes_ au niveau du traffic sinks

$sink0 set bytes_ 0

#On relance la procedure

$ns at [expr $now+$time] "record"
}
On définit le fichier de trace
set f0 [open out0.tr w]

Il ne faut pas oublier de modifier la procédure finish

proc finish {} {
global f0
#Fermeture du fichier de trace
close $f0
#Appel à xgraph pour afficher les résultats
exec xgraph out0.tr -geometry 800x400 &
exit 0
}

Il ne faut pas non plus oublier de lancer l’enregistrement des données.

$ns at 0.0 "record"

Question
1. Reprendre l’exemple précédent de flux TCP et UDP concurrents et tracer les bandes
passantes du flux TCP et du flux UDP.
2. Tracer également les bandes passantes pour 2 flux TCP concurrents, et pour 2 flux
UDP concurrents.

V. Un exemple simple de topologie de réseau sans fils

Nous allons simuler un scénario simple de réseau sans fils avec 2 nœuds mobiles. Ces nœuds
mobiles se déplacent dans un monde de 500m x 500m. Une connexion TCP est établie entre
ces 2 nœuds et des paquets sont alors échangés.

Au début d’une simulation sans fil, il faut définir le type de chaque composant réseau. De plus
il faut définir d’autres paramètres tels que : le type d’antenne, le modèle de propagation radio,
le type de protocole de routage ad-hoc utilisé par les nœuds mobiles.

Nous commençons notre script simple-wireless.tcl avec les différents paramètres suivants:

# ======================================================================
# Define options
# ======================================================================
set val(chan) Channel/WirelessChannel ;# channel type
set val(prop) Propagation/TwoRayGround ;# radio-propagation model
set val(ant) Antenna/OmniAntenna ;# Antenna type
set val(ll) LL ;# Link layer type
set val(ifq) Queue/DropTail/PriQueue ;# Interface queue type
set val(ifqlen) 50 ;# max packet in ifq
set val(netif) Phy/WirelessPhy ;# network interface type
set val(mac) Mac/802_11 ;# MAC type
set val(rp) DSDV ;# ad-hoc routing protocol
set val(nn) 2 ;# number of mobilenodes
On crée ensuite une instance du simulateur,

set ns_ [new Simulator]

Le fichier de trace sera simple.tr

set tracefd [open simple.tr w]

$ns_ trace-all $tracefd

Ensuite on crée un objet topology

set topo [new Topography]

Les limites du monde avec les coordonnées x=500 et y=500 :

$topo load_flatgrid 500 500

Ensuite il faut créer un objet God (General Operations Director). Il s’agit d’un objet utilisé
pour stocker les informations globales à propos de l’environnement.

create-god $val(nn)

Ensuite il faut créer et configurer les noeuds. Il s’agira de définir le type d’adressage, le type
de protocole de routage ad-hoc, Link Layer, MAC layer, IfQ, etc. L’API est la suivante :

(parameter examples)
# $ns_ node-config -addressingType flat or hierarchical or expanded
# -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

Toutes les valeurs par défaut pour ces options sont NULL à l’exception de :
addressingType: flat

L’API pour créer de noeuds mobiles:

# Configure nodes
$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

On peut créer 2 noeuds mobiles de cette façon:

for {set i 0} {$i < $val(nn) } {incr i} {

set node_($i) [$ns_ node ]
$node_($i) random-motion 0 ;# disable random motion
}

On désactive les mouvements aléatoires en mettant à 0 le random-motion.

Les noeuds ont été créés et ils vont être positionnés suivant les coordonnées :

#
# Provide initial (X,Y, for now Z=0) co-ordinates for node_(0) and node_(1)
#
$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

Pour produire des mouvements,

#
# Node_(1) starts to move towards node_(0)
#
$ns_ at 50.0 "$node_(1) setdest 25.0 20.0 15.0"
$ns_ at 10.0 "$node_(0) setdest 20.0 18.0 1.0"

# Node_(1) then starts to move away from node_(0)

$ns_ at 100.0 "$node_(1) setdest 490.0 480.0 15.0"

Ensuite, configuration du trafic entre les nœuds (ici TCP):

# TCP connections between node_(0) and node_(1)

set tcp [new Agent/TCP]
$tcp set class_ 2
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"

On définit l’instant ou la simulation va se terminer et on indique aux noeuds de faire un reset

sur leurs valeurs.

#
# Tell nodes when the simulation ends
#
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 "puts \"NS EXITING...\" ; $ns_ halt"
proc stop {} {
global ns_ tracefd
close $tracefd
}

On lance la simulation,

puts "Starting Simulation..."

$ns_ run

Questions

1. Réaliser une simulation avec 2 noeuds fixes distants de 100m. Emettre du trafic UDP
entre ces 2 nœuds. Tracer les résultats avec xgraph.
a. Comment se comporte le trafic ?
b. Que déduisez-vous ?
2. Améliorer le réalisme
a. Se renseigner à l’adresse suivante : http://www-ece.rice.edu/~jpr/ns-
802_11b.html
b. Appliquer les modifications
3. Faire s’éloigner les nœuds progressivement et interpréter les résultats obtenus
4. Mettre en évidence l’impact de la concurrence entre 2 flux UDP, puis entre 2 flux
TCP.