Network Simulator et Network Animator

1) Avant propos
Les réseaux de télécommunications, et en particulier les réseaux informatiques connaissent
une expansion sans précédent.. Devant l'évolution des techniques et de la technologie, de
nombreuses solutions sont envisageable pour un même problème. La simulation permet ainsi
de tester sans aucun coût ces nouvelles technologies, les nouveaux protocoles mais aussi
d'anticiper les problèmes qui pourront se poser dans le futur.

2) NS et NAM
NS est un Network Simulator : il permet à l'utilisateur de définir un réseau et de simuler des
communications entre les noeuds de ce réseau. NS v2 utilise le language OTcl (Object Tools
Command Language) dérivé de TCL. A travers ce language, l'utilisateur décrit les conditions
de la simulation : la topologie du réseau, les caractéristiques des liens physique, les protocoles
utilisés, les communications qui ont lieu...
La simulation doit d'abord être saisie sous forme de fichier texte que NS va utiliser pour
produire un fichier trace contenant les résultats.

Ensuite, on utilise le programme NAM pour interpréter ces données et en donner un rendu
graphique. Voici un exemple de simulation que nous visionnons avec NAM :
Mais l'utilisation de l'OTcl permet aussi à l'utilisateur de créer ses propres procédures (par
exemple si il souhaite enregistrer dans un fichier l'évolution d'une variable caractéristique du
réseau au cours du temps).

3) Les travaux pratiques

Nous vous proposons donc une série de Travaux Pratiques qui vont vous permettre de vous
familiariser avec l'OTcl et avec l'utilisation de NS et de NAM. Les trois premiers TP vous
montrerons progressivement comment déclarer vos simulations, puis lors du dernier TP, vous
serez amené à créer votre propre simulation en utilisant vos acquis.

