II.2 les simulateurs
Beaucoup de simulateurs pour les réseaux informatiques ont
été développés pour répondre aux attentes
des utilisateurs. Parmi ces simulateurs, nous pouvons citer :
· OPNET [KKa] : un simulateur à
caractère commercial. Il fournit des outils optimisés pour
créer et tester des modèles de réseaux. Il utilise un
paradigme de modélisation hiérarchique dans chaque couche pour
aider les utilisateurs à effectuer des simulations à
évènement discrets de grande exactitude, et à
récupérer les métriques voulues. OPNET est facile à
utiliser et est relativement extensible.
· GloMosim[KfK05]: un simulateur basé sur un
ensemble de modules et de bibliothèque chacune d'elles simule un aspect
particulier des réseaux filaires ou sans fil sur une couche
particulière du modèle OSI. GloMoSim est développé
en langage PARSEC (Parallel Simulation Environnement for Complex Systems)
qui permet la simulation parallèle des processus via les messages
et les entités indépendantes. GloMoSim est extensible vers
d'autres modèles via le langage PARSEC.
· QualNet [TNS] : produit commercial dérivé
de GloMoSim.
· INSANE : le simulateur INSANE est conçu dans le
but de tester les algorithmes IP sur ATM avec un trafic réel
dérivé d'un trafic empirique mesuré.
· NetSim [ECE02] : ce simulateur est conçu pour
fournir des simulations détaillées de ETHERNET incluant la
détection des collisions.
· OMNeT++ [ECE02] : distribution libre, modulaire,
orienté objet et à événements discrets écrit
en C++. Il est conçu pour but général. Il permet la
spécification de modèles à l'aide du langage NED.
· NS2 [TCL04] : simulateur à
événements discrets, écrit en C++. Il est le simulateur le
plus célèbre dans le domaine de la simulation des réseaux.
Le projet de NS2 a débuté en 1989 avec le simulateur
réseau REAL, et a connu plusieurs extensions via les
contributions de la communauté scientifique. Il permet
des simulations filaires et sans fil. C'est ce dernier simulateur que nous
avons utilisé pour nos simulations.
II.3 Philosophie de NS2
L'application NS est composée de deux
éléments fonctionnels : un interpréteur et un moteur de
simulation. Au moyen de l'interpréteur l'utilisateur est capable de
créer le modèle de simulation, ce qui revient à assembler
les différents composants nécessaires à l'étude.
Les composants du modèle de simulation sont appelés objets ou
encore instances de classe. Le moteur de simulation quant à lui effectue
les calculs applicables au modèle préalablement construit par
l'utilisateur via l'interpréteur [KfK05] [PaE99].
NS est un outil de simulation de réseaux de
données. Il est développé en C++ avec une interface
textuelle utilisant le langage OTcl (Object Tool Command Language) qui
est une extension objet du langage de commande TCL (Tool Command
Language).
Il est bâti autour d'un langage de programmation
appelé Tcl dont il est une extension. Du point de vue de l'utilisateur,
la mise en °uvre de ce simulateur se fait via une étape de
programmation qui décrit la topologie du réseau et le
comportement de ses composants, puis vient l'étape de simulation
proprement dite et enfin l'interprétation des résultats. Cette
dernière étape peut être prise en charge par des outils
annexes, à titre d'exemple le xgraph et autres. Le NS2 est aussi
accompagné d'outils de visualisation graphique, le nam, permett ant
D'ob server graphiquement le comportement des objets durant
la simulation.
a. Le langage TCL (Tool Command Language)
Tcl est l'acronyme de "Tool Command Language"
(langage de commandes outils). Tcl est en fait divisé en deux
parties : un langage et une bibliothèque.
Tcl est un langage de programmation dont le but est de passer
des commandes à des programmes interactifs tels que des éditeurs
de texte, des débogueurs et des interpréteurs shell. Il
possède une syntaxe simple et il est lui-même programmable : les
utilisateurs de Tcl peuvent en effet écrire des procédures pour
créer des commandes plus puissantes que celles fournies par l'ensemble
préconstruit. La bibliothèque Tcl est constituée d'un
analyseur syntaxique du langage Tcl, de routines implémentant les
commandes prédéfinies de Tcl, et de procédures permettant
à chaque application d'ajouter à Tcl des commandes additionnelles
qui lui sont spécifiques. Le programme applicatif génère
des commandes Tcl et les passe à l'analyseur syntaxique de Tcl pour
l'exécution.
· Tcl fournit une syntaxe standard : une fois que les
utilisateurs connaissent Tcl, ils seront capables de passer facilement des
commandes à n'importe quelle application basée sur Tcl.
· Tcl parvient à une bonne «
programmabilité ». Tout ce qu'une application nécessite est
l'implémentation de quelques commandes spécifiques de bas niveau.
Tcl fournit de nombreuses commandes utilitaires et une interface
générique de programmation pour construire des procédures
de commandes complexes. En utilisant Tcl, les applications ne
nécessitent pas de ré-implémentation de ces
caractéristiques.
· Les extensions à Tcl, telles que la boîte
à outils Tk, fournissent des mécanismes pour la communication
entre applications, en envoyant des commandes Tcl dans un sens et dans l'autre.
La structure commune du langage Tcl rend plus aisée la communication
entre applications.
Toutes applications qui utilisent tcl créent et
utilisent un interpréteur tcl. Lorsque l'on tape ns,
une série d'initialisation est faite, puis l'application passe
en mode interactif, c'est-à-dire que l'interpréteur est
prêt à recevoir une nouvelle commande; et on peut entrer des
commandes tcl. Le retour à la ligne d'une commande provoque son
exécution ; deux commandes sur une même ligne sont
séparées par un point virgule.
Construire une application avec un interpréteur Tcl
revient à inclure une bibliothèque Tcl qui définit les
commandes de bases de Tcl dans l'application. Comme nous l'avons dit,
l'interpréteur effectue l'analyse syntaxique et appelle la fonction C
correspondant à la commande Tcl. Ajouter une commande Tcl consiste
à établir un lien entre un mot et une fonction C. Le mot sera le
nom de la commande Tcl. La fonction C est définie dans le code source de
l'application. Au démarrage, l'application procède dans son
main() aux initialisations nécessaires et passe la main à
l'interpréteur. L'application passe en mode interactif à chaque
commande tapée par l'utilisateur, la fonction C correspondante est
appelée afin de réaliser la commande demandée.
b. le OTcl :
OTcl est une extension orientée objet de Tcl. Les
commandes Tcl sont appelées pour un objet. En OTcl, les classes sont
également des objets avec des possibilités d'héritage. La
définition d'une classe commence par la directive Class.
Les fonctions et les attributs d'une classe s'installent par la suite
par les commandes instvar et insproc. L'utilisation instproc définit les
méthodes de la classe de manière assez semblable à C++.
Lors d'une instanciation en OTcl, le
constructeur de la classe appelle init{ } pour les
initialisations et les traitements propres à l'objet. La méthode
init{} est optionnelle, c'est à dire que si l'instanciation ne
nécessite aucune initialisation il n'est pas nécessaire de la
définir. On peut l'appeler également variable d'instance. La
valeur de l'attribut appartient à l'objet. La commande instvar est
utilisée dans une méthode pour mettre en correspondance une
variable d'instance avec une variable locale à la méthode. Il
n'est pas nécessaire de faire une déclaration préalable au
niveau de la classe. Une déclaration d'une variable d'instance se fait
à l'intérieur d'une méthode membre. Par exemple, pour
déclarer la variable d'instance, il suffit d'écrire "$self
instvar x". Le schéma général de déclaration d'une
classe est le suivant:
Class <Nom de classe>
<Nom de classe> instproc init {args} {
# constructeur
...
}
<Nom de classe> instproc methode1 {args} {
$self instvar variable1 # variable membre de la classe
...
}
En NS, les objets sont créés par la commande new
<nom de la classe> qui retourne une référence sur l'objet
créé. Par exemple, la création d'une instance de Simulator
est effectuée par la commande suivante:
set ns [new Simulator]
Les objets topologiques (noeud et lien) ont une syntaxe de
création quelque peu différente. On n'utilise pas la commande
new{} mais une procédure de la classe Simulator. Dans les deux cas, la
classe est uniquement OTcl et la référence des instances de ces
classes est mémorisée dans un tableau de la classe Simulator. Par
exemple la création d'un noeud est effectuée avec la syntaxe
suivante: $ns node.
Une fois créés, les objets sont manipulables
avec les méthodes dont ils disposent. Ces méthodes proviennent de
leur classe et de leurs super-classes. L'appel d'une méthode est
effectué via l'objet. Le nom de la méthode est le premier
argument qui suit la référence de l'objet comme c'est le cas pour
créer un noeud. La méthode appelée est la première
trouvée dans l'arbre d'héritage de l'objet. Les affectations sur
les variables membres se font par la commande set{} et suivent le format
général des commandes OTcl:
<référence instance> set <instance
variable> <valeur>
| 
