Laboratorio 7

Laboratorio 7 - Monitoreo de medidas de desempeño

Hola, en esta ocasión vamos a monitorear las medidas de desempeño de la distintas transmisiones de datos en el simulador ns-2.

Las medidas que voy a evaluar es el throughput que es la cantidad de bits que se transmiten exitosamente por segundo, además de la latencia que es la velocidad de propagación de la señal, que esta depende del medio por el que viaja la señal.

 

---

Transmisión simple de paquetes UDP sobre un protocolo de ruteo tipo DV

Bien, el primer caso que tenemos es el de una topología con 2 nodos corriendo un protocolo de ruteo tipo DV, la transmisión de paquetes es tipo UDP (esto es similar a la topología del laboratorio anterior). Mediremos el desempeño mediante el throughput y la latencia, como ya lo mencioné antes.

El código para obtener la topología mencionada es el siguiente:

	set ns [new Simulator]
	#Enrutamiento dinamico, en este caso Distance Vector
	$ns rtproto DV
	#Fichero de traza para el nam
	set tr [open udp.tr w]
	set nf [open udp.nam w]
	$ns namtrace-all $nf
	#guardar el trace
	$ns trace-all $tr
	proc finish {} {
	global ns nf
	$ns flush-trace
	close $nf
	exec nam udp.nam &
	exit 0
	}
	#Creacion de los nodos para la simulacion
	set n0 [$ns node]
	set n1 [$ns node]
	#Creacion de los links de los nodos
	$ns duplex-link $n0 $n1 1Mb 10ms DropTail
	#Creacion del agente UDP
	set udp0 [new Agent/UDP]
	$ns attach-agent $n0 $udp0
	#Creacion de trafico CBR
	set cbr0 [new Application/Traffic/CBR]
	$cbr0 set packetSize_ 500
	$cbr0 set interval_ 0.005
	$cbr0 attach-agent $udp0
	#Agente NULL
	set null0 [new Agent/Null]
	$ns attach-agent $n1 $null0
	#Conexion del trafico
	$ns connect $udp0 $null0
	$ns at 0.5 "$cbr0 start"
	$ns rtmodel-at 1.0 down $n0 $n1
	$ns rtmodel-at 2.0 up $n0 $n1
	$ns at 4.5 "$cbr0 stop"
	#Llamar al metodo "finish tras 5 segundos de ejecucion"
	$ns at 5.0 "finish"
	#Ejecutar la simulacion
	$ns run

view raw udp.tcl hosted with ❤ by GitHub

 

Y la simulación en nam es esta.

Seguido de esto echamos un vistazo a nuestro archivo generado de trazas, este contiene el tiempo de llegada de paquetes y el tamaño de los paquetes transportados (por el agente), que son los que nos interesa para obtener la latencia y el throughput.

Las siguiente son unas cuantas de las líneas que contiene el archivo de trazas "tr"

+ 0.00017 0 1 rtProtoDV 2 ------- 0 0.2 1.2 -1 0
- 0.00017 0 1 rtProtoDV 2 ------- 0 0.2 1.2 -1 0
r 0.010186 0 1 rtProtoDV 2 ------- 0 0.2 1.2 -1 0
+ 0.27794 1 0 rtProtoDV 2 ------- 0 1.2 0.2 -1 1
- 0.27794 1 0 rtProtoDV 2 ------- 0 1.2 0.2 -1 1
r 0.287956 1 0 rtProtoDV 2 ------- 0 1.2 0.2 -1 1
+ 0.5 0 1 cbr 500 ------- 0 0.0 1.0 0 2
- 0.5 0 1 cbr 500 ------- 0 0.0 1.0 0 2
+ 0.505 0 1 cbr 500 ------- 0 0.0 1.0 1 3
- 0.505 0 1 cbr 500 ------- 0 0.0 1.0 1 3
+ 0.51 0 1 cbr 500 ------- 0 0.0 1.0 2 4
- 0.51 0 1 cbr 500 ------- 0 0.0 1.0 2 4
r 0.514 0 1 cbr 500 ------- 0 0.0 1.0 0 2
+ 0.515 0 1 cbr 500 ------- 0 0.0 1.0 3 5
- 0.515 0 1 cbr 500 ------- 0 0.0 1.0 3 5
r 0.519 0 1 cbr 500 ------- 0 0.0 1.0 1 3
+ 0.52 0 1 cbr 500 ------- 0 0.0 1.0 4 6
- 0.52 0 1 cbr 500 ------- 0 0.0 1.0 4 6
r 0.524 0 1 cbr 500 ------- 0 0.0 1.0 2 4
+ 0.525 0 1 cbr 500 ------- 0 0.0 1.0 5 7
- 0.525 0 1 cbr 500 ------- 0 0.0 1.0 5 7
r 0.529 0 1 cbr 500 ------- 0 0.0 1.0 3 5
+ 0.53 0 1 cbr 500 ------- 0 0.0 1.0 6 8
- 0.53 0 1 cbr 500 ------- 0 0.0 1.0 6 8
r 0.534 0 1 cbr 500 ------- 0 0.0 1.0 4 6
+ 0.535 0 1 cbr 500 ------- 0 0.0 1.0 7 9
- 0.535 0 1 cbr 500 ------- 0 0.0 1.0 7 9

