Introduction au simulateur réseau NS2

Le simulateur NS est un outil logiciel de simulation de réseaux informatiques, développé dans le cadre du projet VINT, ce dernier est un projet en cours de développement avec la collaboration de plusieurs acteurs (USC/ISI, Xerox parc, LBNL et UCB) dans l'objectif principal de construire un simulateur multiprotocole pour faciliter l'étude de l'interaction entre les protocoles et le comportement d'un réseau à différentes échelles.

Le projet contient des bibliothèques pour la génération de topologies réseau, des trafics ainsi que des outils de visualisation tels que l'animateur réseau NAM (network animator).

NS est un outil logiciel de simulation de réseaux informatiques. Il est essentiellement élaboré avec les idées de la conception par objets, de la réutilisation du code et de modularité. Il est aujourd'hui un standard de référence en ce domaine, plusieurs laboratoires de recherche recommandent son utilisation pour tester les nouveaux protocoles.

Le simulateur NS actuel est particulièrement bien adapté aux réseaux à commutation de paquets et à la réalisation de simulations de grande taille (le test du passage à l'échelle). Il contient les fonctionnalités nécessaires à l'étude des algorithmes de routage unicast ou multicast, des protocoles de transport, de session, de réservation, des services intégrés, des protocoles d'application comme FTP. À titre d'exemple la liste des principaux composants actuellement disponibles dans NS par catégorie est :

• application : Web, ftp, telnet, générateur de trafic (CBR...) ;
• transport : TCP, UDP, RTP, SRM ;
• routage unicast : Statique, dynamique (vecteur distance) ;
• routage multicast : DVMRP, PIM ;
• gestion de file d'attente : RED, DropTail, Token bucket.

II-A. L'outil de visualisation NAM▲

Maintenant que nous avons vu quelques-unes des notions de base sur le simulateur NS-2, regardons comment cela se passe dans le monde réel.

Notez bien que l'installation et la simulation vont être faites sur une distribution GNU Linux Ubuntu.

III-A. Prérequis▲

su -
yum install build-essential autoconf automake libxmu-dev

III-B. téléchargement et installation▲

wget http://nchc.dl.sourceforge.net/sourceforge/nsnam/ns-allinone-vX.tar.gz

./install

# LD_LIBRARY_PATH
OTCL_LIB=/home/<votre dossier personnel>/el>/ns-allinone-X/otcl-Y
NS2_LIB=/home/<votre dossier perso>/ns-allinone-2.31/lib
X11_LIB=/usr/X11R6/lib
USR_LOCAL_LIB=/usr/local/lib
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$OTCL_LIB:$NS2_LIB:$X11_
LIB:$USR_LOCAL_LIB
 
# TCL_LIBRARY
TCL_LIB=/home/<votre dossier personnel>/ns-allinone-2.31/tclZ/library
USR_LIB=/usr/lib
export TCL_LIBRARY=$TCL_LIB:$USR_LIB
 
# PATH
XGRAPH=/home/<votre dossier perso>/ns-allinone-2.31/bin:/home/<votre dossier perso>/
ns-allinone-X/tclZ/unix:/home/<votre dossier perso>/ns-allinone-2.31/tk8.4.14/unix
NS=/home/<votre dossier perso>/ns-allinone-X/ns-X/
NAM=/home/<votre dossier perso/-allinone-X/nam-T/
PATH=$PATH:$XGRAPH:$NS:$NAM

$ source ~/.bashrc

cd ns-X
 ./validate

Pour observer le fonctionnement de NS-2 et de son outil de simulation NAM, nous avons simulé un montage réseau simple, correspondant au diagramme suivant :

Pour cela, nous avons créé six nœuds NS-2 (node), reliés par des liens full duplex (duplex-link) supportant des débits différents, un temps d'accès au medium de 10 ms, avec un algorithme de file d'attente DropTail2 pour la gestion des files d'attente.

La création des nœuds se fait par deux méthodes (explicite ou dynamique)

1^re méthode :

set n0 [$ns node]
$n0 label "source UDP"
set n1 [$ns node]
$n0 label "source TCP"
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
$n0 label "destination UDP"
set n5 [$ns node]
$n0 label "destination TCP"

2^e méthode :

set nbNodes 5
for {set i 0} {$i < $nbNodes } {incr i} {
set n$i [$ns node]
lappend NodeList $n$i
}

Nous avons ensuite créé un agent UDP (Agent/UDP) attaché au nœud n0 (attach-agent) qui permet à n0 de transmettre des paquets UDP sur le réseau. Puis, nous avons créé un agent pour envoyer des paquets à débit constant (Constant Bit Rate -CBR-Application/Traffic/CBR) attaché à l'agent UDP défini précédemment (attach-agent).

# Création de l'agent implanté dans n0 
set udp [new Agent/UDP]
$ns attach-agent $n0 $udp
# Traffic CBR de 500 octets toutes les 5 ms pour UDP0
set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp

Et de la même façon pour le trafic TCP

# Création de l'agent implanté dans n0 
set tcp [new Agent/TCP]
$ns attach-agent $n1 $tcp
 
# Traffic CBR de 500 octets toutes les 10 ms pour tcp
set cbr1 [new Application/Traffic/CBR]
$cbr1 set packetSize_ 500
$cbr1 set interval_ 0.010
$cbr1 attach-agent $tcp

Nous avons enfin créé un agent vide, destiné à recevoir les paquets UDP sans les traiter (Agent/Null). On l'attache au nœud n4 (attach-agent) puis on connecte l'agent UDP et l'agent vide (connect).

# Création d'un agent vide, destiné à recevoir les paquets implantés dans n3
set null0 [new Agent/Null]
$ns attach-agent $n4 $null0
$ns connect $udp $null0

Contrairement au UDP (protocole de transport sans connexion), TCP est un protocole orienté connexion ce qui demande une certaine coordination entre la source et la destination, pour cela nous avons mis un agent (Agent/TCPSink) au nœud de destination qui permet de communiquer avec le nœud source

# Création d'un agent vide, destiné à recevoir les paquets implantés dans n3
set tcpsink [new Agent/TCPSink]
$ns attach-agent $n5 $tcpsink
$ns connect $tcp $tcpsink

Enfin, on indique que les traces de simulation doivent être logées, qu'on souhaite lancer NAM à la fin de la simulation, que celle-ci va durer 10 secondes et que le CBR ne sera émis qu'à partir de la 0.5ème seconde de simulation, et jusqu'à la 14.5ème seconde.

Le code TCL de la simulation, commenté en détail, est le suivant :

# Création du simulateur
set ns [new Simulator]
# Création du fichier de traces NS-2
set nf [open out.nam w]
$ns namtrace-all $nf
 
# Définition de classes pour la coloration
$udp set class_ 1
$tcp set class_ 2
 
# Coloration des classes : bleu pour udp (classe 1) et rouge pour tcp (classe 2)
$ns color 1 Blue
$ns color 2 Red
 
# Procédure de fin de simulation, qui écrit les données dans le fichier
# et lance NAM pour la visualisation
proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}
 
