Para esta semana de clase, se nos pidió correr una simulación en Network Simulator ya sea en la versión 2 o 3, en mi caso utilicé la 2.
Para escribir estas simulaciones se utiliza la extensió "tcl".
La programación NS-2 basicamente tiene el siguiente procedimiento.
- Crear el planificador de eventos
- Encender el rastreo
- Crear red
- Configuración de enrutamiento - rtproto
- Crear conexión (capa de transporte) - agentes
- Crear trafico - aplicaciones - Monitoreo
- Visualización usando nam
Comunicación UDP
Los datos son los flujos del agente UDP al agente Nulo.
#Crear un agente UDP y ponerselo al nodo 0
set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
# Crear un agente Nulo que actue como recolector de tráfico y se lo adjunte al
$ns attach-agent $n0 $udp0
# Crear un agente Nulo que actue como recolector de tráfico y se lo adjunte al
# nodo 1
set null0 [new Agent/Null]
$ns attach-agent $n1 $null0
# Conectar dos agentes
$ns connect $udp0 $null0
$ns attach-agent $n1 $null0
# Conectar dos agentes
$ns connect $udp0 $null0
Comunicación TCP
Los datos son flujos del agente TCP al agente recolector TCP
# Crear agente TCP y adjuntarselo al nodo n0
set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0
# Crear un agente tcpsink que actue como recolector de tráfico y se lo adjunte al
set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0
# Crear un agente tcpsink que actue como recolector de tráfico y se lo adjunte al
# nodo 1
set tcpsink0 [new Agent/TCPSink]
$ns attach-agent $n1 $tcpsink0
# Conecta dos agentes
$ns connect $tcp0 $tcpsink0
set tcpsink0 [new Agent/TCPSink]
$ns attach-agent $n1 $tcpsink0
# Conecta dos agentes
$ns connect $tcp0 $tcpsink0
Generador de tráfico
Se necesita generadores de tráfico para los datos actuales, estos simulan alguna aplicación de tráfico
Ejemplo simple utilizando CBR
# Crear agente CBR
set cbr0 [new Application/Traffic/CBR]
# Adjuntar el agente CBR a algun agente UDP/TCP
$cbr0 attach-agent $udp0
Planificar los eventos
"At" juega el rol más importante
$ns at 1.0 “$cbr0 start”
$ns at 5.0 “finish"
$ns at 1.0 “$cbr0 start”
$ns at 5.0 “finish"
cbr0 empezará al tiempo de 1.0 ms y todo el proceso se parara a los 5.0 ms, también se puede parar cada generador de tráfico.
$ns at 4.0 ”$cbr0 stop”
El generador de tráfico cbr0 se parará a los 4.0 ms
A continuación pongo unas simulaciones que corrí, agregue algunos comentarios a los códigos según lo que entendí que hacia cada simulación.
Simulación 1.
Código
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| set ns [new Simulator] | |
| $ns color 0 blue | |
| $ns color 1 red | |
| # Abrir trace files | |
| set f [open out.tr w] | |
| $ns trace-all $f | |
| set nf [open out.nam w] | |
| $ns namtrace-all $nf | |
| # Crear topologia, tres nodos en linea | |
| set n0 [$ns node] | |
| set n1 [$ns node] | |
| set n2 [$ns node] | |
| $ns duplex-link $n0 $n2 2Mb 5ms DropTail | |
| $ns duplex-link $n2 $n1 1.5Mb 10ms DropTail | |
| $ns duplex-link-op $n0 $n2 orient right | |
| $ns duplex-link-op $n2 $n1 orient right | |
| # Creación de agentes UDP | |
| set udp0 [new Agent/UDP] | |
| $ns attach-agent $n0 $udp0 | |
| set udp1 [new Agent/UDP] | |
| $ns attach-agent $n1 $udp1 | |
| $ns connect $udp0 $udp1 | |
| # La instancia "process_data" es la que va a procesar los datos recibidos | |
| # en caso de que ninguna aplicacion estuviera adjuntada al agente | |
| # en este caso se responde a mensajes de la forma "ping(####") | |
| Agent/UDP instproc process_data {size data} { | |
| global ns | |
| $self instvar node_ | |
| $ns trace-annotate "[$node_ node-addr] received {$data}" | |
| # Si el mensaje fue en forma "ping(####)" entonces se manda una respuesta de la forma "pong(####)" | |
| if {[regexp {ping *([0−9]+)} $data entirematch number]} { | |
| $self send 100 "pong($number)" | |
| } elseif {[regexp {countdown *([0−9]+)} $data entirematch number] | |
| && $number > 0 } { | |
| incr number -1 | |
| $self send 100 "countdown($number)" | |
| } | |
| } | |
| # Crear clases nos permite poner colores en NAM | |
| $udp0 set class_ 0 | |
| $udp1 set class_ 1 | |
| # Se programan algunos mensajes para ser enviados, usando el procedimientoUDP "enviar" | |
| # El primer argumento es la longitud de los datos y el segundo son los datos | |
| # Se puede fingir con la longitud, esto permite que se envien paquetes de cualquier | |
| # tamaño que se necesite en la simulación sin necesidad de generar una cadena con | |
| # la longitud de los datos, la longitud que se especifica no debe ser mas grande que | |
| # el maximo tamaño del paquete UDP (el default es 1000 bytes) | |
| $ns at 0.1 "$udp0 send 724 ping(42)" | |
| $ns at 0.2 "$udp1 send 100 countdown(5)" | |
| $ns at 0.3 "$udp0 send 500 {ignore this message please}" | |
| $ns at 0.4 "$udp1 send 828 {ping (12345678)}" | |
| $ns at 1.0 "finish" | |
| proc finish {} { | |
| global ns f nf | |
| $ns flush-trace | |
| close $f | |
| close $nf | |
| puts "running nam..." | |
| exec nam out.nam & | |
| exit 0 | |
| } | |
| $ns run |
Este programa simple que muestra como se envían datos en datagramas UDP.
Simulación 2.
Código
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #Creación de nodos | |
| set ns [new Simulator] | |
| set n0 [$ns node] | |
| set n1 [$ns node] | |
| set n2 [$ns node] | |
| set f [open out.tr w] | |
| #Simulacion para ver los resultados | |
| $ns trace-all $f | |
| set nf [open out.nam w] | |
| $ns namtrace-all $nf | |
| set trace_flow 1 | |
| $ns color 0 red | |
| $ns color 1 blue | |
| #Se crean los enlaces entre los nodos | |
| $ns duplex-link $n2 $n1 0.2Mbps 100ms DropTail | |
| $ns duplex-link $n0 $n1 0.2Mbps 100ms DropTail | |
| $ns duplex-link-op $n2 $n1 orient right-down | |
| $ns duplex-link-op $n0 $n1 orient right-up | |
| set exp1 [new Application/Traffic/Exponential] | |
| $exp1 set packetSize_ 128 | |
| $exp1 set burst_time_ [expr 20.0/64] | |
| $exp1 set idle_time_ 325ms | |
| $exp1 set rate_ 65.536k | |
| set a [new Agent/UDP] | |
| $a set fid_ 0 | |
| $a set rate_ 32.768k | |
| $a set bucket_ 1024 | |
| $exp1 attach-agent $a | |
| set tbf [new TBF] | |
| $tbf set bucket_ [$a set bucket_] | |
| $tbf set rate_ [$a set rate_] | |
| $tbf set qlen_ 100 | |
| $ns attach-tbf-agent $n0 $a $tbf | |
| set rcvr [new Agent/SAack] | |
| $ns attach-agent $n1 $rcvr | |
| $ns connect $a $rcvr | |
| set exp2 [new Application/Traffic/Exponential] | |
| $exp2 set packetSize_ 128 | |
| $exp2 set burst_time_ [expr 20.0/64] | |
| $exp2 set idle_time_ 325ms | |
| $exp2 set rate_ 65.536k | |
| set a2 [new Agent/UDP] | |
| $a2 set fid_ 1 | |
| $exp2 attach-agent $a2 | |
| $ns attach-agent $n2 $a2 | |
| $ns connect $a2 $rcvr | |
| $ns at 0.0 "$exp1 start;$exp2 start" | |
| $ns at 20.0 "$exp1 stop;$exp2 stop;close $f;close $nf;exec nam out.nam &;exit 0" | |
| $ns run |
Este programa muestra como utilizar el filtro del algoritmo Token
Bucket (algoritmo utilizado para controlar la cantidad de datos
inyectados a la red, permitiendo el envío de ráfagas de éstos) para
cosas como:
- Catalogación de paquete. Cuando hay dos modelos del mismo origen conectados a un Receptor común, una de las fuentes está conectada a través de un filtro Token Bucket mientras el otro está conectado directamente.Los parámetros TBF dan forma a la exponencial (on/off) para parecer una codificación bitrate constante.
Simulación 3.
En la última simulación podemos ver una simulación TCP, en la cual se reenvía una ACK para confirmar que el paquete fue enviado.
Referencias:
