# PRF - TP 3
[Sujet](https://moodle.insa-lyon.fr/pluginfile.php/47815/mod_resource/content/4/2018/4tc-prf_tp3-ns2.pdf)
###### tags : `PRF` `TP`
## Introduction
## The network simulator ns-2
## A simple network scenario
### Basic ns-2 commands
> **Question 2.1**
> La sortie de ces commandes est le résultat de l'opération.
> *Exemple : ```set a 4``` assigne la valeur 4 à la variable. La sortie est donc 4.*
#### Simulator
#### Nodes
> **Question 2.2**
```
set n0 [$ns node]
set n1 [$ns node]
```
#### Physical links
> **Question 2.3**
```
$ns simplex-link $n0 $n1 2Mb 10ms DropTail
```
> Mise en place d'un lien simple de capacité 2Mb/s, avec un délai de propagation de 10ms (temps mis par un paquet pour parcourir le lien) et une politique d'attente FIFO.
#### Link and network layers
#### Transport layer
> **Question 2.4**
```
set udp0 [new Agent/UDP]
set sink [new Agent/Null]
$ns attach-agent $n0 $udp0
$ns attach-agent $n1 $sink
$ns connect $udp0 $sink
```
> On associe un agent UDP au noeud $n_0$ (celui qui envoie les données) et un agent Null au noeud $n_1$ (qui ne fait que recevoir des données). On connecte ensuite les deux agents.
#### Application layer
> **Question 2.5**
```
set cbr0 [new Application/Traffic/CBR]
$cbr0 attach-agent $udp0
$ns at 5.0 "$cbr0 start"
$ns at 30.0 "$cbr0 stop"
```
> On associe une application CBR à l'agent $udp_0$ (ce qui va nous permettre d'envoyer des données à un débit constant sur le lien). On démarre cette application après 5 secondes de simulation et on l'arrête après 30 secondes.
#### Tracing
> **Question 2.6**
```
set nf [open log.txt w]
$ns trace-all $nf
```
> On ouvre un fichier ```log.txt``` dans lequel on va enregistrer toutes les opération seffectuées sur les paquets pendant la simulation (mise en buffer, sortie du buffer, réception, perte).
> :warning: Doit être placé au début du code (juste avant l'utilisation des noeuds)
#### Starting and ending the simulation
> **Question 2.7**
```
$ns at 30.1 "close $nf"
$ns at 30.2 "$ns halt"
$ns run
```
> La commande ```$ns run``` doit être placée à la fin du code.
> Lorsqu'on programme plusieurs commandes au même instant avec la commande ```$ns at``` il vaut mieux mettre des instants légèrement différents (ici 30, 30.1 et 30.2) pour éviter de terminer la simulation avant d'avoir fermer le fichier par exemple.
Script ```simple.tcl``` complet :
```
set ns [new Simulator]
set nf [open log-part3.txt w]
$ns trace-all $nf
set n0 [$ns node]
set n1 [$ns node]
$ns duplex-link $n0 $n1 2Mb 10ms DropTail
set udp0 [new Agent/UDP]
set sink [new Agent/Null]
$ns attach-agent $n0 $udp0
$ns attach-agent $n1 $sink
$ns connect $udp0 $sink
set cbr0 [new Application/Traffic/CBR]
$cbr0 attach-agent $udp0
$ns at 5.0 "$cbr0 start"
$ns at 30.0 "$cbr0 stop"
$ns at 30.1 "close $nf"
$ns at 30.2 "$ns halt"
$ns run
```
### Trace analysis
Extrait du fichier ```log.txt``` :
```
+ 5 0 1 cbr 210 ------- 0 0.0 1.0 0 0
- 5 0 1 cbr 210 ------- 0 0.0 1.0 0 0
+ 5.00375 0 1 cbr 210 ------- 0 0.0 1.0 1 1
- 5.00375 0 1 cbr 210 ------- 0 0.0 1.0 1 1
+ 5.0075 0 1 cbr 210 ------- 0 0.0 1.0 2 2
- 5.0075 0 1 cbr 210 ------- 0 0.0 1.0 2 2
r 5.01084 0 1 cbr 210 ------- 0 0.0 1.0 0 0
+ 5.01125 0 1 cbr 210 ------- 0 0.0 1.0 3 3
- 5.01125 0 1 cbr 210 ------- 0 0.0 1.0 3 3
r 5.01459 0 1 cbr 210 ------- 0 0.0 1.0 1 1
```
> **Question 2.8**
> La taille des paquets transmis est de 210 bytes.
> **Question 2.9**
> Ce temps représente le temps mis par le paquet pour passer du buffer au lien (serialization) et le temps passé par le paquet sur le lien (10 ms)
> *Calcul temps de serialization : $\frac{210 \cdot 8}{2000} = 0.84ms$*
> *On envoie 210 bytes ($210 \cdot 8$ bits) sur un lien à 2Mb/s (2000 b/ms). On obtient donc un temps de serialization égal à 0.84 ms*
> Si on ajoute ce temps au temps de propagation, on obtient un délai de 10.84 ms entre l'envoi et la réception du paquet.
> Cela correspond à ce qu'on obtient sur la trace.
> **Question 2.10**
> On note (adresse.port)
> $n_0$ : 0.0
> $n_1$ : 1.0
> Les adresses sont assignées de manière incrémentale (0.0.0.0 puis 0.0.0.1, etc...)
Script ```postprocess.awk``` :
```awk
BEGIN {
start = 5 # second
timestep = 0.1 # second
nextstep = start + timestep;
}
{
if($2 > nextstep) {
for(f=0; f<=flows; f++) {
if(rx[f] > 0) {
avg_delay = delay[f]/rx[f];
}
else {
avg_delay = 0;
}
printf("%6.2f %4d %8d %8d %10.6f %10.6f\n",
nextstep, f, (bytes_tx[f]*8)/(timestep*1000),
(bytes_rx[f]*8)/(timestep*1000), avg_delay);
bytes_tx[f] = 0;
tx[f] = 0;
bytes_rx[f] = 0;
delay[f] = 0;
rx[f] = 0;
}
nextstep = int($2/timestep)*timestep + timestep;
}
if($1 == "+") {
if($8 > flows)
flows = $8;
time_buf[$12] = $2;
}
if($1 == "-") {
bytes_tx[$8] += $6;
tx[$8]++;
}
if($1 == "r") {
bytes_rx[$8] += $6;
delay[$8] += $2 - time_buf[$12];
rx[$8]++;
}
}
```
> **Question 2.11**
> Données générées par ```postprocess.awk``` :
> - Temps de simulation
> - Numéro du "flow de transmission" (agent qui envoie des données)
> - Débit en émission (en b/s)
> - Débit en réception (en b/s)
> - Délai moyen entre l'émission et la réception d'un paquet
Extrait du fichier ```postprocess.log``` obtenu après avoir executé le script ```postprocess.awk``` :
```
5.10 0 453 403 0.010840 0.000000
5.20 0 453 453 0.010840 0.000000
5.30 0 453 453 0.010840 0.000000
5.40 0 436 436 0.010840 0.000000
5.50 0 453 453 0.010840 0.000000
5.60 0 453 453 0.010840 0.000000
5.70 0 436 436 0.010840 0.000000
5.80 0 453 453 0.010840 0.000000
5.90 0 453 453 0.010840 0.000000
6.00 0 436 436 0.010840 0.000000
6.10 0 453 453 0.010840 0.000000
6.20 0 453 453 0.010840 0.000000
6.30 0 436 436 0.010840 0.000000
6.40 0 453 453 0.010840 0.000000
6.50 0 453 453 0.010840 0.000000
6.60 0 436 436 0.010840 0.000000
```
> **Question 2.12**
> Le débit en émission varie entre 453 kb/s et 436 kb/s. On peut considérer ce débit comme étant constant car les calculs sont effectués sur un intervalle de 10 ms et le nombre de paquets envoyés peut varier entre deux intervalles.
> On observe pas de pertes car le débit de l'application (égal au débit en émission) est inférieur à la capacité physique du lien (2 Mb/s).
## Adding and controlling flows
> **Question 3.1**
```
set udp1 [new Agent/UDP]
$udp0 set fid_ 0
$udp1 set fid_ 1
$ns attach-agent $n0 $udp1
$ns connect $udp1 $sink
```
> On créé un nouvel agent UDP qu'on associe au noeud $n_0$. On paramètre les identifier de chaque agent pour pouvoir les différencier.
> On connect le nouvel agent au récepteur (agent sink associé au noeud $n_1$).
> **Question 3.2**
```
set cbr1 [new Application/Traffic/CBR]
$cbr1 set rate_ 1.8Mb
$cbr1 set packetSize_ 450
$cbr1 set maxpkts_ 5000
$cbr1 attach-agent $udp1
$ns at 15.0 "$cbr1 start"
```
> On créé une nouvelle application CBR qu'on associé à l'agent $udp_1$
> On paramètres son débit à 1,8 Mb/s et la taille des paquets à 450 bytes (nécessaire pour envoyer un paquet toute les 2 ms). On paramètre aussi le nombre maximum de paquets à envoyer (ici 5000). Cette application démarrera après 15 s de simulation.
> *Calcul taille des paquets : $\frac{1.8 \cdot 10^6 \cdot 2 \cdot 10^{-3}}{8} = 450$. On multiplie la capacité d'envoi (1,8 Mb/s)sur une seconde par 2 ms pour obtenir le nombre de bits à envoyer dans un intervalle de 2 ms. On divise par 8 pour obtenir un résultat en bytes*
Extrait de ```log-part3.txt``` :
```
r 15.68008 0 1 cbr 450 ------- 1 0.1 1.0 298 3124
r 15.68092 0 1 cbr 210 ------- 0 0.0 1.0 2826 3125
- 15.6816 0 1 cbr 450 ------- 1 0.1 1.0 305 3135
+ 15.682 0 1 cbr 450 ------- 1 0.1 1.0 341 3190
r 15.68272 0 1 cbr 450 ------- 1 0.1 1.0 300 3127
- 15.6834 0 1 cbr 450 ------- 1 0.1 1.0 306 3136
r 15.68356 0 1 cbr 210 ------- 0 0.0 1.0 2827 3128
+ 15.68375 0 1 cbr 210 ------- 0 0.0 1.0 2849 3191
+ 15.684 0 1 cbr 450 ------- 1 0.1 1.0 342 3192
d 15.684 0 1 cbr 450 ------- 1 0.1 1.0 342 3192
- 15.6852 0 1 cbr 210 ------- 0 0.0 1.0 2830 3137
r 15.68536 0 1 cbr 450 ------- 1 0.1 1.0 301 3129
+ 15.686 0 1 cbr 450 ------- 1 0.1 1.0 343 3193
- 15.68604 0 1 cbr 450 ------- 1 0.1 1.0 307 3138
```
> **Question 3.3**
> On observe maintenant des pertes car le débit cumulé des deux applications est supérieur à la capicité du lien ($1.8 + 0.4 = 2.2 > 2$). Le noeud $n_0$ ne peut plus envoyer tous les paquets sur le lien donc son buffer se remplit. Quand le buffer est plein, les paquets sont alors refusés.
> **Question 3.4**
> Script ```postprocess.awk``` après modifications :
```
BEGIN {
start = 5 # second
timestep = 0.1 # second
nextstep = start + timestep;
}
{
if($2 > nextstep) {
for(f=0; f<=flows; f++) {
if(rx[f] > 0) {
avg_delay = delay[f]/rx[f];
lost_rate = lx[f]/(lx[f]+rx[f]);
}
else {
avg_delay = 0;
lost_rate = 0;
}
printf("%6.2f %4d %8d %8d %10.6f %10.6f\n",
nextstep, f, (bytes_tx[f]*8)/(timestep*1000),
(bytes_rx[f]*8)/(timestep*1000), avg_delay, lost_rate);
bytes_tx[f] = 0;
tx[f] = 0;
bytes_rx[f] = 0;
delay[f] = 0;
rx[f] = 0;
lx[f] = 0;
}
nextstep = int($2/timestep)*timestep + timestep;
}
if($1 == "+") {
if($8 > flows)
flows = $8;
time_buf[$12] = $2;
}
if($1 == "-") {
bytes_tx[$8] += $6;
tx[$8]++;
}
if($1 == "r") {
bytes_rx[$8] += $6;
delay[$8] += $2 - time_buf[$12];
rx[$8]++;
}
if($1 == "d") {
lx[$8]++;
}
}
```
Script ```postprocess.plt``` : (donné par le professeur donc pas d'explications)
```
# set the terminal, i.e., the figure format (eps) and font (Helvetica, 20pt)
set term postscript eps enhanced "Helvetica" 20
# reset all options to default, just for precaution
reset
# set the figure size
set size 0.7,0.7
##############
# throughput #
##############
# set the figure name
set output "tput.eps"
# set the x axis
set xrange [5:30]
set xlabel "Time (s)"
set xtics 5,5,30
set mxtics 2
# set the y axis
set yrange [0:2000]
set ylabel "Throughput (kbps)"
set ytics 0,500,2000
set mytics 2
# set the legend (boxed, on the bottom)
set key box left width 1 height 0.5 samplen 2
# set the grid (grid lines start from tics on both x and y axis)
set grid xtics ytics
# plot the data from the log file
plot "< awk '$2 == 0 {print}' postprocess.log" u 1:4 t "CBR 0" \
w l lt 1 lw 3 lc rgb "#cc0000", \
"< awk '$2 == 1 {print}' postprocess.log" u 1:4 t "CBR 1" \
w l lt 1 lw 1 lc rgb "#0000cc"
#########
# delay #
#########
# set the figure name
set output "delay.eps"
# set the x axis
set xrange [5:30]
set xlabel "Time (s)"
set xtics 5,5,30
set mxtics 2
# set the y axis
set yrange [0:100]
set ylabel "Delay (ms)"
set ytics 0,20,100
set mytics 2
# set the legend (boxed, on the bottom)
set key box left width 1 height 0.5 samplen 2
# set the grid (grid lines start from tics on both x and y axis)
set grid xtics ytics
# plot the data from the log file
plot "< awk '$2 == 0 {print}' postprocess.log" u 1:($5*1000) t "CBR 0" \
w l lt 1 lw 3 lc rgb "#cc0000", \
"< awk '$2 == 1 {print}' postprocess.log" u 1:($5*1000) t "CBR 1" \
w l lt 1 lw 1 lc rgb "#0000cc"
##########
# losses #
##########
# set the figure name
set output "loss.eps"
# set the x axis
set xrange [15:27]
set xlabel "Time (s)"
set xtics 15,2,27
set mxtics 2
# set the y axis
set yrange [0:0.5]
set ylabel "Loss ratio"
set ytics 0,0.1,0.5
set mytics 2
# set the legend (boxed, on the bottom)
set key box right width 1 height 0.5 samplen 2
# set the grid (grid lines start from tics on both x and y axis)
set grid xtics ytics
# plot the data from the log file
plot "< awk '$2 == 0 {print}' postprocess.log" u 1:6 t "CBR 0" \
w l lt 1 lw 3 lc rgb "#cc0000", \
"< awk '$2 == 1 {print}' postprocess.log" u 1:6 t "CBR 1" \
w l lt 1 lw 1 lc rgb "#0000cc"
```
> **Question 3.5**
> 
> Il semblerait que quand $udp_1$ démarre, il occupe la bande passante restante (ici 1,6 Mb/s environ). Quand il s'arrête, il y a un burst de débit pour $udp_0$ car tous les paquets qui sont stockés dans le buffer à ce momment sont envoyés en même temps sur le lien (possible grâce à la capacité du lien) ce qui correspond à une quantité de données plus importante que la normale.
> **Question 3.6**
> 
> Le délai calculé est le temps écoulé entre l'entrée d'un paquet dans le buffer et sa réception de l'autre côté du lien (temps passé dans le buffer + temps de serialization, temps de propagation). Quand seul $udp_0$ est actif, le débit de l'application est inférieur à la capacité du lien donc le buffer ne contient jamais plus d'un paquet. Au démarrage d'$udp_1$, le débit cumulé est supérieur à la capacité du lien donc le buffer se remplit. Un paquet passe donc plus de temps dans le buffer qu'auparavant et le délai augmente.
> **Question 3.7**
> 
> Selon PFR et SPE, on ne peut pas répondre à cette question
Sign in with Wallet
Connect another wallet