1

Année Universitaire 2011/2012

Matière : Protocoles des réseaux mobiles

Filière : RT4

TP : Démarrer avec NsTP : Démarrer avec NsTP : Démarrer avec NsTP : Démarrer avec Ns----2222

Dans ce TP, il s'agit de se familiariser avec le simulateur de réseaux NS2 qui est un outil

qui permet d’étudier le comportement de différents réseaux de transmission de données

(mode paquet) filaires ou sans fils. Il permet de modéliser les réseaux et d’évaluer leurs

performances. Pour le faire, dans ce TP ,qui est une initiation à l’utilisation de NS2, nous

allons étudier le comportement des protocoles TCP et UDP en utilisant le simulateur

NS2. C’est un simulateur (disponible à partir des ressources), qui utilise un langage

simple pour la description physique et comportementale des réseaux. Pour plus

d'informations sur NS2, cf : http://www.isi.edu/nsnam/ns ou le tutorial :

http://www.isi.edu/nsnam/ns/tutorial/ (toutefois, ces liens ne devraient pas être d'une

utilité primordiale pour ce TP). Pour visualiser vos courbes, vous pouvez utiliser Excel,

Matlab, ou gnuplot. IIII---- Présentat Présentat Présentat Présentation de NSion de NSion de NSion de NS----2222

NS est un logiciel de simulation de réseaux informatiques développé lors d'un projet

de la DARPA. Il est principalement bâti avec les idées de la conception par objets, de

réutilisabilité du code et de modularité. Il est devenu aujourd'hui un standard de

référence en ce domaine. C'est un logiciel dans le domaine public disponible sur

Internet. Son utilisation est gratuite. Le logiciel est exécutable tant sous Unix que

sous Windows. Le Simulateur se compose d'une interface de programmation en tcl et

d'un noyau écrit en C++ dans lequel la plupart des protocoles réseaux ont été

implémentés :

� TraficTraficTraficTrafic Pareto, ON/OFF, CBR, FTP, telnet, etc.

� Couche TransportCouche TransportCouche TransportCouche Transport TCP, UDP

� Couche RéseauxCouche RéseauxCouche RéseauxCouche Réseaux IP, routage dans les réseaux ad hoc (aodv, dsr , dsdv, tora,

amodv), routage dans les réseaux filaire (Link state, Distance vector), les

réseaux multicast, IntServ, DiffServ

� Couche MACCouche MACCouche MACCouche MAC CSMA, CDMA, 802,X, Token ring, MPLS, liens satellites, etc.

2

La méthode de simulation à suivre est présentée dans la figure suivante :

NS-2 est un logiciel de simulation de réseaux informatique développé lors d'un projet

de la DARPA.

1.1 Le langage de script TCL

Le langage TCL est un langage de script puissant qui permet d’utiliser éventuellement

une approche de programmation orienté objet. Il est facilement extensible par un certain

nombre de modules. Dans notre cas, il est indispensable d’utiliser le langage TCL pour

pouvoir travailler avec les objets fournis par NS-2.

II. Installer NsII. Installer NsII. Installer NsII. Installer Ns----2222

La version de NS-2 la plus à jour actuellement est la version 2.34 disponible en

http://www.isi.edu/nsnsam/ns/ mais pour plus de confort pour l'utilisateur il est

conseillé d'installer la version all-in-one. La version all-in-one regroupe tous les

utilitaires et les plugin nécessaire à la compilation et au fonctionnement de NS.

IIIIIIIIIIII---- Premiers pas avec NS2 Premiers pas avec NS2 Premiers pas avec NS2 Premiers pas avec NS2

3.1. Commenter et exécuter le script tcl suivant : 3.1. Commenter et exécuter le script tcl suivant : 3.1. Commenter et exécuter le script tcl suivant : 3.1. Commenter et exécuter le script tcl suivant :

# Ecrire une procédure appelée "test"

