NS-2: Principes de conception et dutilisation             par P. Anelli & E. Horlait                   Version 1.3
UPMC - LIP6                                                                                                               ...
UPMC - LIP6                                                                                                               ...
UPMC - LIP6                                                                             Manuel NSRéseaux et PerformancesAv...
UPMC - LIP6                                                                             Manuel NSRéseaux et PerformancesI....
UPMC - LIP6                                                                            Manuel NSRéseaux et Performances2. ...
UPMC - LIP6                                                                             Manuel NSRéseaux et PerformancesTo...
UPMC - LIP6                                                                          Manuel NSRéseaux et PerformancesIl ex...
UPMC - LIP6                                                                             Manuel NSRéseaux et PerformancesLa...
UPMC - LIP6                                                                            Manuel NSRéseaux et PerformancesLhé...
UPMC - LIP6                                                                             Manuel NSRéseaux et PerformancesII...
UPMC - LIP6                                                                           Manuel NSRéseaux et Performancesset ...
UPMC - LIP6                                                                          Manuel NSRéseaux et Performances     ...
UPMC - LIP6                                                                             Manuel NSRéseaux et Performances# ...
UPMC - LIP6                                                                          Manuel NSRéseaux et Performances     ...
UPMC - LIP6                                                          Manuel NSRéseaux et Performances# création dun simula...
UPMC - LIP6                                                                            Manuel NSRéseaux et PerformancesNou...
UPMC - LIP6                                                                               Manuel NSRéseaux et Performances...
UPMC - LIP6                                                                            Manuel NSRéseaux et PerformancesLa ...
UPMC - LIP6                                                                              Manuel NSRéseaux et Performancess...
UPMC - LIP6                                                                                     Manuel NSRéseaux et Perfor...
UPMC - LIP6                                                                              Manuel NSRéseaux et PerformancesI...
UPMC - LIP6                                                                                     Manuel NSRéseaux et Perfor...
UPMC - LIP6                                                                            Manuel NSRéseaux et Performances   ...
UPMC - LIP6                                                                              Manuel NSRéseaux et PerformancesP...
UPMC - LIP6                                                                                  Manuel NSRéseaux et Performan...
UPMC - LIP6                                                                                  Manuel NSRéseaux et Performan...
UPMC - LIP6                                                                                       Manuel NSRéseaux et Perf...
UPMC - LIP6                                                                           Manuel NSRéseaux et Performances2.2....
UPMC - LIP6                                                                             Manuel NSRéseaux et Performances  ...
UPMC - LIP6                                                                             Manuel NSRéseaux et Performancescl...
UPMC - LIP6                                                                             Manuel NSRéseaux et PerformancesQu...
UPMC - LIP6                                                                              Manuel NSRéseaux et Performancesp...
UPMC - LIP6                                                                            Manuel NSRéseaux et Performances   ...
UPMC - LIP6                                                                              Manuel NSRéseaux et Performances ...
UPMC - LIP6                                                                               Manuel NSRéseaux et Performances...
UPMC - LIP6                                                                                Manuel NSRéseaux et Performance...
UPMC - LIP6                                                                           Manuel NSRéseaux et PerformancesA re...
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Manuel ns1.3
Prochain SlideShare
Chargement dans…5
×

Manuel ns1.3

2 209 vues

Publié le

Ns 2 tutorial en francais. il permet de connaitre les bases de la programmation avancée en ns 2

