RESUMEN:
NS (Network Simulator) actualmente en la versión 2 nos permite realizar simulaciones de múltiples tipos de redes (cableadas, inalámbricas y por satelite). Para ello utiliza un lenguaje de script llamado Tcl que nos permite ir generando el modelo.
También disponemos de una interfaz gráfica llamada nam que nos permite visualizar las simulaciones e incluso crear y editar los modelos a simular.
Ns es una gran herramienta que nos puede ayudar en muchos campos a la hora de realizar pruebas o generar nuevos tipos de redes.

NOTA:
Este artículo está basado fundamentalmente en información que podeis encontrar en las páginas web de los enlaces que podeis encontrar en el último capitulo, aunque no se una traducción propiamente dicha ya que contiene datos de varias de ellas y algunos datos basados en mi propia experiencia usando este simulador. Con este artículo simplemente se intenta acercar a todos aquellos que quieran comenzar a utilizar este simulador de redes o al menos conocerlo y para los que el idioma (casi todas en ingles) o el nivel de las mismas sea un impedimento.

INDICE:

0 - Indice

1 - Introducción

2 - El Simulador ns

2.1 - ¿Qué podemos hacer con estas herramientas?

2.2 - Nuestro primer script TCL

2.3 - Un script TCL con 3 nodos

2.4 - Monitorizar una cola

2.5 - Nam

3 - Conclusiones

Ns es un simulador de eventos centrado en la investigación sobre redes. Ns dispone simulación para TCP, routing y multicast sobre redes cableadas o inalámbricas (locales y por satélite).

Ns empieza como una variante de el REAL network simulator en 1989 y ha evolucionado substancialmente durante los últimos años. En 1995 el desarrollo lo llevaba acabo DARPA a través del proyecto VINT de LBL, Xerox PARC, UCB y USC/ISI. Actualmente el desarrollo de ns lo lleva DARPA junto a SAMAN y otros. Ns siempre ha contado con contribuciones de muchos otros desarrolladores, incluyendo código inalámbrico de los proyectos CMU Monach y UCB Daedelus y también de Sun Microsystems.

Ns se está utilizando tanto en entornos de investigación como en entornos educativos. Ns nos va a ser útil para la investigación ya que nos permite acceder a simulaciones con elementos a las que no podríamos acceder normalmente en caso de no disponer de un simulador. También nos permite modificar casi todos los parámetros que influyen en el estado o configuración de una red en tan solo unos segundos mientras que recrear en la realidad este entorno podría costarnos días o incluso meses.

Ns se utiliza en entornos educativos ya que nos permite simular sencillas redes que nos van a ayudar a comprender los distintos protocolos y observar como se produce el envió de paquetes entre nodos, etc.

Para definir una simulación en ns utilizamos un lenguaje de script llamado TCL que nos va a permitir definir los distintos elementos de la red y como debe comportarse. Una vez terminado el script se lo pasamos al ns y este irá realizando la simulación.

Ns dispone de una interfaz gráfica para visualizar las simulaciones llamada nam (network animator). Nam también dispone de un editor gráfico, que nos va a permitir no tener que usar código TCL para crear las animaciones. Puedes crear la topología de red y simular varios protocolos y fuentes de tráfico mediante el uso del ratón.

2.1 ¿Qué podemos hacer con estas herramientas?

DEFINIR:

Redes terrestres, inalámbricas y por satélite con varios algoritmos de enrutado (DV, LS, PIM-DM, PIM-SM, AODV, DSR).
Distintas fuentes de tráfico: Web, ftp, telnet, cbr ,etc..
Fallos como perdidas probabilísticas y deterministas, fallos en la conexión, etc.

Distintas disciplinas de encolado (drop-tail, RED, FQ, SFQ, DRR, etc) y QoS (calidad de servicio, como por ejemplo InmtServ y Diffserv).

VISUALIZAR:

Flujo del paquete, su encolado y su posible descarte.

Comportamientos del protocolo: comienzo lento de TCP, control de congestión, retransmisión rápida y recuperación.