proc test {} {

set a 43

3

set b 27

set c [expr $a + $b]

set d [expr [expr $a - $b] * $c]

for {set k 0} {$k < 10} {incr k} {

if {$k < 5} {

puts "k < 5, pow = [expr pow($d, $k)]"

} else {

puts "k >= 5, mod = [expr $d % $k]"

}

}

}

# Appeler la procédure "test" crée ci-dessus

test

Pour exécuter ce programme taper : tcl <file-name>.tcl ou ns <file-name>

3.2. Première simulation Ns3.2. Première simulation Ns3.2. Première simulation Ns3.2. Première simulation Ns----2222

AAAA---- Utilisation du protocole UDP Utilisation du protocole UDP Utilisation du protocole UDP Utilisation du protocole UDP

Cet exemple est une simple simulation d’un réseau minimal constitué de deux stations

communiquant l’une avec l’autre via une liaison spécialisée.

Dans la terminologie NS, ce que nous appelons machine s’appelle un noeud. Un noeud

peut contenir des agents qui représentent des comportements, par exemple des

applications. Une bibliothèque assez complète de composants existe de façon standard.

Une propriété intéressante de ce système est son extensibilité. En effet, il est assez facile

d’étendre la bibliothèque des comportements, des types de liens, ou de tout autre

élément du système en programmant ses propres extensions qui deviennent alors

intégrées au système. Pour traiter ce premier cas, nous allons donc écrire un programme

4

