I. Introduction

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).

II. Présentation du simulateur NS2

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. A 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

NS-2 ne permet pas de visualiser le résultat des expérimentations. Il permet uniquement de stocker une trace de la simulation, de sorte qu'elle puisse être exploitée par un autre logiciel, comme NAM.

NAM est un outil de visualisation qui présente deux intérêts principaux : représenter la topologie d'un réseau décrit avec NS-2, et afficher temporellement les résultats d'une trace d'exécution NS-2. Par exemple, il est capable de représenter des paquets TCP ou UDP, la rupture d'un lien entre noeuds, ou encore de représenter les paquets rejetés d'une file d'attente pleine. Ce logiciel est souvent appelé directement depuis les scripts TCL pour NS-2, pour visualiser directement le résultat de la simulation.

III. Installation du simulateur NS2

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

Pour l'installation du ns2, on doit tout d'abord installer les paquets suivants :

  • build-essential ;
  • autoconf ;
  • Automak ;
  • libxmu-dev. 

Cela par la commande suivante (sous Fedora pour Ubuntu vous allez utiliser apt-get au lieu de yum):

 
Sélectionnez
su -
yum install build-essential autoconf automake libxmu-dev  

III-B. téléchargement et installation

Le téléchargement du NS2 se fait par la commande suivante (il faut remplacer le X par la version du NS2 que vous voulez installer, personnellement je travaille avec la version 2.31) :

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


Après la décompression de l'archive avec la commande tar -xzvf ns-allinone-X.tar.g , vous tapez la commande d'installation suivante après l'accès au dossier ns-allinone-X :

 
Sélectionnez
./install

L'étape la plus importante est la gestion des variables d'environnement qui s'affichent après la fin d'installation. La déclaration de ces variables se fait dans le fichier .bashrc comme suivant (il faut changer les X, Y, Z, T par les versions que vous avez) :

 
Sélectionnez
# 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

Après chaque changement au niveau du fichier .bashrc, on doit le recharger sinon on est obligé de redémarrer le terminal avec la commande :

 
Sélectionnez
$ source ~/.bashrc


Pour tester l'installation il suffit de lancer la commande ns qui affichera un % indiquant le bon fonctionnement de notre simulateur NS2. Une étape optionnelle de validation qui va tester des exemples de simulation déjà implémentés (cette étape prend plus ou moins de temps selon la puissance de la machine) :

 
Sélectionnez
cd ns-X
 ./validate

IV. Exemple de simulation avec NS2

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 :

\\VBOXSVR\Thèse\Dropbox\tuto devloppez\Diagramme1.jpg
Montage réseau à simuler

Pour cela, nous avons créé six noeuds 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 noeuds se fait par deux méthodes (explicite ou dynamique)

1re méthode :

 
Sélectionnez
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"

2e méthode :

 
Sélectionnez
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 noeud 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).

 
Sélectionnez
# 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

 
Sélectionnez
# 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 noeud n4 (attach-agent) puis on connecte l'agent UDP et l'agent vide (connect).

 
Sélectionnez
# 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 noeud de destination qui permet de communiquer avec le noeud source

 
Sélectionnez
# 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 :

 
Sélectionnez
# 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 noeuds
 
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 :

 
Sélectionnez
$ ns <le nom du fichier>.tcl

Ce qui donne le résultat suivant:

\\VBOXSVR\Thèse\Dropbox\tuto devloppez\capture1.jpg
Montage réseau avec les flux de communication visualisés avec le NAM

V. Conclusion

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.

A 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).

Remerciements

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.