Movimiento de nodos en redes inalámbricas.

Notas de los sucesos más importantes.

Estados del protocolo.

Primero crearemos un fichero que llamaremos ejemplo.tcl y al que iremos agregando las distintas líneas del script.

Primero de todo necesitamos un objeto de simulador:

set ns [new Simulator]

Ahora abriremos un fichero para guardar la traza para nam:

set nf [open out.nam w]
$ns namtrace-all $nf

La primera línea abre el fichero out.nam para escritura y nos da un manejador ‘nf’. En la segunda línea le decimos al objeto simulador que creamos al principio que envie todos los datos que se generen a este fichero.
El siguiente paso es añadir una función finish que cierre el fichero y que comience nam.

proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}

La siguiente línea indica que transcurridos 5 segundos se termine la simulación invocando a la función finish.

$ns at 5.0 "finish"

Y a continuación indicaríamos el inicio de la simulación.

$ns run

Este es el esqueleto básico de cualquier script Tcl para ns, ahora hemos de añadir los distintos elementos que conformaran la simulación.

Vamos a crear una topología muy sencilla formada por dos nodos y un enlace:



El código debemos incluirlo antes de $ns run o no será incluido en la simulación. Para crear los nodos usamos $ns node y los asignamos a dos identificadores n0 y n1:

set n0 [$ns node]
set n1 [$ns node]

Ahora definimos el enlace que los conecta: enlace duplex con 1 Megabit de ancho de banda , un retardo de 10ms y encolado por Drop Tail.

$ns duplex-link $n0 $n1 1Mb 10ms DropTail

Ya tenemos definida la topología, así que ahora vamos a definir el envió de datos, esto se realiza creando un agente que envie datos y otro agente que los reciba. Definiremos un tamaño de paquete de 500 bytes y cada uno será enviado cada 0.005 segundos (200 paquetes por segundo)

#Creamos un agente UDP y se lo agregamos al nodo 0
set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
# Creamos una fuente de trafico CBR (Constant Bit Rate) y la añadimos a udp0:

set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp0

Podemos encontrar todas las posibles opciones en el manual de ns: http://www.isi.edu/nsnam/ns/doc/index.html

Ahora crearemos un agente Null para recibir os paquetes en el nodo n1:

set null0 [new Agent/Null]
$ns attach-agent $n1 $null0

Y conectamos ambos agentes:

$ns connect $udp0 $null0

Ahora solo tenemos que indicarles cuando deben de comenzar y terminar de enviar los datos. Es recomendable ponerlo antes del secuenciador para finish.

$ns at 0.5 "$cbr0 start"
$ns at 4.5 "$cbr0 stop"

Ya hemos terminado. Salvamos el fichero y comenzamos la simulación. Se abrirá una ventana de nam y podemos observar como los paquetes viajan del nodo 0 al 1.

Pinchando sobre los paquetes podremos obtener información sobre ellos y monitorizarlos. Pinchando sobre la linea obtendremos estadísticas sobre la misma.
Este es un ejemplo muy sencillo pero que ilustra con claridad como se definen simulaciones en ns.

Vamos a ver otro ejemplo ahora con 3 nodos:

n0
\bs
5Mb \bs
2ms \bs
\bs
n2 --------- n3
/ 1.5Mb
5Mb / 10ms
2ms /
/
n1

Aquí tenemos el código:

# Creamos el simulador
set ns [new Simulator]

# Definimos el fichero de traza
set f [open out.tr w]
$ns trace-all $f
set nf [open out.nam w]
$ns namtrace-all $nf

\clearpage
# Creamos los 3 nodos
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

$ns duplex-link $n0 $n2 5Mb 2ms DropTail
$ns duplex-link $n1 $n2 5Mb 2ms DropTail
$ns duplex-link $n2 $n3 1.5Mb 10ms DropTail