Graficaremos estos datos con la ayuda de gnuplot, pero para eso primero vamos a aplicar un filtrado con awk sobre los datos obtenidos, porque se puede notar que contiene caracteres que no le gustan a gnuplot. 
Tenemos un archivo awk para el filtrado de datos de la latencia y otro para el filtrado de datos del throughput.

Archivo awk para la latencia

#latency

BEGIN {

                time1 = 0.0;
                time2 = 0.0;
}

{
                time2 = $2;
                if ($1=="r") {

                                printf("%f %f\n", time1, time2) > "latency";
                                time1 += $2;
                }
}

END {
                print("Done");
}

Archivo awk para el throughput

#throughput

BEGIN {

                node =1;
                time1 = 0.0;
                time2 = 0.0;
                num_packet=0;
                bytes_counter=0;

}
{
                time2 = $2;

                if (time2 - time1 > 0.05) {
                                thru = bytes_counter / (time2-time1);
                                thru /= 1000000;
                                printf("%f %f\n", time2, thru) > "throughput";
                                time1 = $2;
                }

                if ($1=="r") {
                                bytes_counter += $6;
                                num_packet++;
                }
}

END {
print("Done");

}

Después de procesar los datos con awk obtenemos archivos como los siguientes.

Datos de latencia

0.000000 0.010186
0.010186 0.287956
0.298142 0.514000
0.812142 0.519000
1.331142 0.524000
1.855142 0.529000
2.384142 0.534000
2.918142 0.539000
3.457142 0.544000
4.001142 0.549000
4.550142 0.554000
5.104142 0.559000
5.663142 0.564000
6.227142 0.569000
6.796142 0.574000
7.370142 0.579000
7.949142 0.584000
8.533142 0.589000
9.122142 0.594000
9.716142 0.599000
10.315142 0.604000
10.919142 0.609000
11.528142 0.614000
12.142142 0.619000
12.761142 0.624000

Datos de throughput

0.277940 0.000007
0.500000 0.000018
0.550000 0.080080
0.604000 0.166741
0.654000 0.280080
0.705000 0.382431
0.755000 0.490080
0.805000 0.590080
0.859000 0.638963
0.909000 0.790080
0.960000 0.882431
2.000000 0.047119
2.054000 0.972370
2.104000 1.150160
2.155000 1.235490
2.205000 1.360200
2.259000 1.352037
2.309000 1.560200
2.360000 1.637451
2.410000 1.770200
2.464000 1.731667
2.515000 1.941373
2.569000 1.926111
2.619000 2.180200
2.670000 2.245294
2.720000 2.390200
2.774000 2.305741
2.825000 2.549216
2.879000 2.500185

Totalmente digeribles para gnuplot. Ahora solo generamos nuestro plot.
Mi plot para la latencia es el siguiente, el eje x representa el tiempo transcurrido, mientras que el y representa el tamaño de los paquetes.

Plot para throughput

---

Realicé lo mismo pero ahora la transmisión de datos simula comunicación en Voz IP, igualmente por medio del protocolo de transporte UDP.