[Retour à la page d'accueil]

TP1 : Création d'un réseau et transfert FTP

Dans ce TP, vous devez effectuer un transfer FTP entre deux noeuds du réseau. Pour cela, il
va falloir au préalable, définir les noeuds du réseau, les liens entre chaque noeud, définir des
agents TCP adéquats pour les deux noeuds qui vont communiqués et enfin définir la couche
applicative FTP de ces deux noeuds. Pour pouvoir faire ce TP, téléchargez (par SHIFT +
Click) le fichier tp1.tcl

1. Déclaration de la simulation et des fichiers de sortie

2. Définition des noeuds et des liens
3. Définition des agents et des applications
4. Lancement et visualisation des résultats

1. Déclaration de la simulation et des fichiers de sortie

#Déclaration d'une nouvelle simulation
set ns [new Simulator]

#Declaration des fichiers contenant les résultats

set ftrace [open ftp1.tr w]
set nf [open tp1.nam w]
$ns namtrace-all $nf

#Procédure qui termine la simulation

proc finish {}
{
global ns ftrace nf
$ns flush-trace
 close $nf
close $ftrace
exit 0
}

2. Définition des noeuds et des liens

La définition des noeuds est tres simple : pour définir le noeud n0, la syntaxe est la suivante.
set n0 [$ns node]

Definissez cinq autres noeuds dans le fichier TP1.tcl que vous appelerez n1, n2, n3, n4, n5.

Une fois les Noeuds définis, on peut déclarer les liens. Nous voulons obtenir la topologie
suivante :

Le lien entre les noeuds n0 et n2 se défini de la manière suivante :

$ns duplex-link $n0 $n2 10Mb 10ms DropTail

Cette ligne défini le lien  entre n0 et n2 avec les caractéristiques suivantes :

 liaison full duplex

 bande passante : 10Mb pour chaque sens
 délai de propagation de 10ms
 type : droptail

Définissez les autres liaisons pour pour avoir la topologie souhaitée. Toutes les autres liaisons
ont les même caracteristiques que la liaison definie ci-dessus.

3. Définition des agents et des applications

On souhaite faire communiquer n0 et n4 : nous allons donc attribuer a ces noeuds des agents
TCP. Pour le transfert de fichier FTP, le noeud n0 sera la source et le noeud n4 le destinataire.
Pour NS, il faut déclarer :

 la source TCP puis l'attacher au noeud n0 :

set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0

 le puit TCP puis l'attacher au noeud n4 :

set tcp1 [new Agent/TCPSink/DelAck]
$ns attach-agent $n4 $tcp1

Il reste enfin a définir la couche applicative FTP de la source et de l'attachée à n0 comme

suit :

set ftp [new Application/FTP]

$ftp set agent_ $tcp0

4. Lancement et visualisation des résultats

Vous avez fini de déclarer l'instance de la simulation. Il ne reste plus qu'à lancer la simulation
par la commande :
ns tp1.tcl

Le fichier tp1.nam sera généré par ns. Pour l'ouvrir avec NAM, tapez :

nam tp1.nam

Pour voir le graphe de la taille de la fenêtre de congestion de l'émetteur, ouvrez "ftp1.tr"

avec "gnuplot".

[TP suivant] [Retour à la page d'accueil]

TP2 : Routage Dynamique

Le but de ce TP est d'observer le principe du routage dynamique : nous allons simuler un transfert
FTP entre deux noeuds du réseau et rendre momentanément inutilisable le lien utiliser par le
transfert. Ainsi, les tables de routages vont être recalculées grâce à des échanges de paquets de
signalisation entre les noeuds. D'autre part, ce calcul des tables de routages aura aussi lieu au début
de la simulation.

Pour faire ce TP, téléchargez le fichier tp2.tcl par (Shift + Click) et travaillez dessus.

1. Le réseau
2. La déclaration du routage dynamique
3. Disfonctionnement d'un lien
4. Résultats

1. Le réseau
Nous allons donc visualiser le routage dynamique sur la topologie suivante :

Comme dans le Tp1, definissez correctement les noeuds et les liens (on gardera le même type
de lien), les agents TCP et l'application FTP. Le transfert FTP a lieu entre le noeud n°0 et le
n°5 :

Noeud n°0 Source

Noeud n°5 Puit

Caractéristiques des liens :

 liaison full duplex

 bande passante : 10Mb pour chaque sens
 délai de propagation de 10ms
 type : droptail

2. La déclaration du routage dynamique

Elle est très simple et consiste en la ligne suivante :

$ns rtproto DV

Il n'y a rien d'autre a ajouter ! Cela revient à assigner la valeur DV à la variable "rtproto" du
simulateur.

3. Disfonctionnement d'un lien

Ensuite, il reste à faire "tomber" le lien entre le noeud n°1 et le n°2 à l'instant t=1,0s et à le
rétablir à t=1,2s. La syntaxe est la suivante :

$ns rtmodel-at 1.0 down $n1 $n2

$ns rtmodel-at 1.2 up $n1 $n2

4. Résultats
Lancer alors la simulation et observez le résultat... (tp2.nam)

[TP précédent] [TP suivant] [Retour à la page d'accueil]

TP3 : Multicast

L'objectif de ce TP est de se familiariser avec le multicast, tel qu'il est implémenté dans NS. Nous
allons voir les quelques protocoles directement utilisables, et dont le résultat est rapidement
visualisable sous NAM. Après ce TP, vous aurez une bonne vue d'ensemble des différentes
possibilités de Multicast qu'offre NS.

1. La topologie du réseau
2. Premier contact avec pimDM
3. Les fonctions join-groupe et leave-groupe
 4. Un protocle plus probant : DM
5. L'algorithme de routage par arbre recouvrant
6. Multicast avec routage dynamique

1. La topologie du réseau
Pour ce TP, nous allons utiliser le même réseau pour chaque question. Voici la topologie du réseau :

Vous créerez donc cette topologie, soit à la main, soit avec l'utilitaire convertisseur. Nous ne nous
interessons pas au temps de propagation, ni au débit, vous pourrez prendre les mêmes pour chaque
lien.

2. Premier contact avec pimDM

Dès que vous utilisez des adresses de diffusion, il faut mettre une variable booléenne à 1 pour
avertir NS. Il a aussi besoin de la variable NumberInterfaces à 1. Tout fichier contiendra donc
les lignes suivantes (que l'on peut mettre après la déclaration de l'objet Simulator) :

Simulator set EnableMcast_ 1

Simulator set NumberInterfaces_ 1

Ensuite, il faudra déclarer quel protocole nous allons utiliser. Pour cela, il faut utiliser la
méthode mrtproto de l'objet Simulator. La méthode mrtproto nécessite deux arguments : le
nom du protocole, la liste des noeuds concernés par ce protocole (par défaut tous les noeuds
déjà déclarés). Pour cette question, nous utiliserons le protocole pimDM. Nous allons donc
ajouter la ligne suivante :

$ns mrtproto pimDM {}

Le protocole pimDM (Protocol Independant Multicast - Dense Mode) est le plus simple qui
soit. Pour atteindre toutes les machines du réseau (lors de l'initialisation), chaque noeud
régenère le message sur tous les ports, sauf celui par lequel est arrivé le message.

Pour toutes les questions, nous définirons un flux CBR (Constant Bit Rate) partant de la
machine 0. Il faut donc créer un agent CBR que l'on attachera au noeud n0. L'agent capable de
"récupérer" les flux CBR (comme l'agent TCPSink pour un flux TCP) est LossMonitor.

Pour cette question, nous allons générer un flux CBR depuis le noeud n0 vers une adresse de
diffusion. Les adresses de diffusion doivent être comprises entre 0x8000 et 0xFFFF, sinon NS
ne comprendra pas. Pour indiquer que le destinataire du flux CBR est une adresse de
diffusion, nous mettons dans la variable dest_ de l'agent CBR le numéro de la liste de
diffusion.

$cbr set dst_ 0x8001

Vous ferez commencer ce flux à l'instant 0.5. Vous étudierez le résultat sous NAM et
trouverez une explication.
Remarque : vous pourrez utiliser une couleur particulière pour le flux CBR (ce qui permettra
de comprendre mieux le mécanisme).

3. Les fonctions join-groupe et leave-groupe

Dans la question précédente, l'adresse de diffusion utilisée ne contenait aucune machine. Pour
mettre ou retirer une machine d'une adresse de diffusion, NS prévoit les fonctions join-groupe et
leave-groupe dont voici  la syntaxe :

$node join-groupe agent group

L'agent agent est ajouté à la liste de diffusion group, et l'agent est attaché au noeud
node.
La même syntaxe est utilisé pour leave-group.

Vous ferez commencer le flux CBR partant du noeud 0 à l'instant 0.5, vous ajouterez le noeud
4 à la liste de diffusion (l'agent à attacher est ici l'agent qui peut récupérer le flux CBR) à
l'instant 0.6, le noeud 3 à l'instant 0.7, vous supprimerez le noeud 4 à l'instant 0.8 et le
remettrez à l'instant 0.9.
Vous étudierez une nouvelle fois le résultat sous NAM.

4. Un protocole plus probant : DM

DM pour Dense Mode est un autre protocole mis en oeuvre dans NS. Malheureusement, les
différentes implémentations dans NS, ne simulent pas les envois de paquet pour initialiser le réseau
et le routage. un algorithme est effectué, mais nous ne pouvons que visualiser le résultat.
Rexécuter le programme précédent en changeant le protocole et visualiser le résultat sous NAM.

5. L'algorithme de routage par arbre recouvrant

Nous allons apprendre un troisième protocole : CtrMcast. Cette fois, pour atteindre toutes les
machines (dans la phase d'initialisation pour connaître les machines), l'algorithme mis en place est un
algorithme de routage par arbre recouvrant. Malheureusement, une nouvelle fois, NS effectue le
calcul de manière transparente et aucun paquet de signalisation n'est simulé. Nous ne pouvons que
visualiser le résultat. La manière de déclarer le protocole est ici légèrement plus complexe : la
méthode mrtproto appliqué avec CtrMcast renvoit un objet en argument (on pourra récupérer cet
argument en effectuant un set) qui contient entre autre la méthode set_c_rp. Set_c_rp permet
d'effectuer le calcul qui va engendrer l'arbre recouvrant.set_c_rp prend une liste comme argument,
cette liste contient tous les noeuds susceptibles d'être RP (ou Rendez-vous Point, cad le noeud racine
de l'arbre).
En prenant les mêmes évenements que pour les questions précédentes, visualisez le résultat sous
NAM lorsque le noeud 2 est RP, puis le neoud 4.

6. Multicast avec routage dynamique

Seul le protocole DM que nous avons étudié à la question 4 permet de faire du routage dynamique.
La version de DM implémenté dans NS qui simule ce mode est appelé dynamicDM.
Vous créerez un fichier en utilisant du routage dynamique, et le protocole de Multicast appelé
dynamicDM, vous rajouterez deux évènements en plus des évènements déjà présents : le lien entre
le noeud 1 et le noeud 3 va tomber puis se remettre aux instants 1.2 et 1.5. Une nouvelle fois,
visualisez le résultat...

Fichier nam du TP :
tp3_3.nam correspond au fichier nam de la question 3 (qui permet aussi de visualiser les
questions précédentes)
tp3_5.nam correspond au fichier nam de la question 5
tp3_6.nam correspond au fichier nam de la question 6.

[TP précédent] [TP suivant] [Retour à la page d'accueil]

 
 TP4 : modélisation d'un réseau plus
complexe

Nous allons, pour ce dernier TP, réaliser un réseau plus complexe et simuler trois flux FTP
qui vont devoir se partager la bande passante. Nous allons ensuite visualiser le résultat à l'aide
de graphes.

Vous devrez d'abord contruire la topologie suivante (vous pouvez utiliser le convertisseur)
(chaque lien aura la même capacité):

Cette topologie peut simuler différents LANs reliés entre eux par un "backbone". (Ce
backbone devrait permettre des débits plus élevés pour être réaliste, mais il faudrait alors
générer de nombreux flux pour obtenir quelque chose d'exploitable).

Pour simuler les congestions, nous utiliserons les files d'attente de chaque noeud. Pour cela,
vous mettrez deux lignes supplémentaires pour configurer ces iles d'attente que nous
choisissons toujours avec une politique de service FIFO.

$ns queue-limit $n0 $n1 10

$ns duplex-link-op $n0 $n1 queuePos 0.25

La première ligne indique la taille de la mémoire en nombre de paquets pouvant être en

attente dans le noeud.
La deuxième ligne indique la position de la file d'attente dans le fichier de visualisation (cette
ligne n'a aucun intérêt pour ns). 0.25 signifie un huitieme de tour en partant de l'horizontale
(c'est un nombre en radians).
Il faut donc rajouter ces deux lignes après avoir défini les quatre liens centraux.

Nous allons faire tomber des liens, donc nous allons utiliser le protocole DV pour le routage
dynamique.

Vous définirez quatre connexions FTP entre 6 et 9, puis entre 7 et 4 et enfin entre 8 et 5.
(Penser à appliquer trois couleurs différentes aux connexions)
Pour visualiser le trafic, nous pourrons utiliser les variables d'état de chaque connexion tcp
"ack_" qui donne le numéro le plus élevé des paquets acquittés. Pour construire les fichiers de
trace, nous définirons une fonction traceack :

proc traceack {} {
    global tcp ackt
    set ns [Simulator instance]
    set time 0.01
    set now [$ns now]
    puts $ackt "$now [$tcp set ack_]"
    $ns at [expr $now+$time] "traceack"
    }

Ns va écrire dans le fichier défini par la variable ackt (fichier que nous avons   préalablement
ouvert en écriture) toutes les 10 ms le temps plus le nombre de paquet acquitté par le flux
nommé tcp. Il faut la lancer manuellement la première fois par la ligne habituelle :

$ns at 0.0 "traceack"

Vous améliorerez cette fonction pour faire la trace des trois flux FTP dans trois fichiers
différents.

Pour visualiser les traces, vous pourrez utiliser le logiciel GNUplot (par exemple).

Enfin, vous lancerez le premier FTP à l'instant 0.3, le deuxième à 0.5, le troisième à 1.0.
Vous ferez tomber le lien du noeud 0 au noeud 3 à l'instant 2.0 et remettrez en marche le lien
à l'instant 2.5.

Voici le fichier nam de la simulation, ainsi que les trois fichiers de trace : ackt1, ackt2 et ackt3

[TP précédent] [Retour à la page d'accueil]

Utilisation du Convertisseur
Téléchargez ici convertisseur.c ou bien le programme convertisseur compilé pour Unix.
Le Convertisseur permet de créer une topologie utilisable pour NSet NAM de façon très
simple. Il prend en entrée un fichier texte contenant la matrice du réseau et renvoit un fichier
contenant l'ossature du fichier pour NS avec la procédure de fin, la déclaration des fichiers
traces etc...

1. Exemple d'utilisation

Le format du fichier texte d'entrée est la suivante :

4
0 0 1 1 1 2 0 0
0 0 0 0 0 0 1 1
0 0 0 0 0 0 2 2

le premier nombre est le nombre de noeud du réseau, la matrice contient les liens du réseau.
Par exemple, ici, le noeud 0 a un lien vers le noeud 1 et le noeud 2, les noeuds 1 et 2 ont un
lien vers le noeud 3.

Code créé :
set ns [new Simulator]
set f [open out.tr w]
$ns trace-all $f
set nf [open out.nam w]
$ns namtrace-all $nf

set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

$ns duplex-link $n0 $n1 1.000000Mb 1ms DropTail

$ns duplex-link $n0 $n2 2.000000Mb 1ms DropTail
$ns duplex-link $n1 $n3 1.000000Mb 1ms DropTail
$ns duplex-link $n2 $n3 2.000000Mb 2ms DropTail

$ns at 5.0 "finish"

proc finish {} {
global ns f nf
$ns flush-trace
close $f
close $nf
exit 0
}

$ns run
Et la topologie obtenue est :

Convertisseur prend deux arguments : le nom du fichier texte dans lequel se trouve la matrice
du réseau, et le nom du fichier dans lequel écrire le source pour ns.

2. Remarques

 Le convertisseur ne fait que des liens duplex, il ne tient pas compte du triangle inférieur de la
matrice. (une version future pourra prendre en compte les liens simplex)
 Attention, le fichier de sortie pour nam est par défaut out.nam, il faut penser à le renommer.
 Le débit du lien peut être conservé en flottant, le temps de propagation est par contre
forcément conservé en entier.

# include <stdio.h>
# include <stdlib.h>

// format du fichier … lire : nombre de noeud puis la matrice [aij] avec

aij
// form‚ de deux nombres : le d‚lai en ms et le debit en Mb. seuls les
‚l‚ments
// avec i<j sont pris en compte. (lien duplex uniquement)

void main (int argc, char *argv[])

{
int n,i,j,delay;
float bandwidth;
FILE *data,*tcl;
if (argc != 3)
{
printf("utilisation : %s fichier_d'entree fichier_de_sortie",
argv[0]);
exit(2);
}
data=fopen(argv[1],"r");
if (!data)
{
printf("Le fichier %s n'a pas ete trouve ou n'a pas pu etre
ouvert\n",argv[1]);
exit(9);
}
tcl=fopen(argv[2],"w");
if (!tcl)
{
printf("Le fichier %s n'a pas pu etre ouvert en
ecriture\n",argv[2]);
 exit(9);
}
fprintf(tcl,"set ns [new Simulator]\n\n");
fprintf(tcl,"set f [open out.tr w]\n");
fprintf(tcl,"$ns trace-all $f\n");
fprintf(tcl,"set nf [open out.nam w]\n");
fprintf(tcl,"$ns namtrace-all $nf\n\n");
fscanf(data,"%d",&n);
for (i=0;i<n;i++)
fprintf(tcl,"set n%d [$ns node]\n", i);
fprintf(tcl,"\n");
for (i=0;i<n-1;i++)
{
for (j=0;j<n;j++)
{
fscanf(data,"%d",&delay);
fscanf(data,"%f",&bandwidth);
if ((i<j)&&(bandwidth!=0))
fprintf(tcl,"$ns duplex-link $n%d $n%d %fMb
%dms DropTail\n",i,j,bandwidth,delay);
}
}
fclose(data);
fprintf(tcl,"$ns at 5.0 \"finish\"\n\n");
fprintf(tcl,"proc finish {} {\n");
fprintf(tcl,"global ns f nf\n");
fprintf(tcl,"$ns flush-trace\n");
fprintf(tcl,"close $f\n");
fprintf(tcl,"close $nf\n");
fprintf(tcl,"exit 0\n");
fprintf(tcl,"}\n\n");
fprintf(tcl,"$ns run");
fclose(tcl);
}