Introduction à l'utilisation du simulateur ns

Ce document constitue une introduction au simulateur ns dont l'utilisation permettra de réaliser les travaux pratiques du cours "Structure des réseaux informatiques et multimédia"".

Les travaux seront effectués à l'aide du simulateur ns. Ce simulateur a été conçu pour la recherche dans l'environnement Internet. Donc les simulations concernant ATM n'y sont pas disponibles. Les résultats des simulations ns peuvent être visualisés à l'aide de l'outil d'animation nam, ainsi que des programmes tels que xgraph ou gnuplot pour les graphiques.

Ns et nam sont installés sur le réseau 8 sur moon. Il vous suffit sous tcsh de faire un source /app/NS-simulator/.tcshrc-ns pour mettre à jour vos variables d'environnement.
Gnuplot remplace xgraph qui n'est pas disponible.

Ils sont également installés sur le serveur ms800 et sont donc disponibles sur les nouvelles machines. Il faut faire sous tcsh un source /usr/server/net-sim/.tcshrc-ns.

Ensuite ns se lance en tapant ns et nam se lance en tapant nam -a ce_que_vous_voulez nam_file.
L'option -a fait que nam crée une nouvelle instance et donc évite de se connecter à une instance déjà existante, ce qui avait pour effet de faire apparaître votre fenêtre nam sur l'écran de quelqu'un d'autre. Le numero de port utilisé par nam pour une machine donnée est dans le fichier ~/.nam-port.

Documentation sur ns et tcl

Comme pour la plupart des logiciels libres, la meilleure documentation sur ns est son propre source code en C++ et tcl... Cependant, pour les débutants, mieux vaut commencer par le tutoriel de Marc Greis (en anglais). Celui-ci possèdent de nombreux liens vers des documentations supplémentaires. Pour ceux qui préfèrent un tutoriel en français, le TP de Romain VINOT et Vu Anh NGUYEN peut être utile.

Le développement de ns suit une approche orientée objet où deux languages 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 ces 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. Une connaissance moyenne de tcl est pourtant indispensable.

Voici quelques liens utiles:

Un manuel de référence sur ns est aussi disponible, pour ceux qui souhaitent mieux connaître le simulateur et son fonctionnement interne. Attention: ce document n'est pas forcément à jour (même si la dernière version date d'hier) et est loin d'être un tutoriel.

Indications pratiques pour les TPs

Voici une procedure qui permet de créer une source CBR (Constant Bit Rate), de spécifier le moment à partir duquel elle va commencer à émettre ses paquets à raison d'un paquet toutes les interval secondes, et de la lier à un agent (UDP pour bien faire).

proc build_cbr { agent_from agent_to packet_size startTime interval } {
        global ns
        set src [new Application/Traffic/CBR]
        $src set packet_size_ $packet_size
        $src set rate_ [expr $packet_size * 8 / [$ns delay_parse $interval]] 
        $src attach-agent $agent_from
        $ns at $startTime "$src start"
        return $src
}

Il est possible de modifier le débit d'une source (ici CBR) pendant la simulation. La procédure suivante en est un exemple. Il existe cependant la subtilité suivante: si la source émet avec une période T et que vous désirez la faire émettre avec une période T' à partir du temps t, la modification ne deviendra effective qu'en x+T où x<=t est le moment d'émission d'un paquet le plus proche de t avec l'ancien débit. Ceci parce que les valeurs des variables ne sont "rafraîchies" que lors de l'émission d'un paquet.

proc modify_rate_interval { src starttime endtime interval } {
    global ns
    set old_rate [$src set rate_]
#    set old_interval [$src set interval_]
#    $ns at $starttime "$src set interval_ $interval"
    $ns at $starttime "$src set rate_ [expr [$src set packet_size_] * 8 / [$ns delay_parse $interval]]"
    if {[string compare [string index $endtime 0] "+"] == 0} {
	$ns at [expr $starttime + [$ns delay_parse [string range $endtime 1 end]]] "$src set rate_ $old_rate"
    } else {
	$ns at $endtime "$src set rate_ $old_rate"
#    $ns at $endtime "$src set interval_ $old_interval"
    }
}

Les # indiquent une alternative pour changer le débit.

Vous pouvez fixer la valeur de certaines constantes telle que:
- La taille des files d'attente de manière globale, par exemple à 15, en écrivant Queue set limit_ 15
- La taille d'une file d'attente (de manière locale), par exemple à 20, en écrivant $ns queue-limit $node0 $node3 20
Il est utile de s'inspirer des exemples fournis avec ns càd dans le répertoire
/app/NS-simulator/ns-2.1b6/tcl/ex
L'étude de variables telles que le délai, le débit ou le pourcentage de pertes peut se faire en analysant le fichier produit (c'est à vous de le demander) par l'exécution de la simulation et qui s'appelle typiquement out.tr. Une ligne de ce fichier a le format suivant:
<what> <time> <link source> <link dest> <name> <size> <flags> <flow id> <src node>.<port> <dest node>.<port> <sequence number> <unique id> où
- what est 'r' (le paquet est reçu), 'd' (le paquet est perdu), '+' (le paquet est entré dans la file) ou '-' (le paquet a quitté la file).
- flow id est l'identificateur de flux càd fid_.
- sequence number est un identificateur de paquet tel que la réémission d'un paquet contient le même numéro que le paquet initial.
- unique id est un identificateur unique de paquet.
Par exemple pour connaître le nombre de paquet TCP non dupliqués transmis sur le lien entre le noeud 0 et le noeud 3:
grep "\-\ .*\ 0\ 3\ tcp.*" out.tr | cut -d" " -f11 | sort -n | uniq | wc. Il est bien sûr possible de réaliser la même chose en Perl, en C (pattern matching dans la librairie gnu libc. Documentation en dvi et en postscript à /locapp/bin/NS-simulator/doc) ou en Tcl.
Pour "tracer" une variable càd suivre l'évolution des valeurs de la variable au cours du temps, il suffit d'adapter votre code de la manière suivante.
1. Au début de la simulation, vous ouvrez un fichier de trace en écriture:
  set grfile [open out.gr w]
2. Vous fixez l'intervalle d'échantillonage de la variable:
  set recinterval 0.01
3. Vous indiquez à ns qu'il doit exécuter la procédure record au début de la simulation:
  $ns at 0.0 "record"
4. A la fin de la simulation, il faut le fermer (typiquement dans la procédure finish):
  close $grfile
La procédure record est la suivante (à adapter selon vos besoins):
```
proc record {} {
    global ns grfile recinterval tcp
    set now [$ns now]
    puts $grfile "$now  [$tcp set window_] [$tcp set cwnd_]"
    $ns at [expr $now+$recinterval] "record"
}
      
```
Cet exemple est tiré du tutoriel de Marc Greis.

Presque

Ludovic Kuty, kuty@run.montefiore.ulg.ac.be.
Lidia Yamamoto, yamamoto@run.montefiore.ulg.ac.be.

Last modified: Wed Mar 21 11:05:03 CET 2001