# Creamos los agentes
set udp0 [new Agent/UDP] # Agente UDP
$ns attach-agent $n0 $udp0 # en el nodo $n0
set cbr0 [new Application/Traffic/CBR] # Un generador de trafico
$cbr0 attach-agent $udp0 # en el nodo $1
$udp0 set class_ 0 #
but\ldots;

set null0 [new Agent/Null] # Nodo nulo
$ns attach-agent $n3 $null0 # en el $n3;

$ns connect $udp0 $null0
$ns at 1.0 "$cbr0 start"

puts [$cbr0 set packetSize_]
puts [$cbr0 set interval_]

# Definimos una conexión TCP entre el nodo 1 y el 3
set tcp [new Agent/TCP]
$tcp set class_ 1
$ns attach-agent $n1 $tcp

set sink [new Agent/TCPSink]
$ns attach-agent $n3 $sink

set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ns at 1.2 "$ftp start"

$ns connect $tcp $sink
$ns at 1.35 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink"

\clearpage
# Definimos 3 segundos de duración para la simulación

$ns at 3.0 "finish"
proc finish {} {
global ns f nf
$ns flush-trace
close $f
close $nf

puts "Ejecutando nam..."
exec nam out.nam &
exit 0
}

# Finalmente iniciamos la simulación
$ns run

Apartir de los dos ejemplos de scipts aquí espuestos y de la información contenida en el manual podemos definir casi cualquier tipo de red para crear la simulación.

Puede ser interesante monitorizar el estado de una cola e ir observando como los paquetes van entrando y saliendo de ella.

Por ejemplo si tuviésemos una simulación con 4 nodos y quisiéramos monitorizar la cola para el enlace entre 2 y 3 usaríamos:

$ns duplex-link-op $n2 $n3 queuePos 0.5

También visualizaremos los paquetes que no pueden ser procesados y son descartados.

Nam es el entorno gráfico para ns. Nos permite ver y crear las simulaciones mediante un entorno más sencillo y visual.
Aquí podemos observar dos ejemplos de simulaciones en NAM.

EJEMPLO DE RED TCP:

También visualizaremos los paquetes que no pueden ser procesados y son descartados.



En esta simulación podemos observar tanto envios punto a punto como enlaces multipunto. También podemos observar las colas que hemos creado para monitorizar los envíos entre 6 y 7 y entre 8 y 9. Así también vemos los paquetes que están siendo descartados.

EJEMPLO DE RED INALÁMBRICA:



Este es un ejemplo de simulación de red inalámbrica con 5 nodos. Los enlaces no son “físicos” y podemos observar como los paquetes viajan de un nodo a otro. También podemos observar los movimientos de los nodos en caso de que estos se trasladasen de un sitio a otro.

También podríamos crear redes mixtas: cableadas e inalámbricas.

EL EDITOR DE NAM:

Nam dispone de un editor grafico para que no sea necesario crear los esquemas de red y definir la simulación mediante líneas de código.



Usando el editor es más sencillo definir la topología e ir observando el esquema de la red según vamos creándolo.

Ns, network simulator, es una herramienta muy potente dentro del campo de la simulación de redes. Es a la vez muy flexible dada la posibilidad de trabajar con scripts tcl que nos permite agregar toda la potencia de un lenguaje de programación a los propios elementos de la simulación.

Además dispone de un entorno grafico llamado nam que nos va a simplificar el trabajo del diseño de la simulación al tiempo que nos da la posibilidad de observar los resultados de la simulación de una forma gráfica facilmente comprensible.

Todo ello hace de ns una ayuda inestimable en el campo de la investigación y del aprendizaje de redes.

Aquí teneis los enlaces a las páginas en las que se ha basado este artículo:

Página de ns-2:
http://www.isi.edu/nsnam/ns/

Manual de ns:
http://www.isi.edu/nsnam/ns/doc/index.html

Tutorial de ns de Marc Greis:
http://www.isi.edu/nsnam/ns/tutorial/index.html

NS by Example:
http://nile.wpi.edu/NS/

Para cualquier duda o comentario podeis contactar conmigo enviando un e-mail a:

javi (arroba) ideando.net

- FIN -