0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
2 209
Sur SlideShare
0
Issues des intégrations
0
Intégrations
4
Actions
Partages
0
Téléchargements
36
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Manuel ns1.3

  1. 1. NS-2: Principes de conception et dutilisation par P. Anelli & E. Horlait Version 1.3
  2. 2. UPMC - LIP6 Manuel NSRéseaux et PerformancesSommaireSommaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iAvant propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Conventions ......................................................................................... 1 Avis aux lecteurs.................................................................................... 1I. P r é s e n t a t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2 1. Motivations ........................................................................................ 2 2. Documentation et sites essentiels................................................................ 3 3. Notions pour lutilisation de linterpréteur ..................................................... 3 3.1. Tcl.............................................................................................. 3 3.2. OTcl............................................................................................ 5 3.3. Liens C++ et Tcl ............................................................................. 7II. U t i l i s a t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 1. Utilisation de composants standards............................................................ 8 2. Modification de composants existants ........................................................ 14 2.1. Ajout d’une variable à la classe TcpSink ................................................ 15 2.2. Utilisation de la nouvelle variable dans le simulateur .................................. 15 2.3. Utilisation de la nouvelle variable dans linterpréteur.................................. 16III. Développement de nouveaux composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 9 1. Principes de base................................................................................ 19 1.1. Arborescence des classes compilées ..................................................... 20 1.2. Arborescence des fichiers ................................................................. 20 2. Liaisons entre linterpréteur et le simulateur ................................................. 22 2.1. Attributs ..................................................................................... 25 2.2. Commandes................................................................................. 25 2.3. Initialisation de NS......................................................................... 26 3. Architecture du réseau .......................................................................... 27 3.1. Noeud ....................................................................................... 27 3.2. Lien .......................................................................................... 29 3.3. Agent ........................................................................................ 30 3.4. Paquet et en-tête ............................................................................ 31 4. Eléments de la simulation ...................................................................... 35 4.1. Simulateur................................................................................... 35 4.2. Ordonnanceur............................................................................... 36 4.3. Consommation de temps .................................................................. 37 4.4. Traitement séquentiel en temps simulé................................................... 37 4.5. Temporisateur .............................................................................. 39 5. Interprétation..................................................................................... 40 5.1. Trace......................................................................................... 40 5.2. Moniteur..................................................................................... 42 6. Routage........................................................................................... 43 7. Autres composants et fonctionnalités ......................................................... 44 7.1. Politiques de gestion de files dattente et dordonnancement ......................... 44 7.2. Agent/Loss.................................................................................. 44 7.3. Agent/Message ............................................................................. 45 7.4. Erreurs binaires............................................................................. 45 7.5. Applications................................................................................. 46 8. Ajout déléments dans NS ..................................................................... 46 i
  3. 3. UPMC - LIP6 Manuel NSRéseaux et Performances 9. Script de simulation............................................................................. 47 10. Deboggage ....................................................................................... 47IV. Exemple: nouveau protocole................................................... 4 9Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 5Annexe: Variables dinstances des classes OTcl.................................... 5 6 Simulator .............................................................................................. 56 Node ................................................................................................... 56 Link .................................................................................................... 56Annexe: URL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 8Annexe: Exemple Ping. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 9 ping.h .............................................................................................. 59 ping.cc ............................................................................................. 59 ii
  4. 4. UPMC - LIP6 Manuel NSRéseaux et PerformancesAvant proposNS est un outil logiciel de simulation de réseaux informatiques. Il est principalement bâti avec lesidées de la conception par objets, de réutilisabilité du code et de modularité. Il est devenu aujourdhuiun standard de référence en ce domaine. Cest un logiciel dans le domaine public disponible surlInternet. Son utilisation est gratuite. Le logiciel est exécutable tant sous Unix que sous Windows.Ce document ne vise pas à remplacer la documentation de NS mais plutôt de présenter cetteapplication au lecteur avec un éclairage différent et plus général. Les explications sappliquent à laversion 2.1b4.Conventionsnom{} signifie une fonction ou méthode OTcl. Elle se nomme dans ce langage des "instance procédure".nom() signifie une fonction ou méthode C++."_" Dans le code, ce caractère est appliqué comme suffixe au nom des variables; il indique une variable dinstance.Avis aux lecteursCe manuel a été réalisé avec soin pourtant, en utilisant NS, vous découvrirez peut-être desmodifications, des erreurs qui se sont glissées dans nos descriptions, des phrases un peu obscures,des particularités auxquelles nous navons pas donné limportance quelles méritent. Vous aurezprobablement des suggestions à nous faire, des reproches à formuler. Faites nous part de vosexpériences, de vos conseils pour que dautres lecteurs ne commettent pas les mêmes erreurs. Aideznous à mettre ce manuel à jour. Notre adresse: UPMC - LIP 6 : Laboratoire dInformatique de Paris VI 8, Rue du Capitaine Scott 75015 PARIS FRANCE E-mail: Pascal.Anelli@lip6.fr URL : http://www.lip6.fr/rp/~panLe Mercredi 15 Septembre 1999 -1-
  5. 5. UPMC - LIP6 Manuel NSRéseaux et PerformancesI. Présentation1. MotivationsDans [1], les auteurs donnent les principales raisons qui rendent la simulation de lInternet difficile.Elles peuvent se résumer par la grande hétérogénéité et lévolution rapide. Lhétérogénéité commenceavec les liens, comprend les protocoles et finit avec les trafics dapplications diverses et variées.LInternet évolue rapidement en terme de taille mais également en terme darchitecture et de topologie.Cest devant ce constat que des chercheurs ont essayé délever létat de lart de la simulation delInternet. Le projet VINT (http://netweb.usc.edu/vint) est une collaboration entre USC/ISI,Xerox parc, LBNL et UCB. Il a pour objectif principal de construire un simulateur multi-protocolespour faciliter létude de linteraction entre les protocoles et le comportement dun réseau à différenteséchelles. Le projet contient des bibliothèques pour la génération de topologies réseaux, des traficsainsi que des outils de visualisation tel que lanimateur réseau nam (network animator). Létude descomportements à des échelles différentes dun réseau nest pas obtenue par la simulation parallèle (quipeut être utile pour accélérer la simulation) mais par lutilisation de techniques dabstractionappliquées à différents éléments de la simulation. VINT est un projet en cours qui développe lesimulateur NS.Le simulateur NS actuel est particulièrement bien adapté aux réseaux à commutation de paquets et à laréalisation de simulations de petite taille. Il contient les fonctionnalités nécessaires à létude desalgorithmes de routage unipoint ou multipoint, des protocoles de transport, de session, deréservation, des services intégrés, des protocoles dapplication comme HTTP. De plus le simulateurpossède déjà une palette de systèmes de transmission (couche 1 de larchitecture TCP/IP),dordonnanceurs et de politiques de gestion de files dattente pour effectuer des études de contrôle decongestion. La liste des principaux composants actuellement disponible dans NS par catégorie est: Application Web, ftp, telnet, générateur de trafic (CBR, ...) Transport TCP, UDP, RTP, SRM Routage Statique, dynamique (vecteur distance) et routage multipoint (DVMRP, PIM) Gestion de file dattente RED, DropTail, Token bucket Discipline de service CBQ, SFQ, DRR, Fair queueing Système de transmission CSMA/CD, CSMA/CA, lien point à pointPrises ensembles, ces capacités ouvrent le champ à létude de nouveaux mécanismes au niveau desdifférentes couches de larchitecture réseau. NS est devenu loutil de référence pour les chercheurs dudomaine. Ils peuvent ainsi partager leurs efforts et échanger leurs résultats de simulations. Cette façonde faire se concrétise aujourdhui par lenvoi dans certaines listes de diffusion électronique de scriptsde simulations NS pour illustrer les points de vue.Le Mercredi 15 Septembre 1999 -2-
  6. 6. UPMC - LIP6 Manuel NSRéseaux et Performances2. Documentation et sites essentielsLe site de base de NS est maintenu par le projet VINT à lURL h t t p : / / w w w -mash.CS.Berkeley.EDU/ns/. On y trouve des liens et les informations principales sur NS. Lesprincipales documentations sont: - Le document [3] constitue la référence de NS quil est indispensable de posséder en complément à ce document. Il commente avec plus de détails les spécificités de NS. - le tutoriel de Marc Greis. Il est accessible en ligne à lURL http://titan.cs.uni- bonn.de/~greis/ns/ns.html. Il présente principalement les informations permettant de construire un modèle de simulation et montre comment utiliser linterpréteur. Il ny a que peu dexplications sur la création de nouveaux composants et sur le fonctionnement du simulateur. A noter que sur ce site, une page de liens est dédiée à la localisation de la documentation de NS, Tcl, C++.Toutes les informations que lon peut trouver sur NS sont en miroir sur le siteftp://rp.lip6.fr/rp/pub/documentaire/Simulateur.Deux listes de diffusions traitent exclusivement de NS: ns-users@mash.cs.berkeley.edu et ns-announce@mash.cs.berkeley.edu. Pour sinscrire, il suffit denvoyer une demande àmajordomo@mash.cs.berkeley.edu.3. Notions pour lutilisation de linterpréteurDans ce paragraphe nous allons donner les bases du langage Tcl, les principes de lOTcl et lesexplications sur le mécanisme qui permet à un programme C dutiliser un interpréteur Tcl. Laréférence dans ce domaine est louvrage [2] dont une deuxième édition est maintenant disponible.Pour OTcl, la page à consulter est localisée à lURLftp://ftp.tns.lcs.mit.edu/pub/otcl/doc/tutorial.html3.1. Tcl3.1.1. PrésentationTcl est un langage de commande comme le shell UNIX mais qui sert à contrôler les applications. Sonnom signifie Tool Command Language. Tcl offre des structures de programmation telles que lesboucles, les procédures ou les notions de variables. Il y a deux principales façons de se servir de Tcl:comme un langage autonome interprété ou comme une interface applicative dun programme classiqueécrit en C ou C++. En pratique, linterpréteur Tcl se présente sous la forme dune bibliothèque deprocédures C qui peut être facilement incorporée dans une application. Cette application peut alorsutiliser les fonctions standards du langage Tcl mais également ajouter des commandes à linterpréteur.3.1.2. LancementLe Mercredi 15 Septembre 1999 -3-
  7. 7. UPMC - LIP6 Manuel NSRéseaux et PerformancesToutes les applications qui utilisent Tcl créent et utilisent un interpréteur Tcl. Cet interpréteur est lepoint dentrée standard de la bibliothèque. Lapplication tclsh constitue une application minimaleayant pour but de familiariser un utilisateur au langage Tcl. Elle ne comporte que linterpréteur Tcl.On retrouve cet interpréteur dans lapplication NS. Lorsque lon tape ns, une série dinitialisations estfaite puis lapplication passe en mode interactif. On peut alors entrer les commandes Tcl.3.1.3. Concepts de baseChaque commande consiste en un ou plusieurs mots séparés par des espaces ou des tabulations. Lelangage nest pas typé. Tous les mots sont des chaînes de caractères. Le premier mot de la commandeest le nom de la commande, les autres mots sont les arguments passés à la commande. Chaquecommande Tcl retourne le résultat sous forme dune chaîne de caractères. Le caractère de retour à laligne termine une commande et lance son interprétation. Le caractère de séparation de commandes surune même ligne est ";". Une fois la commande exécutée et terminée, lapplication retourne en modeinteractif cest à dire que linterpréteur est de nouveau prêt à recevoir une nouvelle commande.Tcl nest pas un langage compilé, cest un langage interprété. Il ny a pas de grammaire fixe qui traitelensemble du langage. Tcl est défini par un interpréteur qui identifie les commandes par des règlesdanalyse syntaxique. Seules les règles danalyse des commandes sont fixées. Tcl évalue unecommande en deux étapes: analyse syntaxique et exécution. Lanalyse syntaxique consiste à identifierles mots et effectuer les substitutions. Durant cette étape, linterpréteur ne fait que des manipulationsde chaînes. Il ne traite pas la signification des mots. Pendant la phase dexécution, laspectsémantique des mots est traité comme par exemple déduire du premier mot le nom de la commande,vérifier si la commande existe et appeler la procédure de cette commande avec les arguments.3.1.4. SubstitutionsSubstitution de variable : $<variable>Le contenu dune variable est obtenu en faisant précéder le nom de variable par le symbole $>set a 20>expr $a*2< 4OSubstitution de commande : [<commande>]La substitution de commande permet de remplacer la commande par son résultat. Les caractères entreles crochets doivent constituer un script Tcl valide. Le script peut contenir un nombre quelconque decommandes séparées par des retour à la ligne et des ";".Anti-slash substitution: ""Il est utilisé devant les caractères retour à la ligne, $, [ pour indiquer de les interpréter comme descaractères ordinaires.3.1.5. InhibitionsLe Mercredi 15 Septembre 1999 -4-
  8. 8. UPMC - LIP6 Manuel NSRéseaux et PerformancesIl existe plusieurs façons dempêcher lanalyseur syntaxique de donner une interprétation spéciale auxcaractères tel que $ ou ;. Ces techniques se nomment inhibitions. Tcl fournit deux formesdinhibitions: - double quote (") inhibe les séparations de mots et de commandes. Il reste les substitutions de variable et de commande. Les caractères espaces, tabs, retour à la ligne et point-virgule sont traités comme des caractères ordinaires.>set msg " Aujourd hui: $date ">set msg<Aujourd hui: 22 Décembre - accolade inhibe toutes les substitutions et tous les caractères spéciaux. Les caractères compris entre les crochet sont considérés comme un mot.>set msg {Aujourd hui: $date}>set msg<Aujourd hui: $date3.1.6. ConclusionDans cette section nous venons de donner les bases pour la lecture des scripts écrits en Tcl. Lesdifférentes commandes de Tcl sont détaillées dans louvrage [2] et dans la section 5 du manuel enligne (man) dUNIX.3.2. OTclLa documentation est accessible à lURL ftp://ftp.tns.lcs.mit.edu/pub/otcl/. OTcl est uneextension orientée objet de Tcl. Les commandes Tcl sont appelées pour un objet. En OTcl, les classessont également des objets avec des possibilités dhéritage. Les analogies et les différences avec C++sont: - C++ a une unique déclaration de classe. En OTcl, les méthodes sont attachées à un objet ou à une classe. - Les méthodes OTcl sont toujours appelées avec lobjet en préfixe - Léquivalent du constructeur et destructeur C++ en OTcl sont les méthodes init{}/destroy{} - Lidentification de lobjet lui-même: this (C++), $self (OTcl). $self sutilise à lintérieur dune méthode pour référencer lobjet lui-même. A la différence de C++, il faut toujours utiliser $self pour appeler une autre méthode sur le même objet. Cest à dire "$self xyz 5" serait "this->xyz(5)" ou juste "xyz(5)" en C++. - Les méthodes OTcl sont tout le temps "virtual". A savoir, la détermination de la méthode à appeler est effectuée à lexécution. - En C++ les méthodes non définies dans la classe sont appelées explicitement avec lopérateur de portée "::". En OTcl, les méthodes sont implicitement appelées dans larbre dhéritage par "$self next". Cette commande appelle la méthode de même nom de la classe parent. - Lhéritage multiple est possible dans les deux langages.Le Mercredi 15 Septembre 1999 -5-
  9. 9. UPMC - LIP6 Manuel NSRéseaux et PerformancesLa définition dune classe commence par la directive Class. Les fonctions et les attributs dune classesinstallent par la suite par les commandes instvar et insproc. Lutilisation instproc définit lesméthodes de la classe de manière assez semblable à C++. Par exemple écrire en C++ "voidXTP::send(char* data) " sécrit en OTcl "XTP instproc send {data}". Lors duneinstanciation en OTcl, le constructeur de la classe appelle init{} pour les initialisations et lestraitements propres à lobjet. La méthode init{} est optionnelle, cest à dire que si linstanciation nenécessite aucune initialisation il nest pas nécessaire de la définir.Un attribut est une variable qui sera instanciée autant de fois que la classe comportera dinstances. Onpeut lappeler également variable dinstance. La valeur de lattribut appartient à lobjet. La commandeinstvar est utilisée dans une méthode pour mettre en correspondance une variable dinstance avecune variable locale à la méthode. Il nest pas nécessaire de faire une déclaration préalable au niveau dela classe. Une déclaration dune variable dinstance se fait à lintérieur dune méthode membre. Parexemple, pour déclarer la variable dinstance, il suffit décrire "$self instvar x". Le schémagénéral de déclaration dune 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...}etc.En NS, les objets sont créés par la commande new{} qui retourne une référence sur lobjet créé. Parexemple, la création dune 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. Onnutilise pas la commande new{} mais une procédure de la classe Simulator. Dans les deux cas, laclasse est uniquement OTcl et la référence des instances de ces classes est mémorisée dans un tableaude la classe Simulator. Par exemple la création dun noeud est effectuée avec la syntaxe suivante:$ns nodeUne fois créés, les objets sont manipulables avec les méthodes dont ils disposent. Ces méthodesproviennent de leur classe et de leurs super-classes. Lappel dune méthode est effectué via lobjet. Lenom de la méthode est le premier argument qui suit la référence de lobjet comme cest le cas pourcréer un noeud (cf exemple précédent). La méthode appelée est la première trouvée dans larbredhéritage de lobjet. Les affectations sur les variables membres se font par la commande set{} etsuivent le format général des commandes OTcl:<référence instance> set <instance variable> <valeur>Le Mercredi 15 Septembre 1999 -6-
  10. 10. UPMC - LIP6 Manuel NSRéseaux et PerformancesLhéritage est indiqué par loption -superclass <nom de la super-classe> après la directiveClass. Par exemple la class1 hérite de la class2 et class3 en utilisant la syntaxe suivante:Class class1 -superclass {class2 class3}Lors des créations dobjets en NS, la première ligne est souvent eval $self next $args. Laméthode next est utilisée pour appeler la méthode de même nom dans la hiérarchie de classe. Ellesert à effectuer une agrégation de méthode. Si aucune autre méthode de même nom nest trouvée, unechaîne nulle est retournée sinon les arguments passés avec next sont passés à la méthode. Par lasuite, nous reviendrons sur la création des objets.Les détails les plus "croustillants" à propos de OTcl sont dans sa documentation. La maîtrise dOTclcomme celle de C++ demande dabord une bonne connaissance des concepts objets plutôt que cellede la syntaxe elle-même qui reste dailleurs très simple.3.3. Liens C++ et Tcl[2] explique en détail dans les chapitres 28 à 31 le fonctionnement de lajout dune commande à Tcl.NS utilise la même mécanique. Pour faciliter les interactions entre le code interprété et C++, NSfournit la classe T c l . La documentation de lAPI C de OTcl se situe à lURLftp://ftp.tns.lcs.mit.edu/pub/otcl/doc/capi.html et sert surtout à comprendre commentle simulateur interagit avec linterpréteur.Construire une application avec un interpréteur Tcl revient à inclure une bibliothèque Tcl qui définitles commandes de bases de Tcl dans lapplication. Comme nous lavons dit, linterpréteur effectuelanalyse syntaxique et appelle la fonction C correspondant à la commande Tcl. Ajouter unecommande Tcl consiste à établir un lien entre un mot et une fonction C. Le mot sera le nom de lacommande Tcl. La fonction C est définie dans le code source de lapplication. Au démarrage,lapplication procède dans son main() aux initialisations nécessaires et passe la main à linterpréteur.Lapplication passe en mode interactif: à chaque commande tapée par lutilisateur, la fonction Ccorrespondante est appelée afin de réaliser la commande demandée.Le Mercredi 15 Septembre 1999 -7-
  11. 11. UPMC - LIP6 Manuel NSRéseaux et PerformancesII. UtilisationNS est un outil de simulation de réseaux de données. Il est bâti autour d’un langage deprogrammation appelé Tcl dont il est une extension. Du point de vue de l’utilisateur, la mise en œuvrede ce simulateur se fait via une étape de programmation qui décrit la topologie du réseau et lecomportement de ses composants, puis vient l’étape de simulation proprement dite et enfinl’interprétation des résultats. Cette dernière étape peut être prise en charge par un outil annexe, appelénam qui permet une visualisation et une analyse des éléments simulés. Dans cette section, nous allonsmontrer comment utiliser le simulateur avec les composants disponibles dans la distribution.1. Utilisation de composants standardsNous allons commencer par un exemple simple qui illustre assez bien le comportement de ce systèmeet permet d’en apprendre la terminologie élémentaire. Cet exemple est une simple simulation d’unréseau minimal constitué de deux stations communiquant l’une avec l’autre via une liaison spécialisée. 1 2Dans la terminologie NS, ce que nous appelons machine s’appelle un nœud. Un nœud peut contenirdes agents qui représentent des comportements, par exemple des applications. Une bibliothèque assezcomplète de composants existe de façon standard. Une propriété intéressante de ce système est sonextensibilité. En effet, il est assez facile d’étendre la bibliothèque des comportements, des types deliens, ou de tout autre élément du système en programmant ses propres extensions qui deviennentalors intégrées au système.Pour traiter ce premier cas, nous allons donc écrire un programme simple. En voici le contenu. Lescommentaires (introduits par le caractère #) expliquent le rôle de chaque instruction ou partie deprogramme.# création dun simulateurset ns [new Simulator]# création du fichier de trace utilisé par le visualisateur# et indication à ns de lutiliserset nf [open out.nam w]$ns namtrace-all $nf# lorsque la simulation sera terminée, cette procédure est appelée# pour lancer automatiquement le visualisateurproc finish {} { global ns nf $ns flush-trace close $nf exec nam out.nam & exit 0}# création de deux noeudsLe Mercredi 15 Septembre 1999 -8-
  12. 12. UPMC - LIP6 Manuel NSRéseaux et Performancesset n0 [$ns node]set n1 [$ns node]# création dune ligne de communication full duplex# entre les noeuds n0 et n1$ns duplex-link $n0 $n1 1Mb 10ms DropTail# création dun agent générateur de paquets à vitesse constante# paquets de 500 octets, générés toutes les 5 ms# implantation de cet agent dans le noeud n0set cbr0 [new Agent/CBR]$ns attach-agent $n0 $cbr0$cbr0 set packetSize_ 500$cbr0 set interval_ 0.005# création dun agent vide, destiné à recevoir les paquets# il est implanté dans n1set null0 [new Agent/Null]$ns attach-agent $n1 $null0# le trafic issus de lagent cbr0 est envoyé# vers null0$ns connect $cbr0 $null0# scénario de début et de fin de génération des paquets par cbr0$ns at 0.5 "$cbr0 start"$ns at 4.5 "$cbr0 stop"# la simulation va durer 5 secondes de temps simulé$ns at 5.0 "finish"# début de la simulation$ns runLors de cette simulation, les résultats sont consignés dans un fichier de trace que l’outil devisualisation nam va permettre de traiter. Dans notre programme, l’outil de visualisation est appelédirectement à la fin de la simulation. Deux éléments intéressants sont proposés à la visualisation : undessin de la topologie du réseau étudié, et une visualisation dynamique du déroulement duprogramme dans le temps.Nous verrons plus loin comment accéder à d’autres informations à partir de cette interface.Le Mercredi 15 Septembre 1999 -9-
  13. 13. UPMC - LIP6 Manuel NSRéseaux et Performances Figure 1: Exécution du premier exempleUn deuxième exemple va montrer maintenant comment complexifier un peu la topologie du réseauobtenu et rendre plus visible les comportements en construisant un réseau de quatre nœuds avec deuxsources de paquets. Lors de la visualisation, on souhaite que les paquets d’une source apparaissent enbleu, les autres en rouge. Voici le texte de ce nouveau programme et la visualisation qui en estobtenue. On remarque la visualisation de la file d’attente de messages qui se forme au nœud 2,puisque les trafics en entrée sont assez proches de la saturation.# création dun simulateurset ns [new Simulator]# création du fichier de trace utilisé par le visualisateur# et indication à ns de lutiliserset nf [open out.nam w]$ns namtrace-all $nf# lorsque la simulation sera terminée, cette procédure est appelée# pour lancer automatiquement le visualisateurproc finish {} { global ns nf $ns flush-trace close $nf exec nam out.nam & exit 0}# création de quatrenoeudsset n0 [$ns node]set n1 [$ns node]set n2 [$ns node]set n3 [$ns node]Le Mercredi 15 Septembre 1999 - 10 -
  14. 14. UPMC - LIP6 Manuel NSRéseaux et Performances# création de lignes de communication full duplex# entre les noeuds$ns duplex-link $n0 $n2 1Mb 10ms DropTail$ns duplex-link $n1 $n2 1Mb 10ms DropTail$ns duplex-link $n3 $n2 1Mb 10ms DropTail# création dagents générateurs de paquets à vitesse constante# paquets de 500 octets, générés toutes les 5 ms# implantation de cet agent dans le noeud n0set cbr0 [new Agent/CBR]$ns attach-agent $n0 $cbr0$cbr0 set packetSize_ 500$cbr0 set interval_ 0.005$cbr0 set fid_ 1set cbr1 [new Agent/CBR]$ns attach-agent $n1 $cbr1$cbr1 set packetSize_ 500$cbr1 set interval_ 0.005$cbr1 set fid_ 2# création dun agent vide, destiné à recevoir les paquets# il est implanté dans n1set null0 [new Agent/Null]$ns attach-agent $n3 $null0# routage des trafics$ns connect $cbr0 $null0$ns connect $cbr1 $null0# surveillance dune file dattente du noeud 2 vers le noeud 3$ns duplex-link-op $n2 $n3 queuePos 0.5# scénario de début et de fin de génération des paquets par cbr0$ns at 0.5 "$cbr0 start"$ns at 1.0 "$cbr1 start"$ns at 4.0 "$cbr1 stop"$ns at 4.5 "$cbr0 stop"# paramétrage des couleurs daffichage$ns color 1 Blue$ns color 2 Red# la simulation va durer 5 secondes de temps simulé$ns at 5.0 "finish"# début de la simulation$ns runEn exécutant ce programme (voir figure, on verra que la gestion de la file d’attente à l’entrée du lien 2vers 3 n’est pas très équitable. Pour modifier cela, il suffit d’indiquer une gestion politique différenteà cette file en modifiant la déclaration du lien en question par :$ns duplex-link $n3 $n2 1Mb 10ms SFQLa politique SFQ (Stochastic Fair Queuing) a pour conséquence de mieux équilibrer les pertes depaquets entre les différents flots de données.Le Mercredi 15 Septembre 1999 - 11 -
  15. 15. UPMC - LIP6 Manuel NSRéseaux et Performances Figure 2: Exécution avec politique DropTail Figure 3: Exécution avec politique SFQMontrons maintenant comment créer des systèmes un peu plus complexes. Ce troisième exemple créeune topologie circulaire de réseau, génère un trafic et fait apparaître des pannes sur l’un des liens.Le Mercredi 15 Septembre 1999 - 12 -
  16. 16. UPMC - LIP6 Manuel NSRéseaux et Performances# création dun simulateurset ns [new Simulator]# création du fichier de trace utilisé par le visualisateur# et indication à ns de lutiliserset nf [open out.nam w]$ns namtrace-all $nf# lorsque la simulation sera terminée, cette procédure est appelée# pour lancer automatiquement le visualisateurproc finish {} { global ns nf $ns flush-trace close $nf exec nam out.nam & exit 0}# modèle de routage$ns rtproto DV# création de sept noeuds à laide dune boucle# les descripteurs de noeuds sont stockés dans un tableaufor {set i 0} {$i < 7} {incr i} { set n($i) [$ns node]}# création de lignes de communication full duplex# entre les noeudsfor {set i 0} {$i < 7} {incr i} { $ns duplex-link $n($i) $n([expr ($i+1)%7]) 1Mb 10ms DropTail}# création dagents générateurs de paquets à vitesse constante# paquets de 500 octets, générés toutes les 5 ms# implantation de cet agent dans le noeud n0set cbr0 [new Agent/CBR]$ns attach-agent $n(0) $cbr0$cbr0 set packetSize_ 500$cbr0 set interval_ 0.005# création dun agent vide, destiné à recevoir les paquets# il est implanté dans n1set null0 [new Agent/Null]$ns attach-agent $n(3) $null0# routage des trafics$ns connect $cbr0 $null0# scénario de début et de fin de génération des paquets par cbr0$ns at 0.5 "$cbr0 start"$ns at 4.5 "$cbr0 stop"# panne dun lien$ns rtmodel-at 1.0 down $n(1) $n(2)$ns rtmodel-at 2.0 up $n(1) $n(2)# la simulation va durer 5 secondes de temps simulé$ns at 5.0 "finish"# début de la simulation$ns runLe Mercredi 15 Septembre 1999 - 13 -
  17. 17. UPMC - LIP6 Manuel NSRéseaux et PerformancesNous avons introduit ici un protocole de routage explicite dans le système. Il s’agit simplement d’uneméthode de type vecteur de distance qui modélise un protocole à la RIP. Le résultat obtenugraphiquement est donné à la Figure 4. La déclaration du type de routage est faite par l’instruction :$ns rtproto DVLes pannes qui entraînent un recalcul des routages sont, elles, déclenchées par les instructions :$ns rtmodel-at 1.0 down $n(1) $n(2)$ns rtmodel-at 2.0 up $n(1) $n(2) Figure 4: Panne et re-routage2. Modification de composants existantsNS est en réalité un programme relativement complexe écrit en C++ et interfacé via Tcl. Pourmodifier le comportement d’objets existants, il est donc nécessaire de modifier le code C++ qui enréalise l’implantation.Pour illustrer cette façon de travailler, nous allons traiter un exemple simple. Nous nous proposonsde faire des statistiques de trafic sur un échange de données utilisant TCP. Dans NS, une connexionTCP est modélisée par une source de paquets et un puits de données responsable, entre autres choses,de la génération des acquittements. La méthode choisie est la suivante : 1. Nous utiliserons le puits TCP pour faire notre modification. Pour cela, nous ajouterons dans chaque puits, une variable qui comptabilise le nombre d’octets reçus par le puits. 2. Ensuite, nous rendrons cette variable accessible via l’interface Tcl.Le Mercredi 15 Septembre 1999 - 14 -
  18. 18. UPMC - LIP6 Manuel NSRéseaux et Performances 3. Enfin, lors de l’utilisation, une tâche périodique, écrite en Tcl, sera activée pour venir lire le contenu de cette variable et préparer le fichier de données correspondant.2.1. Ajout d’une variable à la classe TcpSinkLa comptabilisation des octets reçus se fera dans une variable entière de la classe TcpSink ; ladéclaration de cette classe est faite dans le fichier TcpSink.h. La modification apportée est trèssimple : elle est présentée en grisé sur l’extrait de code ci-dessous.class TcpSink : public Agent {public: TcpSink(Acker*); void recv(Packet* pkt, Handler*); void reset(); int command(int argc, const char*const* argv); TracedInt& maxsackblocks() { return max_sack_blocks_; }protected: void ack(Packet*); virtual void add_to_ack(Packet* pkt); Acker* acker_; int ts_echo_bugfix_; /* for byte counting */ int bytes_; friend void Sacker::configure(TcpSink*); TracedInt max_sack_blocks_; /* used only by sack sinks */};2.2. Utilisation de la nouvelle variable dans le simulateurLa classe TcpSink est maintenant munie d’une nouvelle variable que nous allons pouvoir utiliser.Deux choses principales restent à réaliser : l’initialisation correcte de cette variable dans leconstructeur de la classe TcpSink et la mise à jour en cours de simulation de cette variable. Dans lesdeux cas, les modifications interviennent ici dans le code C++ implantant la classe TcpSink, c’est àdire dans le fichier TcpSink.cc.L’initialisation de cette variable, bytes_, est faite dans le constructeur de TcpSink, comme le montrel’extrait de code suivant :TcpSink::TcpSink(Acker* acker) : Agent(PT_ACK), acker_(acker){ bind("packetSize_", &size_); bind("bytes_", &bytes_); // for statistics bytes_ = 0; // init bind("maxSackBlocks_", &max_sack_blocks_); // used only by sack bind_bool("ts_echo_bugfix_", &ts_echo_bugfix_);}La fonction bind permet de faire le lien entre une variable C++ et une variable (de même nom ici)accessible par l’interface Tcl. Lors de la construction d’un objet TcpSink, la variable est initialisée à0.Le Mercredi 15 Septembre 1999 - 15 -
  19. 19. UPMC - LIP6 Manuel NSRéseaux et PerformancesLa deuxième phase de la modification dans ce même fichier consiste à mettre à jour le contenu de cettevariable en fonction du trafic reçu. Ce travail peut être facilement implanté dans la procédure deréception d’un paquet par un object TcpSink. La méthode à modifier est appelée recv(). L’extrait decode ci-dessous montre la modification réalisée.void TcpSink::recv(Packet* pkt, Handler*){ int numToDeliver; int prebytes; // tempo int numBytes = ((hdr_cmn*)pkt->access(off_cmn_))->size(); hdr_tcp *th = hdr_tcp::access(pkt); acker_->update_ts(th->seqno(),th->ts()); numToDeliver = acker_->update(th->seqno(), numBytes); if (numToDeliver) recvBytes(numToDeliver); ack(pkt); // statistics prebytes = th->seqno() + numBytes -1; if (prebytes > bytes_) bytes_ = prebytes; Packet::free(pkt);}La mise à jour de la variable bytes_ intervient juste avant la libération du paquet de données. Ellemarque la progression du nombre d’octets reçus en séquence par l’objet TcpSink (ce n’est pasnécessairement le nombre d’octets du paquet qui peut être dupliqué).Ces modifications étant faites, il suffit de recompiler le code de NS, puisque les éléments sur lesquelsnous venons de travailler en sont des composants.2.3. Utilisation de la nouvelle variable dans linterpréteurL’exemple suivant illustre l’utilisation de cette nouvelle variable dans un environnement de typeréseau local. Cette illustration montre également la mise en œuvre du composant “ LAN ” fourni parNS. Le code Tcl de cet exemple est reproduit ci-dessous.# création dun simulateurset ns [new Simulator]set bw bw1.dat# création du fichier de traceset f0 [open $bw w]# lorsque la simulation sera terminée, cette procédure est appelée# pour lancer automatiquement le visualisateurproc finish {} { global ns f0 close $f0 exit 0}Après avoir créé le simulateur proprement dit, préparé le fichier de trace et défini la procédure determinaison du simulateur, nous allons créer les nœuds du réseau et construire la topologie associée.# création de noeudsset n0 [$ns node]Le Mercredi 15 Septembre 1999 - 16 -
  20. 20. UPMC - LIP6 Manuel NSRéseaux et Performancesset n1 [$ns node]set n2 [$ns node]set n3 [$ns node]set n4 [$ns node]set n5 [$ns node]# création dun réseau local Ethernet$ns make-lan "$n0 $n1 $n2 $n3" 10Mb 0.05ms LL Queue/DropTail Mac/Csma/Cd# création dun autre Ethernet avec passerelle entre les deux$ns make-lan "$n3 $n4 $n5" 10Mb 0.05ms LL Queue/DropTail Mac/Csma/CdL’étape suivante consiste en la définition des trafics générés. Nous avons choisi de définir ici deuxéchanges : l’un CBR, l’autre de type transfert de fichier qui utilisera TCP et notre version modifiéede TcpSink.# création dun agent générateur de paquets à vitesse constante# paquets de 500 octets, générés toutes les 5 ms# implantation de cet agent dans le noeud n0set cbr0 [new Agent/CBR]$ns attach-agent $n0 $cbr0$cbr0 set packetSize_ 800$cbr0 set interval_ 0.01ms# création dun agent vide, destiné à recevoir les paquets# il est implanté dans n5set null0 [new Agent/Null]$ns attach-agent $n5 $null0# le trafic issus de lagent cbr0 est envoyé# vers null0$ns connect $cbr0 $null0# une connexion TCPset src [new Agent/TCP]set dst [new Agent/TCPSink]$ns attach-agent $n1 $src$ns attach-agent $n5 $dst$src set fid_ 2# set tcp0 [$ns create-connection TCP $n1 TCPSink $n5 2]set tcp0 [$ns connect $src $dst]# $tcp0 set window_ 50set ftp0 [new Application/FTP]$ftp0 attach-agent $tcp0#set sink [new Agent/LossMonitor]#$ns attach-agent $n5 $sinkLa topologie et les trafics sont définis. Il reste maintenant à créer le scénario d’exécution et leséléments de mesure. Pour cela, nous définissons une procédure record qui sera appelée régulièrementau cours de la simulation. C’est cette procédure qui accédera à la variable bytes_ que nous avonscréée. Ici, la valeur de la variable est écrite dans un fichier en même temps que la date de la collecte del’information. Ce fichier pourra ensuite être récupéré pour un traitement graphique ou numérique.proc record {} { global f0 dst set ns [Simulator instance] set time 0.01 set bw0 [$dst set bytes_] set now [$ns now] puts $f0 "$now $bw0"Le Mercredi 15 Septembre 1999 - 17 -
  21. 21. UPMC - LIP6 Manuel NSRéseaux et Performances # $dst set bytes_ 0 $ns at [expr $now+$time] "record"}# scénario de début et de fin de génération des paquets par cbr0$ns at 0.0 "record"$ns at 1.5 "$cbr0 start"$ns at 0.5 "$ftp0 start"$ns at 3.5 "$cbr0 stop"$ns at 5.5 "$ftp0 stop"# la simulation va durer 5 secondes de temps simulé$ns at 6.0 "finish"# début de la simulation$ns runL’exécution de ce programme génère un fichier de trace des numéros de séquence en fonction dutemps. La courbe suivante représente la variation, dans le temps de ce numéro de séquence, ainsi quela dérivée de cette valeur (variation instantanée). 6000 5000 4000 3000 2000 1000 0 0 1 2 3 4 5 6 7 -1000 emps Numéros de séquence Dérivée premièreLa topologie du réseau étudié est rappelée ci-après. 0 1 2 3 CBR TCP 4 5Le Mercredi 15 Septembre 1999 - 18 -
  22. 22. UPMC - LIP6 Manuel NSRéseaux et PerformancesIII. Développement de nouveaux composants1. Principes de baseNS est un simulateur à événements discrets orienté objet. Il est écrit en C++ avec une interfacetextuelle (ou shell) qui utilise le langage OTcl (Object Tool Command Langage). LOTcl est uneextension objet au langage de commande Tcl. Le langage C++ sert à décrire le fonctionnement internedes composants de la simulation. Pour reprendre la terminologie objet, il sert à définir les classes.Quant au langage OTcl, il fournit un moyen flexible et puissant de contrôle de la simulation comme ledéclenchement dévénements, la configuration du réseau, la collecte de statistiques, etc. LapplicationNS se compose de deux élèments fonctionnels: un interpréteur et un moteur de simulation. Au moyende linterpréteur lutilisateur est capable de créer le modèle de simulation ce qui revient à assembler lesdifférents composants nécessaires à létude. Les composants du modèle de simulation sont appelésobjets ou encore instances de classe. Le moteur de simulation effectue les calculs applicables aumodèle préalablement construit par lutilisateur via linterpréteur.NS bénéficie de toutes les possibilités quoffrent les techniques objets comme lhéritage, lepolymorphisme, la surcharge, etc. Lhéritage permet délaborer des arborescences de classes. Lemodèle de simulation est construit à partir dune arborescence de classes qui en fait se dédouble: - une définie en OTcl dite arborescence interprétée. Elle est utilisée par linterpréteur et est visible par lutilisateur. - une définie en C++ que lon nommera compilée. Elle forme larborescence utilisée par le moteur de simulation (que lon appellera par la suite simulateur). Cest lombre de larborescence interprétée.Les deux arborescences sont très proches lune de lautre. Du point de vue de lutilisateur, il y a unecorrespondance univoque entre une classe dune arborescence et une classe de lautre arborescence.La figure 1 montre la dualité des classes qui peut exister dans NS. C++ OTcl NS Figure 1: Dualité des classes OTcl et C++Le Mercredi 15 Septembre 1999 - 19 -
  23. 23. UPMC - LIP6 Manuel NSRéseaux et PerformancesLe principe général de la création des objets du modèle de simulation est le suivant: lutilisateur créeun nouvel objet via linterpréteur OTcl. Le nouvel objet interprété est cloné en un objet compilécorrespondant dans le simulateur.En réalité toutes les classes ne sont pas dans les deux arborescences de NS. On peut avoir des classesqui ne sont que dans linterpréteur: elles servent à faire par exemple des assemblages (ou agrégationsde classes) pour faciliter la manipulation. On parlera de classe OTcl dans la suite de ce document pourfaire référence à ce type de classe. On peut avoir des classes qui sont purement dans le simulateur:elles ne sont pas visibles de lutilisateur et servent au fonctionnement interne dun composant commepar exemple certaines structures de données.1.1. Arborescence des classes compiléesLa figure 2 représente larborescence de classes utilisée par le simulateur. Les classes visibles auniveau de linterpréteur comportent une déclaration dans la classe TclClass. Nous y reviendronslorsque nous étudierons la création des objets. Nous verrons également lobjectif des différentesclasses. Le nom des classes correspond à celui utilisé dans le code source. TclObject Event Application PacketQueue Packet TrafficGenerator Scheduler QueueMonitor Handler CBR_Traffic NsObject QueueHandler TimerHandler Connector Classifier Mac Trace AddrClassifier Channel MacClassifier Queue SnoopQueue HashClassifier DropTail RED Agent LinkDelay FidHashClassifier TCP UDP LL Clep Reno Figure 2: Arborescence de dérivation des classes C++ du simulateur1.2. Arborescence des fichiersLe Mercredi 15 Septembre 1999 - 20 -
  24. 24. UPMC - LIP6 Manuel NSRéseaux et Performances nam-1 tclcl ns-2 lib gen ex tcl lib test Figure 3: Arborescence des fichiers de la distribution NS.La distribution de NS comprend principalement 3 répertoires: - ns-2, lapplication NS. Ce repertoire contient lensemble des fichiers .h et .cc de NS. - nam-1, loutil de visualisation des résultats de la simulation: lanimateur réseau. - tclcl, sources du code assurant la liaison entre linterpréteur et le simulateur. Citons lun des principaux fichiers: tcl-object.tcl.Dans le répertoire ns-2, on trouve les répertoires: - tcl pour tous les codes interprétés. - bin pour les utilitaires et les exécutables pour la réalisation du binaire ns-2 - lib pour la bibliothèque de libg++ - gen pour les sources générées lors de la réalisation du binaire ns-2 par le makefile. - test_output pour les résultats des simulations. - tous les fichiers .h et .cc des classes C++ du simulateur.Le répertoire tcl contient les répertoires: - lib pour les méthodes OTcl des classes de larborescence interprétée. Dans ce répertoire, les fichiers ns_lib.tcl et ns_default.tcl ont un rôle particulier. Le premier est interprété automatiquement au lancement de NS. Il contient lensemble du code interprété de NS via la commande Tcl "source" (lecture dun fichier) des différents fichiers OTcl. Les valeurs par défaut affectées aux objets sont déclarées dans le second. Les autres fichiers de ce répertoire sont lAPI OTcl de NS. Ils ont un nom préfixé par ns_. - ex pour les scripts de simulation donnés à titre dexemple. - test, il recense lensemble des scripts des suites de tests pour la validation du simulateur. On peut également prendre le contenu de ce répertoire comme des exemples. Les autres répertoires contiennent les codes interprétés des contributions.Pour un utilisateur qui souhaite écrire seulement des scripts, limpression des commandes disponiblesde linterpréteur constitue une bon complément à la documentation existante. Quelle que soit létude àmener, les principaux fichiers sont:ns-lib.tcl, ns-node.tcl, ns-link.tcl, ns-agent.tcl, ns-default.tcl, ns-packet.tclLe Mercredi 15 Septembre 1999 - 21 -
  25. 25. UPMC - LIP6 Manuel NSRéseaux et PerformancesPour lutilisateur qui souhaite faire des développements de composants NS, les fichiers importantssont:connector.{h,cc}, classifier.{h,cc}, packet.{h,cc}, timer-handler.{h,cc},queue.{h,cc}, agent.{h,cc}, udp.{h,cc}, app.{h,cc}, trafgen.{h,cc}, trace.{h,cc}2. Liaisons entre linterpréteur et le simulateurComme nous pouvons le voir dans larborescence de dérivation des classes C++, la classe TclObjectest la racine de toutes les autres classes à la fois dans larborescence compilée et interprétée. La classeTclObject constitue donc la classe de base de la plupart des autres classes. Tous les objets du modèlede simulation sont des instances de la classe TclObject. Cette classe sert aux objets dont la création estinitiée par linterpréteur. Elle possède les interfaces nécessaires aux liaisons entre les variables quidoivent être visibles à la fois en C++ et OTcl. Elle définit la fonction command() qui est très utilepour ajouter des commandes à linterpréteur. La classe TclObject ainsi que les autres sources durépertoire tclcl sont partagés entre NS et le projet MASH de Berkeley. Dans la hiérarchie des classesOTcl, le nom de la classe racine se nomme autrement et porte le nom de SplitObject.La classe NsObject est une sous-classe de la classe TclObject mais reste cependant une super-classeaux autres classes. La principale différence avec la classe TclObject tient à ce quelle est capable derecevoir des paquets et traiter des événements. Elle hérite de la classe Handler. Cette classe constituela principale racine des objets dans NS. Elle contient les fonctions communes nécessaires ausimulateur et définit la fonction virtuelle "void recv (Packet *, Handler* callback =0)=0;".Cette fonction est une fonction générique utilisée par tous les objets dérivés de NsObject pourrecevoir un paquet. Elle est réellement définie par les sous-classes. Nous reviendrons sur la classeNsObject lorsque nous verrons lordonnanceur (scheduler).Lutilisateur crée les objets de sa simulation via linterpréteur. Cest à dire que ces objets existeront àla fois dans linterpréteur et dans le simulateur. La création dun objet est en fait linstanciation dedeux objets qui sont chacun au même niveau dans leur arborescence de classe. La classe TclClass sertà établir larborescence de classes OTcl en fonction de celle de C++. La classe TclClass na pasdinstance créée dynamiquement. Tous les objets de cette classe sont créés par déclaration dunevariable statique. Par exemple, pour un estimateur de débit par fenêtre temporelle, nous avons:static class TimeWindow_EstClass : public TclClass {public: TimeWindow_EstClass() : TclClass ("Est/TimeWindow") {} TclObject* create(int, const char*const*) { return (new TimeWindow_Est()); }}class_timewindow_est;Le nom de la classe OTcl est Est/TimeWindow. Au lancement du simulateur toutes les variables deTclClass sont créées, le constructeur est appelé, dans notre exemple TimeWindow_EstClass (), leconstructeur de la classe TclClass est lui-même appelé. Ce dernier a en charge de procéder àlenregistrement de la classe en OTcl sous le nom donné en paramètre (ici Est/TimeWindow).Le Mercredi 15 Septembre 1999 - 22 -
  26. 26. UPMC - LIP6 Manuel NSRéseaux et PerformancesPour que la hiérarchie des classes du simulateur soit reproduite dans linterpréteur, NS utilise laconvention suivante pour nommer les classes OTcl. Le caractère / est utilisé comme séparateur. Lenom de lascendant est à gauche, celui du descendant se situe à droite. Dans notre exemple:TimeWindow est la classe dérivée de la classe Est (estimateur). La déclaration de la classe OTclEst/TimeWindow est faite en précisant que la classe parent est Est.Ainsi grâce à la classe TclClass, nous avons larborescence de classes C++ reproduite en OTcl.Pourquoi faire cette copie? La réponse tient en un mot: héritage. Quand un objet est créé, il a lesattributs de sa classe mais aussi ceux de ses ascendants. Les objets sont créés via linterpréteur et sontdabord des instances de classes OTcl. Pour que ces objets aient les mêmes attributs que leur clonedans le simulateur, nous devons avoir la même hiérarchie en OTcl et C++.Nous allons maintenant étudier la création dun objet. Le schéma général de la construction suit lesenchaînements montrés par la figure 4. new{} (tcl-object.tcl) Méthodes OTcl Const. de lobjet Const. du parent Const. SplitObject $self next $self next Crée objet C++ par create_shadow() Finit linit Finit linit Méthodes C++ Const. du TclObject Const. du parent Const. de lobjet appel du const. du appel du const. du parent parent Return attache attributs attache attributs Figure 4: Cinématique de la création dun objet NSPour illustrer cette figure prenons lexemple de la classe Trace/Enq. Cette classe sert à créer un objetqui écrit une trace à chaque arrivée de paquet. Cet exemple est intéressant car il mélange danslarborescence de classes de linterpréteur une classe purement OTcl (Trace/Enq) avec une classeOTcl/C++ (Trace). La hiérarchie des classes pour cet exemple est montré par la figure 5. Une instancede la classe Trace/Enq est crée par la commande:set trace [new Trace/Enq]Le Mercredi 15 Septembre 1999 - 23 -
  27. 27. UPMC - LIP6 Manuel NSRéseaux et Performances OTcl C++ TclObject Handler NsObject Tra ce cre SplitObject ate Connector -sh ado w{} Trace Trace Trace/Enq Figure 5: Constructeurs utilisés par Trace/Enq.La liaison entre linterpreteur et le simulateur est effectuée par la TclClass TraceClass:class TraceClass : public TclClass {public: TraceClass() : TclClass("Trace") { } TclObject* create(int argc, const char*const* argv) { if (argc >= 5) return (new Trace(*argv[4])); return 0; }} trace_class;La séquence des opérations est la suivante: - Comme toute création dobjet en OTcl, la méthode init{} de la classe Trace/Enq est appelée par la méthode OTcl create{}. - Par la méthode next, linit{} de la classe Trace/Enq appelle le constructeur de la classe parent, ici Trace. - le constructeur de Trace fait appel également à init{} de cette classe qui fait elle-même appel au constructeur du SplitObject. - La méthode init{} du SplitObject (tcl-object.tcl ) appelle la méthode C++ create_shadow() pour la classe Trace via create-shadow{} de Trace. Trace/Enq na pas de méthode create-shadow{} propre, cest la première méthode trouvée dans la hiérarchie des classes parentes qui sera appelée. La méthode create-shadow{} est ajoutée à la classe Trace et attachée à la fonction create_shadow() lors de linitialisation de NS. Trace::create_shadow() appelle la méthode TraceClass ::create(). Dans la déclaration de la TraceClass, on voit que create() appele le constructeur dune trace et le retourne comme un TclObject. - Le constructeur de Trace appelle le constructeur de classe parente (ici Connector). Ce schéma dappel sapplique jusquà la classe TclObject. Ici nous assistons ni plus ni moins à la création dun objet selon la méthode définie par C++. - Une fois lobjet TclObject créé, nous redescendons la hiérarchie des classes jusquà notre classe dappel initial en exécutant chaque fois le code de chaque constructeur. Ce code consiste principalement à initialiser les attributs de lobjet et à les lier ou attacher avec leurLe Mercredi 15 Septembre 1999 - 24 -
  28. 28. UPMC - LIP6 Manuel NSRéseaux et Performances homologue de linterpréteur. Nous reviendrons par la suite sur cet aspect des attributs communs au simulateur et à linterpréteur. - la méthode Trace create-shadow{} est terminée, le code de linit{} de chaque classe de larborescence finit dêtre évalué jusquà celui de la classe dappel. - Lobjet est créé. Une référence sur cet objet est rendue. Il possède également un identificateur de la forme _o<nnn>.Quand il ny a pas de classe purement OTcl comme cest le cas pour lestimateur de débit par fenêtretemporelle, le schéma de la construction dune instance de cette classe est représentée dans la figure 6. OTcl C++ TclObject Handler Es t/T im SplitObject e NsObject cr Win ea te dow -s ha Est do Est w{} Est/TimeWindow TimeWindow_Est Figure 6: Constructeurs pour lestimateur de débit par fenêtre temporelle2.1. AttributsUn attribut est une variable dinstance. Il indique une variable membre dune classe. NS permet queles attributs des objets entre linterpréteur et le simulateur soient liés de manière à ce quunchangement de valeur dun attribut compilé soit répercuté dans lattribut interprété et inversement. NSoffre 5 types dattributs: réel, entier, débit, temps et booléen.La liaison entre lattribut des objets de linterpréteur et du simulateur est établie par le constructeur delobjet compilé au moyen de la fonction bind():bind("<nom variable OTcl>", &<variable C++>);Pour que la liaison fonctionne, il faut que lattribut existe préalablement dans linterpréteur. Pour cela,les attributs sont définis pour la classe avec une valeur par défaut. La plupart de ces initialisations sonteffectuées dans le fichier tcl/lib/ns-default.tcl. La syntaxe est la suivante:<classe> set <attribut> <valeur>Les attributs sont supposés être initialisés à partir de tclcl. Linitialisation se produit après lappel auconstructeur C++. Le code de linitialisation est dans le fichier ns-default.tcl. La conclusion decette remarque est quil ne faut pas procéder aux initialisations dattributs dans un constructeur C++.2.2. CommandesLe Mercredi 15 Septembre 1999 - 25 -
  29. 29. UPMC - LIP6 Manuel NSRéseaux et Performances2.2.1. Classe TclLaccès à linterpréteur à partir du C++ se fait par les méthodes fournies par la classe Tcl. Lesméthodes fournies permettent notamment de procéder à lévaluation de commandes Tcl à partir ducode C++.Tous les objets créés dans le simulateur sont enregistrés dans une table avec comme clé lID attribué àlobjet lors de sa création. Cette classe comporte également les méthodes pour ajouter, supprimer etretrouver un élément dans la table.2.2.2. Méthodes CommandPour chaque objet de la classe TclObject, NS fournit la méthode cmd{} . Cette procédure sert àexécuter des méthodes pour lobjet interprété qui sont définies pour lobjet compilé. Lappel à laprocédure cmd{} revient à faire appel à la méthode command() de lobjet compilé correspondant.Par exemple pour Trace (trace.cc), le schéma général de command() est le suivant:int Trace::command(int argc, const char*const*argv){ Tcl& tcl = Tcl::instance(); //récupère la référence sur linterpreteur if (argc == 2){ if (strcmp(argv[1], "detach") == 0){ [...] return (TCL_OK); } }}Lappel peut être explicite "$trace cmd detach" ou implicite "$trace detach". Les deux formessont équivalentes.2.3. Initialisation de NSAprès avoir vu les principales classes de base du simulateur, nous allons présenter les principalesétapes effectuées lors du démarrage de NS. Ce code figure dans le fichier tclcl/Tcl.cc ettclcl/ns_tclsh.cc. Pour illustrer notre propos, nous reprenons lexemple de lestimateur de débitpar fenêtre temporelle du début cette section. - Au lancement de NS, toutes les variables statiques dérivées de TclClass sont créées et enregistrées dans une liste chainée au moyen de TclClass() comme cest le cas pour la classe TimeWindow_EstClass. - A linitialisation de NS qui est effectuée par Tcl_AppInit() : • Linterpréteur est créé. • Le code de tclcl/tcl-object.tcl est évalué. • Ensuite chaque classe dérivée de la classe TclClass déclare dans linterpréteur une sous-classe de TclObject avec une méthode OTcl pour lancer la construction de lobjet dans le simulateur (cf. TclClass::bind()). Cette méthode se nomme create-Le Mercredi 15 Septembre 1999 - 26 -
  30. 30. UPMC - LIP6 Manuel NSRéseaux et Performances shadow{} et appele TclObject::create_shadow(). Avec notre exemple le code OTcl suivant est exécuté: class Est/TimeWindow -parent Est Est/TimeWindow instproc create-shadow {...} • Le code de tcl/lib/ns-lib.tcl est évalué. Lévaluation de ce fichier se termine par lévaluation du fichier tcl/lib/ns-default.tcl qui procéde à linitialisation des attributs des classes.Lenvironnement est prêt. La main est maintenant passée à linterpréteur, lutilisateur peut dorénavanttaper ses commandes Tcl.3. Architecture du réseauDans cette section, nous présentons les classes de bases utilisables pour définir larchitecture et latopologie du modèle. Les classes Node et Link servent à la composition de la topologie du réseau.Elles modélisent les noeuds et les arcs dun graphe.3.1. NoeudLa classe Node est une classe OTcl: elle na donc pas dexistence en tant que telle dans le simulateur.Cette classe et ses méthodes sont définies dans le fichier tcl/lib/ns-node.tcl. Un noeud est unecollection de classifiers et dagents. Le classifier démultiplexe les paquets. Lagent est habituellementlentité dun protocole. Lassemblage des composants est représenté par la figure 6: Node id_ Port classifier Agent dmux_ agents_ Address classifier entry_ classifier_ Link Figure 6: Composants dun noeud.Les mots se terminant par le caractère "_" indique des instances variables du noeud. Ce sont pour laplupart des références à un composant du noeud. Lentrée du noeud est indiquée par la référenceentry_ qui pointe sur le premier objet à lentrée du noeud.Le trafic émis par lagent est transmis au point dentrée du noeud. Que ce soit des paquets reçus deses voisins ou émis par ses agents, le traitement effectué par le noeud reste identique. Quand unnoeud reçoit un paquet, il examine les champs du paquet (habituellement sa destination) et le commutevers la bonne interface de sortie. Cette tâche est exécutée par le classifier. La table des adresses duLe Mercredi 15 Septembre 1999 - 27 -
  31. 31. UPMC - LIP6 Manuel NSRéseaux et Performancesclassifier est remplie par la procédure de routage (add-routes{}). Celle du "port multiplexer" seremplit à chaque ajout dun agent au noeud.Une adresse (ou node id_) est affectée au noeud lors de sa création. Ladresse est un entier codé sur8 bits contenu dans la variable dinstance id_ et aussi dans la variable address_. Lidentificationdun agent est composé par un mot de 16 bits: les 8 bits de poids forts identifient le noeud et les 8 bitsde poids faible servent de numéro de port et identifient lagent dans le noeud. Une simulation peutcomporter donc 256 noeuds au maximum. Lextension de lespace dadressage est réalisée par lacommande "Node expandaddr". Lespace dadressage des noeuds se code alors sur 22 bits.Cette commande doit être appelée avant la création des noeuds. "Node expandaddr" a unecommande équivalente:$ns set-address-format expandedCette commande augmente la taille de ladressage de 16 à 32 bits. Elle fait partie de la nouvelle APIsur le format des adresses NS. Le code est localisé dans le fichier tcl/lib/ns-address.tcl. Lacommande "Node expandaddr" reste toujours disponible par soucis de compatibilité.3.1.1. ClassifierUn classifier a pour objectif de retrouver une référence à un autre objet de la simulation à partir dunecomparaison sur un critère dont la valeur est contenue dans le paquet. Il a un rôle de démultiplexeuren quelque sorte. Le classifier sert notamment pour un noeud à modéliser la fonction de relayage(forwarding). Le classifier contient une table de n slots. A chaque slot correspond la référence à unNsObject. Quand un paquet est reçu par le classifier, il identifie le slot de sortie par classify(). Sile slot est invalide, le classifier lance no-slot{}. Les méthodes du classifiers sont: - install{}, installe une référence à un élément dans le classifier. - element{}, retourne la liste des éléments installés dans le classifier. - slot{}, retourne la référence installée à un slot spécifique. - clear{}, efface le contenu dun slot spécifique.Il existe plusieurs sortes de classifiers dans NS. Il y a ceux qui font : - des classifications avec plusieurs critères ou des critères spécifiques comme par exemple le flow id, ladresse de destination. - des traitements particuliers comme le classifier replicator. Ce classifier duplique un paquet sur tous ses slots.Concernant le classifieur dadresse du noeud, la table de slots est indexée par lid_ du noeud dedestination. A réception dun paquet et suivant ladresse de destination, le classifier détermine quel estlobjet de simulation suivant cest à dire à qui donner ce paquet. Cest soit au port classifier du noeud,soit à un lien de sortie.3.1.2. Détail sur le noeudLe Mercredi 15 Septembre 1999 - 28 -
  32. 32. UPMC - LIP6 Manuel NSRéseaux et PerformancesQuand un paquet est reçu par un noeud, ce dernier le conserve, détermine sa route et lenvoie à unautre NsObject. Il ny a pas de durée ou de temps consommé pour ces opérations. Pour prendre encompte ces temps, il convient dajouter un élément de délai dans le noeud comme cest fait pour lelien.3.2. LienLe lien sert à relier les noeuds. Il modélise le système de transmission. Le lien est principalementcaractérisé par un délai de propagation et une bande passante. Cest une classe OTcl qui regroupe unensemble de composants dérivés de la classe Connector. Cette classe et ses méthodes sont définiesdans le fichier tcl/lib/ns-link.tcl. Des liens plus sophistiqués peuvent être dérivés de cetteclasse. Quelque soit le type du lien, il comporte 5 références sur des objets qui le composent. Le lienpeut se représenter selon la figure 7. Link Delay TTL head_ queue_ link_ ttl_ drophead_ Figure 7: Composants dun lien.Les 5 instances variables suivantes ont la sémantique: - head_, point dentrée du lien, il pointe sur le premier objet du lien. - queue_ , référence la file dattente de paquets. Cette file modélise celle que lon trouve habituellement aux interfaces de sortie. - link_ , référence lélément qui caractérise le lien souvent en terme de délai et bande passante. - ttl_, référence lélément qui manipule la durée de vie de chaque paquet. - drophead_, référence lélément qui traite les pertes de paquets au niveau de la file dattente.Parmi les variables du lien, une référence est gardée sur le noeud amont (fromNode_) et sur le noeudaval (toNode_).3.2.1. ConnectorTous les objets du lien sont dérivés de la classe C++ Connector. Un Connector à la différence dunclassifier, envoie les paquets à un seul récepteur. Dans le cas normal le Connector a un voisin connusous la référence Connector::target_. Si il doit détruire le paquet il le passe à lobjet référencé parConnector::drop_. En somme, le Connector délivre le paquet à son voisin indiqué par target_ oudrop_. Si drop_ est indéfini, le paquet à jeter est supprimé de la simulation. target_ doit être définisous peine dobtenir un "Segmentation fault" lors de son utilisation à la simulation. Linitialisation deces variables se fait par les commandes OTcl target ou drop-target qui sont définies par laLe Mercredi 15 Septembre 1999 - 29 -
  33. 33. UPMC - LIP6 Manuel NSRéseaux et Performancesprocédure Connector::command(). Par exemple pour relier lobjet référencé par queue_ à celuiréférencé par link_, la syntaxe de la commande est la suivante:$queue_ target $link_La variable C++ target_ de lobjet queue contient la référence à lobjet link.La variable target_ définit lobjet auquel le paquet sera envoyé. Ainsi tous les paquets reçus parlobjet Connector une fois traités, sont passés à la target_ du Connector. Le passage dun paquetdirectement à son voisin peut se faire sans passer par lordonnanceur par"Connector::send(Packet* p, Handler* h)". Si le second argument est absent, par défaut ilprend la valeur nulle . Ce paramètre sert de "callback" (voir le paragraphe: traitement séquentiel entemps simulé).3.3. AgentLagent est un autre composant dun noeud. Il modélise les constructeurs et les consommateurs depaquets IP. La classe agent fournit des méthodes utiles au développement de la couche transport et àdautres protocoles du plan de signalisation ou de gestion. Cette classe est à la fois dans linterpréteuret dans le simulateur. Cest la classe de base pour définir des nouveaux protocoles dans NS. Ellefournit ladresse locale et de destination, les fonctions pour générer les paquets, linterface à la classeApplication. Actuellement NS comporte de nombreux agents citons: UDP, protocoles de routage,différentes versions de TCP, RTP, etc.Les principales commandes sont celles qui ont trait à des attachements: - $ns_ attach-agent $node_ $agent_ attache lagent au noeud. Concrètement cela signifie que la référence de lagent est mis dans le port classifier pour quil puisse recevoir des paquets. La variable target_ est initialisée avec la valeur entry_ (point dentrée du noeud). Cest par cette commande quun numéro de port (variable OTcl portID_) est attribué et que ladresse de lagent est déterminée. La variable Agent::addr_ contient cette adresse. - $ns_ connect $agent1 $agent2 établit une connexion entre les deux agents. Cette commande consiste uniquement à initialiser la variable Agent::dst_ (adresse de destination) de chaque agent. - $agent_ attach-source $source_ attache une source de trafic à un agent. - $source_ attach-agent $agent_ idemLa création dun nouvel agent demande de définir son héritage, de créer sa classe et de définir lesfonctions virtuelles de lAPI Agent. Ensuite il faut définir les fonctions qui feront office de liaisonavec linterpréteur. Le travail se termine par lécriture de code OTcl pour laccès à lagent.Les fonctions utiles aux classes dérivées ou pouvant être redéfinies sont: - allocpkt() crée un paquet et initialise ses différents champs avec des valeurs nulles. - trace() constitue la fonction de trace (ou tracer) dune variable dun agent. Nous y reviendrons par la suite.Le Mercredi 15 Septembre 1999 - 30 -
  34. 34. UPMC - LIP6 Manuel NSRéseaux et Performances - send() et recv () servent à envoyer et recevoir des paquets constitués. - sendmsg() envoie une suite binaire (cest un ou des paquets non constitués).Lors du développement dun nouvel agent, il ne faut pas oublier dappeler à la dernière lignecommand() la méthode équivalente de la classe parent. Ainsi la dernière ligne doit avoir cetteinstruction "return Agent::command(argc, argv);". Le destinataire dun agent nest pasforcément toujours le même, lexemple dans tcl/rtglib/route-proto.tcl montre commentchanger le destinataire.Avec lévolution de NS, le rôle de lagent a évolué. Dans des versions passées, lagent faisaitégalement office de source de trafic. Cest la raison pour laquelle on a la classe Agent/CBR ouAgent/UDP/CBR. Ces deux classes sont identiques. Il nest pas conseillé dutiliser ces classesactuellement. La bonne démarche est dutiliser la classe Agent/UDP et la classeApplication/Traffic/CBR. La séparation de la source de trafic de lagent apporte une plus grandeflexibilité.3.4. Paquet et en-têteLa gestion des paquets dans NS met en oeuvre trois classes: - la classe Packet modélise les unités de données échangées entre les composants du réseau. - la classe PacketHeaderClass est dérivée de la classe TclClass et fournit les méthodes pour accéder et communiquer avec linterpréteur. Elle sert à localiser dans le paquet len-tête dun protocole particulier. - la classe PacketHeaderManager sert à gérer les en-têtes de paquets qui seront disponibles dans le simulateur.La classe Packet est définie dans le fichier packet.{h,cc}. La classe Packet est dérivée de la classeEvent. Un paquet peut être donc placé dans léchéancier avec lheure de son arrivée. Seules lesinstances de la classe NsObject peuvent recevoir et émettre des paquets. Un paquet NS se schématiseselon la figure 8 et contient : - un élément liant pour pouvoir les chaîner entre eux, - la longueur de la zone mémoire du paquet dédiée aux en-têtes de protocoles, - une zone mémoire dédiée spécialement aux en-têtes de protocoles, - une zone mémoire pour les éventuelles données dapplication.Le Mercredi 15 Septembre 1999 - 31 -
  35. 35. UPMC - LIP6 Manuel NSRéseaux et Performances Packet éventuellement vers next_ le paquet suivant hdrlen_ Header bits_ Common data_ Données IP applicatives TCP Message RTP Figure 8: Le paquet NS.La zone mémoire dédiée spécialement aux en-têtes de protocoles est considérée comme un tableaudoctets et a une taille suffisante pour tous les en-têtes. Cette zone est la concaténation de tous les en-têtes de paquets disponibles dans le simulateur. Le contenu et la taille de cette zone sont définis àlinitialisation de lobjet Simulator. Sa taille est conservée dans la variable Packet::hdrlen_. Len-tête dun protocole particulier est accédé par une adresse relative dans la zone mémoire à partir deladresse indiquée par bits_. Pour illustrer la gestion des paquets et des en-têtes dans NS, nousallons prendre lexemple de lajout dun format de paquet pour le protocole imaginaire smart. Nouscommençons par définir son en-tête cest à dire le format de la PDU de ce protocole:struct hdr_smart {int id_;int seqno_;static int offset_; /* Utilisé pour la localisation de cet en-tête dans la zone des en-têtes du paquet *//* Fonctions pour accès aux champs de len-tête */inline int& id() {return (id_);}inline int& seqno() {return (seqno_);}};Ladresse relative du début de len-tête est conservée dans la variable static offset_ de len-tête duprotocole. Nous verrons par la suite que cette valeur est également conservée dans linterpréteur sousle nom off_<hdrname>_.Pour utiliser cet en-tête dans le simulateur, il faut maintenant lajouter dans la liste maintenue par lePacketHeaderManager. Ceci se fait dans le fichier tcl/lib/ns-packet.tcl en ajoutant la ligne {SMART off_smart_ } qui donne le suffixe du nom de la classe OTcl de len-tête de ce paquet et lenom de la variable OTcl destinée à indiquer la localisation de cet en-tête dans la zone des en-têtes dupaquet NS. La classe OTcl du paquet porte le nom de PacketHeader/SMART.# set up the packet format for the simulationPacketHeaderManager set hdrlen_ 0foreach pair {Le Mercredi 15 Septembre 1999 - 32 -
  36. 36. UPMC - LIP6 Manuel NSRéseaux et Performances { Common off_cmn_ } { IP off_ip_ } { TCP off_tcp_ } { SMART off_smart_ } } { set cl PacketHeader/[lindex $pair 0] set var [lindex $pair 1] PacketHeaderManager set vartab_($cl) $var}Selon notre exemple, le paquet du simulateur aura le format représenté par la figure 9. Packet éventuellement vers next_ le paquet suivant hdrlen_ Header bits_ Common data_ Données IP applicatives TCP SMART Figure 9: Exemple dun format du paquet .La zone den-tête comportera lespace mémoire nécessaire aux quatre en-têtes rangés selon lordreindiqué par le schéma 9. La simulation pourra se faire uniquement avec ces quatre protocoles. Il est anoter que len-tête "common" doit toujours être présent. Elle sert à la fonction de trace et à dautresfonctions indispensables à la simulation. Les principaux champs de len-tête "common" sont: - size_, taille simulée du paquet. - ptype_, type du paquet. - ts_, timestamp. - ref_count_, durée de vie en nombre de sauts. Le paquet est supprimé quand la durée de vie vaut 0.Le calcul de Packet::hdrlen_ est effectué par PacketHeaderManager. Pour cela il a besoin deconnaître le taille de len-tête de chaque paquet. Il faut donc indiquer quelle structure den-tête (cest àdire dans notre exemple hdr_smart ) utiliser pour chaque protocole. Ceci est fait au moyen de la classePacketHeaderClass. Cette classe sert également à établir les liens sur les attributs du paquet entrelinterpréteur et le simulateur. Pour notre exemple, la déclaration est la suivante:class SmartHeaderClass: public PacketHeaderClass{public: SmartHeaderClass(): PacketHeaderClass ("PacketHeader/SMART", sizeof (hdr_smart)){ offset(&hdr_smart::offset_); } void export_offsets() { field_offset("id_", OFFSET(hdr_smart, id_)); };Le Mercredi 15 Septembre 1999 - 33 -
  37. 37. UPMC - LIP6 Manuel NSRéseaux et Performances} class_smarthdr;Le constructeur SmartHeaderClass() appelle le constructeur PacketHeaderClass() avec deuxparamètres: - le nom de la classe OTcl de cet en-tête. Le suffixe du nom de cette classe est identique à celui qui figure dans la liste du PacketHeaderManager. Au total, la chaine de caractères "SMART" est écrite 2 fois (une fois dans linterpréteur et une fois dans le simulateur). - la taille de la structure hdr_smart.La PacketHeaderClass contient 2 variables privées: - hdrlen_, taille de la structure de len-tête. - offset_, un pointeur sur la variable static offset_ de len-tête du paquet. Le constructeur initialise ce pointeur par lappel à offset() . Dans notre exemple, le constructeur est SmartHeaderClass().Dernier aspect de notre exemple, la procédure export_offsets() sert à acceder à un champparticulier de len-tête de linterpréteur. Ici cest le champ id_. Cette fonctionnalité peut être utile pourconfigurer la classification dun classifier sur la valeur de lid_ dun paquet.Attention: Il ne faut pas oublier de définir la variable static hdr_smart::offset_ par la ligne suivantedans le fichier smart.cc:int hdr_smart::offset_;Laccès à len-tête du paquet smart seffectue par Packet::access(). Supposons que le composantqui utilise ce paquet soit lagent smart.class SmartAgent: public Agent {public: SmartAgent(): Agent (PT_SMART) { bind("off_smart_", &off_smart_); };[...]protected: int off_smart_;};A la création de lagent smart, la variable SmartAgent::off_smart_ est liée avec la variable OTcloff_smart_ qui contient ladresse relative de len-tête. Le résultat est que lagent smart connaîtladresse relative de len-tête smart dans la zone mémoire dédiée aux en-têtes de protocoles. Pour quela liaison fonctionne, il faut que le composant C++ ait un objet en miroir dans linterpréteur. Cest lecas de la classe Agent. La raison est que toutes les variables off_<hdrname>_ sont des instancesvariables de SplitObject. Pour accéder ensuite à len-tête smart, le code est le suivant:void SmartAgent::sendmsg(int nbytes) {Packet* p= allocpkt();hdr_smart* sh= (hdr_smart*)p->access(off_smart_);sh->id() = 10;[...]}Le Mercredi 15 Septembre 1999 - 34 -
  38. 38. UPMC - LIP6 Manuel NSRéseaux et PerformancesA retenir pour lécriture C++ de composants, loffset du "common header" (off_cmn_) est initialisépar le constructeur de NsObject et loffset de IP (off_ip_ ) est initialisé quant à lui avec leconstructeur de lAgent.3.4.1. Quelques détails "croustillants" sur la gestion des paquetsLinitialisation de la partie en charge de la gestion des paquets se fait en plusieurs étapes: - au lancement de lapplication (défini comme lallocation mémoire des variables statiques) • La PacketHeaderClass de chaque protocole est activée. Le calcul de hdrlen_ de chaque en-tête et le positionnement du pointeur PacketHeaderClass::offset_ sur la variable offset_ de len-tête de chaque protocole sont effectués. - à linitialisation de lapplication proprement dite (appel à TclAppInit() (ns_tclsh.cc)) • Lancement de PacketHeaderClass::bind() pour les différents protocoles par TclClass::init() (Tcl.cc). • Initialisation de lattribut PacketHeaderClass::hdrlen_ pour chaque classe de paquet, selon notre exemple la commande suivante est executée: PacketHeader/SMART set hdrlen_ 4 • Ajout de la commande offset{} pour chaque classe de paquet. offset{} appelle PacketHeaderClass::method() (packet.cc). Selon notre exemple, cela revient à définir : PacketHeader/SMART instproc offset{ {offset ""} }{...} • Appel à export_offsets() pour chaque classe de paquet. - à linitialisation de lintance de la classe OTcl Simulator (appel à Simulator init{} (ns- lib.tcl)) • Création dune instance de PacketHeaderManager. Il effectue le calcul de loffset pour chaque en-tête. • Initialisation des variables dinstances OTcl off_<hdrname>_ de SplitObject et de la variable offset_ contenue dans len-tête de chaque protocole.4. Eléments de la simulation4.1. SimulateurLa simulation est configurée, contrôlée et exploitée via linterface fournie par la classe OTclSimulator. Cette classe joue le rôle dAPI. Elle nexiste que dans linterpréteur. Un script desimulation commence toujours par créer une instance de cette classe par la commande:set ns_ [new Simulator]Lobjet Simulator (ici représenté par la référence ns_) contiendra une référence sur chaque élément dela topologie du réseau simulé et sur les options mises pour la simulation comme par exemple les nomsdes fichiers de trace. La topologie du réseau est construite avec des instances des classes OTcl Nodeet Link. Les méthodes de la classe Simulator sont définies dans le fichier tcl/lib/ns-lib.tcl.Le Mercredi 15 Septembre 1999 - 35 -

×