martes, 30 de abril de 2013

Actividad 5. Control de tráfico

Para esta tarea se nos pidió lo siguiente:

Código documentado en blog (10 pts)
  • Desarrollen para ns-2/3 un módulo que permite
  • Crear topologías (reciclar de lab)
  • Generar “patrones” tráfico (reciclar de lab)
  • Comparar por lo menos dos diferentes esquemas de control de congestión (inventados por ustedes mismos, no anden googleando ni por ideas ni por código
Para esta tarea se utilizaron los códigos de dos laboratorios anteriores.
La congestión de redes es el fenómeno producido cuando a la red (o parte de ella) se le ofrece más tráfico del que puede cursar.

Primero aquí esta un video que muestra la simulación de tráfico ya que en el laboratorio que se pidió eso no pude realizarlo bien, y lo volví a realizar.




Aquí se puede ver que hay demasiada pérdida de paquetes, con un script en awk, se obtuvieron los datos de los paquetes enviados y recibidos, así como también los paquetes que se perdieron. Estos datos se obtuvieron a través de un archivo trace que genera la simulación, este archivo contiene los paquetes que son enviados, el tiempo, el nodo transmisor y receptor, entre otras cosas.

Código AWK:

BEGIN {
pckt_snt = 0
pckt_recvd = 0
pckt_lost = 0
}
{
if ("r" == $1 && ("tcp" == $5)){# || "cbr" == $5)){
if ($2 > 0.0 && $2 <= 0.5){
cont1 += 1
}
else if ($2 > 0.5 && $2 <= 1.0){
cont2 += 1
}
else if ($2 > 1 && $2 <= 1.5){
cont3 += 1
}
else if ($2 > 1.5 && $2 <= 2.0){
cont4 += 1
}
for (dst_node = 0; dst_node <= 5; dst_node ++){
if (dst_node == $4){
pckt_recvd += 1
}
for (src_node = 0; src_node <= 5; src_node ++){
if (src_node == $3){
pckt_snt += 1
}
}
}
}
prom = (cont1+cont2+cont3+cont4)/4
}
END {
printf("Paquetes enviados: %g\nPaquetes recibidos: %g\nPaquetes perdidos: %g\nPaquetes por medio segundo: %g\n", pckt_snt, pckt_recvd, pckt_snt-pckt_recvd,prom)
}
view raw file.awk hosted with ❤ by GitHub
En este código se obtiene como resultado el número de paquetes que fueron enviados, los que se recibieron, los paquetes que se perdieron en la comunicación y también un promedio de la cantidad de paquetes por cada medio segundo que se envían y reciben.




Como se puede ver los paquetes que se perdieron es una cantidad muy grande. En estos casos es cuando es requerido un control de congestión. Para esto lo que hice fue apagar o prender los enlaces con más tráfico después de analizar bien la situación y saber cuales son los enlaces con mayor tráfico. Este esquema es muy útil ya que tras analizar todos los enlaces puedes hacer que a cierto tiempo se apague el enlace y se renueve la conexión después. Esto con el fin de que ya no haya tanta pérdida de paquetes. Es una manera muy sencilla ya que lo único que se hace es "romper o apagar" enlaces donde se sabe que hay congestión para después volverlos a encender.


El código es el siguiente:

set ns [new Simulator]
# Definimos que sea un protocolo de ruteo dinamico
set tr [open out.tr w]
set nf [open out.nam w]
$ns namtrace-all $nf
$ns trace-all $tr
# Definimos el metodo finish
proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}
#Se crean los nodos
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
# Creamos un nodo central
set centro [$ns node]
# Vinculamos los nodos en forma de anillo
$ns duplex-link $centro $n0 1.5Mb 10ms DropTail
$ns duplex-link $n0 $n1 1.5Mb 10ms DropTail
$ns duplex-link $n1 $n2 1.5Mb 10ms DropTail
$ns duplex-link $n2 $n3 1.5Mb 10ms DropTail
$ns duplex-link $n3 $n4 1.5Mb 10ms DropTail
$ns duplex-link $n4 $centro 1.5Mb 10ms DropTail
$ns duplex-link-op $centro $n0 orient down-right
$ns duplex-link-op $n0 $n1 orient down
$ns duplex-link-op $n1 $n2 orient down-left
$ns duplex-link-op $n2 $n3 orient up-left
$ns duplex-link-op $n3 $n4 orient up
$ns duplex-link-op $n4 $centro orient up-right
# Creamos un agente UDP y lo conectamos al nodo central
set udp0 [new Agent/UDP]
$ns attach-agent $centro $udp0
$udp0 set class_ 1
$ns color 1 Blue
# Generamos traficos con paquetes e intervalos definidos y lo conectamos al agent UDP
set tcp [new Agent/TCP]
$ns attach-agent $centro $tcp
$tcp set class_ 2
$ns color 2 Red
set sink [new Agent/TCPSink]
$ns attach-agent $n1 $sink
$ns connect $tcp $sink
set tcp2 [new Agent/TCP]
$ns attach-agent $n4 $tcp2
set sink2 [new Agent/TCPSink]
$ns attach-agent $n2 $sink2
$ns connect $tcp2 $sink2
set ftp [new Application/FTP]
$ftp attach-agent $tcp
set ftp2 [new Application/FTP]
$ftp2 attach-agent $tcp2
set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.002
$cbr0 attach-agent $udp0
set null [new Agent/Null]
$ns attach-agent $n3 $null
$ns connect $udp0 $null
$ns duplex-link-op $centro $n0 queuePos 0.05
$ns connect $tcp $sink
$ns connect $udp0 $null
$ns rtmodel-at 0.008 down $n4 $n3
$ns rtmodel-at 0.0092 down $n4 $centro
$ns rtmodel-at 0.7 up $n4 $n3
$ns rtmodel-at 1.0 up $n4 $centro
# Iniciamos el trafico y lo detenemos en el segundo 1.5
$ns at 0.01 "$cbr0 start"
$ns at 0.1 "$ftp start"
$ns at 0.03 "$ftp2 start"
$ns at 1.0 "$ftp stop"
$ns at 1.0 "$ftp2 stop"
$ns at 1.5 "$cbr0 stop"
# La simulacion termina al segundo 1.5
$ns at 1.7 "finish"
$ns run
view raw congestion.tcl hosted with ❤ by GitHub

El resultado corriendo el script:




Video:




Como se puede ver ya no se pierden paquetes en la comunicación así que lo que se realizó tuvo éxito. 


Referencias:
http://elisa.dyndns-web.com/~elisa/teaching/comp/net/congestion.pdf 

1 comentario:

  1. El chiste es tomar las decisiones de apagar/prender durante la ejecución, no via análisis posterior. El análisis estadístico del método propuesto es deficiente. Faltó el otro método con el cual comparar. 4 pts.

    ResponderEliminar