Vous êtes sur la page 1sur 27

INSTITUT NATIONAL DES POSTES ET TELECOMMUNICATIONS (INPT - RABAT)

Simulation dun rseau de Jackson sous NS-2


Rapport du mini-projet Conception et Modlisation des rseaux

Mohamed ABOUZRAR

Ce document est le rapport dun mini projet ralis dans le cadre du cours Conception et Modlisation des Rseaux coordonn par M. BENSAID, et a pour sujet ltude et la simulation dun rseau de Jackson ouvert. Lenvironnement de simulation est NS-2. Les rsultats obtenus sont compars avec celles de la thorie et avec celles obtenus par la librairie sim.js.

Anne universitaire 2012/2013

Table des Matires


Introduction :........................................................................................................................................... 2 I. 1. 2. 3. II. III. 1. 2. 3. IV. 1. 2. 3. 4. Rseau de Jackson :......................................................................................................................... 3 Les files dattentes : .................................................................................................................... 3 Le rseau ouvert de Jackson : ..................................................................................................... 3 Exemple de calcul : ..................................................................................................................... 5 Gnralits sur la simulation :........................................................................................................ 7 Lenvironnement de simulation NS-2......................................................................................... 9 Principe : ..................................................................................................................................... 9 Installation de NS-2: ................................................................................................................. 10 Comprendre le code:................................................................................................................. 11 Exemple de simulation : ........................................................................................................... 12 Les scripts ................................................................................................................................. 12 Les rsultats de la simulation ................................................................................................... 22 La simulation en ligne par SIM.JS ............................................................................................. 23 La comparaison des rsultats ................................................................................................... 25

Conclusion : .......................................................................................................................................... 26

Simulation dun rseau de Jackson sous NS-2

Introduction :
Dans le cadre du cours Conception et Modlisation des Rseaux coordonn par M. BENSAID, jai ralis un mini projet qui a pour sujet ltude et la simulation dun rseau de Jackson ouvert files dattente M/M/1 sous NS-2. Au dbut de ce rapport jai prsent lenvironnement global de ce mini -projet, savoir, les rseaux de Jackson et la simulation en gnral. Le but de cette partie du rapport est de situer le lecteur et lui permet de bien comprendre lutilit des simulations, particulirement pour la conception et la modlisation des rseaux. Une brve prsentation de lenvironnement de simulation Ns -2 savre importante pour bien connatre les composants principaux du simulateur et les diffrentes tapes quil faut suivre pour mener une simulation. En fin, on arrive la simulation du rseau de Jackson quon a propos, en fait, ce rseau se compose de trois files dattente M/M/1, avec une seule entre de paquets et deux sorties. Les rsultats obtenus sont compars avec celles de la thorie et avec celles obtenus une simulation base sur la librairie sim.js crite en javascript. Les scripts utiliss sont cits avec des commentaires et des explications. Cet exemple est donn titre indicatif, aprs la comprhension des scripts le lecteur qui a un peu dexprience avec NS -2 et OTcl peu larranger pour la simulation dun de Jackson de son choix.

Simulation dun rseau de Jackson sous NS-2

I. Rseau de Jackson :
1. Les files dattentes :
La file dattente est une structure qui permet de stocker des objets dans un ordre donn et de les retirer dans le mme ordre, cest dire selon le protocole FIFO first in first out. On ajoute toujours un lment en queue de liste et on retire celui qui est en tte.

Les files dattente sont utilises, pour grer des objets qui sont en attente dun traitement ultrieur, tel que la gestion des documents imprimer, des programmes excuter, des messages reus, des paquets transmettre ...etc.

Objets (lentre) La file Le traitement (serveur)

Objets traits (sortie)

2. Le rseau ouvert de Jackson :


Le rseau ouvert de files dattente est un rseau constitu de plusieurs files dattente interconnectes. Ce rseau peut modliser un client qui circule dune file une autre dans les bureaux administratifs, banque, supermarch. Il peut aussi modlise un paquet durant sa transmission au travers des routeurs dans un rseau de paquets. Louverture du rseau exige que la probabilit quun client sort du rseau est toujours 1, cela signifie que chaque file du rseau on peut toujours trouver un chemin vers lextrieur.

