Simulation d'un réseau de Jackson sous NS-2

INSTITUT NATIONAL DES POSTES ET TELECOMMUNICATIONS (INPT - RABAT)

Simulation d’un réseau de Jackson sous NS-2

Rapport du mini-projet Conception et Modélisation des réseaux

Mohamed ABOUZRAR

Ce document est le rapport d’un mini projet réalisé dans le cadre du cours Conception et Modélisation

des Réseaux coordonné par M. BENSAID, et a pour sujet l’étude et la simulation d’un réseau de Jackson

ouvert. L’environnement de simulation est NS-2. Les résultats obtenus sont comparés avec celles de la

théorie et avec celles obtenus par la librairie sim.js.

Année universitaire 2012/2013

Simulation d’un réseau de Jackson sous NS-2 1

Table des Matières Introduction : ........................................................................................................................................... 2

I. Réseau de Jackson :......................................................................................................................... 3

1. Les files d’attentes : .................................................................................................................... 3

2. Le réseau ouvert de Jackson : ..................................................................................................... 3

3. Exemple de calcul : ..................................................................................................................... 5

II. Généralités sur la simulation : ........................................................................................................ 7

III. L’environnement de simulation NS-2......................................................................................... 9

1. Principe : ..................................................................................................................................... 9

2. Installation de NS-2: ................................................................................................................. 10

3. Comprendre le code:................................................................................................................. 11

IV. Exemple de simulation : ........................................................................................................... 12

1. Les scripts ................................................................................................................................. 12

2. Les résultats de la simulation ................................................................................................... 22

3. La simulation en ligne par SIM.JS ............................................................................................. 23

4. La comparaison des résultats ................................................................................................... 25

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


Introduction :

Dans le cadre du cours Conception et Modélisation des Réseaux coordonné par

M. BENSAID, j’ai réalisé un mini projet qui a pour sujet l’étude et la simulation d’un réseau de

Jackson ouvert à files d’attente M/M/1 sous NS-2.

Au début de ce rapport j’ai présenté l’environnement global de ce mini-projet, à savoir,

les réseaux de Jackson et la simulation en général. Le but de cette partie du rapport est de situer

le lecteur et lui permet de bien comprendre l’utilité des simulations, particulièrement pour la

conception et la modélisation des réseaux.

Une brève présentation de l’environnement de simulation Ns-2 s’avère importante pour

bien connaître les composants principaux du simulateur et les différentes étapes qu’il faut

suivre pour mener une simulation.

En fin, on arrive à la simulation du réseau de Jackson qu’on a proposé, en fait, ce réseau

se compose de trois files d’attente M/M/1, avec une seule entrée de paquets et deux sorties.

Les résultats obtenus sont comparés avec celles de la théorie et avec celles obtenus une

simulation basée sur la librairie sim.js écrite en javascript. Les scripts utilisés sont cités avec des

commentaires et des explications. Cet exemple est donné à titre indicatif, après la

compréhension des scripts le lecteur qui a un peu d’expérience avec NS-2 et OTcl peu l’arranger

pour la simulation d’un de Jackson de son choix.


I. Réseau de Jackson :

1. Les files d’attentes :

La file d’attente est une structure qui permet de stocker des objets dans un ordre donné et

de les retirer dans le même ordre, c’est à dire selon le protocole FIFO ’first in first out’. On

ajoute toujours un élément en queue de liste et on retire celui qui est en tête.

Les files d’attente sont utilisées, pour gérer des objets qui sont en attente d’un traitement

ultérieur, tel que la gestion des documents à imprimer, des programmes à exécuter, des

messages reçus, des paquets à transmettre ...etc.

2. Le réseau ouvert de Jackson :

Le réseau ouvert de files d’attente est un réseau constitué de plusieurs files d’attente

interconnectées. Ce réseau peut modéliser un client qui circule d’une file à une autre dans les

bureaux administratifs, banque, supermarché. Il peut aussi modélise un paquet durant sa

transmission au travers des routeurs dans un réseau de paquets. L’ouverture du réseau exige

que la probabilité qu’un client sort du réseau est toujours 1, cela signifie que à chaque file du

réseau on peut toujours trouver un chemin vers l’extérieur.

L’histoire des réseaux de files d’attente :

• Théorème de Burke, Burke (1957), Reich (1957)

• Jackson (1957, 1963): réseaux de files d’attente ouvert, solution en forme productive ;

• Gordon and Newell (1967): réseaux de files d’attente fermés ;

Objets

(l’entrée)

La file Le traitement

(serveur)

Objets traités

(sortie)


• Baskett, Chandy, Muntz, Palacios (1975): généralisations sur les types de files d'attente ;

• Reiser and Lavenberg (1980, 1982): analyse de la valeur moyenne, MVA.

Le réseau de Jackson est un réseau de files d’attente formé de N nœuds satisfaisant les

conditions suivantes :

Chaque nœud i est une file FIFO avec un nombre d’attente illimité ;

Le temps de service dans chaque nœud suit une loi exponentielle de moyen μ i :

Dans chaque nœud, le temps de service d’un client est établi indépendamment

des autres temps de service dans les autres nœuds ;

Note : dans un réseau de paquets le temps de transmission d’un paquet, en fait,

est le même dans toutes les files ;

Pourtant, cette dépendance, n’affecte pas le système ( appelée l'hypothèse de

l'indépendance de Kleinrock).

A la sortie du serveur du nœud i, le client choisi aléatoirement le prochain nœud j avec

une probabilité qi,j ou sort définitivement du réseau avec un probabilité qi,d ;

Le réseau est ouvert aux arrivants de l’extérieur (source).

La conservation du flux :

Posons λi le taux moyen des arrivés au nœud i. Même si que le flux des arrivés de l’extérieur est

poissonien, il n’est pas garanti que les flux intérieurs le sont aussi.

Le flux λi est composé du direct provenant de la source et de flux indirects provenant des autres

nœuds :

Une équation similaire pour le nœud extérieur :

Théorème de Jackson :

Soit n = (n1 , n2 , n3 , …., nN ) le vecteur d’état qui présente l’état de tout le système. On a :

, tq


Le réseau se comporte comme si il est composé de M/M/1 ;

La probabilité d’état est de la forme produit ;

Si il y a plusieurs client dans un nœud, cela n’a rien avoir avec le nombre de client dans

les autres nœuds.

Principaux résultats du théorème :

Les résultats suivants se déduisent aisément du théorème. Posons μi le taux de service dans le

nœud i :

Le nombre moyen de client dans le nœud i :

Le temps moyen du séjour dans le nœud i :

Le temps moyen d’attente dans un nœud i :

Le temps moyen dans le système :

3. Exemple de calcul :

Considérant l’exemple suivant:

C’est le même exemple qu’on va traiter dans la simulation.

Les taux des arrivés de chaque file d’attente est comme suivant : {

On va traiter le réseau comme si il est composé de trois M/M/1 ayant des taux des arrivés

comme c’est donné ci-dessus.


Pour l’application numérique : λ = 10 p/ms , μ1 = 11 p/ms , μ2 = 8 p/ms , μ3 = 7 p/ms

Le tableau qui suit résume tous les résultats :

File 1 File 2 File 3

Taux de trafics 0.909 0.625 0.857

Temps moyen de séjour (ms) 1 0.333 1

Temps moyen d’attente (ms) 0.909 0.208 0.857

Nombre moyen dans la file (paquets)

10 2.664 7

Le nombre moyen de paquet dans tout le système est : 19.664 paquets

Le temps moyen d’attente d’un paquet dans tout le réseau est : 1.966 ms


II. Généralités sur la simulation :

La simulation est un outil utilisé par le chercheur, l'ingénieur, le militaire etc. pour étudier

les résultats d'une action sur un élément sans réaliser l'expérience sur l'élément réel. Lorsque

l'outil de simulation utilise un ordinateur on parle de simulation numérique.

Les chercheurs, les ingénieurs, les militaires et bien d'autres professionnels se posent

souvent la question : quel est le résultat que j'obtiens si j'exerce telle action sur un élément ? Le

moyen le plus simple serait de tenter l'expérience, c'est-à-dire d'exercer l'action souhaitée sur

l'élément en cause pour pouvoir observer ou mesurer le résultat. Pourtant, l’expérience n’est

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 résume les avantages et les inconvénients de la simulation :

Avantages Inconvénients

Très proche de la réalité dans la plupart de temps avec moins des hypothèses simplificatrices.

Les simulateurs prennent beaucoup de temps pour les construire et les debuger.

On peut rapidement changer la structure du model, les algorithmes et les variables pour visualiser ses influences sur le système.

La validation des résultats peut prendre assez de temps et d’effort.

Il se peut dont tirer des résultats sur la performance, ce qui est pas toujours valable pour les expériences.

La visualisation des relations entre les différents variables du model peut être difficile.

La simulation peut être à temps continu/discret et à état continu/discret :


Et on peut distinguer deux catégories principales de simulations :

La simulation continue, où le système se présente sous la forme d’équations

différentielles à résoudre. Elle permet de suppléer à la résolution analytique quand

celle-ci est impossible.

La simulation discrète dans laquelle le système est soumis à une succession

d’évènements qui le modifient. Ces simulations ont vocation à appliquer des

principes simples à des systèmes de grande taille. La simulation discrète se divise en

deux grandes catégories :

Asynchrone ou time-slicing : on simule à chaque fois le passage d’une

unité de temps sur tout le système.

Synchrone ou event-sequencing : on calcule l’arrivée du prochain

événement, et on ne simule qu’événement par événement, ce qui permet

souvent des simulations rapides, bien qu’un peu plus complexes à

programmer.

Le simulateur qu’on va utiliser, NS-2, lui réalise des simulations discrètes et synchrones (event-

sequencing).

La programmation d’une simulation se compose généralement des événements, points

de temps ou le système change d’état, à chaque événement on associe une durée, et on associe

un modèle élaborant le temps qui sépare deux événements successifs.

Diagramme d’un simulateur discret


III. L’environnement de simulation NS-2

1. Principe :

NS est un simulateur orienté objet, écrit en C + +, avec un interprète OTcl comme une

interface. Le simulateur prend en charge une hiérarchie de classes en C + + (aussi appelé la

hiérarchie établie), et une hiérarchie de classes similaire au sein de l'interprète OTcl (aussi

appelé la hiérarchie interprété). Les deux hiérarchies sont étroitement liés les uns aux autres, du

point de vue de l'utilisateur, il y une correspondance one-to-one entre une classe dans la

hiérarchie interprété et une dans la hiérarchie établie. La racine de cette hiérarchie est la classe

TclObject. Les utilisateurs créent de nouveaux objets de simulation à travers l'interpréteur, ces

objets sont instanciés au sein de l'interpréteur, et sont étroitement reflétées par un objet

correspondant dans la hiérarchie établie. La hiérarchie de classe interprété est

automatiquement établie par des méthodes définies dans la classe TclClass. Les objets

instanciés des utilisateurs sont reflétés par des méthodes définies dans le TclObject de classe. Il

y a d'autres hiérarchies dans les code C++ et OTcl son exécution; ces hiérarchies ne sont pas

reflétées dans la manière de TclObject.

Avec les objets proposés par ce moteur de simulation, on peut représenter des réseaux

avec liens filaires ou sans fils, des machines et routeurs (Node), des flux TCP et UDP (par

exemple pour simuler un flux CBR), et sélectionner les politiques et règles régissant les files

d’attentes mises en œuvre dans chacun des nœuds. Il est essentiellement élaboré avec les idées

de la conception par objets, de la réutilisation du code et de modularité. Il est aujourd'hui un

standard de référence en ce domaine, plusieurs laboratoires de recherche recommandent son

utilisation pour tester les nouveaux protocoles.

Exemple : set tcp [new Agent/TCP]

init

Agent/TCP

init

Agent

Create Otcl

shadow object

TclObject

Create C++

object

constructor

TclObject

(C++)

constructor

parent

constructor

TcpAgent

OTcl

C++

static class TcpClass : public TclClass

{

public:

TcpClass() : TclClass("Agent/TCP")

{}

TclObject* create(int, const

char*const*) {

return (new TcpAgent );}

} class_tcp;


2. Installation de NS-2:

Le NS-2 est disponible pour sous l’environnement linux et windows, mais il est initialement

conçu pour l’environnement linux. Dans ce qui suit j’ai utilisé la distribution Ubuntu 12.04 LTS.

Pour une simple installation, il est recommandé d’utiliser le package all-in-one : ns-allinone-

2.35.tar.gz

On le décompresse : tar -xzvf ns-allinone-2.34.tar.gz

Puis une simple commande va faire l’affaire : ./install

Il y a une commande optionnelle pour valider l’installation : ./validate

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

A chaque fois qu’on veut lancer une simulation, il faut se positionner dans le fichier root de ns-

2 : ns-2.35.

Pour remédier à ce problème il suffit juste d’ajouter les commandes principales : ns , nam ,

xgraph aux variables du système :

cd ns-2.35/bin

cp –l ns nam xgraph /usr/local/bin


3. Comprendre le code:

Dans cette section on va présenter 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 événements

# Scheduling

$ns at 0.5 “$ftp0 start”

$ns at 4.5 “$ftp0 stop”

$ns at 5.0 “stop”

# Lancer la simulation

$ns run


IV. Exemple de simulation :

Ci-dessous l’exemple du réseau de Jackson :

1. Les scripts

Pour bien mener la simulation, j’ai écrit quatre scripts :

jackson_net.tcl : c’est le script principal écrit on OTcl pour définir 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 séjour d’un paquet dans

chaque file ;

test-ns.sh : script shell pour automatiser le lancement des simulations.

Dans ce qui suit les scripts commentés :

# 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]]



# 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 tf [open out-$lambda-$mu1-$mu2-$mu3.tr w]

$ns trace-all $tf


# On crée deux noeuds

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]

