TP ns2

‫الجمهورية التونسية‬ REPUBLIQUE TUNISIENNE
Ministère De L’Enseignement Supérieur

‫وزارة التعليم العالي‬ Direction Générale Des Etudes Technologiques
‫اإلدارة العامة للدراسات التكنولوجية‬ Institut Supérieur des Etudes Technologiques de
‫المعهد العالي للدراسات التكنولوجية بقابس‬ Gabes
Fascicule de Travaux Pratiques
Simulation de Réseaux Sous NS2

(Atelier Telecom 5.2)
Département STIC
Classe
RST (semestre 3)
Elaboré par :
Awatef BENFRADJ GUILOUFI
1
Avant propos
Ce fascicule de TP contient les différents travaux pratiques présentés pendant les séances de
l’atelier réseau 3 qui a pour objectif, au premier lieu, d’apprendre aux étudiants les notions de
base d’un réseau local d’après la manipulation de commandes réseau de base, câblage et
configuration matériel et logiciel. Et au deuxième lieu de comprendre le comportement de
quelques dispositifs réseau (concentrateur, commutateur) sous un simulateur.
NB :
 Les étudiants sont menus à rendre un compte rendue après chaque TP contenant les
réponses justifiées pour les questions posées dans les énoncés des TP, plus
l'interprétation des résultats obtenus après chaque manipe.
2
Table des matières
TP0: Prise en main de TCL pour NS2......................................................................................................................6

TP1 : Introduction au Simulateur Réseaux NS2.......................................................................................................9
TP 2 : Simulation d’un réseau filaire......................................................................................................................12
TP3 : Simulation de congestion dans un réseau......................................................................................................17
TP 4 : Topologie dynamique en anneau..................................................................................................................21
3
Présentation générale du TP
1. Introduction
Une formation en réseaux permettant à l’étudiant de maîtriser les notions théoriques et pratiques relatives aux
systèmes, protocoles et architectures des réseaux de communications. Ces notions incluent les architectures
protocolaires et protocoles de communications, les systèmes de transmission, et les notions pratiques de
configuration et d’administration des services et équipements réseaux. Le but est de préparer l’étudiant à la
compréhension des aspects théoriques et pratiques relatifs à la sécurisation des réseaux, et le former pour être
capable de déployer, superviser et administrer des réseaux de télécommunication.
Etablissement : Réseau Licence Appliquée x

Université : D.G.E.T
I.S.E.T Fondamentale
Domaine de Formation : Sciences et Technologie Mention STIC : Parcours RST
Unité Volume Horaire Semestriel
d’Enseigne Nature de Eléments Constitutifs
N°
ment L’UE (ECUE) C TD TP
UE
Réseaux d’Accès et de Transport 0.75 0.75
Télécoms
UE5.2 Fondamentale VoIP 0.75 0.75
5.2
Atelier télécoms 5.2 1.5
2. Objectifs des Travaux Pratiques
 Se familiariser avec le simulateur réseau NS

 Savoir écrire des scripts TCL
 Savoir dresser les courbes des paramètres QoS : débit, délai, gigue et taux de perte.
 Savoir évaluer les performances du réseau
3. 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.
4. L’outil de simulation NS-2
4
L’outil NS-2 fournit un ensemble d’objets TCL spécialement adaptés à la simulation de
réseaux. Avec les objets proposés par ce moteur de simulation, on peut représenter des
réseaux avec liens filaires ou sans fils, des machines et routeurs (Node), des flux TCP et UDP
(par exemple pour simuler un flux CBR1), et sélectionner les politiques et règles régissant les
files d’attentes mises en œuvre dans chacun des nœuds. 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 :
 Traffic parreto, ON/OFF, CBR, FTP, telnet, etc.
 Couche Transport TCP, UDP
 Couche 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 MAC CSMA, CDMA, 802,X, Token ring, MPLS, liens satéllite, etc.
La méthode de simulation à suivre est montrée dans la figure suivante :
Dans tous nos exemples, nous avons toujours simulé des flux UDP constants, car ils
permettent d’étudier les phénomènes de rejet de paquets sans encombrer le réseau. NS-2
permet en fait de garder la trace de la simulation, afin d' être traitée par un autre logiciel,
comme par exemple le NAM.
5
5. L’outil de visualisation NAM
NAM est un outil de visualisation qui a deux rôles principaux :
1. Présentation de la topologie du réseau qui a été décrit par NS-2,
2. Affichage des résultats du trace d’exécution NS-2.
A titre d'exemple, cet outil effectue la présentation des paquets de transport TCP ou UDP, la
rupture d’un lien entre nœuds, ou encore de représenter les paquets rejetés d’une file d’attente
pleine.
6
Matière :Atelier réseau 3 Classe : RST21/ RST 22
Enseignant :Awatef BENFRADJ Durée : 03 Heures
TP0
Prise en main de TCL pour NS2
Objectifs
 Comprendre un script TCL
 Traduire un programme C en TCL
 Réaliser une première application pour NS-2 et NAM
Travail demandé :
Exemple de script TCL commenté
Afin de prendre un premier contact efficace avec le langage de script TCL, qui permet de
manipuler les objets de simulation de NS2, nous avons étudié et commenté le script suivant :
# -- Définition d’une méthode appelée “test”
proc test {} {
# -- a vaut 43
set a 43
# -- b vaut 27
set b 27
# -- c vaut 27 + 43 = 70
set c [expr $a + $b]
# -- d vaut (43 – 27) * 70 = 16 * 70 = 1120
set d [expr [expr $a - $b] * $c]
# -- pour k allant de 0 à 10 exclu, on incrémente k à chaque boucle
for {set k 0} {$k < 10} {incr k} {
if {$k < 5} {
# -- si k vaut moins de 5 exclus, on affiche val. de d puissance k
puts "k < 5, pow = [expr pow($d, $k)]"
} else {
# -- si k est sup. ou égal à 5, on affiche val. de d modulo k
puts "k >= 5, mod = [expr $d % $k]"
}
}
}
# -- Appel de la méthode appellée “test”
test
L’exécution de ce script se fait, grâce à ns, en utilisant simplement la commande :

