Carmen Suarez: Laboratorio 5. Simulación con NS-2

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

# nodo 1

set null0 [new Agent/Null]
$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

# nodo 1
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"

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

	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

view raw simu2.tcl hosted with ❤ by GitHub

Este programa simple que muestra como se envían datos en datagramas UDP.

Simulación 2.

Código

	#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

view raw simu.tcl hosted with ❤ by GitHub

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.