# On crée un lien de 100Kbps entre les deux (FIFO, pas de temps d'accès)

set link_1_2 [$ns simplex-link $n1 $n2 100kb 0ms DropTail]



# On limite la file à 100000 octets, ce qui dans notre cas tend vers l'infini

$ns queue-limit $n1 $n2 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


$size_2_RNG seed 0


$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 crée des lois d'arrivée exponentielles pour le temps entre les arrivés

set InterArrTime [new RandomVariable/Exponential]

$InterArrTime set avg_ [expr 1/$lambda]

$InterArrTime use-rng $arrivalRNG

# On crée des lois exponentielles pour la taille des paquets

set pktSize_1 [new RandomVariable/Exponential]


$pktSize_1 set avg_ [expr 100000.0/(8*$mu1)]

$pktSize_1 use-rng $size_1_RNG







# On crée des lois uniformes pour les liens concernés

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







# On place les récepteurs

set sink2 [new Agent/LossMonitor]







# 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



# Variables pour la gestion des packets reçus

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





close $fq

set fs [open nbrs_$lambda-$mu1-$mu2-$mu3.dat w]

puts $fs "TitleText: Le nombre de packets dans le reseau"


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

}

# Procédure 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'entrée des nouveaux packets au réseau

$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 événement

$ns at $nextSend "sendpacket_1"

}



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'entrée d'un nouveau packet au réseau


} else {


}