$ ns test.tcl
7
Le résultat commenté de l’exécution est le suivant, les lignes en rouge correspondant à des
commentaires :
# ns test.tcl
# d = 1120 puissance 0 vaut 1
k < 5, pow = 1.0
k < 5, pow = 1120.0
k < 5, pow = 1254400.0
# d = 1120 puissance 3 vaut 1404928000
k < 5, pow = 1404928000.0
# d = 1120 puissance 4 vaut 1573519360000
k < 5, pow = 1573519360000.0
# 1120 modulo 5 vaut 0 (1120/5 = 224 reste 0)
k >= 5, mod = 0
k >= 5, mod = 4
k >= 5, mod = 0
k >= 5, mod = 0
k >= 5, mod = 4
Ceci correspond bien au résultat attendu : la compréhension d’un script TCL est donc assez
intuitive et simple.
Entraînement au TCL par traduction d’un script C
Afin de nous familiariser plus avant avec le langage TCL, et pour découvrir sa simplicité
d’utilisation, nous avons réécrit le programme C suivant en TCL :
#include <stdio.h>
int main( int argc, char *argv[] ) {
int count = 20; /* The number of Fibonacci numbers to print */
int num[] = { 0, 1 }; /* First and second seed values */
int i;
printf( "The first %d Fibonacci numbers:\n", count );
for ( i = 1; i < count; i++ ) {
printf( "%d:\t%d\n", i, num[0] );
num[1] = num[0] + num[1];
i++;
printf( "%d:\t%d\n", i, num[1] );
num[0] = num[0] + num[1];
}
return 0;
}
Ce que nous avons traduit par le script TCL suivant. La traduction est faite ligne àligne :
l’algorithme n’a pas été modifié ni optimisé :
proc main {} {
set count 20
array set num {
0 0
1 1
}
8
puts "The first $count Finonacci numbers:\n"
for {set i 1} {$i < $count} {incr i} {
puts "$i:\t$num(0)"
set num(1) [expr ($num(0) + $num(1))]
incr i
puts "$i:\t$num(1)"
set num(0) [expr ($num(0) + $num(1))]
}
}
main
On notera, entre autre, qu’en TCL pour simuler un tableau il faut utiliser un dictionnaire (une
table de hachage), que la commande 'puts' permet d’insérer directement la valeur d'une
variable dans la chaîne qu’elle affiche sur la sortie standard, et qu’il existe une instruction
spécifique pour l’assignation d’une valeur à une variable (set) et pour l’incrément d’une
variable (incr). De plus, on remarque que les crochets sont utilisés pour extraire la valeur de
retour d’une instruction et pouvoir la passer directement comme paramètre d’une méthode.
Après ces quelques notions de TCL, nous avons découvert le fonctionnement de NS-2 et
NAM, qui permettent respectivement de fournir des objets TCL permettant de manipuler des
objets réseaux (ordinateur/routeur = Node, trafic réseau, files d’attente…) et de visualiser les
résultats d’une simulation NS-2 en montrant la topologie du réseau étudié, et les résultats des
calculs (transmission de paquets) sous forme de dessins.
9
TP1
Introduction au Simulateur Réseaux NS2
Objectif de TP
L'objectif de ce TP est l'apprentissage de l'utilisation du simulateur NS2. En particulier,

l'apprentissage du langage TCL , l'interprétation des résultats de simulation et la visualisation
des simulation avec l' outils nam.
Travail demandé:
Première simulation avec NS-2
A la première simulation, on désire découvrir les outil NS-2 NAM. Pour ce faire, le réseau
qui correspond à la figure suivante va être simulé :
En se basant sur la figure ci-dessus, il faut créer deux nœuds NS-2 (node), reliés par un lien
full duplex(duplex-link) ayant un débit de 1Mbps, un temps d’accès au medium est de10 ms.
Déclaration du scénario de simulation et les fichiers traces

 Création de l'instance de simulation
# Création d'un simulateur

set ns [new Simulator]
 création des fichiers de trace
# Création du fichier de trace utilisé par le visualisateur

set nf [open out.nam w]
# Indique à NS de logguer ses traces dans le fichier $nf (out.nam)
$ns namtrace-all $nf
# Lorsque la simulation sera terminée, cette procédure sera appelée
10
# pour lancer automatiquement le visualisateur (NAM)
proc finish {} {
# Force l'écriture dans le fichier des infos de trace
global ns nf
$ns flush-trace
close $nf
# Lance l'outil de visualisation nam
exec nam out.nam &
# Quitte le script TCL
exit 0
}
Définition des nœuds et des liens
Les lignes suivantes permettent de définir deux nœuds de « n0 » et « n1»

 Création de l'instance de simulation
# création de deux noeuds

set n0 [$ns node]
set n1 [$ns node]
 création du lien entre les deux nœuds
# Création d'une liaison de communication full duplex entre les noeuds n0 & n1
# Fonctionne à 1Mbps, 10ms de délai, et utilise l'algorithme de file DropTail
$ns duplex-link $n0 $n1 1Mb 10ms DropTail
Par la suite, il faut crée un agent UDP (Agent/UDP) lié au noeud n0 (attachagent). Il permet
au nœud n0 de transférer des paquets UDP.
Puis, il faut réaliser l'envoi des paquets avec un débit constant (Constant Bit Rate –
CBRApplication/Traffic/CBR) lié à l’agent UDP.
# création d'un agent UDP implanté dans n0

set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
Ensuite, il faut concevoir un agent vide qui permet de recevoir des paquets TCP ou UDP sans
traitement.
L’agent UDP va être connecté à l’agent vide (connect).
Enfin, il faut indiquer que les traces de simulation doivent être loguées, que le NAM est lancé
à la fin de la simulation, que cette procédure dure 5s et que le CBR sera émis entre 0.5ms et
4.5ms.
# Création d'un agent vide, destiné à recevoir les paquets dans le noeud n1
set null0 [new Agent/Null]
11
$ns attach-agent $n1 $null0
# Le trafic issu de l'agent udp0 est envoyé vers null0
$ns connect $udp0 $null0
# Début de l'envoi du CBR à 0.5s après le début de la simulation
$ns at 0.5 "$cbr0 start"
# Fin de l'envoi du CBR à 4.5s après la fin de la simulation
# Création d'un traffic CBR pour le noeud 0 générateur de paquets à vitesse
constante
# Paquets de 500 octets (4000 bits), générés toutes les 5 ms.
# ---> Ceci représente un trafic de 800 000 bps (inférieur à la capacité du
lien)
set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
# Ce traffic est attaché à l'agent UDP udp0
$cbr0 attach-agent $udp0
# Création d'un agent vide, destiné à recevoir les paquets dans le noeud n1
# Le trafic issu de l'agent udp0 est envoyé vers null0
# Début de l'envoi du CBR à 0.5s après le début de la simulation
# Fin de l'envoi du CBR à 4.5s après la fin de la simulation
$ns at 4.5 "$cbr0 stop"
# La simulation s'arrête après 5 secondes, et appelle la procédure
# TCL nommée "finish" définie précédemment
$ns at 5.0 "finish"
 lancement de la simulation
# Démarrage du moteur de simulation

$ns run
 Il est également possible de choisir différentes couleurs pour les paquets
$udp0 set class_ 1

$ns color 1 red
Une fois la définition du scénario de simulation est termine, la simulation doit être exécutée à
l’aide de la commande « ns nomscenario.tcl ». Ce qui donne le résultat suivant :

12
TP 2
Simulation d’un réseau filaire

Objectifs
Ce TP a pour but de prendre en main l’utilisation de NS2 en particulier la définition du
scénario de simulation avec le script TCL ainsi que l’interprétation des résultats de simulation
avec l’analyse des fichiers traces.
Travail demandé:
Simulation d’un réseau filaire (Ethernet)

Dans cette partie, nous souhaitons simuler la topologie réseau suivante :
Déclaration du scénario de simulation et les fichiers traces :
Définir la durée de simulation :
13
Pour terminer la simulation, il suffit d’ajouter la durée de simulation (par exemple 110s)
comme suit :
Définition des nœuds et des liens :

Les lignes suivantes permettent de définir six noeuds de « n0 » jusqu’à « n5 »
Définition d’un lien de communication bidirectionnel :
Où duplex-link indique que le lien est bidirectionnel et pour utiliser un lien directionnel il
suffit de remplacer cette option par « simplex-link ». De plus, 10 ms représente le délai de
propagation et 10 Mb la capacité du lien de communication.
Dans NS2, la sortie de la file d’attente du nœud est conçue comme partie intégrante du lien de
communication. Par conséquent, la déclaration du lien, nécessite de définir la méthode utilisée
pour la gestion de la file d’attente. Dans cet exemple, nous avons utilisé. L’option « DropTail
» qui consiste à supprimer tous les paquets en cas de débordement de la file. Il existe d’autres
mécanismes de gestion de la file sur NS2 comme : RED (Random Early Discard), FQ (Fair
Queuing), DRR (Deficit Round Robin), SFQ (Stochastic Fair Queuing), etc.
La taille du buffer de la file est par défaut fixée à 50. Cependant, nous pouvons attribuer une
autre valeur comme suit :
Remarque :Toutes les valeurs par défaut sous NS2 sont déclarées dans le fichier nommé «ns-
default.tcl». La déclaration de tous les liens de la topologie réseau définis dans la figure
précédente estcomme suit :
14
Définition des agents et des applications :
Une fois que nous avons défini la topologie du réseau, nous allons définir le type du trafic
réseauet les applications réseau associées. Nous utilisons deux applications : FTP (File
TransfertProtocol) entre les nœuds n0 et n4, CBR (Constant Bit Rate) entre les nœuds n1 et
n5. Le protocole utilisé par l’application FTP est le protocole TCP, mais celui qui est utilisé
parl’application CBR est UDP.
Tout d’abord, il faut créer un agent pour chaque protocole TCP et UDP. Ensuite, il faut
associerles applications aux agents appropriés.
Programmer le lancement des applications :
15
Dans la définition du scénario, nous allons définir quand les événements se déclenchent.
Dansnotre exemple, il faut indiquer quand les applications FTP et CBR se lancent et se
terminent.
Une fois que nous avons terminé la définition du scénario de simulation, nous exécutons
lasimulation à l’aide de la commande « ns nomscenario.tcl ».

