Simulation des réseaux dynamiques - TP Noté

M. Haddad

Construisez votre rapport au fur et à mesure de votre avancement et n’hésitez pas à fournir
des screenshots de NAM afin d’illustrer vos configurations.

Partie 1 : Génération réseau et communications aléatoires

1. Construire un réseau de 100 nœuds tel que chaque nœud soit connecté à chacun des autres
nœuds avec une probabilité p = 0.5. Tous les liens ainsi générés doivent offrir exactement
2 Mb/s de débit et 10 ms de latence.

2. Établir 15 flux constants (CBR) ayant des sources et des destinations différentes. Fixer
les débits des flux à 1.5Mb/s et démarrer les communications à t = 0.5s.

3. Tracer le graphique (histogramme) qui montre le nombre de paquets perdus par seconde
pour les 10 premières secondes de la simulation.

4. Remplacer 5 flux CBR par des flux FTP et retracer le graphique. Interpréter.

5. Supprimer les deux flux de votre code puis établir un nouveau flux CBR à 2Mb/s entre

Partie 2 : Arbre de diffusion

1. Arrêter toutes les communications et reprendre le même réseau généré dans la Partie 1.

2. Implémenter l’algorithme de construction d’un arbre vu en cours en fixant le nœud 0

comme racine. Modifier la fonction Agent/UDP instproc process data du TP1 afin de
traiter vos messages personnalisés.

3. Les nœuds souhaiteraient connaı̂tre leur nombre dans le réseau. Pour ce faire, les feuilles
de l’arbre (nœuds n’ayant pas de fils) commencent par envoyer un message à leurs pères
avec un argument N b = 1. Un nœud non feuille attend de récolter tous les N b de ses
fils, puis rajoute 1 à leur somme et envoie le résultat à son père. Lorsque la racine reçoit
l’information finale, elle détermine le nombre de nœuds du réseau et devra le diffuser via
l’arbre. Cette diffusion se fera donc de père en fils.

Partie 3 : Réseaux sans fil

Considérons le script TCL suivant:

# A 3-node example for ad-hoc simulation with AODV

# Define options
set val(chan) Channel/WirelessChannel ;# channel type
set val(prop) Propagation/TwoRayGround ;# radio-propagation model
set val(netif) Phy/WirelessPhy ;# network interface type
set val(mac) Mac/802_11 ;# MAC type

1
set val(ifq) Queue/DropTail/PriQueue ;# interface queue type
set val(ll) LL ;# link layer type
set val(ant) Antenna/OmniAntenna ;# antenna model
set val(ifqlen) 50 ;# max packet in ifq
set val(nn) 3 ;# number of mobilenodes
set val(rp) AODV ;# routing protocol
set val(x) 300 ;# X dimension of topography
set val(y) 300 ;# Y dimension of topography
set val(stop) 15 ;# time of simulation end

set ns [new Simulator]

set tracefd [open simple.tr w]
set windowVsTime2 [open win.tr w]
set namtrace [open simwrls.nam w]

$ns trace-all $tracefd

$ns namtrace-all-wireless $namtrace $val(x) $val(y)

# set up topography object

set topo [new Topography]

$topo load_flatgrid $val(x) $val(y)

create-god $val(nn)

#
# Create nn mobilenodes [$val(nn)], attach to the channel anf configure them.
#

$ns node-config -adhocRouting $val(rp) \

-llType $val(ll) \
-macType $val(mac) \
-ifqType $val(ifq) \
-ifqLen $val(ifqlen) \
-antType $val(ant) \
-propType $val(prop) \
-phyType $val(netif) \
-channelType $val(chan) \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON \
-macTrace OFF \
-movementTrace ON

for {set i 0} {$i < $val(nn) } { incr i } {

set node_($i) [$ns node]
}

# Provide initial location of mobilenodes

$node_(0) set X_ 150.0
$node_(0) set Y_ 50.0
$node_(0) set Z_ 0.0

$node_(1) set X_ 280.0

$node_(1) set Y_ 10.0

2
$node_(1) set Z_ 0.0

$node_(2) set X_ 40.0

$node_(2) set Y_ 50.0
$node_(2) set Z_ 0.0

# Generation of movements : set dest to x, y with speed s.

$ns at 1.0 "$node_(0) setdest 80.0 100.0 5.0"
$ns at 1.0 "$node_(2) setdest 1.0 250.0 15.0"

# Set a TCP connection between node_(0) and node_(1)

set tcp [new Agent/TCP/Newreno]
$tcp set class_ 2
set sink [new Agent/TCPSink]
$ns attach-agent $node_(1) $tcp
$ns attach-agent $node_(2) $sink
$ns connect $tcp $sink
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ns at 1.0 "$ftp start"
$ns at 12.0 "$ftp stop"

# Printing the window size

proc plotWindow {tcpSource file} {
global ns
set time 0.01
set now [$ns now]
set cwnd [$tcpSource set cwnd_]
puts $file "$now $cwnd"
$ns at [expr $now+$time] "plotWindow $tcpSource $file" }
$ns at 10.1 "plotWindow $tcp $windowVsTime2"

# Define node initial position in nam

for {set i 0} {$i < $val(nn)} { incr i } {
# 30 defines the node size for nam
$ns initial_node_pos $node_($i) 30
}

# Telling nodes when the simulation ends

for {set i 0} {$i < $val(nn) } { incr i } {
$ns at $val(stop) "$node_($i) reset";
}

# ending nam and the simulation

$ns at $val(stop) "$ns nam-end-wireless $val(stop)"
$ns at $val(stop) "stop"
$ns at 150.01 "puts \"end simulation\" ; $ns halt"
proc stop {} {
global ns tracefd namtrace
$ns flush-trace
close $tracefd
close $namtrace
}

$ns run

3
 Dans cet exemple, la procédure de finalisation s’appelle stop. Elle ne fait pas appel à nam.
Faites le manuellement à partir de votre console avec la commande : nam fichier.nam. Référez
vous au script pour avoir le nom du fichier nam en question.

1. Entre quelle paire de nœuds la communication est établie ?

2. À quel instant exact les deux nœuds se retrouvent hors de portée l’un de l’autre ? comment
la communication est alors rétablie ?

Dans le langage que vous préférez (le C/C++ par exemple), concevez un générateur de
mouvements aléatoires pour ce type de réseaux. Appelez votre générateur setdest. Il prendra
en argument le nombre de nœuds, les dimensions de l’arène, les bornes de vitesse et temps de
simulation en seconde. Il générera une séquence de commandes (dans un fichier) de la forme :

$ns at T "$node_(i) setdest destX DestY V"

où T est en secondes, i est un numéro de nœud, V est la vitesse et destX et destY sont les
coordonnées de la destination (à l’intérieur de l’arène).

(a) Générer une scène de mouvement impliquant 10 nœuds mobiles.

(b) Proposer une étude montrant l’impact de la mobilité sur les déconnexions et pertes de
paquets.