$sink2 set bytes_ 0.0

# Le noeud suivant


}


global ns src3 sink3 pktSize_3 pkts_3 unif_3_4

set proba [$unif_3_4 value]

if { $proba < 0.2} {


# 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'entrée d'un nouveau packet au réseau


}


# 80% de temps les pckets sort du réseau


# Le noeud suivantt


}


global sink4


}

proc outputdata {} {

# Cette fct° permis d'écrire les valeurs résultantes de chaque seconde

global ns qmon qmon1 qmon2 nbr_pkt nbr_pkt1 nbr_pkt2 nbr_pkt3

# démarrer encore cette fct° après 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"



}

# scheduling des événements

$ns at 0.0001 "sendpacket_1"

$ns at 0.01 "outputdata"

$ns at 10000.0 "finish"

$ns run


Dans ce script, jackson_net.tcl, j’ai eu des problèmes avec queue-monitor, il ne permet de

lancer qu’un 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

Quant au script queue-time.awk, lui utilise le fichier résultant de la trace de la simulation : out-

$lambda-$mu1-$mu2-$mu3.tr

# 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;

}

# script queu-time.awk

BEGIN {

total_time_0 = 0;

total_time_1 = 0;

total_time_2 = 0;

total_packets_0 = 1;



}

{

action = $1;


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;


break;


break;

}

} else if (action == "-") {

switch(src) {

case "0": total_packets_0 ++;

total_time_0 += (time - packets_0[packet_id]);

break;



break;



break;

}

}

}

