Université Paul Sabatier

Master ISTR – Spécialité ASTR

Simulation de systèmes en réseau avec ns2

Guthemberg Silvestre
(http://guthemberg.co.nr)

UE Réseau et Commande

Année 2014-2015.
Sommaire.
I Les objectifs du cours,
I Les systèmes connectés en réseau,
I La simulation,
I Une introduction au ns2,
I Collecte et analyse des résultats,
I Exemple de simulation.
Les objectifs du cours.
Le cours a les objectifs suivants :
I Comprendre le phénomène de congestion pouvant apparaı̂tre dans un
réseau,
I Acquérir des connaissances sur les files d’attente et leurs politiques
d’ordonnancement,
I Appliquer les connaissances acquises dans d’autres modules.
Les étapes pour atteindre nos objectifs :
I Étude du comportement d’un protocole de transport comme TCP,
I Utilisation de mécanismes d’asservissement issus de l’automatique,
I Réalisation de simulations et analyse des résultats obtenus.
Les systèmes connectés en réseau.
Nous nous intéressons aux systèmes connectés en réseau.

Nœud A Routeur Routeur Nœud B

Les couches réseau se communiquent
entre nœuds voisins ou en pair-à-pair.
Topologie du réseau

Nœud Nœud
Routeur Routeur
A B

Flux de données
Application processus-à-processus Application

Transport nœud-à-nœud Transport

IP IP IP IP

Accès Accès Accès Accès

réseau réseau réseau réseau

Fibre,
Ethernet Satellite, Ethernet
etc.
Encapsulation de données et pile de protocoles TCP/IP.

FTP Telnet

TCP UDP

IP ARP

Nœud
Ethernet
A
Nœud B

Ethernet IP TPC FTP

Routeur Routeur
Les couches Application et Transport.
I Application: Telnet (terminal à distance), FTP (transfert de fichier),
etc.
I Transport: TCP (fiabilité et performance), UDP (performance), etc.
Le TCP utilise un espace en mémoire
pour stoker les segments.

application application

TCP
window size window size
Nœud A Nœud B

I Window size: pour écriture et lecture des segments TCP,

I Utile pour le controle de congestion,
I Exemples d’algorithmes: tahoe, Reno, New Reno, et SACK TCP.
Les couches Internet, Accès Réseau et les queues.
Application

Transport
Routeur

Nœud A IP IP
queue queue queue

Accès Accès
réseau réseau

I Les files d’attente :

I Présentes dans tout interface réseau / routeur,
I Classer les paquets suivant des priorités (Qualité de Service),
I Algorithmes d’ordonnancement: Drop-Tail, SFQ (Stochastic Fair queu-
ing), FQ (Fair Queuing), DRR (Deficit Round Robin), RED (Random
Early-Detection) et CBQ (Class-Based Queueing).
Algorithmes d’ordonnancement.
Transport
Flux 1
Nœud A Flux 2 Nœud B

IP

Routeur Routeur

I DropTail :
Routeur
F1 F2 F2 F2 F2 F1 F1
IP
queue
F2
F2
F2

I SFQ (Stochastic Fair queuing) :

Routeur
F1 F2 F2 F2 F2 F1 F1
IP
queue
F2
F2
F2
La couche Accès Réseau.
I Permet de gérer l’accès au support (si partagé),
I Types basiques de lien : Simplex et Duplex.
I Protocoles dépendant du support physique :
I Ethernet/LAN : CSMA-CD,
I Wi-Fi : 802.11*, TDMA,
I Satellite : Unslotted Aloha, TDMA/DAMA.
Nous pouvons émuler l’envoi de données
par TCP en utilisant l’outil iperf.

application: iperf iperf

window size window size

Client Serveur
ip:localhost ip:localhost
port:56500 port: 5001 (commplex-link)

I Les outils pour émuler l’exemple:

I iperf: un outil pour mesurer la bande-passante,
I tcpdump: un outil pour capturer du trafic réseau.
Les étape pour faire tourner l’exemple
d’envoi de données par TCP.
I Le Serveur attend des connexions sur le port 5001 :

I Le tcpdump permet la collecte de paquets pour l’analyse :

I le Client ouvre une nouvelle connexion pour envoyer 1KByte :

Analyse : les paquets de notre connexion TCP peuvent
être regroupés en trois types selon leur flags.
Où trouver des informations complémentaires
sur les systèmes connectés en réseau ?
I Les outils iperf et tcpdump: iperf −−help (ou man iperf), tcpdump
-help (man tcpdump)
I Un cours introductoire en ligne :
http://courses.cs.washington.edu/courses/csep561/13au/
I Autres références :
I Seth, Sameer, and M. Ajaykumar Venkatesulu. TCP/IP architecture,
design and implementation in Linux. Vol. 68. John Wiley & Sons,
2009.
I Anderson, Al, and Ryan Benedetti. Head First Networking. O’Reilly
Media, Inc., 2009.
La simulation.
La simulation permet de comprendre le comportement
d’un système avec moins d’efforts.

réalisme

système
réel

émulation

simulation

efforts
Le système réel et son émulation.
I Expériences sur le système réel :
I Résultats probants,
I (Quand il est possible) La mise en place est éventuellement coûteuse.
I Son émulation :
I La prise en compte de plusieurs facteurs (logiciels et/ou matériels)
contribuent à l’obtention des résultats plus fiables,
I Problèmes liées au passage à l’échelle.
Exemples des systèmes de diffusion de vidéo sur Internet.

I Exemples: YouTube, Netflix, etc..

Les plate-formes cloud publiques nous
permettent d’émuler des systèmes en réseaux.
I Exemples: PlanetLab.

I Autres: Microsoft Azure, Amazon EC2, etc.

La simulation utilise des modèles
pour représenter le système.
I Avoir une compréhension du comportement du système,
I Permet de passer à l’échelle plus facilement,
I Pour valider le modèle, les résultats peuvent être croisés avec des
données du système réel,
I Modélisation mathématique : Monte Carlo simulation, bootstrap, théorie
des réseaux, etc.
I Modélisation informatique : transmission de messages d’une simulation
orientée événements, protocoles de routages de paquets, etc.
Exemples des simulateurs.
I PeerSim ( http://peersim.sourceforge.net/).
I OMNeT++ ( http://www.omnetpp.org/).
I SimGrid (http://simgrid.gforge.inria.fr/).
I ns2 (http://www.isi.edu/nsnam/ns/) et ns3 (http://www.nsnam.
org/) .
Temps de transmission de données entre deux nœuds.

10KB
10 Mbps
20 ms

Client Serveur
données

écriture
délai

lecture

données
temps de transmission=
temps d'écriture+
délai +
temps de lecture
Où trouver des informations complémentaires
sur la simulation ?
I Jain, Raj. The art of computer systems performance analysis. John
Wiley & Sons, 2008.
I Wehrle, Klaus, Mesut Güneş, and James Gross. Modeling and tools
for network simulation. Heidelberg: Springer, 2010.
Une introduction au ns2.
ns2, le network simulator 2, est un simulateur à
événements discrets conçu pour la recherche sur réseau.
I L’ordonnanceur d’événements discret maintient l’état du système.

handler()
time_uid_next_handler
Objet
réseau
tête

chemin de donées
Ordonnanceur
d'événements
handler()
time_uid_next_handler
Objet
réseau
ns2 a une riche librairie d’objets réseau et protocoles.
I Conception modulaire qui facilite la mise en place de modifications,
I ns2 utilise deux langages principales:
I Une librairie d’objets réseau et protocoles écrite en C++ (Files d’attente,
Liens, Sources et Puits. . . ),
I Un interpréteur script OTcl (une version du Tool Command Language
orientée objet).
La représentation d’un nœud.

application
agent
port
classifier

link
node
addr
entry
classifier

link
unicast node
La représentation d’un lien simplex.

I Lien entre deux noeud,

I Paramètres: délai, bande passante, type de file d’attente, etc..
Les files t’attente sont présentes dans toutes interfaces
réseau et sont indispensables pour l’échange de paquets.
I Stocker les paquets en attendant l’envoi :
I Présence de congestion,
I Volonté de réguler le flux de données.
I Classifier les paquets suivant des priorités :
I Mécanismes de Qualité de Service (QdS).
I Indispensables dans les réseaux de communication.
Gestion de la congestion avec les files d’attente.
I Définies dans la classe Queue,
I Composants de base :
I Méthode enque : Ajoute un paquet dans la file,
I Méthode deque : Enlève un paquet dans la file,
I Paramètre len : Taille de la file.
I Algorithmes disponibles: DropTail, RED, SFQ, etc.
Les adresses et ports des couches Réseau et Transport.
I Deux types d’adressage :
I Adressage hiérarchique : déclaration de plusieurs niveaux, proche de
IP mais plus complexe.
I Adressage plat : utilisation de l’identifiant du nœud, plus abstrait donc
plus simpliste.
I Utilisation de ports :
I Similaire aux ports réels,
I Permettent de retrouver un agent,
I Port 255 utilisé par l’agent de routage.
Les objets de la classe application permettent de
générer du trafic sur le système en réseau simulé.
I Les applications communes : Telnet et FTP.
I Autres générateurs de trafic : CBR, Pareto, Exponential, Trace.
Une application doit être attachée un
agent pour établir une communication.
I Un agent est une entité du nœud qui communique avec l’extérieur
(e.g. Protocole de Transport, Protocole de Routage, etc.)

application
ftp
agent
tpc tcp_sink

0 1

I Si aucune action n’est nécessaire en réception, l’agent null peut être

utilisé.
L’utilisateur décrit une simulation avec script en OTcl.
I Définition du système en réseau à être simuler et des résultats :
I La topologie du réseau, les protocoles et les applications,
I Durée simulée et événements particuliers à être introduits,
I Collecte des métriques de performance.
I A chaque variable TCL du script correspond un objet C++ (le lien
étant assuré en TCL).
L’interaction des composants pendant une simulation.

La commande suivante lance la simulation défini dans exemple 01.tcl:

Le Network AniMator (NAM) nous permet
de visualiser la communication simulée.
L’exercice consiste à simuler les transferts de
fichiers sur un réseau entre deux nœud avec ns2.
I Le Client envoie des fichiers de 10KB au Serveur en trois configura-
tions différentes :
I Première, envoie des fichiers par une application CBR (Constant Bi-
tRate) sur UDP comme protocole de transport;
I Deuxième, CBR sur TCP;
I Troisième, FTP sur TCP (en effet, la taille de la fenêtre TCP (buffer)
doit avoir approximativement la taille du fichier à être transféré).

10KB
10 Mbps
20 ms
Client Serveur

I Vous trouvez en ligne un squelette du script tcl pour la première

simulation. Pour le télécharger par un terminal unix/linux :
wget http://homepages.laas.fr/gdasilva/scripts/squelette.tcl
Où trouver des informations complémentaires
sur ns2 ?
I Comment installer ns2 (Mac et linux):
http://www.nsnam.com/2011/11/
installation-of-network-simulator-ns235.html
http://nsnam.isi.edu/nsnam/index.php/Downloading_and_
installing_ns-2
I Comment utiliser ns2 :
http://www.isi.edu/nsnam/ns/doc/index.html
http://www.isi.edu/nsnam/ns/tutorial/
http://nile.wpi.edu/NS/
http://nile.wpi.edu/NS/simple_ns.html
I La liste de paramètres par défaut :
ns-allinone-RELEASE/ns-x.xx/tcl/lib/ns-default.tcl
L’exercice de lecture et simulation.
1. Choisir un article à lire. (liste suggérée : http://homepages.laas.
fr/gdasilva/liste_de_confs.txt);
2. Faire un résumé de l’article, puis indiquer au moins deux points forts
et deux points faibles;
3. Écrire un script tcl qui simule un système (inspiré) de l’article;
Collecte et visualisation de résultats des
simulations.
ns2 permet d’enregistrer les traces d’une
simulation dans un fichier texte.

### T r a c e s en t e x t e b r u t ASCII
s e t a l l [ open a l l . t r a c e w ]
$ns t r a c e − a l l $ a l l

### P r o c e d u r e de f i n a l i s a t i o n
proc f i n i s h {} {
g l o b a l ns n f a l l
$ns f l u s h − t r a c e
close $nf
close $ a l l
exec nam out.nam &
exit 0
}
Les résultats sont collectés par quatre objets.
Le fichier texte de traces contient des informations
sur les événements en ordre chronologique.

From, To are recorded by link events. Addr in "node.port" format.

From To Pkt Pkt Flags Src Dest Seq Pkt

Event Time Fid
Node Node Type Size Addr Addr Num Id

e.g. cbr, Seq. Number can

tcp, etc. repeat (retrasmission).
+= enqueue One can set a Pkt ID is always unique.
-= dequeue Flow ID for each
r= recv (at the output of the link) (agent) source
d= dropped in OTcl script.

− 5 .016736 1 3 cbr 160 −−−−−−− 1 1 . 0 4 . 0 19 2803

r 5 .016752 3 0 ack 40 −−−−−−− 0 4 . 1 0 . 0 1374 2765
+ 5 .016752 0 3 tcp 1500 −−−−−−− 0 0 . 0 4 . 1 1394 2805
− 5 .016752 0 3 tcp 1500 −−−−−−− 0 0 . 0 4 . 1 1394 2805
Nous pouvons collecter des informations
spécifiques d’une file d’attente.

I Le mécanisme monitor-queue collecte des échantillons de l’état

d’une file :
### f i c h i e r p o u r l e s queue t r a c e s
s e t queue [ open q u e u e . t r a c e w ]

# S u r v e i l l e r l a f i l e d ’ a t t e n t e e n t r e n3 e t n4
# , c o l l e c t e r des i n f o s tous l e s 0 .1 s e c , et
# l e s e n r e g i s t r e r d a n s $queue
s e t qmon [ $ns monitor−queue $n3 $n4 $queue 0 . 1 ]
[ $ n s l i n k $n3 $n4 ] queue−sample−timeout

I Il y a aussi le monitor-queue, qui enregistre les événements d’une

file en fichier.
Le fichier texte contient des statistiques sur
une file d’attente spécifique.

departures (packets)
From, To are recorded by link events in monitor interval.

From To Queue Queue

Time arr P dep P drop arr B dep B drop
Node Node size B size P

current queue size in bytes

arrivals (packets) same, in bytes
during the monitor interval
in monitor interval
current queue size in packets drops (packets)
in the monitor interval in monitor interval.

5 3 4 499 . 6 0 . 5 1517 1515 0 2245540 2243880 0

5 .1 3 4 489 . 2 0 . 4 1651 1650 0 2415040 2414880 0
5 .2 3 4 678 . 8 0 . 6 1794 1793 0 2599420 2597960 0
5 .3 3 4 422 . 2 0 . 4 1920 1919 0 2756960 2755500 0
ns2 nous permet de surveiller une source TCP.
I Collecte de la taille de la fenêtre de congestion et la taille de la fenêtre
s(buffer) :
set congestion window \
[ open c o n g e s t i o n w i n d o w . t r a c e w ]
proc plotWindow { t c p S o u r c e o u t f i l e } {
g l o b a l ns
s e t time 0 . 1
s e t now [ $ns now ]
s e t cwnd [ $ t c p S o u r c e s e t cwnd ]
s e t window [ $ t c p S o u r c e s e t window ]
puts $ o u t f i l e ”$now\ t$cwnd \ t$window ”
$ n s a t [ expr $now+$ t i m e ] ” plotWindow \
$tcpSource $ o u t f i l e ”
}
$ n s a t 1 ” plotWindow $ t c p 2 $ c o n g e s t i o n w i n d o w ”
Traitement de données et visualisation.
Où trouver les scripts pour traiter et générer des graphes
des simulations ?
I Les scripts pour le traitement de données des simulations (codé en
Perl) :
http://homepages.laas.fr/gdasilva/scripts/format_
throughput_data.pl
http://homepages.laas.fr/gdasilva/scripts/format_
queue_data.pl
I Les scripts pour générer les graphes pour visualiser les résultats des
simulations (codés en gnuplot) :
http:
//homepages.laas.fr/gdasilva/scripts/plot_throughput.p
http://homepages.laas.fr/gdasilva/scripts/plot_queue.p
http://homepages.laas.fr/gdasilva/scripts/plot_
congestion_window.p
Comment utiliser les scripts à partir d’un terminal ?
I D’abord, if faut faire tourner la simulation :
ns s i m u l a t i o n d e f i n i t i o n . t c l

I Puis, traitez les données de sortie avec les scripts suivants :

perl format throughput data.pl a l l . t r a c e \
4 1 1000000 > t h r o u g h p u t . d a t
perl format queue data.pl queue.trace \
0 .2 > queue.dat

I Finalement, générez les graphes :

gnuplot plot throughput.p
gnuplot plot queue.p
gnuplot plot congestion window.p