El código es el siguiente:

	# start new simulation
	set ns [new Simulator]
	# setup tracing/nam
	set tr [open voip.tr w]
	set nf [open voip.nam w]
	$ns trace-all $tr
	$ns namtrace-all $nf
	# finish function, close all trace files and open up nam
	proc finish {} {
	global ns nf tr
	$ns flush-trace
	close $nf
	close $tr
	exec nam voip.nam &
	exit 0
	}
	### creating nodes
	set node0 [$ns node]
	$node0 label "Voz 1"
	$node0 color red
	set node1 [$ns node]
	$node1 label "Voz 2"
	$node1 color blue
	# creating duplex-link
	$ns duplex-link $node0 $node1 256Kb 50ms DropTail
	$ns duplex-link-op $node0 $node1 orient right
	# setup colors
	$ns color 1 Yellow
	$ns color 2 Green
	## 2-way VoIP connection
	#Create a UDP agent and attach it to node0
	set udp0 [new Agent/UDP]
	$ns attach-agent $node0 $udp0
	# set udp0 flowid to 1
	$udp0 set fid_ 1
	# Create a CBR traffic source and attach it to udp0
	set cbr0 [new Application/Traffic/CBR]
	$cbr0 set packetSize_ 128
	$cbr0 set interval_ 0.020
	# set traffic class to 1
	$cbr0 set class_ 1
	$cbr0 attach-agent $udp0
	# Create a Null sink to receive UDP
	set sinknode1 [new Agent/LossMonitor]
	$ns attach-agent $node1 $sinknode1
	# Connect the UDP traffic source to Null sink
	$ns connect $udp0 $sinknode1
	set udp1 [new Agent/UDP]
	$ns attach-agent $node1 $udp1
	$udp1 set fid_ 2
	set cbr1 [new Application/Traffic/CBR]
	$cbr1 set packetSize_ 128
	$cbr1 set interval_ 0.020
	$cbr1 set class_ 2
	$cbr1 attach-agent $udp1
	set sinknode0 [new Agent/LossMonitor]
	$ns attach-agent $node0 $sinknode0
	$ns connect $udp1 $sinknode0
	# end of voice simulation setup
	# start up traffic
	$ns at 0.1 "$cbr0 start"
	$ns at 0.1 "$cbr1 start"
	$ns at 10.0 "$cbr0 stop"
	$ns at 10.0 "$cbr1 stop"
	$ns at 10.5 "finish"
	# run the simulation
	$ns run

view raw VoIP.tcl hosted with ❤ by GitHub

 

Y esta es la simulación en nam

Filtramos las trazas obtenidas con awk nuevamente y obtenemos los siguientes archivos para plotearlos con gnuplot.

Archivo de trazas de latencia filtrado.

0.000000 0.154000
0.154000 0.154000
0.308000 0.174000
0.482000 0.174000
0.656000 0.194000
0.850000 0.194000
1.044000 0.214000
1.258000 0.214000
1.472000 0.234000
1.706000 0.234000
1.940000 0.254000
2.194000 0.254000
2.448000 0.274000
2.722000 0.274000
2.996000 0.294000
3.290000 0.294000
3.584000 0.314000
3.898000 0.314000
4.212000 0.334000
4.546000 0.334000
4.880000 0.354000
5.234000 0.354000
5.588000 0.374000

Archivo de trazas de throughput filtrado.

0.100000 0.000000
0.154000 0.000000
0.214000 0.012800
0.274000 0.025600
0.334000 0.038400
0.394000 0.051200
0.454000 0.064000
0.514000 0.076800
0.574000 0.089600
0.634000 0.102400
0.694000 0.115200
0.754000 0.128000
0.814000 0.140800
0.874000 0.153600
0.934000 0.166400
0.994000 0.179200
1.054000 0.192000
1.114000 0.204800
1.174000 0.217600
1.234000 0.230400
1.294000 0.243200
1.354000 0.256000

Los siguientes plots cooresponden a los de transmisión de voIP, es el de latencia y throughput respectivamente.

Bibliografía

https://sites.google.com/site/networksprojectwiki/bit10/compnetworks/voip-performance-over-udp-and-sctp-in-ns2/simulating-voip/voip-over-udp
http://www.linuxtotal.com.mx/index.php?cont=info__tips_021 
http://nile.wpi.edu/NS/simple_ns.html

Cualquier duda o aclaración pueden dejarla en comentarios.
Saludos a todos!