TP3
Simulation de congestion dans un réseau
Objectifs
Pour simuler une congestion dans un réseau, nous avons réalisé un montage correspondant au
diagramme suivant :
16
Gestion FIFO
Etant donné deux nœuds qui envoient un CBR de 800 000 bps, à destination d'un nœud
écoutant ces deux CBR, et passant par routeur ou commutateur dont les trois nœuds sont
connectés.
Pour ce scénario, la congestion va se faire entre le routeur/commutateur et le nœud
destination, parceque le lien est limité à 1 Mbps mais la somme des CBR transmis à la
destination est de l'ordre de 1 600 Kbps. Nous supposons que les deux équipements
commencent la transmission en même temps, et nous essayons d'observer le comportement du
nœud de commutation à ce moment. Le script que nous avons mis en place est décrit et
commenté comme suit :
# Création du simulateur
# Création du fichier de traces NS-2
# 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]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
# Création des liens, tous en 1Mbps/10ms de TR/file d'attente DropTail
# Création de deux agents implantés dans n0 et n1
17
# Traffic CBR de 500 octets toutes les 5 ms pour UDP0
# Traffic CBR de 500 octets toutes les 5 ms pour UDP1
# Création d'un agent vide, destiné à recevoir les paquets implanté dans n1
# Le trafic issus des agents udp0 et udp1 est envoyé vers null0
# Scénario de début et de fin de génération des paquets par cbr0
# La simulation va durer 5 secondes et appeller la proc finish
$ns at 5.0 "finish"
# Definition de classes pour la coloration
$udp0 set class_ 1
$udp1 set class_ 2
# Coloration des classes : bleu pour udp0 (classe 1) et rouge pour udp1
(classe 2)
$ns color 1 Blue
$ns color 2 Red
# début de la simulation
$ns run
L’ensemble des files d’attente des liens sont des FIFO, ce qu’il est important de noter à ce
moment. Lorsque nous exécutons la simulation, nous obtenons un résultat proche du suivant :
Le lien qui relie les deux nœuds 2 et 3 vient d'être saturé à partir du moment où la quantité de
données à transmettre est très supérieure à la taille du lien. Etant donné que la file est de type
18
FIFO, alors, les premiers paquets arrivés seront servis les premiers. Avant la saturation, la
transmission des paquets arrivant au nœud 2 de la part des nœud 0 et 1 se réalise d'une
manière équitable.
Lorsque la file d’attente est saturée, 37,5% des paquets sont rejetés. En effet, ce sont les
paquets de la part du nœud 1 qui sont rejetés, de l'ordre de 75% des paquets reçu. Avec la
procédure FIFO, toutes les données arrivant de la part du nœud 0 sont servis, tandis que le un
quart des données du nœud seulement sera transmis, et le trois quart des paquets émis est
perdu.
Gestion SFQ
Dans cette partie, nous allons remplacer la file d'attente par une SFQ (Stochastic Fairness
Queueing). Le SFQ est un algorithme de répartition équitable qui essaye de servir les paquets
reçus d'une manière équitable. Les lignes à modifier sont les suivantes :
Qu’on remplace par les lignes suivantes :