# Création des nœuds
 
set n0 [$ns node]
$n0 label "source UDP"
set n1 [$ns node]
$n0 label "source TCP"
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
$n0 label "destination UDP"
set n5 [$ns node]
$n0 label "destination TCP"
 
# Création des liens, tous en 1Mbps/10ms de TR/file d'attente DropTail
$ns duplex-link $n0 $n2 1Mb 10ms DropTail
$ns duplex-link $n1 $n2 1Mb 10ms DropTail
$ns duplex-link $n2 $n3 1Mb 10ms DropTail
$ns duplex-link $n3 $n4 1Mb 10ms DropTail
$ns duplex-link $n3 $n5 1Mb 10ms DropTail
 
# gestion du layout de la topologie 
$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
$ns duplex-link-op $n3 $n4 orient right-up
$ns duplex-link-op $n3 $n5 orient right-down
 
# Création de deux agents implantés dans n0 
set udp [new Agent/UDP]
$ns attach-agent $n0 $udp
 
set tcp [new Agent/TCP]
$ns attach-agent $n1 $tcp
 
# Traffic CBR de 500 octets toutes les 5 ms pour UDP0
set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp
 
# Traffic CBR de 500 octets toutes les 10 ms pour UDP1
set cbr1 [new Application/Traffic/CBR]
$cbr1 set packetSize_ 500
$cbr1 set interval_ 0.010
$cbr1 attach-agent $tcp
 
# Création d'un agent vide, destiné à recevoir les paquets implantés dans n3
set null0 [new Agent/Null]
$ns attach-agent $n4 $null0
 
# Création d'un agent vide, destiné à recevoir les paquets implantés dans n3
set tcpsink [new Agent/TCPSink]
$ns attach-agent $n5 $tcpsink
 
# Le traffic issu des agents udp0 et udp1 est envoyé vers null0
$ns connect $udp $null0
$ns connect $tcp $tcpsink
 
# Scénario de début et de fin de génération des paquets par cbr0
$ns at 0.5 "$cbr0 start"
$ns at 0.5 "$cbr1 start"
$ns at 14.5 "$cbr0 stop"
$ns at 14.5 "$cbr1 stop"
 
 
 
# La simulation va durer 15 secondes et appelle la procédure finish
$ns at 15.0 "finish"
# Début de la simulation
$ns run

On lance ensuite la simulation qui permet de lancer la visualisation du résultat avec l'outil NAM à l'aide de la commande :

$ ns <le nom du fichier>.tcl

Ce qui donne le résultat suivant:

Le logiciel NS-2 et l'outil de visualisation NAM sont particulièrement adaptés à l'étude de réseaux complexes (filaires, sans fils) mettant en oeuvre de nombreux types de files d'attente, protocoles de routage, de couches transport (UDP, TCP), et couches application.

À travers ce tutoriel, nous avons pu cerner la problématique d'installation du simulateur NS2, et nous avons fait une simulation simple d'un réseau de communication avec deux types de protocoles transport (TCP et UDP).

Dans des tutoriels futurs, nous allons étudier en profondeur la gestion des files d'attente et l'utilisation des fichiers trace pour la génération de statistiques sur les performances du réseau (utilisation de la bande passante, taux de perte).

Je remercie les équipes de Developpez.com pour leur collaboration à la mise au point de ce tutoriel.

Un grand merci à Djug pour ses excellents retours, et 3DArchi en particulier pour ses remarques.

Je tiens également à remercier ClaudeLELOUP pour sa relecture attentive.