Distribution d`une interface de modélisation pour ns-2

UFR Sciences et Technologies
Université de la Réunion
Distribution d'une interface de modélisation pour ns-2
Master 1 Sciences et Technologies de l'information et de la
Communication (STIC)
LAROSE Cedrik
ANELLI Pascal
Université de la Réunion
Laboratoire d'Informatique et de
Mathématiques(LIM)
2009/2010
1
Sommaire
1. Introduction
2
2. Etat de l'art
3
2.1 NS WorkBench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 TCP eval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.Travaux réalisées
7
3.1 Documentation utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Documentation développeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Amélioration du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.4 Publication des travaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.Conclusion
10
2
1. Introduction
Ce travail d'étude et de recherche à été réalisé sous la tutelle de M. Pascal ANELLI du laboratoire
d'informatique et de mathématiques (LIM) de l'UFR des sciences et technologies de l'université de
la Réunion. L'objectif de ce TER était de faire la distribution d'une interface de modélisation de ns2 développé à l'Université de la Réunion par M. Anelli.
Network Simulator ou ns-2 est un logiciel libre de simulation par événements discrets très
largement utilisé dans la recherche académique et dans l'industrie. Il est considéré par beaucoup de
spécialistes des télécommunications comme le meilleur logiciel de simulation par événements
discrets, en raison de son modèle libre, permettant l'ajout très rapide de modèles correspondant à
des technologies émergentes. Il est basé sur l'utilisation de langages de scripts pour la commande
des simulations (OTcl) alors que le cœur des simulations est implémenté avec le langage C++.
OTcl est un langage orienté objet qui est une extension de Tcl qui fut créé par David Wetherall au
MIT. C'est un langage qui tourne principalement sur les environnements Unix.
De nombreux chercheurs effectuent des simulations ns-2 pour tester leurs idées dans le stade
précoce du protocole de conception. En règle générale, chaque chercheur écrit ses propres scripts
ns-2 qui servent à dupliquer des topologies réseaux et modèles de trafic et à effectuer les mesures de
performance.
Le logiciel NS est fourni avec une interface graphique (NAM) permettant de démontrer le
fonctionnement des réseaux. Ce qui en fait un outil à valeur pédagogique très intéressante. Ce
logiciel est notamment utilisé en Licence 3 et Master 1 à l'Université de La Réunion pour les
simulations en travaux pratiques des modules de « Réseaux Informatiques ».
L'utilisation de ns-2 peut se révéler parfois très compliqué. L'écriture d'un modèle de simulation est
un travail long, qui demande une bonne connaissance de l'interface OTcl de ns-2 et avec une
documentation partielle, ce travail d'écriture de script est fastidieux. Lorsque des conditions
changent, le modèle de simulation peut évoluer en une multitude de fichiers qui devient complexe à
gérer. Il faut aussi savoir que les données et les instructions sont mélangés. Les données
correspondent aux paramètres qui décrivent le modèle de simulation et les traitements d'analyses à
réaliser sur les traces de simulations.
Nous proposons donc une bibliothèque de scripts qui permet à tout utilisateur de pouvoir constituer
rapidement et sans connaissance du Tcl, un modèle de simulation pour ns-2. L'idée de base est de
séparer les données des instructions.
Ce rapport détail la mise en oeuvre du TER qui avait été découpé en plusieurs phases, notamment:
– le développement la documentation de l'utilisateur à partir d'une documentation existante
– l'élaboration d'une documentation du développeur
– une amélioration d'un point de vue de la conception objet
– la publication des travaux
3
2. Etat de l'art
La communauté de développeur ns-2 ne dispose pas toujours d'un ensemble de repères qui peut
servir à faire des comparaisons valables entre les schémas proposés par les différents groupes de
recherche. Cependant, il est possible de trouver des travaux de recherche qui se rapproche de ce qui
été fait dans le cadre de ce projet. Nous allons faire un bref bilan de ce qui à été réalisé par les
différents groupes dans ce domaine, avec notamment:
– le projet NS-2 WorkBench,
– l'outil TCP eval.
2.1 NS-2 WorkBench
Le projet NS-2 WorkBench (nsBench) a été developpé à l'université de DePaul à Chicago.
L'objectif du projet était de développer des outils d'aide qui permettent automatiquement de créer,
d'analyser et de visualiser les scripts et traces de simulation ns-2.
Le nsBench fonctionne avec une interface utilisateur graphique fonctionnant en mode
cliquer-glisser. nsBench est utilisé a l'université de DePaul par les étudiants du premier cycle et des
cycles supérieurs pour les cours de réseaux.
L'ajout de nouveaux composants tel que les noeuds ou les liens, le paramétrage de ces composants
ainsi que la définition des scénarios de simulation se font via l'interface utilisateur.
nsBench rend le développement et l'analyse de simulation ns-2 à la fois plus rapide et plus facile.
Le logiciel a été developpé en Java et distribué sous forme d'un fichier jar.
Le logiciel permet aussi de générer les scripts OTcl correspondant aux différents objets crées ainsi
4
que les scénarios de simulation.
Dans un même registre que le nsBench, il existe aussi le logiciel nscript developpé à l'université de
George Washington aux Etats-Unis. Le nscrpit a aussi été developpé en Java , fonctionne en mode
interface utilisateur graphique et permet la géneration automatique de scripts.
Toutefois, la possibilité est donnée à l'utilisateur d'étendre le modèle en créant ses porpres librairies
dans les 2 cas.
2.2 TCP eval
Le TCP eval est un outil d'évaluation ns-2 des performances de TCP qui a été developpé par les
laboratoires NEC en Chine. Cet outil comprend plusieurs topologies typiques et les modèles de
trafic et il mesure quelques-uns des metriques les plus couramment utilisées, et il peut générer
automatiquement des statistiques et des graphiques de simulation.
Grâce à cet outil, il suffit simplement de définir les scénarios de simulation (la topologie du réseau,
le modèle de trafic et les indicateurs de performance). L'outil est très facile à utiliser et
à étendre. Il permet d'économiser beaucoup de temps passé dans l'écriture de scripts de simulation
ns-2.
L'outil est distribué sous forme de patch pour la version 2.31 de ns-2 et se lance en ligne de
commande.
2.3 Comparaison
Nous proposons une interface de modélisation ainsi qu'une bibliothèque de scripts visant à
constituer rapidement des modèles de simulations sans une grande connaissance de Tcl. Elle offre
des fonctions d'analyse des traces produites par la simulation. Ces fonctions de post-process
calculent les métriques pour évaluer le service perçu par un flot comme le taux de perte, le débit
écoulé, etc.
Le modèle de simulation ainsi que le post-process sont spécifiés dans un fichier dit de ressources.
Les fichier ressources comportent l'ensemble des paramètres de description d'une étude: le modèle
de simulation et les analyses .
Des exemples de fichiers ressources sont aussi fournis. L'utilisateur pourra ainsi modifier les
fichiers ressources en fonction du scénario qu'il souhaite établir, les mesures qu'il souhaite effectuer
et les traces qu'il veut obtenir. Il pourra s'aider de la documentation utilisateur(Annexe) qui détaille
le fonctionnement de chaque composant du fichier ressources.
Par exemple, dans un fichier ressource, le code suivant indique les métriques à mesurer sur un flot
TCP, notamment: l'activité, le débit utile total et le débit utile.
set conf(pkt) { \
5
{Flow { \
{ {*} {activity goodputT goodput}} \
}\
}\
}
Les simulation se lancent en ligne de commande comme pour le TCP eval.
ns <nom du script> <nom du test> -f <nom du fichier ressources> [options]
Les graphiques correspondant à aux métriques indiquées peuvent être obtenues en lançant la
simulation en fonction des options choisies.
La documentation fournie (Annexe) comprend aussi un guide du développeur destiné à ceux qui
voudront étendre le modèle. Cela correspond à écrire de nouveax fichiers de scripts.
Les outils fournies par les différents équipes ont tous pour objectif de faciliter l'utilisation de ns-2.
Les outils nsBench et nscript privilégient le fonctionnement automatique. Ce qui fait que
6
l'utilisateur peut partir de rien, et arriver à créer un modèle de simulation et générer les scripts qui
correspondent. Cette approche est d'une part intéressante car elle évite a l'utilisateur de devoir écrire
des script en OTcl s'il ne maîtrise pas ce langage. Mais d'autre part elle retire la possibilité a
l'utilisateur de pouvoir programmer un minimum. De plus, même si l'utilisateur réalise son objectif,
qui est de faire un modèle de simulation, rien ne garantit le fait qu'il ait compris le mécanisme qui
existe dèrriere la création des différents composants de son modèle.
L'approche utilisé par l'équipe des laboratoires NEC ressemble le plus à celui que nous avons
adopté. C'est un outil qui fournissant des topologies et des modèles typiques qui peuvent être utilisé
pour créer un scénario de simulation. Le TCP eval lance aussi en ligne de commandes.
Cependant elle a l'inconvénient de n'etre fonctionnelle que sur la version 2.31 de ns-2, qui est une
ancienne version, contrairement à la bibliothèque que nous proposons qui fonctionne su la version
2.34, qui est la dernière version, ainsi que les version antérieurs.
Ceci dût au fait que l'outil proposé utilise seulement des formats génériques de traces.
7
3. Travaux réalisés
Afin de pouvoir mener à bien l'objectif à atteindre, le TER avait été divisé en plusieurs phases,
notamment:
– le développement la documentation de l'utilisateur à partir d'une documentation existante
– l'élaboration d'une documentation du développeur
– une amélioration d'un point de vue de la conception objet
– la publication des travaux
3.1 Documentation utilisateur
La première phase du TER fût de réaliser la documentation utilisateur de l'outil de simulation. A
savoir qu'une partie de cette documentation utilisateur existait déjà mais n'était pas complète car il y
manquait les évolutions et les améliorations apportés à la bibliothèque de scripts.
Il fallait donc completer la documentation. D'autre part la documentation avait été écrit en français
Dans un soucis d'atteindre une plus grande partie de la communauté des utilisateurs ns-2, il était
donc plus judicieux de publier une documentation en anglais.
La documentation utilisateur présente en détails différents aspects de l'interface de modélisation,
dont:
– la structure et syntaxe des fichiers ressources
– la définition des composants (topologies du réseau, systèmes d'extrémités)
– l'implémentation du modèle d'erreur
– l'analyse de traces
– le contrôle de l'éxécution
La documentation à été réalisé avec LaTeX qui est particulièrement utilisé dans les domaines
techniques et scientifiques pour la production de documents de taille moyenne ou importante.
3.2 Documentation développeur
La deuxième phase du TER consistait à développer une documentation du développeur pour aider
ceux qui ne voudront pas s'arrêter à l'utilisation seulement. Le but étant de donner à ceux qui auront
envi de développer leur propre modèle ou d'étendre ceux existant, le moyen de la faire en se basant
sur la bibliothèque de scripts proposé.
La documentation présente en détails la structure d'un modèle de simulation en donnant des
exemples de codes pouvant servir à:
– initialiser un modèle,
– définir une topologie,
– créer les souces, le trafic et la connexion entre les noeuds,
8
– définir les traitements à effectuer après la simulation,
– tracer les courbes des paramètres après le traitement.
Cette phase consistait concrètement à faire du reverse engineering afin de comprendre le
fonctionnement de l'interface de modélisation, pour être en mesure d'expliquer son implémentation
et les différents modules qui ont été developpés.
Le code des différents composants d'un modèle de simulation ns-2 sont écrits en OTcl.
Il a donc fallu apprendre les bases de ce langage, pour mieux comprendre l'implémentation des
composants et pouvoir détailler le fonctionnement de chaque composants dans la documentation.
3.3Amélioration du code
Les codes de l'interface de modélisation ont été écrite par M. Anelli.
La troisième phase consistait à devoir améliorer une partie du code effectuant les traitements d'un
point de vue conception objet. A savoir qu'au départ, l'analyse des traces de simulation et les calculs
mathématiques étaient réalisés dans la même classe.
L'objectif était de faire un découplage pour avoir une classe dédiée aux calculs.
Au final, on se retouve avec une classe Metric et une classe Math.
L'objectif de la classe Metric étant d'analyser les traces de simulations sur un certains nombres de
propriétés charactérisant un chemin de routage.
La classe Metric fait appel à la classe Math et définit ainsi une relation d'association avec cette
classe.
L'interet de cette adaptation était de simplifier la classe Metric et aussi dans un soucis de la
réutilisabilité de la classe Math, pour qu'elle puisse être appelé par d'autre classes ou des versions
modifiées de la classe Metric.
Math
Metric
makeData()
average()
mean()
statistics()
cdf()
9
3.4 Publication des travaux
La dernière phase du projet consiste à mettre en ligne les travaux réalisés.
Il s'agira ici de faire le packaging et la communication pour la communauté des utilisateurs ns-2.
La distribution sera faite sous une licence publique et la mise en ligne sera effectué sur le site web
personnel de M. Pascal Anelli.
10
4. Conclusion
Ce TER a été très enrichissant sur le plan académique et m'a permis d'acquérir certains techniques
de travail. D'un point de vue académique, le TER a requis l'apprentissage des bases de nouveaux
langages tels que OTcl qui est utilisé dans la définitions des objets en ns-2 et aussi LaTeX pour la
structuration de document scientifique.
Le TER m'a permis de mettre en oeuvre et mieux comprendre le mécanisme de reverse engineering
car dans une phase du projet, il a fallu analyser du code pour comprendre l'implémentation de
différents objets et par la suite décrire ce fonctionnement dans un documentation destinée aux
développeurs.
De plus, comme j'envisage de m'orienter dans l'administration de système, un domaine ayant très
aux réseaux, ce TER m'a permis d'acquérir des connaissances et compétences qui me seront
certinement utiles à l'avenir.
La principale difficulté rencontré fût de pouvoir comprendre le codes et techniques et de
programmation utilisés par un développeur aguéri, avec une connaissance limité du langage.
11
Remerciements
Mes remerciements vont à M. Pascal Anelli qui a été d'un grand soutien et m'a poussé à
perfectionner le travail accompli dans le cadre de ce TER
Bibliographie
George Washington University website: http://home.gwu.edu/~ecamposn/software.html
NS-2 Workbench Project page: http://www.mnlab.cs.depaul.edu/projects/nsbench/
NS2 TCP Evaluation Tool page: http://labs.nec.com.cn/tcpeval.htm
12