$ns duplex-link $n0 $n2 1Mb 10ms SFQ
Le résultat visuel de la simulation est le suivant :
Avec cette méthode, un paquet sur deux qui est rejeté, elle présente l’avantage d’être en effet
équitable : les deux flux ont la même priorité et sont acheminés dans les mêmes conditions, ce
qui permet d’avoir une transmission harmonieuse des données sur le réseau. Cependant, on
remarque que les disciplines de file d’attente utilisées précédemment ne permettent toujours
19
que de détecter la congestion au niveau du nœud 2 (routeur ou commutateur). L’inconvénient
de cette solution est qu’une partie de la bande passante utilisée sur les liens n0-n2 et n1-n2 est
perdue inutilement puisqu’un tiers des paquets sont jetés au niveau du nœud n2.
Par conséquent, nous avons souhaité identifier les pertes au niveau des émetteurs, pour
optimiser la consommation de bande passante globale sur le réseau. Pour cela, nous avons
tenté d’utiliser l’algorithme de discipline de file d’attente RED (Random Early Detection) sur
le lien reliant le noeud 2 au noeud 3. Toutefois, ceci n’a pas été concluant dans la mesure où
les pertes sont toujours identifiées seulement au niveau du noeud 2 : les noeuds 0 et 1
consomment toujours inutilement de la bande passante.
Pour pouvoir gérer les pertes au niveau de la source, il conviendrait d’utiliser plutôt un
algorithme de gestion de la QoS, externe à la discipline de files d’attentes. Toutefois, après
maintes recherches, aucune solution acceptable n’a été trouvée comme implantée en standard
dans NS-2 pour remplir cette fonction pour un flux UDP.

TP 4
Topologie dynamique en anneau
Objectif:
Travail demandé:
Afin d’étudier les protocoles de routage implantés dans NS-2, nous avons étudié le cas d’un
réseau en anneau correspondant au diagramme suivant :
20
Tous les liens sont d’égale longueur, et possèdent des caractéristiques similaires(temps
d’accès, vitesse de transmission, discipline de file d’attente).
L’objectif est de faire émettre un CBR depuis le noeud 0 et à destination du noeud 3,à
compter de la 2ème seconde et jusqu’à la 10ème seconde de simulation, et encoupant le lien
entre les noeuds 1 et 2 après 2 secondes de simulation, pendant 2secondes.
Le résultat que nous obtenons dans un premier temps est le suivant :
On remarque qu’en temps normal, les paquets émis par le noeud 0 à destination dunoeud 3
sont routés en passant par les liens 0-1, 1-2 et 2-3. Lors de la rupture de lienentre les noeuds 1
et 2, la route n’est pas recalculée, ce qui provoque la perte de tousles paquets émis durant la
rupture de lien, soit 2 secondes (400 paquets de 500octets).
En effet, par défaut, NS-2 utilise un algorithme de routage utilisant la proximité
pourdéterminer le plus court chemin, mais avec des tables de routage statiques. En casde
rupture d’un lien, la route vers le noeud 3 n’est pas recalculée.
21
# création d'un simulateur
# lorsque la simulation sera terminée, cette procédure est appelée pour lancer
automatiquement le visualisateur
proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}
# Creating network nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
set n6 [$ns node]
# Creating network links
# On tente de réduire la taille de la queue
#$ns queue-limit $n2 $n3 100
$ns duplex-link-op $n0 $n1 queuePos 0.5
# Création de deux agents implantés dans n0 et n1
# création d'un traffic 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 traffic est
attaché au udp0
# création d'un agent vide, destiné à recevoir les paquets implanté dans n1
set sink0 [new Agent/LossMonitor]
$ns attach-agent $n3 $sink0
# le trafic issus de l'agent udp0 est envoyé vers sink0
$ns connect $udp0 $sink0
# scénario de début et de fin de génération des paquets par cbr0
$ns rtmodel-at 2.0 down $n1 $n2
$ns rtmodel-at 4.0 up $n1 $n2
# la simulation va durer 10.5 secondes de temps simulé
$ns at 10.5 "finish"
$udp0 set class_ 1
$ns color 1 Orange
# début de la simulation
$ns run
22
Pour palier à ce phénomène, il est possible de préciser l’algorithme de routage quel’on
souhaite utiliser dans NS-2. Par exemple, on peut choisir l’algorithme de routagedynamique
Distance Vector (vecteur de distance) qui permet de déterminer le pluscourt chemin parmi les
liaisons disponibles.
Pour préciser l’algorithme de routage, il suffit d’ajouter la ligne suivante juste aprèsla création
du simulateur :
$ns rtproto DV
Par conséquent, quand le lien 1-2 est rompu, les paquets transitent par le nouveauchemin le
plus court : 0-6, 6-5, 5-4, 4-3 comme montré sur le diagramme ci-après.Les paquets perdus
sont ceux qui étaient déjà en train de transiter sur le lien 0-1, ouqui étaient déjà en file
d’attente pour l’envoi sur le lien 1-2 au moment de la rupturedu lien. Ce nombre est
sensiblement négligeable comparé aux 400 paquets perdusprécédemment.
De plus, une fois le lien rétabli, l’algorithme de routage DV est capable de recalculerla route
la plus courte, et les paquets sont de nouveau transmis par les liens 0-1, 1-2et 2-3.
23