END {

mean_0 = total_time_0 / total_packets_0 ;



mean = mean_0 + mean_1 + mean_2 ;

printf "%3f\t, %3f\t, %3f\t, %3f", mean_0, mean_1, mean_2, mean;

}


On arrive au dernier script, le script shell test-ns.sh pour l’automatisation 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=àwk -f queue.awk < qm1-$1-$2-$3-$4.out`



avg=èxpr $avg1 + $avg2 + $avg3`

avg=èxpr $avg / 3`

echo "Le nombre moyen des packets"

echo " Queue1 Queue2 Queue3 Net"

echo " $avg1 $avg2 $avg3 $avg"

echo ""

avgtime=àwk -f queue-time.awk < out-$1-$2-$3-$4.tr`

echo "Le temps moyen dans le reseau: "

echo " Queue1 Queue2 Queue3 Net"

echo $avgtime

echo ""

}

# Lancement des simulations:

# simulate lambda mu1 mu2 mu3

simulate 10.0 11.0 8.0 7.0


2. Les résultats de la simulation

On va lancer le script test-ns.sh dans le terminal, avec les valeurs utilisées dans l’exemple de

calcul de la section réseau de Jackson, afin de comparer les résultats obtenues.

La capture du terminal :

Les graphes du nombre de paquets dans chaque file :


Le graphe du nombre de paquets dans tout le système :

Remarques :

Les valeurs de lambda et mu sont choisi de façon à avoir la stabilité du système, 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 système

vu que celui qui a lambda la plus grande.

Les valeurs moyennes pour les queues 2 et 3 données par le terminale, ne sont pas prise

en compte, vue le problème expliqué précédemment.

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 très simple, il suffit de glisser les

composants du réseau de files d’attente sur l’espace du travail puis les interconnectés et les

configurés.

Ci-dessous, le schéma de simulation et les résultats obtenus :



4. La comparaison des résultats

Le tableau ci-dessous résume les résultats de nos simulations et de nos calculs :

théorie NS-2 SIM.JS

Nombre moyen dans queue_1 10 9.750 9.767

Nombre moyen dans queue_2 2.664 NAN 0.828

Nombre moyen dans queue_3 7 NAN 6.121

Temps moyen dans queue_1 0.909 0.970 0.887



Nombre moyen dans le système 19.664 Entre 10 et 20 16.716

Temps moyen dans le système 1.974 1.233 1.841

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 idée sur le travail, et donc

les changements qu’il fallait apportés au réseau pour avoir les résultats désirés.


Conclusion :

Le logiciel NS-2 , son outil de visualisation NAM (qui n’est pas utilisé ici) et le visualiseur

des graphes XGRAPH sont particulièrement adaptés à l’étude de réseaux complexes (filaires,

sans fils) mettant en œuvre de nombreuses files d’attente, procédés de routage, types de

trafics…

A travers ce mini-projet, j’ai pu manipuler mainte composants du NS-2, ainsi de

comprendre l’utilité des réseaux de Jackson dans le domaine de la modélisation des réseaux.

J’avais l’occasion aussi de découvrir l’histoire des files d’attente jusqu’à les réseaux de BCMP, et

de manipuler le calcul théorique de différents théorèmes.

NS-2 semble être un bon outil de simulation, et fournir une réelle assistance dans le cas

d’élaboration de réseaux complexes en entreprise, même si il présente des difficultés de prise

en main, pour pouvoir simuler les comportements théoriques des différents éléments du réseau

en fonction de leurs propriétés comme la vitesse d’un lien, ou la discipline de file d’attente d’un

routeur.

Documents

Simulation d'un réseau de Jackson sous NS-2