Lhistoire des rseaux de files dattente : Thorme de Burke, Burke (1957), Reich (1957) Jackson (1957, 1963): rseaux de files dattente ouvert, solution en forme productive ; Gordon and Newell (1967): rseaux de files dattente ferms ;
Simulation dun rseau de Jackson sous NS-2 3

Baskett, Chandy, Muntz, Palacios (1975): gnralisations sur les types de files d'attente ; Reiser and Lavenberg (1980, 1982): analyse de la valeur moyenne, MVA.

Le rseau de Jackson est un rseau de files dattente form de N n uds satisfaisant les conditions suivantes : Chaque nud i est une file FIFO avec un nombre dattente illimit ; Le temps de service dans chaque nud suit une loi exponentielle de moyen i : Dans chaque nud, le temps de service dun client est tabli in dpendamment des autres temps de service dans les autres nuds ; Note : dans un rseau de paquets le temps de transmission dun paquet, en fait, est le mme dans toutes les files ; Pourtant, cette dpendance, naffecte pas le systme ( appele l'hypothse de l'indpendance de Kleinrock). A la sortie du serveur du nud i, le client choisi alatoirement le prochain nud j avec une probabilit qi,j ou sort dfinitivement du rseau avec un probabilit qi,d ; Le rseau est ouvert aux arrivants de lextrieur (so urce).

La conservation du flux : Posons i le taux moyen des arrivs au nud i. Mme si que le flux des arrivs de lextrieur est poissonien, il nest pas garanti que les flux intrieurs le sont aussi. Le flux i est compos du direct provenant de la source et de flux indirects provenant des autres nuds :

Une quation similaire pour le nud extrieur :

Thorme de Jackson : Soit n = (n1 , n2 , n3 , ., nN ) le vecteur dtat qui prsente ltat de tout le systme. On a :
, tq

Simulation dun rseau de Jackson sous NS-2

Le rseau se comporte comme si il est compos de M/M/1 ; La probabilit dtat est de la forme produit ; Si il y a plusieurs client dans un nud, cela na rien avoir avec le nombre de client dans les autres nuds.

Principaux rsultats du thorme : Les rsultats suivants se dduisent aisment du thorme. Posons i le taux de service dans le nud i : Le nombre moyen de client dans le nud i :

Le temps moyen du sjour dans le nud i :

Le temps moyen dattente dans un nud i :

Le temps moyen dans le systme :

3. Exemple de calcul :
Considrant lexemple suivant:

Cest le mme exemple quon va traiter dans la simulation. Les taux des arrivs de chaque file dattente est comme suivant : { On va traiter le rseau comme si il est compos de trois M/M/1 ayant des taux des arrivs comme cest donn ci-dessus.
Simulation dun rseau de Jackson sous NS-2

Pour lapplication numrique : = 10 p/ms , 1 = 11 p/ms , 2 = 8 p/ms , 3 = 7 p/ms Le tableau qui suit rsume tous les rsultats : File 1 0.909 1 0.909 10 File 2 0.625 0.333 0.208 2.664 File 3 0.857 1 0.857 7

Taux de trafics Temps moyen de sjour (ms) Temps moyen dattente (ms) Nombre moyen dans la file (paquets)

Le nombre moyen de paquet dans tout le systme est : 19.664 paquets Le temps moyen dattente dun paquet dans tout le rseau est : 1.966 ms

Simulation dun rseau de Jackson sous NS-2

II.

Gnralits sur la simulation :

La simulation est un outil utilis par le chercheur, l'ingnieur, le militaire etc. pour tudier les rsultats d'une action sur un lment sans raliser l'exprience sur l'lment rel. Lorsque l'outil de simulation utilise un ordinateur on parle de simulation numrique. Les chercheurs, les ingnieurs, les militaires et bien d'autres professionnels se posent souvent la question : quel est le rsultat que j'obtiens si j'exerce telle action sur un lment ? Le moyen le plus simple serait de tenter l'exprience, c'est--dire d'exercer l'action souhaite sur l'lment en cause pour pouvoir observer ou mesurer le r sultat. Pourtant, lexprience nest pas toujours valable, elle est couteuse ou dangereux, ou si on cherche des valuations rapides. Dans ces cas nous se trouvons obliger de faire des simulations. Le tableau ci-dessous rsume les avantages et les inconvnients de la simulation : Avantages Trs proche de la ralit dans la plupart de temps avec moins des hypothses simplificatrices. On peut rapidement changer la structure du model, les algorithmes et les variables pour visualiser ses influences sur le systme. Il se peut dont tirer des rsultats sur la performance, ce qui est pas toujours valable pour les expriences. Inconvnients Les simulateurs prennent beaucoup de temps pour les construire et les debuger. La validation des rsultats peut prendre assez de temps et deffort. La visualisation des relations entre les diffrents variables du model peut tre difficile.

La simulation peut tre temps continu/discret et tat continu/discret :

Simulation dun rseau de Jackson sous NS-2

Et on peut distinguer deux catgories principales de simulations :

La simulation continue, o le systme se prsente sous la forme dquations diffrentielles rsoudre. Elle permet de suppler la rsolution analytique quand celle-ci est impossible. La simulation discrte dans laquelle le systme est soumis une succession dvnements qui le modifient. Ces simulations ont vocation appliquer des principes simples des systmes de grande taille. La simulation discrte se divise en deux grandes catgories : Asynchrone ou time-slicing : on simule chaq ue fois le passage dune unit de temps sur tout le systme. Synchrone ou event-sequencing : on calcule larrive du prochain vnement, et on ne simule quvnement par vnement, ce qui permet souvent des simulations rapides, bien quun peu plus complexe s programmer.

Le simulateur quon va utiliser, NS-2, lui ralise des simulations discrtes et synchrones (eventsequencing). La programmation dune simulation se compose gnralement des vnements, points de temps ou le systme change dtat, chaque vnement on associe une dure, et on associe un modle laborant le temps qui spare deux vnements successifs.

Diagramme dun simulateur discret

Simulation dun rseau de Jackson sous NS-2

III.

Lenvironnement de simulation NS-2

1. Principe :
NS est un simulateur orient objet, crit en C + +, avec un interprte OTcl comme une interface. Le simulateur prend en charge une hirarchie de classes en C + + (aussi appel la hirarchie tablie), et une hirarchie de classes similaire au sein de l'interprte OTcl (aussi appel la hirarchie interprt). Les deux hirarchies sont troitement lis les uns aux autres, du point de vue de l'utilisateur, il y une correspondance one-to-one entre une classe dans la hirarchie interprt et une dans la hirarchie tablie. La racine de cette hirarchie est la classe TclObject. Les utilisateurs crent de nouveaux objets de simulation travers l'interprteur, ces objets sont instancis au sein de l'interprteur, et sont troitement refltes par un objet correspondant dans la hirarchie tablie. La hirarchie de classe interprt est automatiquement tablie par des mthodes dfinies dans la classe TclClass. Les objets instancis des utilisateurs sont reflts par des mthodes dfinies dans le TclObject de classe. Il y a d'autres hirarchies dans les code C++ et OTcl son excution; ces hirarchies ne sont pas refltes dans la manire de TclObject. Avec les objets proposs par ce moteur de simulation, on peut reprsenter des rseaux avec liens filaires ou sans fils, des machines et routeurs (Node), des flux TCP et UDP (par exemple pour simuler un flux CBR), et slectionner les politiques et rgles rgissant les files dattentes mises en uvre dans chacun des nuds. Il est essentiellement labor avec les ides de la conception par objets, de la rutilisation du code et de modularit. Il est aujourd'hui un standard de rfrence en ce domaine, plusieurs laboratoires de recherche recommandent son utilisation pour tester les nouveaux protocoles.
Exemple : set tcp [new Agent/TCP]

Agent/TCP

Agent

TclObject
Create C++ object Create Otcl shadow object

static class TcpClass : public TclClass {

public:
TcpClass() : TclClass( "Agent/TCP") {}

init

init

OTcl TclObject (C++)


constructor

TclObject* create(int, const char*const*) {


return (new TcpAgent);} } class_tcp;

C++ parent
constructor

TcpAgent
constructor

Simulation dun rseau de Jackson sous NS-2

2. Installation de NS-2:
Le NS-2 est disponible pour sous lenvironnement linux et windows, mais il est initialement conu pour lenvironnement linux. Dans ce qui suit jai utilis la distribution Ubuntu 12.04 LTS. Pour une simple installation, il est recommand dutiliser le package all-in-one : ns-allinone2.35.tar.gz On le dcompresse : tar -xzvf ns-allinone-2.34.tar.gz Puis une simple commande va faire laffaire : ./install
Il y a une commande optionnelle pour valider linstallation :

./validate

Si tous passe bien, on aura une arborescence comme ci-dessous :

A chaque fois quon veut lancer une simulation, il faut se positionner dans le fichier root de ns 2 : ns-2.35. Pour remdier ce problme il suffit juste dajouter les commandes principales : ns , nam , xgraph aux variables du systme :

cd ns-2.35/bin cp l ns nam xgraph /usr/local/bin

Simulation dun rseau de Jackson sous NS-2

10

3. Comprendre le code:
Dans cette section on va prsenter un simple code avec sa signification, pour mieux comprendre un script ns-2 :

set ns [new Simulator]

set n0 [$ns node] set n1 [$ns node]

$ns duplex-link $n0 $n1 1Mb 10ms DropTail

set tcp0 [new Agent/TCP] $ns attach-agent $n0 $tcp0 Set sink0 [new Agent/TCPSink] $ns attach-agent $n1 $sink0 $ns connect $tcp0 $sink0 set ftp0 [new Application/FTP] $ftp0 attach-agent $tcp0

# Reste planifier les vnements # Scheduling $ns at 0.5 $ftp0 start $ns at 4.5 $ftp0 stop $ns at 5.0 stop # Lancer la simulation $ns run

Simulation dun rseau de Jackson sous NS-2

11

IV.

Exemple de simulation :

Ci-dessous lexemple du rseau de Jackson :

1. Les scripts
Pour bien mener la simulation, jai crit quatre scripts : jackson_net.tcl : cest le script principal crit on OTcl pour dfinir notre simulation ; queue.awk : script awk pour retourner le nombre moyen de paquets dans chaque file ; queue-time.awk : script awk pour retourner le temps moyen de sjour dun paquet dans chaque file ; test-ns.sh : script shell pour automatiser le lancement des simulations.

Dans ce qui suit les scripts comments :


# Jackson_net.tcl set ns [new Simulator] # Lambda set lambda [expr 1.0*[lindex $argv 0]] # les Mus set mu1 [expr 1.0*[lindex $argv 1]] set mu2 [expr 1.0*[lindex $argv 2]] set mu3 [expr 1.0*[lindex $argv 3]] # Enregistrement des longueurs moyens de paquets des files set nbr_pkt [open nbr_$lambda-$mu1-$mu2-$mu3.tr w] set nbr_pkt1 [open nbr_1_$lambda-$mu1-$mu2-$mu3.tr w] set nbr_pkt2 [open nbr_2_$lambda-$mu1-$mu2-$mu3.tr w] set nbr_pkt3 [open nbr_3_$lambda-$mu1-$mu2-$mu3.tr w] set tf [open out-$lambda-$mu1-$mu2-$mu3.tr w] $ns trace-all $tf Simulation dun rseau de Jackson sous NS-2 12

# On cre deux noeuds set n1 [$ns node] set n2 [$ns node] set n3 [$ns node] set n4 [$ns node] # On cre un lien de 100Kbps entre les deux (FIFO, pas de temps d'accs) set link_1_2 [$ns simplex-link $n1 $n2 100kb 0ms DropTail] set link_2_3 [$ns simplex-link $n2 $n3 100kb 0ms DropTail] set link_3_4 [$ns simplex-link $n3 $n4 100kb 0ms DropTail] # On limite la file 100000 octets, ce qui dans notre cas tend vers l'infini $ns queue-limit $n1 $n2 100000 $ns queue-limit $n2 $n3 100000 $ns queue-limit $n3 $n4 100000 # set up some random number generators set arrivalRNG [new RNG] $arrivalRNG seed 0 set size_1_RNG [new RNG] $size_1_RNG seed 0 set size_2_RNG [new RNG] $size_2_RNG seed 0 set size_3_RNG [new RNG] $size_3_RNG seed 0 set unif_2_3_RNG [new RNG] $unif_2_3_RNG seed 0 set unif_3_4_RNG [new RNG] $unif_3_4_RNG seed 0 # On cre des lois d'arrive exponentielles pour le temps entre les arrivs set InterArrTime [new RandomVariable/Exponential] $InterArrTime set avg_ [expr 1/$lambda] $InterArrTime use-rng $arrivalRNG # On cre des lois exponentielles pour la taille des paquets set pktSize_1 [new RandomVariable/Exponential]

Simulation dun rseau de Jackson sous NS-2

13

$pktSize_1 set avg_ [expr 100000.0/(8*$mu1)] $pktSize_1 use-rng $size_1_RNG set pktSize_2 [new RandomVariable/Exponential] $pktSize_2 set avg_ [expr 100000.0/(8*$mu2)] $pktSize_2 use-rng $size_2_RNG set pktSize_3 [new RandomVariable/Exponential] $pktSize_3 set avg_ [expr 100000.0/(8*$mu3)] $pktSize_3 use-rng $size_3_RNG # On cre des lois uniformes pour les liens concerns set unif_2_3 [new RandomVariable/Uniform] $unif_2_3 set min_ 0.0 $unif_2_3 set max_ 1.0 $unif_2_3 use-rng $unif_2_3_RNG set unif_3_4 [new RandomVariable/Uniform] $unif_3_4 set min_ 0.0 $unif_3_4 set max_ 1.0 $unif_3_4 use-rng $unif_3_4_RNG # Affectation des agents aux noeuds set src1 [new Agent/UDP] $src1 set packetSize_ 1000000 $ns attach-agent $n1 $src1 set src2 [new Agent/UDP] $src2 set packetSize_ 1000000 $ns attach-agent $n2 $src2 set src3 [new Agent/UDP] $src3 set packetSize_ 1000000 $ns attach-agent $n3 $src3 # On place les rcepteurs set sink2 [new Agent/LossMonitor] $ns attach-agent $n2 $sink2 set sink3 [new Agent/LossMonitor] $ns attach-agent $n3 $sink3 set sink4 [new Agent/LossMonitor] $ns attach-agent $n4 $sink4 Simulation dun rseau de Jackson sous NS-2

14

# On monitore la file d'attente au cours du temps set qmon2 [$ns monitor-queue $n3 $n4 [open qm3-$lambda-$mu1-$mu2-$mu3.out w] 0.5] set qmon [$ns monitor-queue $n1 $n2 [open qm1-$lambda-$mu1-$mu2-$mu3.out w] 0.5] set qmon1 [$ns monitor-queue $n2 $n3 [open qm2-$lambda-$mu1-$mu2-$mu3.out w] 0.5] $link_1_2 queue-sample-timeout #$link_2_3 queue-sample-timeout #$link_3_4 queue-sample-timeout # Connexion entre la source et la destination $ns connect $src1 $sink2 $ns connect $src2 $sink3 $ns connect $src3 $sink4 # Variables pour la gestion des packets reus set pkts_2 0.0 set pkts_3 0.0 proc finish {} { global ns tf namf nbr_pkt nbr_pkt1 nbr_pkt2 nbr_pkt3 lambda mu1 mu2 mu3 $ns flush-trace close $tf close $namf close $nbr_pkt close $nbr_pkt1 close $nbr_pkt2 close $nbr_pkt3 set fq [open nbrq_$lambda-$mu1-$mu2-$mu3.dat w] puts $fq "TitleText: Le nombre des packets dans chaque file" puts $fq "XUnitText: time" puts $fq "YUnitText: Nbr de packets" puts $fq \n\"nbr_queue_1 exec cat nbr_1_$lambda-$mu1-$mu2-$mu3.tr >@ $fq puts $fq \n\"nbr_queue_2 exec cat nbr_2_$lambda-$mu1-$mu2-$mu3.tr >@ $fq puts $fq \n\"nbr_queue_3 exec cat nbr_3_$lambda-$mu1-$mu2-$mu3.tr >@ $fq close $fq Simulation dun rseau de Jackson sous NS-2 set fs [open nbrs_$lambda-$mu1-$mu2-$mu3.dat w] puts $fs "TitleText: Le nombre de packets dans le reseau" 15

close $fq set fs [open nbrs_$lambda-$mu1-$mu2-$mu3.dat w] puts $fs "TitleText: Le nombre de packets dans le reseau" puts $fs "XUnitText: time" puts $fs "YUnitText: Nbr de packets" puts $fs \n\"nbr_systeme exec cat nbr_$lambda-$mu1-$mu2-$mu3.tr >@ $fs close $fs exec rm nbr_$lambda-$mu1-$mu2-$mu3.tr nbr_1_$lambda-$mu1-$mu2-$mu3.tr nbr_2_$lambda-$mu1-$mu2-$mu3.tr nbr_3_$lambda-$mu1-$mu2-$mu3.tr exec xgraph nbrq_$lambda-$mu1-$mu2-$mu3.dat -geometry 800x400 & exec xgraph nbrs_$lambda-$mu1-$mu2-$mu3.dat -geometry 800x400 & exit 0 } # Procdure d'envoi d'un paquet selon les lois exponentielles proc sendpacket_1 {} { global ns src1 pktSize_1 InterArrTime pkts_1 # Le temps de simulation actuel set simTime [$ns now] # La taille du packet set Xbytes [expr ([$pktSize_1 value])] # L'entre des nouveaux packets au rseau $src1 send [expr $Xbytes] # Le noeud suivant $ns at [$ns now] "sendpacket_2" # Le temps interarriv set T [$InterArrTime value] # Le temps du prochain packet set nextSend [expr $simTime + $T] # re-schedule cette vnement $ns at $nextSend "sendpacket_1" } Simulation dun rseau de Jackson sous NS-2 16

proc sendpacket_2 {} { global ns src2 sink2 pktSize_2 pkts_2 pkts_3 unif_2_3 set proba [$unif_2_3 value] if { $proba > 0.5 } { set pkts_2 [expr $pkts_2 + [$sink2 set bytes_]] set Xbytes [$pktSize_2 value] if {$Xbytes > $pkts_2} { set Xbytes_2 $pkts_2 set pkts_2 0.0 } else { set pkts_2 [expr $pkts_2 - $Xbytes] } # L'entre d'un nouveau packet au rseau $src2 send [expr $Xbytes] } else { set pkts_3 [expr $pkts_3 + [$sink2 set bytes_]] } $sink2 set bytes_ 0.0 # Le noeud suivant $ns at [$ns now] "sendpacket_3" } proc sendpacket_3 {} { global ns src3 sink3 pktSize_3 pkts_3 unif_3_4 set proba [$unif_3_4 value] if { $proba < 0.2} { set pkts_3 [expr $pkts_3 + [$sink3 set bytes_]] # La taille du packet set Xbytes [expr ([$pktSize_3 value])] if {$Xbytes > $pkts_3} { set Xbytes $pkts_3 set pkts_3 0.0 } else { set pkts_3 [expr $pkts_3 - $Xbytes] } # L'entre d'un nouveau packet au rseau $src3 send [expr $Xbytes] } Simulation dun rseau de Jackson sous NS-2 17

# 80% de temps les pckets sort du rseau $sink3 set bytes_ 0.0 # Le noeud suivantt $ns at [$ns now] "sendpacket_4" } proc sendpacket_4 {} { global sink4 $sink4 set bytes_ 0.0 } proc outputdata {} { # Cette fct permis d'crire les valeurs rsultantes de chaque seconde global ns qmon qmon1 qmon2 nbr_pkt nbr_pkt1 nbr_pkt2 nbr_pkt3 # dmarrer encore cette fct aprs une 10 ms set simTime [$ns now] $ns at [expr $simTime + 10] "outputdata" # extract the queue length set Q1 [$qmon set pkts_] set Q2 [$qmon1 set pkts_] set Q3 [$qmon2 set pkts_] set Q [expr $Q1 + $Q2 + $Q3] # Le nombre des packets dans chaque file puts $nbr_pkt "$simTime $Q" puts $nbr_pkt1 "$simTime $Q1" puts $nbr_pkt2 "$simTime $Q2" puts $nbr_pkt3 "$simTime $Q3" } # scheduling des vnements $ns at 0.0001 "sendpacket_1" $ns at 0.01 "outputdata" $ns at 10000.0 "finish" $ns run

Simulation dun rseau de Jackson sous NS-2

18

Dans ce script, jackson_net.tcl, jai eu des problmes avec queue -monitor, il ne permet de lancer quun seul queue-monitor, donc on a lanc celui du lien 1-2. Le script queue.awk a pour entrer le fichier de trace du queue monitor : qmx-$lambda-$mu1$mu2-$mu3.out , tq x = 1, 2, 3

# script queue.awk BEGIN { total_queue_size = 0; total_lines_count = 1; } { mean_size = $5; total_queue_size += mean_size; total_lines_count ++; } END { average = total_queue_size / total_lines_count printf "%3f\n", average; }

Quant au script queue-time.awk, lui utilise le fichier rsultant de la trace de la simulation : out$lambda-$mu1-$mu2-$mu3.tr
# script queu-time.awk BEGIN { total_time_0 = 0; total_time_1 = 0; total_time_2 = 0; total_packets_0 = 1; total_packets_1 = 1; total_packets_2 = 1; } { action = $1; Simulation dun rseau de Jackson sous NS-2

19

time = $2; src = $3; dst = $4; name = $5; size = $6 ; flow_id = $8; src_address = $9; dst_address = $10; seq_no = $11; packet_id = $12; if (action == "+") { switch(src) { case "0": packets_0[packet_id] = time; break; case "1": packets_1[packet_id] = time; break; case "2": packets_2[packet_id] = time; break; } } else if (action == "-") { switch(src) { case "0": total_packets_0 ++; total_time_0 += (time - packets_0[packet_id]); break; case "1": total_packets_1 ++; total_time_1 += (time - packets_1[packet_id]); break; case "2": total_packets_2 ++; total_time_2 += (time - packets_2[packet_id]); break; } } } END { mean_0 = total_time_0 / total_packets_0 ; mean_1 = total_time_1 / total_packets_1 ; mean_2 = total_time_2 / total_packets_2 ; mean = mean_0 + mean_1 + mean_2 ; printf "%3f\t, %3f\t, %3f\t, %3f", mean_0, mean_1, mean_2, mean; } Simulation dun rseau de Jackson sous NS-2 20

On arrive au dernier script, le script shell test-ns.sh pour lautomatisation des simulations :

#!/bin/bash simulate() { echo "Simulating with lambda=$1, mu1=$2, mu2=$3 and mu3=$4:" ns jackson_net.tcl $1 $2 $3 $4 avg1=`awk -f queue.awk < qm1-$1-$2-$3-$4.out` avg2=`awk -f queue.awk < qm2-$1-$2-$3-$4.out` avg3=`awk -f queue.awk < qm3-$1-$2-$3-$4.out` avg=`expr $avg1 + $avg2 + $avg3` avg=`expr $avg / 3` echo "Le nombre moyen des packets" echo " echo " echo "" avgtime=`awk -f queue-time.awk < out-$1-$2-$3-$4.tr` echo "Le temps moyen dans le reseau: " echo " Queue1 echo $avgtime echo "" } # Lancement des simulations: # simulate lambda mu1 mu2 mu3 simulate 10.0 11.0 8.0 7.0 Queue2 Queue3 Net" Queue1 $avg1 Queue2 $avg2 Queue3 $avg3 Net" $avg"

Simulation dun rseau de Jackson sous NS-2

21

2. Les rsultats de la simulation


On va lancer le script test-ns.sh dans le terminal, avec les valeurs utilises dans lexemple de calcul de la section rseau de Jackson, afin de comparer les rsultats obtenues. La capture du terminal :

Les graphes du nombre de paquets dans chaque file :

Simulation dun rseau de Jackson sous NS-2

22

Le graphe du nombre de paquets dans tout le systme :

Remarques : Les valeurs de lambda et mu sont choisi de faon avoir la stabilit du systme, en fait les graphes montre une certaine oscillation autour d un moyen ; Le nombre de paquet dans la queue_1 constitue la majorit des paquets dans le systme vu que celui qui a lambda la plus grande. Les valeurs moyennes pour les queues 2 et 3 donnes par le terminale, ne sont pas prise en compte, vue le problme expliqu prcdemment.

3. La simulation en ligne par SIM.JS


Pour enrichir notre travail, on a utilis un autre simulateur, cette fois en ligne sur le site web : www.simjs.com/queuing/ Ce simulateur est crit en javascript, son utilisation est trs simple, il suffit de glisser les composants du rseau de files dattente sur lespace du travail puis les interconnects et les configurs. Ci-dessous, le schma de simulation et les rsultats obtenus :

Simulation dun rseau de Jackson sous NS-2

23

Simulation dun rseau de Jackson sous NS-2

24

4. La comparaison des rsultats


Le tableau ci-dessous rsume les rsultats de nos simulations et de nos calculs : thorie 10 2.664 7 0.909 0.208 0.857 19.664 1.974 NS-2 9.750 NAN NAN 0.970 0.204 0.594 Entre 10 et 20 1.233 SIM.JS 9.767 0.828 6.121 0.887 0.075 0.879 16.716 1.841

Nombre moyen dans queue_1 Nombre moyen dans queue_2 Nombre moyen dans queue_3 Temps moyen dans queue_1 Temps moyen dans queue_2 Temps moyen dans queue_3 Nombre moyen dans le systme Temps moyen dans le systme

Remarques : Les valeurs moyennes concernant le nombre de paquets sont quasiment gaux ; Les valeurs moyennes concernant le temps sont relativement proches, sauf celles du queue_3; Ces indicateurs de performance donnent aux concepteurs une ide sur le travail, et donc les changements quil fallait apports au rseau pour avoir les rsultats dsirs.

Simulation dun rseau de Jackson sous NS-2

25

Conclusion :
Le logiciel NS-2 , son outil de visualisation NAM (qui nest pas utilis ici) et le visualiseur des graphes XGRAPH sont particulirement adapts ltude de rseaux complexes (filaires, sans fils) mettant en uvre de nombreuses files dattente, procds de routage, types de trafics A travers ce mini-projet, jai pu manipuler mainte composants du NS -2, ainsi de comprendre lutilit des rseaux de Jackson dans le domaine de la modlisation des rseaux . Javais loccasion aussi de dcouvrir lhistoire des files dattente jusqu les rseaux de BCMP, et de manipuler le calcul thorique de diffrents thormes. NS-2 semble tre un bon outil de simulation, et fournir une relle assistance dans le cas dlaboration de rseaux complexes en entreprise, mme si il prsente des difficults de prise en main, pour pouvoir simuler les comportements thoriques des diffrents lments du rseau en fonction de leurs proprits comme la vitesse dun lien, ou la discipline de file dattente dun routeur.

Simulation dun rseau de Jackson sous NS-2

26