simple. En voici le contenu. Les commentaires (introduits par le caractère #) expliquent

le rôle de chaque instruction ou partie de programme.

# création d'un simulateur

set ns [new Simulator]

# création du fichier de trace utilisé par l’afficheur et indication à ns de l'utiliser

set nf [open out.nam w]

$ns namtrace-all $nf

# lorsque la simulation sera terminée, cette procédure est appelée pour lancer

automatiquement l’afficheur

proc finish {} {

global ns nf

$ns flush-trace

close $nf

exec nam out.nam &

exit 0

}

# création de deux noeuds

set n0 [$ns node]

set n1 [$ns node]

# création d'une ligne de communication full duplex entre les noeuds n0 et n1

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

# création d'un agent UDP implanté dans n0

set udp0 [new Agent/UDP]

$ns attach-agent $n0 $udp0

# création d'un trafic CBR pour le nœud 0 générateur de paquets à vitesse

constante paquets de 500 octets, générés toutes les 5 ms. Ce trafic est attaché au

udp0

set cbr0 [new Application/Traffic/CBR]

$cbr0 set packetSize_ 500

$cbr0 set interval_ 0.005

$cbr0 attach-agent $udp0

5

# création d'un agent vide, destiné à recevoir les paquets implanté dans n1

set null0 [new Agent/Null]

$ns attach-agent $n1 $null0

# le trafic issus de l'agent udp0 est envoyé vers null0

$ns connect $udp0 $null0

# scénario de début et de fin de génération des paquets par cbr0

$ns at 0.5 "$cbr0 start"

$ns at 4.5 "$cbr0 stop"

# la simulation va durer 5 secondes de temps simulé

$ns at 5.0 "finish"

# début de la simulation

$ns run

Lors de cette simulation, les résultats sont consignés dans un fichier de trace que l’outil

de visualisation nam va permettre de traiter. Dans notre programme, l’outil de

visualisation est appelé directement à la fin de la simulation. Deux éléments intéressants

sont proposés à la visualisation : un dessin de la topologie du réseau étudié, et une

visualisation dynamique du déroulement du programme dans le temps.

B- Utilisation du protocole TCP

Afin de vous familiariser avec ce langage, nous avons détaillé le script correspondant au

fichier fenetre.tcl. L'exécution de NS présente une interface où vous pouvez taper une

suite de commandes interprétées. Vous devez taper source fenetre.tcl pour simuler le

réseau décrit par le script fenetre.tcl.

# Les instructions suivies du caractère # sont des commentaires

# Initialisation du simulateur

set ns [new Simulator]

# Création de fichiers de traces

set ftrace [open fout.tr w]

set nf [open out.nam w]

6

# traces animées

$ns namtrace-all $nf

# Procédure fermant les fichiers de traces

proc finish {} {

global ns ftrace nf

$ns flush-trace

close $nf

close $ftrace

exit 0

}

# Procédure permettant d'obtenir la taille de la fenêtre de congestion

# toutes les 0.01s

proc tracefenetre {} {

global tcp0 ftrace

set ns [Simulator instance]

set time 0.01

set now [$ns now]

puts $ftrace "$now [$tcp0 set cwnd_]"

$ns at [expr $now+$time] "tracefenetre"

}

# Initialisation de certains paramètres TCP

# Taille des paquets TCP, en octets

Agent/TCP set packetSize_ 1500

# Taille maximale de la fenêtre de congestion, en paquets

Agent/TCP set maxcwnd_ 30

Agent/TCPSink/DelAck set interval_ 0.00001

# Création du noeud n0 et de ses caractéristiques

# les connexions TCP étant unidirectionnelles, il y a une source et un puits par

connexion

# Création du noeud n0

set n0 [$ns node]

# Création de la couche TCP (agent TCP), côté source

set tcp0 [new Agent/TCP]

# Attachement de la couche TCP au noeud

$ns attach-agent $n0 $tcp0

# Création de la couche applicative FTP

7

set ftp [new Application/FTP]

# Attachement de la couche applicative à la couche TCP

$ftp attach-agent $tcp0

# Création du noeud n1

set n1 [$ns node]

# Création de la couche TCP, côté puits

set tcp1 [new Agent/TCPSink/DelAck]

# Attachement de la couche TCP au noeud

$ns attach-agent $n1 $tcp1

# Création du lien point à point bidirectionnel entre les deux noeuds

# Le débit du lien est de 10Mb/s et le délai de propagation est de 10ms

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

# Création de la connexion entre les deux couches TCP

$ns connect $tcp0 $tcp1

# Départ de la source FTP à la date 0.0 s

$ns at 0.0 "$ftp start""

# Arrêt de la source FTP à la date 0.7 s

$ns at 0.7 "$ftp stop"

# Exécution de la procédure tracefenetre

$ns at 0.0 "tracefenetre"

# Exécution de la procédure finish à la date 0.8 s

$ns at 0.8 "finish"

# Exécution de la simulation

$ns run

Décrire la topologie simulée par le script fenetre.tcl ci-dessus. Interpréter les résultats de

simulations

3.3. Écrire et tester le code correspondant à ce modèle de réseau

8

� Le noeud n0 génère un traffic UDP de type CBR vers le noeud n3. Un

paquet de taille 500 octets est envoyé vers le noeud n3 chaque 0,005s.

� Le noeud n1 génère un traffic UDP de type CBR vers le noeud n3. Un

paquet de taille 500 octets est envoyé vers le noeud n3 chaque 0,005s.

Pour séparer les flux au niveau de nam, on peut rajouter le code suivant.

$udp0 set class_ 1

$udp1 set class_ 2

$ns color 1 Blue

$ns color 2 Red

• Changer la méthode de gestion des files d'attente . Vous remarquez

quoi?

• Changer le code pour avoir des pertes uniquement au niveau des

sources.

3.4. Exercice

Afin d'étudier le comportement du partage des ressources de TCP, nous allons simuler le

réseau représenté dans la figure ci-après. Il est constitué de 4 stations (A, A', B et B')

reliés par un lien à 10 Mb/s. Les délais de propagation séparant les stations au lien sont

négligeables, par contre le délai de propagation sur le lien est de 4 ms. Dans cette

configuration, la ressource partagée est le lien principal.

9

1) À la date t = 0 s, une connexion TCP est ouverte entre A et B pour transporter un

flux FTP continu. Ensuite, une connexion TCP est ouverte entre A' et B' pour

transporter un flux FTP qui stoppera avant la fin de simulation (la durée totale de

simulation est de 10 s). Simulez ce réseau en s’inspirant du fichier fenetre.tcl que

vous devrez modifier.

2) Visualisez le comportement de cette topologie avec le NAM

3) Quelles sont les modifications à introduire à ce dernier script si on compte utiliser

un agent UDP