TP ns2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP ns2

Transféré par

Droits d'auteur :

Formats disponibles

‫الجمهورية التونسية‬ REPUBLIQUE TUNISIENNE

Ministère De L’Enseignement Supérieur

Fascicule de Travaux Pratiques

Simulation de Réseaux Sous NS2

Awatef BENFRADJ GUILOUFI

TP0: Prise en main de TCL pour NS2......................................................................................................................6

Etablissement : Réseau Licence Appliquée x

2. Objectifs des Travaux Pratiques

 Se familiariser avec le simulateur réseau NS

3. Le langage de script TCL

 Traffic parreto, ON/OFF, CBR, FTP, telnet, etc.

 Couche Transport TCP, UDP

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

Prise en main de TCL pour NS2

L’exécution de ce script se fait, grâce à ns, en utilisant simplement la commande :

Introduction au Simulateur Réseaux NS2

L'objectif de ce TP est l'apprentissage de l'utilisation du simulateur NS2. En particulier,

Déclaration du scénario de simulation et les fichiers traces

# Création d'un simulateur

 création des fichiers de trace

# Création du fichier de trace utilisé par le visualisateur

Définition des nœuds et des liens

Les lignes suivantes permettent de définir deux nœuds de « n0 » et « n1»

# création de deux noeuds

 création du lien entre les deux nœuds

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

# Démarrage du moteur de simulation

 Il est également possible de choisir différentes couleurs pour les paquets

$udp0 set class_ 1

Matière :Atelier réseau 3 Classe : RST21/ RST 22

Simulation d’un réseau filaire

Simulation d’un réseau filaire (Ethernet)

Déclaration du scénario de simulation et les fichiers traces :

Définir la durée de simulation :

Définition des nœuds et des liens :

Définition d’un lien de communication bidirectionnel :

Programmer le lancement des applications :

Matière :Atelier réseau 3 Classe : RST21/ RST 22

Qu’on remplace par les lignes suivantes :

Le résultat visuel de la simulation est le suivant :

Matière :Atelier réseau 3 Classe : RST21/ RST 22

Vous aimerez peut-être aussi