mdr projet cornilleau-delaunoy
TRANSCRIPT
DELAUNOY Yann - CORNILLEAU KevinIR 3ème année - 2008/09
MDR - ProjetHakim Badis
http://www-igm.univ-mlv.fr/~badis/IR3/ns2/
Projet de modélisation desréseaux
Introduction .................................................................................. 2Présentation des outils utilisés ...................................................... 3
NS................................................................................................ 3TCL .............................................................................................. 3NAM ............................................................................................. 3
Configuration de travail ................................................................. 4Installation des différents outils ........................................................ 4
Dépendances .............................................................................. 4NS............................................................................................. 4NAM........................................................................................... 5Patch UM-OLSR ........................................................................... 5
Présentation générale de la démarche ........................................... 6Modèle de simulation ...................................................................... 6Scénarios d'étude ........................................................................... 6Traitements automatisés ................................................................. 7Algorithmes étudiés ...................................................................... 13
DSR (Dynamic Source Routing) ................................................... 13AODV (Ad-hoc On-demand Distance Vector).................................. 14OLSR (Optimized Link State Routing Protocol) ............................... 14
Étude d'un réseau ad-hoc statique............................................... 15Scripts de simulation..................................................................... 15Résultats de simulation ................................................................. 19
Bande passante moyenne ........................................................... 19Probabilité de perte.................................................................... 20Délai de bout-en-bout ................................................................ 21
Conclusion de l'étude sur un réseau statique .................................... 21Étude d’un réseau ad-hoc dynamique .......................................... 23
Scripts de simulation..................................................................... 23Résultats de simulation ................................................................. 28
Bande passante moyenne ........................................................... 28Probabilité de perte.................................................................... 29Délai de bout-en-bout ................................................................ 30
Conclusion de l'étude sur un réseau dynamique ................................ 30Comparaison des scénarios.......................................................... 32Conclusion ................................................................................... 35
1
INTRODUCTION
Dans le cadre des enseignements de modélisation des réseaux, nous avons simuléplusieurs types de réseaux sans fil.
Ce projet a pour objectif de comparer et d'étudier les performances de différentsprotocoles de routage dans différents scénarios.
En utilisant le logiciel de simulation NS2 (Network Simulator 2), dont les simulations seprogramment en TCL/TK, nous avons évalué par la simulation les principes defonctionnement, et plus particulièrement les performances, des algorithmes DSR(Dynamic Source Routing), AODV (Ad-hoc On-demand Distance Vector) et OLSR(Optimized Link State Routing Protocol) dans des réseaux ad-hoc.
L’objectif de ce rapport est de présenter notre démarche, les scripts que nous avons misen place pour évaluer les trois algorithmes dans les différentes situations, et les analysesque nous avons tirées de ces expériences.
2
PRÉSENTATION DES OUTILS UTILISÉS
NS
NS est un outil logiciel de simulation de réseaux informatiques développé lors d'un projetde la Defense Advanced Research Projects Agency. Il est principalement bâti avecles idées de la conception par objets, de réutilisation du code et de modularité. Il estdevenu aujourd'hui un standard de référence en ce domaine. C'est un logiciel dans ledomaine public disponible sur l'Internet. Son utilisation est gratuite. Le logiciel estexécutable tant sous Unix que sous Windows. Le Simulateur se compose d'une interfacede programmation en TCL et d'un noyau écrit en C++ dans lequel la plupart desprotocoles 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), lesréseaux multicast, IntServ, DiffServ
▪ Couche MAC CSMA, CDMA, 802,X, Token ring, MPLS, liens satellite, etc.
Dans tous nos exemples, nous avons toujours simulé des flux UDP constants, car ilspermettent d’étudier les phénomènes de rejet de paquets sans encombrer le réseau.
NS-2 ne permet pas de visualiser le résultat des expérimentations. Il permet uniquementde stocker une trace de la simulation, de sorte qu’elle puisse être exploitée par un autrelogiciel, tel que NAM par exemple.
TCL
TCL (Tool Command Language) est un langage de commande, comme le shell UNIX,mais qui sert à contrôler les applications. TCL offre des structures de programmationtelles que les boucles, les procédures ou les notions de variables. Il y a deux principalesfaçons de se servir de TCL : comme un langage autonome interprété ou comme uneinterface applicative d'un programme classique écrit en C ou C++.
NAM
NAM est un outil de visualisation qui présente deux intérêts principaux : représenter latopologie d’un réseau décrit avec NS-2, et afficher temporellement les résultats d’unetrace d’exécution NS-2. Par exemple, il est capable de représenter des paquets TCP ouUDP, la rupture d’un lien entre nœuds, ou encore de représenter les paquets rejetésd’une file d’attente pleine.
Ce logiciel est souvent appelé directement depuis les scripts TCL pour NS-2, afin devisualiser directement le résultat de la simulation.
3
CONFIGURATION DE TRAVAIL
Nous effectuerons les manipulations sur une machine tournant sous GNU/Linux Debianou une distribution dérivée (Ubuntu, etc...). Ainsi les installations de logiciels ferontappel à l'application Aptitude disponible pour gérer les paquets et les dépendances sur cetype de systèmes.La version de NS-2 la plus à jour actuellement est la version 2.33 disponible entéléchargement sur le site officielle de NS mais pour plus de confort, nous utiliserons laversion all-in-one 2.31 déjà présente sur nos machines. Celle-ci regroupe tous lesutilitaires et les plugins nécessaires à la compilation et au fonctionnement de de NS.NS nous permettra de compiler les scripts TCL que sur lesquels nous travaillerons.
Sur nos postes de travail, NS-2 est exécutable par la ligne de commande suivante :
# /usr/local/apps/ns-allinone-2.31/ns-2.31/ns <arg>
Des fichiers d'exemples sont également disponibles dans le répertoire /usr/local/apps/ns-allinone-2.31/ns-2.31/tcl/ex/.
Installation des différents outils
Voici les quelques étapes pour installer ces différents outils sur un poste n'en disposantpas.
Dépendances
Préalablement à ces manipulations, il convient d'installer un certain nombre de paquetsqui nous permettront de compiler les outils, grâce à la commande :
# aptitude install libx11-dev tk8.5-dev libxt-dev libxmu-dev
NS
Il faut télécharger le paquetage all-in-one accessible à l'adresse :http://sourceforge.net/project/showfiles.php?group_id=149743&package_id=169689&release_id=588643
On extrait ensuite les fichiers de l'archive et, dans le répertoire nouvellement créé, onlance le script d'installation.
4
NAM
NAM étant inclus dans NS all-in-one, on se place dans le répertoire nam-X.XX desfichiers de l'archive, et on exécute les commandes :
# ./configure# make
Patch UM-OLSR
Ce patch nous sera nécessaire car le protocole OLSR n'est pas inclus nativement dansl'outil NS.
Il faut tout d'abord télécharger le plugin :http://sourceforge.net/projects/um-olsr/
Il faut copier um-olsr-0.8.8.tgz (où "0.8.8" est la version du patch) dans le répertoire ns-allinone-2.31/ns-2.31/ (où "2.31" est la version de NS installée sur le système). Onexécute ensuite les commandes :
$ cd ns-allinone-2.29/ns-2.29/$ tar zxvf um-olsr-0.8.8.tgz$ ln -s ./um-olsr-0.8.8 ./olsr$ patch -p1 < olsr/um-olsr_ns-2.31_v0.8.8.patch
Ensuite, pour que le patch soit pris en compte par NS :
$ ./configure$ make distclean$ ./configure$ make
Des documentations pour ce patch sont accessibles aux adresses suivantes :http://masimum.inf.um.es/?Software:UM-OLSRhttp://masimum.inf.um.es/um-olsr/html/
/!\ Ce script est encore en développement et les résultats observés peuvent ne pasêtre significatifs. Nous tenterons malgré tout cette simulation en tenant compte dece point dans nos analyses.
5
PRÉSENTATION GÉNÉRALE DE LA DÉMARCHE
La démarche présentée ici nous permettra de comparer les performances de troisprotocoles différents sur des réseaux ad-hoc dans plusieurs situations :
• DSR (Dynamic Source Routing) ;• AODV (Ad-hoc On-demand Distance Vector) ;• OLSR (Optimized Link State Routing Protocol).
/!\ En raison de la limitation de la puissance de calcul de nos machinespersonnelles, nous avons choisi après discussion avec le responsable de projet delimiter le cadre de notre étude. Les valeurs modifiées sont graissées.
Modèle de simulation
Le modèle de simulation est le suivant :▪ le protocole IEEE 802.11 est utilisé comme protocole d’accès au médium ;▪ la capacité du médium est de 2Mbit/s ;▪ la puissance de transmission est de 0.28183815 dB ;▪ la portée de communication (threshold RXThresh_) est de 250 m ;▪ la porté de détection (threshold CSThresh_) est de 500 m ;▪ le réseau se trouve sur une région carrée de 1 km de côté ;▪ 25 nœuds sont utilisés ;▪ la taille de la queue de chaque nœud est de 50 paquets, et sa gestion est faite
selon la discipline FIFO ;▪ les paquets ont une taille de 512 octets et sont envoyés toutes les 0,1 s.
pendant 30 secondes par le CRB ;▪ la position initiale de chaque nœud est aléatoire, il peut utiliser ensuite le modèle
de mobilité random waypoint.
Le modèle random waypoint est couramment utilisé dans l’analyse des performance d'unprotocoles de routage. Chaque nœud choisit aléatoirement un point de destination et sedéplace vers celui-ci à une vitesse constante sélectionnée uniformément entre 0 et 10m/s. Une fois la destination atteinte, le nœud marque un pause de 5s.
Scénarios d'étude
L’étude que nous allons faire se divise en deux étapes.
Tout d'abord, nous simulerons le fonctionnement de chacun des trois protocoles dans lecas d'un réseau statique, dont les nœuds sont placés aléatoirement dans la zone decouverture de l’étude.
Ensuite nous effectuerons à nouveau ces simulations en affectant à chaque nœud lemodèle de mobilité aléatoire défini plus haut.
Pour chacune des configurations étudiées, nous ferons varier le nombre de nœudsémetteurs (le CBR) de 1 à 12 nœuds (la moitié des nœuds).
6
Chaque valeur obtenue expérimentalement est issue de la moyenne des résultats de 20simulations utilisant les mêmes paramètres, et avec une valeur de seed différente.
/!\ Afin d'obtenir un résultat parfaitement satisfaisant, nous aurions du faire lamoyenne de 100 valeurs. Toutefois, les simulations étant particulièrement lentessur notre matériel personnel, nous réduirons ce chiffre afin de pouvoir traiterl'ensemble des cas dans les délais qui nous sont impartis.
Traitements automatisés
Étant donné le nombre de simulations à effectuer et le temps que prennent celles-ci avecnotre matériel, nous effectuerons donc des simulation par lots, en faisant appel àdifférents scripts.
Un script start.sh a pour rôle d'exécuter les différentes simulations :• pour chacun des 3 protocoles ;• pour chacun des 2 scénarios ;• pour chacune des valeurs de CBR (nombre d'émetteurs) ;• il effectue la simulation 20 fois ;• il exécute pour chaque simulation les scripts awk permettant d'extraire les
valeurs attendues (bande passante, délai bout-en-bout et perte des paquets) ;• il exécute un script awk permettant de calculer une valeur moyenne à partir de
ces 20 simulations pour chacune des valeurs étudiées et exporte celles-ci dansun fichier qui sera ensuite traité par gnuplot.
Ce script est retranscrit ci-dessous.
start.sh
#!/bin/bash
# Projet MdR# DELAUNOY Yann - CORNILLEAU Kevin# IR 3ème année - 2008/09# http://www-igm.univ-mlv.fr/~badis/IR3/ns2/## Script de lancement des différentes simulation
# Config. des cheminsTCL=simulationsAWK=scripts_awkRESULT_DIR=resultsRESULT=./results.trNS=../ns-allinone-2.33/ns-2.33/ns
# set -x
rm $RESULT_DIR/*
# On effectue l'ensemble des simulation contenues dans le répertoirefor f in ./$TCL/*.tcl ; do
echo "*** Operate $f"
7
TCL_FILE=${f%.*}TCL_FILE=${TCL_FILE##*/}j=1# On fait varier le CRB de 1 à 12while [ $j -lt 13 ] ; do
echo "*** CBR=$j"i=0# On fait 20 simulationswhile [ $i -lt 20 ] ; do
echo "****** Simulation #$i"$NS $f $j
for x in ./$AWK/*.awk ; doecho "********* Operate $x"AWK_FILE=${x%.*}AWK_FILE=${AWK_FILE##*/}
$x $RESULT >> "$RESULT_DIR/$TCL_FILE-$AWK_FILE-$j.csv"donei=$[$i+1]echoecho
done
# On fait la moyenne des valeurs, pr export en courbeecho "****** Calculate average for CBR=$j"for x in ./$AWK/*.awk ; do
AWK_FILE=${x%.*}AWK_FILE=${AWK_FILE##*/}echo -n "$j " >> "$RESULT_DIR/curve-$TCL_FILE-$AWK_FILE.csv"./calc_average.awk $RESULT_DIR/$TCL_FILE-$AWK_FILE-$j.csv >>
"$RESULT_DIR/curve-$TCL_FILE-$AWK_FILE.csv"done
j=$[$j+1]
echoecho
donedone
rm $RESULTrm *.nam
La réalisation des programme TCL est détaillée dans les paragraphes d'étude.
Les scripts awk chargés du calcul des valeurs étudiées sont inspirés de ce qui a étéréalisé préalablement durant les TD.
La bande passante est calculée en convertissant le nombre de paquets reçus pour avoirl'unité qui nous intéresse.bande_passante.awk
8
#!/usr/bin/awk -f
# Projet MdR# DELAUNOY Yann - CORNILLEAU Kevin# IR 3ème année - 2008/09# http://www-igm.univ-mlv.fr/~badis/IR3/ns2/## Fichier AWK qui permet calculer la bande passante
BEGIN {size_packets = 0current_node = 0node_dest = 0node_src = 0id = 0
}
{# Récupération des valeurscurrent_node = $3 # nœud courantid = $6 # ID du paquetnode_src = $14 # nœud sourcenode_dest = $15 # nœud destination
# On récupère le nœud destinationsub(/\:([0-9]*)/,"", node_dest)sub(/\[/,"", node_dest)
# On récupère le nœud sourcesub(/\:([0-9]*)/,"", node_src)sub(/\[/,"", node_src)
# On supprime les "_" contenus dans le nœud courantgsub(/_/, "", current_node);
# Le type du paquet est cbrif($7=="cbr") {
# Il s'agit d'une réception de paquetif($1 == "r") {
# Si le nœud destination est le nœud courantif( packet_dest[id] == current_node ) {
size_packets = size_packets + $8;}
}
# Il s'agit d'un envoi de paquetelse if($1 == "s") {
if ( !(id in start) ) {start[id] = time;packet_dest[id] = node_dest;packet_src[id] = node_src
}}
}
9
}
END {# print "Bande passante : " (size_packets * 8) / (30 * 1e6) " Mbits/sec";print (size_packets * 8) / (30 * 1e6);
}
Le délai de bout en bout est obtenu par simple soustraction.
delai_bout_en_bout.awk
#!/usr/bin/awk -f
# Projet MdR# DELAUNOY Yann - CORNILLEAU Kevin# IR 3ème année - 2008/09# http://www-igm.univ-mlv.fr/~badis/IR3/ns2/## Fichier AWK qui permet de calculer le délai de bout# en bout des paquets envoyés
BEGIN {nb_packets = 0time = 0current_node = 0node_dest = 0node_src = 0id = 0highest_packet_id = 0
}
{# Récupération des valeurstime = $2 # Tempscurrent_node = $3 # nœud courantid = $6 # ID du paquetnode_src = $14 # nœud sourcenode_dest = $15 # nœud destination
# On récupère le nœud destinationsub(/\:([0-9]*)/,"", node_dest)sub(/\[/,"", node_dest)
# On récupère le nœud sourcesub(/\:([0-9]*)/,"", node_src)sub(/\[/,"", node_src)
# On supprime les "_" contenus dans le nœud courantgsub(/_/, "", current_node);
# Le type du paquet est cbrif($7=="cbr") {
10
# Il s'agit d'une réception de paquetif($1 == "r") {
# Si le nœud destination est le nœud courantif( packet_dest[id] == current_node )
end[id] = time;if( id > highest_packet_id )
highest_packet_id = id;}
# Il s'agit d'un envoi de paquetelse if($1 == "s") {
if ( !(id in start) ) {start[id] = time;packet_dest[id] = node_dest;packet_src[id] = node_src
}}
}}
END {for ( id = 0; id <= highest_packet_id; id++ ) {
if( ( id in start ) && ( id in end ) ) {
if ( start[id] < end[id] ) {total_time = end[id] - start[id] + total_time;nb_packets++;
}}
}
# Calcul du délai de bout en boutdelay = total_time / (nb_packets * 512 * 8);
# Affichage du résultatprint delay;
}
La probabilité de perte de paquets est obtenue par un rapport du nombre de paquetsenvoyés sur le nombre de paquets rejetés.
perte_paquets.awk
#!/usr/bin/awk -f
# Projet MdR# DELAUNOY Yann - CORNILLEAU Kevin# IR 3ème année - 2008/09# http://www-igm.univ-mlv.fr/~badis/IR3/ns2/## Fichier AWK qui permet de calculer le nombre de# paquets perdus
BEGIN{
11
packets_sent = 0packets_received = 0packets_dropped = 0
}
{# Si le type du paquet est cbrif($7=="cbr"){
# Si il s'agit d'une réception de paquetif($1 == "r")
packets_received++;
# Si il s'agit d'un envoi ou d'un forward de paquetelse if($1 == "s" || $1 =="f")
packets_sent++;
# Si il s'agit d'un paquet droppéelse if($1 == "D")
packets_dropped++;}
}
END{print (packets_dropped / packets_sent) * 100;
}
Le calcul de la moyenne de chacune des simulations est obtenu très simplement avec lescript awk suivant.
calc_average.awk
#!/usr/bin/awk -f
# Projet MdR# DELAUNOY Yann - CORNILLEAU Kevin# IR 3ème année - 2008/09# http://www-igm.univ-mlv.fr/~badis/IR3/ns2/## Fichier AWK qui permet calculer la moyenne des valeurs# d'un fichier
BEGIN {sum = 0;cpt = 0;
}
{sum += $1;cpt++;
}
END {average = sum / cpt;
12
printf "%f\n", average;}
Le tracé des courbes sous GNUPLOT est ensuite obtenu à l'aide des commandessuivantes (ces commandes sont données ici pour le calcul de la bande passante, dans lecas de nœud mobiles, et sera adapté pour chaque courbe) :
set term pngset output "../graphs/dynamique-bande_passante.png"
set xlabel 'CBR'set ylabel 'Bande passante'set title 'nœuds dynamiques'
plot "../results/curve-aodv_dynamique-bande_passante.csv" using 1:2 withlinespoints, "../results/curve-dsr_dynamique-bande_passante.csv" using 1:2with linespoints, "../results/curve-olsr_dynamique-bande_passante.csv"using 1:2 with linespoints
Algorithmes étudiés
Un réseau ad-hoc est un réseau créé par les liaisons de nœuds mobiles. Il s'agit doncd'un réseau ne s'appuyant pas sur une infrastructure préexistante.
DSR (Dynamic Source Routing)
DSR est un protocole réactif (c'est à dire que les nœuds ne possèdent pas de table deroutage à jour, mais construisent des routes au besoin lors de l'envoi de paquets) utilisédans les réseaux ad-hoc. Une route est calculée par la source vers la destination. Àchaque nœud intermédiaire traversé, l’adresse de ce dernier est inscrite dans le paquet.
Le protocole est divisé en deux phases : la découverte de routes et la maintenance decelles-ci.
Pour la découverte, l’émetteur envoie un paquet RouteRequest en inondant le réseau. Àla réception d’un de ces paquets, le nœud réagit différemment suivant les cas. Si lenœud est le destinataire, il retourne un paquet RouteReply contenant le chemin. Sinon,soit le nœud a déjà vu le paquet (son adresse est présente dans le paquet) et dans cecas, il rejette le paquet ; soit c’est la première fois que le paquet arrive par le nœud etdans ce cas le nœud inscrit son adresse dans la route (RouteRecord) et fait suivre lepaquet.
Afin de maintenir les routes, le concept utilisé par DSR est simple : chaque nœud estresponsable de transférer aux nœuds suivants. Si plusieurs échecs successifs arriventlors de la transmission d’un paquet, le nœud envoie un message RouteError à l’émetteurqui supprime la route et en utilise soit une autre existante, soit en cherche une nouvelle.
13
AODV (Ad-hoc On-demand Distance Vector)
AODV est également un protocole réactif. Contrairement à DSR, AODV est basé sur laconstruction de table de routage. En effet, chaque nœud possède sa propre table deroutage contenant pour chaque destination, le prochain nœud à contacter.
La découverte d’une route se fait par inondation par l’émetteur d’un paquet RREQ. À laréception d’un de ces paquets, si le nœud connaît le chemin pour accéder à ladestination, il envoie une réponse RREP à l’émetteur qui arrête alors d’inonder le réseau.S’il le nœud ne connaît pas le chemin, il transmet le paquet à ses voisins, tout enmémorisant le nœud précédent ayant fait la requête.
En cas de cassure du lien, un message RERR est envoyé à l’émetteur qui décide ou nonde recommencer l’envoi du paquet suivant le taux d’utilisation de la route.
OLSR (Optimized Link State Routing Protocol)
OLSR est un protocole proactif (c'est à dire que les nœuds possèdent une table deroutage à jour, grâce à l'échange de paquets de contrôle) ayant les mêmes principes debase qu’OSPF, c'est-à-dire qu’il gère un état des liens du réseau.
Le concept principal est celui des MPR (Multi-Point Relays) qui sont des nœuds choisispour expédier les messages de diffusion pendant le processus d’initialisation.
Afin de maintenir une table de routage à jour, chaque nœud envoie, toutes les deuxsecondes, un message de type Hello qui contient la liste de tous les voisins directs del’émetteur ainsi que l’état et le type des liens avec les voisins. Le message Hello permetaussi de spécifier le MPR choisi par l’expéditeur.
14
ÉTUDE D'UN RÉSEAU AD-HOC STATIQUE
Nous commençons par l'étude du réseau dont les nœuds sont placés aléatoirement et nese déplacent pas.
Scripts de simulation
Le script est inspiré de ce qui a été fait lors des TD et de l'exemple qui est à notredisposition sur le sujet du projet. Le voici commenté.
# Définition des variables pour la simulation de notre réseau sans-fil
set val(chan) Channel/WirelessChannel; # Type de canalset val(prop) Propagation/TwoRayGround; # Propagation radioset val(netif) Phy/WirelessPhy; # Type de l'interface réseauset val(mac) Mac/802_11; # Support du wirelessset val(ifq) Queue/DropTail/PriQueue; # Priorité de la fileset val(ll) LL; # Type de la couche de liaisonset val(ant) Antenna/OmniAntenna; # Type de l'antenneset val(ifqlen) 50; # Taille de la queueset val(x) 1000; # X Largeur de la région (en mètres)set val(y) 1000; # Y Hauteur de la région (en mètres)set val(nn) 25; # Nombre de nœudsset val(stop) 30; # Temps de la simulation (en secondes)set val(sources) [lindex $argv 0] # Nombre de sources passé enargumentset val(packet_size) 512; # Taille des paquets envoyés (enoctets)set val(interval) 0.1; # Intervalle d'envoi de paquets (ensecondes)
set val(rp) AODV; # Protocole de routage
# Définition de la variable de Random pour le placement des nœuds dans larégion
global defaultRNG$defaultRNG seed 0set sizeRNG [new RNG]$sizeRNG next-substream
set size_ [new RandomVariable/Uniform]; # Variable Random uniforme$size_ set min_ 1; # Valeur minimum$size_ set max_ 999; # Valeur maximum$size_ use-rng $sizeRNG
# Création du simulateur NS
15
set ns [new Simulator]
# Paramétrage de l'antenne
Antenna/OmniAntenna set X_ 0; # Direction de XAntenna/OmniAntenna set Y_ 0; # Directionde YAntenna/OmniAntenna set Z_ 1.5; # Direction de ZAntenna/OmniAntenna set Gt_ 1.0; # Gain de transmissionAntenna/OmniAntenna set Gr_ 1.0; # Gain de réception
# Paramétrage de l'interface réseau
Phy/WirelessPhy set CPThresh_ 10.0; # Collision ThresholdPhy/WirelessPhy set CSThresh_ 1.559e-11;# Portée de détection : 500mètresPhy/WirelessPhy set RXThresh_ 0.652e-10; # Portée de communication :250 mètres (-91,1db)Phy/WirelessPhy set bandwidth_ 2e6; # Capacité du médium : 2MbitsPhy/WirelessPhy set Pt_ 0.28183815; # Puissance de transmission :24.5dbmPhy/WirelessPhy set freq_ 914e+6; # Fréquence : 914MHzPhy/WirelessPhy set L_ 1.0; # System Loss Factor
# Création des fichiers de trace
set f [open results.tr w]$ns trace-all $f$ns eventtrace-allset nf [open aodv_sim.nam w]$ns namtrace-all-wireless $nf $val(x) $val(y)
# Topographie de la simulation
set topo [new Topography];
# Création de la région pour la simulation
$topo load_flatgrid $val(x) $val(y)
# Création du God
create-god $val(nn)
16
# Création du canal
set chan [new $val(chan)]
# Configuration du nœud
$ns node-config -adhocRouting $val(rp) \-llType $val(ll) \-macType $val(mac) \-ifqType $val(ifq) \-ifqLen $val(ifqlen) \-antType $val(ant) \-propType $val(prop) \-phyType $val(netif) \-channel $chan \-topoInstance $topo \-agentTrace ON \-routerTrace ON \-macTrace ON \-movementTrace OFF
# Création des nœuds pour la simulation
for {set i 0} {$i < $val(nn)} {incr i} {set node_($i) [$ns node]$node_($i) random-motion 0
}
# Position des nœuds dans la région de manière aléatoire
for {set i 0} {$i < $val(nn)} {incr i} {$node_($i) set X_ [expr round([$size_ value])]]$node_($i) set Y_ [expr round([$size_ value])]]$node_($i) set Z_ 0.0
}
# Création des agents pour les nœuds sources
for {set i 0} {$i < $val(sources)} {incr i} {
# Création de l'agent UDPset udp_($i) [new Agent/UDP]$ns attach-agent $node_($i) $udp_($i)
# Création de l'agent Null
17
set null_($i) [new Agent/Null]$ns attach-agent $node_([expr [expr $val(nn) - 1] - $i]) $null_($i)$ns connect $udp_($i) $null_($i)
# Création et paramètrage du CBRset cbr_($i) [new Application/Traffic/CBR];$cbr_($i) attach-agent $udp_($i)$cbr_($i) set type_ CBR; # Type du CBR$cbr_($i) set packet_size_ $val(packet_size); # Taille des paquets
envoyés$cbr_($i) set rate_ [expr $val(packet_size) * 8 / [$ns delay_parse
$val(interval)]]; # Taux$cbr_($i) set random_ false
# Début d'envoi de paquets pas en même temps, sinon Erreur desegmentation
$ns at [expr 0.1 * $i] "$cbr_($i) start"; # Début d'envoi de paquets$ns at $val(stop) "$cbr_($i) stop"; # Fin d'envoi de paquets
}
# Positionne les nœuds sur la grille
for {set i 0} {$i < $val(nn)} {incr i} {$ns initial_node_pos $node_($i) 30; # 30 : taille du nœud dans nam
}
# Arrêt de la simulation
$ns at $val(stop) "finish"$ns at [expr $val(stop) + 0.1] "$ns halt"
# Fonction appelée pour terminer la simulation
proc finish {} {global ns f nf val$ns flush-traceclose $fclose $nfexit 0
}
# Début de la simulation
$ns run
Ce même script est adapté pour les deux autres protocoles.
18
Résultats de simulation
On étudie ici les valeurs en faisant évoluer le nombre de nœuds émetteurs de 1 à 12selon le mode opératoire défini précédemment.
Bande passante moyenne
On s'aperçoit à la lecture de ces courbes que l'augmentation de la bande passante avecle nombre d'émetteurs semble se faire de plus en plus réduite à compter d'une dizained'émetteurs. Cette observation serait à confirmer avec un plus grand nombre de nœuds.Il est possible que nous arrivions à une saturation du réseau.
DSR semble ici beaucoup plus performant que les autres protocoles pour un nombrelimité d'émetteurs. Cependant on semble observer qu'avec ce protocole également, on aun phénomène de saturation, et que la bande passante maximale du réseau paraîtcomparable quelque soit le protocole choisi.
DSR et OLSR paraissent ici offrir des performances assez similaires.
19
Probabilité de perte
On observe assez logiquement que la probabilité de perte augmente avec le nombre denœuds émetteurs.
OLSR paraît ici être beaucoup moins performant que les deux autres protocoles. En effetdès le premier émetteur nous avons un taux de perte de près de 7%.
Il semblerait que DSR soit légèrement plus performant qu'AODV au-dessus de 10émetteurs, mais cette hypothèse serait à confirmer avec une étude plus poussée.
Une étude sur un plus grand nombre de nœuds nous permettrait peut-être d'observerdes différences plus marquées.
20
Délai de bout-en-bout
L'étude des délais de bout-en-bout paraît plus intéressante.
On s'aperçoit que le temps observé avec les différents protocoles est assez comparable(moins d'1/10000 de seconde) jusqu'à 4 émetteurs ; AODV se situant légèrement audessus de DSR et OLSR.
A partir de 5 émetteurs, cette durée augmente de manière très importante pour DSR etde manière beaucoup plus modérée pour AODV et OLSR.
OLSR et AODV restent assez comparables en terme de durée jusqu'à 10 émetteurs où ladurée observée avec OLSR semble augmenter assez fortement.
Conclusion de l'étude sur un réseau statique
En conclusion, il semblerait qu'OLSR soit peu efficace dans les conditions du test, avecun taux de perte beaucoup plus élevé que celui relevé pour DSR et AODV.
Avec une bande-passante plus élevée, et un taux d'erreurs et un délai équivalent aux 2autres protocoles, DSR est le protocole le plus performant pour un faible nombre denœud.
21
Lorsque celui-ci augmente, DSR perd son avantage en terme de bande-passante et sontaux de perte devient beaucoup plus élevé. C'est alors AODV qui paraît être le plusperformant.
22
ÉTUDE D’UN RÉSEAU AD-HOC DYNAMIQUE
Nous réalisons maintenant l'étude d'un système dont les nœuds sont mobiles.
Scripts de simulation
Les simulations utilisées ici sont très proches de celles pour les mesures statiques. Lesscripts de simulation sont identiques à ceux utilisé pour les mesures statiques.
Pour le déplacement des nœuds, nous avons utilisé une implémentation du RandomWaypoint dans la procédure :
proc setNewDest {node currentX currentY} { … }
Voici un exemple commenté.
# Définition des variables pour la simulation de notre réseau sans-fil
set val(chan) Channel/WirelessChannel; # Type de canalset val(prop) Propagation/TwoRayGround; # Propagation radioset val(netif) Phy/WirelessPhy; # Type de l'interface réseauset val(mac) Mac/802_11; # Support du wirelessset val(ifq) Queue/DropTail/PriQueue; # Priorité de la fileset val(ll) LL; # Type de la couche de liaisonset val(ant) Antenna/OmniAntenna; # Type de l'antenneset val(ifqlen) 50; # Taille de la queueset val(x) 1000; # X Largeur de la région (en mètres)set val(y) 1000; # Y Hauteur de la région (en mètres)set val(nn) 25; # Nombre de nœudsset val(stop) 30; # Temps de la simulation (en secondes)set val(sources) [lindex $argv 0] # Nombre de sources passé enargumentset val(packet_size) 512; # Taille des paquets envoyés (enoctets)set val(interval) 0.1; # Intervalle d'envoi de paquets (ensecondes)
set val(rp) AODV; # Protocole de routage
## Mobilité
# Définition de la variable de Random pour le placement des nœuds dans larégion
global defaultRNG$defaultRNG seed 0
23
set sizeRNG [new RNG]$sizeRNG next-substream
# Variable de random utilisée pour un point sur la grilleset size_ [new RandomVariable/Uniform]; # Variable Random uniforme$size_ set min_ 1; # Valeur minimum$size_ set max_ 999; # Valeur maximum$size_ use-rng $sizeRNG
# Variable de random utilisée pour une vitesse de déplacementset sizespeed_ [new RandomVariable/Uniform]; # Variable Randomuniforme$sizespeed_ set min_ 1; # Valeur minimum$sizespeed_ set max_ 10; # Valeur maximum$sizespeed_ use-rng $sizeRNG
# Création du simulateur NS
set ns [new Simulator]
# Paramétrage de l'antenne
Antenna/OmniAntenna set X_ 0; # Direction de XAntenna/OmniAntenna set Y_ 0; # Direction de YAntenna/OmniAntenna set Z_ 1.5; # Direction de ZAntenna/OmniAntenna set Gt_ 1.0; # Gain de transmissionAntenna/OmniAntenna set Gr_ 1.0; # Gain de réception
# Paramétrage de l'interface réseau
Phy/WirelessPhy set CPThresh_ 10.0; # Collision ThresholdPhy/WirelessPhy set CSThresh_ 1.559e-11;# Portée de détection : 500mètresPhy/WirelessPhy set RXThresh_ 0.652e-10; # Portée de communication :250 mètres (-91,1db)Phy/WirelessPhy set bandwidth_ 2e6; # Capacité du médium : 2MbitsPhy/WirelessPhy set Pt_ 0.28183815; # Puissance de transmission :24.5dbmPhy/WirelessPhy set freq_ 914e+6; # Fréquence : 914MHzPhy/WirelessPhy set L_ 1.0; # System Loss Factor
# Création des fichiers de trace
set f [open results.tr w]$ns trace-all $f$ns eventtrace-allset nf [open aodv_sim.nam w]$ns namtrace-all-wireless $nf $val(x) $val(y)
24
# Topographie de la simulation
set topo [new Topography];
# Création de la région pour la simulation
$topo load_flatgrid $val(x) $val(y)
# Création du God
create-god $val(nn)
# Création du canal
set chan [new $val(chan)]
# Configuration du nœud
$ns node-config -adhocRouting $val(rp) \-llType $val(ll) \-macType $val(mac) \-ifqType $val(ifq) \-ifqLen $val(ifqlen) \-antType $val(ant) \-propType $val(prop) \
-phyType $val(netif) \-channel $chan \-topoInstance $topo \-agentTrace ON \
-routerTrace ON \-macTrace ON \-movementTrace OFF
# Création des nœuds pour la simulation
for {set i 0} {$i < $val(nn)} {incr i} {set node_($i) [$ns node]$node_($i) random-motion 0
}
# Position des nœuds dans la région de manière aléatoire# Spécification des déplacements aléatoires
for {set i 0} {$i < $val(nn)} {incr i} {
set X [expr round([$size_ value])]; # Position X en random sur la grilleset Y [expr round([$size_ value])]; # Position Y en random sur la grille$node_($i) set X_ $X]; # Position X du nœud sur la grille
25
$node_($i) set Y_ $Y]; # Position Y du nœud sur la grille$node_($i) set Z_ 0.0; # Position Z du nœud sur la grille
set speed [expr round([$sizespeed_ value])]; # vitesse en randomentre 1m/s et 10m/s
set newX [expr round([$size_ value])]; # Position X en random surla grille
set newY [expr round([$size_ value])]; # Position Y en random surla grille
# Définition du premier mouvement$ns at [expr 0.1 * $i] "$node_($i) setdest $newX $newY $speed";
# Définition des mouvements suivants si la simulation n'est pas terminée$ns at [expr 0.1 * $i] "setNewDest $node_($i) $newX $newY";
}
# Méthode qui permet de définir une nouvelle destination au nœud mobile
proc setNewDest {node currentX currentY} {global ns sizespeed_ size_; # Récupère les variables du programme
set speed [expr round([$sizespeed_ value])]; # Vitesse en randomentre 1m/s et 10m/s
set nextX [expr round([$size_ value])]; # Position X en random surla grille
set nextY [expr round([$size_ value])]; # Position Y en random surla grille
set now [$ns now]; # Date courante de la simulationset longX [expr $nextX-$currentX]; # Distance en X à parcourirset longY [expr $nextY-$currentY]; # Distance en Y à parcourir
# Calcul de la longueur du cheminset distance [expr sqrt(($longX*$longX)+($longY*$longY))];
# Détermination de la date d'arrivée au point destinationset arrivalDate [expr $now + [expr $distance/$speed]];
# Détermination de la prochaine date de mouvement après 5 secondes depause
set nextMove [expr $arrivalDate + 5.0];
# Définition de la prochaine destination$ns at $now "$node setdest $nextX $nextY $speed";
# Définition du prochain mouvement si la simulation n'est pas terminée$ns at $nextMove "setNewDest $node $nextX $nextY";
}
# Création des agents pour les nœuds sources
for {set i 0} {$i < $val(sources)} {incr i} {
26
# Création de l'agent UDPset udp_($i) [new Agent/UDP]$ns attach-agent $node_($i) $udp_($i)
# Création de l'agent Nullset null_($i) [new Agent/Null]$ns attach-agent $node_([expr [expr $val(nn) - 1] - $i]) $null_($i)$ns connect $udp_($i) $null_($i)
# Création et paramètrage du CBRset cbr_($i) [new Application/Traffic/CBR];$cbr_($i) attach-agent $udp_($i)$cbr_($i) set type_ CBR; # Type du CBR$cbr_($i) set packet_size_ $val(packet_size); # Taille des paquets
envoyés$cbr_($i) set rate_ [expr $val(packet_size) * 8 / [$ns delay_parse
$val(interval)]]; # Taux$cbr_($i) set random_ false
# Début d'envoi de paquets pas en même temps, sinon Erreur desegmentation
$ns at [expr 0.1 * $i] "$cbr_($i) start"; # Début d'envoi de paquets$ns at $val(stop) "$cbr_($i) stop"; # Fin d'envoi de paquets
}
# Positionne les nœuds sur la grille
for {set i 0} {$i < $val(nn)} {incr i} {$ns initial_node_pos $node_($i) 30; # 30 : taille du nœud dans nam
}
# Arrêt de la simulation
$ns at $val(stop) "finish"$ns at [expr $val(stop) + 0.1] "$ns halt"
# Fonction appelée pour terminer la simulation
proc finish {} {global ns f nf val$ns flush-traceclose $fclose $nfexit 0
}
# Début de la simulation
$ns run
Ce même script est adapté pour les deux autres protocoles.
27
Résultats de simulation
On étudie également ici les valeurs en faisant évoluer le nombre de nœuds émetteurs de1 à 12 selon le mode opératoire défini précédemment.
Bande passante moyenne
On observe là encore sans surprise que le débit augmente avec le nombre de cellulesémettrice jusqu'à une valeur de saturation qui semble avoisiner les 10 cellules. Les troisprotocoles semblent atteindre à saturation un débit similaire.
On note ici aussi que le débit augmente plus vite avec le nombre de nœuds émetteurspour le protocole DSR, qui atteint donc plus rapidement le point de saturation. AODV etOLSR offrent des valeurs comparables.
On remarque enfin que les valeurs relevées ici sont très proches de celles obtenues dansle cadre du réseau statique.
28
Probabilité de perte
On observe là encore que la mobilité des nœuds ne permet pas de modifier lescommentaires que nous avions relevés dans le cadre du réseau statique.
AODV et DSR semblent offrir un taux de perte relativement comparable. Celui-ciaugmentant avec le nombre de nœuds émetteurs. OLSR paraît se trouver bien au dessusdes 2 autres protocoles selon ce point de vue, mais suit toutefois une augmentationcomparable.
On observe à nouveau que DSR paraît légèrement plus performant qu'AODV au-dessusde 10 émetteurs.
29
Délai de bout-en-bout
Là encore, l'analyse du scénario dynamique ne semble pas différer du scénario à nœudsstatiques.
On s'aperçoit donc que le temps observé avec les différents protocoles est assez faible etcomparable jusqu'à 4 émetteurs. La majoration de temps observée avec AODV paraît iciun peu plus importante.
À partir de 5 émetteurs, cette durée augmente de manière très importante pour DSR etde manière beaucoup plus modérée pour AODV et OLSR. OLSR et AODV restant assezcomparables en terme de durée jusqu'à 10 émetteurs où la durée observée avec OLSRsemble augmenter assez fortement.
Conclusion de l'étude sur un réseau dynamique
Les comportements observés paraissent comparables que les nœuds soient mobiles ounon. En conséquence, les conclusions que nous pouvons tirer de l'étude serontégalement comparables.
DSR est donc le protocole le plus performant pour un faible nombre de nœuds, tandisque dès que ce nombre augmente, c'est AODV qui devient le plus intéressant, avec untaux de perte qui reste faible.
30
OLSR quant à lui présente un taux de perte très élevé quand le délai et le débit relevéssont comparables aux autres.
31
COMPARAISON DES SCÉNARIOS
Arrivé à ce point de l'étude, il peut être intéressant de s'interroger sur la différence derésultats observés sur l'un et l'autre des scénarios.
À la vue des premiers commentaires que nous avons fait, le scénario choisit ne paraîtpas influencer le comportement des protocoles en termes de tendance. La superpositiondes courbes nous permettra de vérifier ceci en termes de valeurs.
Voici les résultats concernant l'étude de la bande passante.
Voici la superposition des taux de perte de paquets.
32
Voici enfin l'étude des délais bout-en-bout.
33
Ces différentes courbes permettent bien de confirmer que le scénario choisi ne modifie niles comportements observés ni les valeurs mesurées.
Cette observation est toutefois à nuancer par 2 point énoncés plus tôt :• Les valeurs utilisées pour nos courbes sont les résultats de la moyenne de 20
simulations. Ce chiffre est insuffisant pour obtenir des valeurs réellementsatisfaisantes. Un plus grand nombre de simulations aurait permis desestimations plus exactes et peut-être d'observer un décalage plus franc.
• Notre étude se limite à un parc de 25 nœuds. Nous ne pouvons donc observer dephénomènes pouvant apparaître après 12 émetteurs.
34
CONCLUSION
En conclusion, ce projet nous a permis au travers d'un exemple concret d'étude dedécouvrir l'intérêt certain de la modélisation des réseaux et de l'utilisation d'outils telsque NS. Nous avons pu sans aucun matériel spécifique, et sans réaliser aucuneconfiguration réseau :
• tester les comportements de différents protocoles dans des scénarios particuliers;
• analyser ceux-ci.
Nous avons pu en extraire une étude chiffrée et comparer les performances de chacunen fonction des configurations observées.
Cette étude nous a donc permis d'observer que le protocole OLSR semblait moinsintéressant qu'AODV et DSR avec un taux de perte qui semble particulièrement élevé.DSR, avec un débit qui augmente rapidement avec le nombre d'émetteurs, semble plusefficace lorsque le nombre d'émetteurs est faible. Toutefois, il devient bien moinsintéressant dès que le nombre d'émetteurs augmente (>6), avec un taux de perte quidevient rapidement très important.Dès que le nombre d'émetteurs augmente, c'est AODV qui est le plus performant avecun délai et un taux de perte limités, mais une bande-passante presque aussi élevée queDSR.
D'une manière plus générale et avec un nombre d'émetteurs élevés, si l'on choisit deprivilégier le taux de perte, on sera peut-être plus enclin à choisir DSR, tandis qu'AODVparaît beaucoup plus judicieux si c'est le délai bout en bout qui est le facteur de décision.
Toutefois, comme nous l'avons souligné plusieurs fois dans ce rapport, il est bon degarder à l'esprit que nos études doivent être nuancées :
• l'étude est limitée par le faible nombre de simulations que nous avons réalisées ;• le périmètre de l'étude a porté à 25 le nombre de nœuds étudiés, et donc à 12 le
nombre maximal d'émetteurs ;• l'implémentation utilisée du protocole OLSR est fournie par un patch dont le
développement est encore en cours (l'implémentation n'est pas parfaite) :certains résultats peuvent être moins bons que ceux attendus, et ne sont pasréellement significatifs.
35