martes, 5 de marzo de 2013

[Lab RT] Actividad 5: Práctica con NS-2 y NAM

"NS es un simulador de redes basado en eventos discretos. Se usa principalmente en ambientes educativos y de investigación. Permite simular tanto protocolos unicast como multicast y se utiliza intensamente en la investigación de redes móviles ad-hoc. Implementa una amplia gama de protocolos tanto de redes cableadas como de redes inalámbricas. La versión actual, ns-3, esta diseñada para soportar todo el flujo de trabajo de la simulación desde la configuración hasta la recolección y análisis de tramas."
de: http://es.wikipedia.org/wiki/Ns_(simulador)


"NAM es una herramienta de animación basada en  TCL / TK, utilizada para ver las huellas de simulación y reales trazas de paquetes de una simulación de una topología de red utilizando NS. Soporta diseño de topologías, animación a nivel de paquete, y varias herramientas de inspección de datos. Nam comenzó a LBL. Ha evolucionado considerablemente en los últimos años. El esfuerzo de desarrollo nam fue una colaboración continua con el proyecto VINT. Actualmente, se está desarrollando como un proyecto de código abierto alojado en Sourceforge."
de: http://www.isi.edu/nsnam/nam/

Instalación


Para instalar el simulador NS y NAM en Ubuntu 12.04 necesitamos hacer lo siguiente:
  1. Descargar el código fuente desde http://sourceforge.net/projects/nsnam/
  2. Verificar que nuestro Ubuntu esté actualizado, tecleando el comando: sudo apt-get update 
  3. Instalar algunas dependencias, el comando completo es: sudo apt-get install build-essential autoconf automake libxmu-dev
  4. Nos desplazamos a la ubicación donde descargamos el código fuente de NAM y lo descomprimimos con el comando tar -xzvf ns-allinone-2.35.tar.gz (el número 2.35 es el número de versión el cual puede variar, para la fecha actual 2.35 es la más nueva)
  5. Una vez descomprimido, escribimos el siguiente comando para cambiar de carpeta cd ns-allinone-2.35
  6. Instalamos ejecutando el comando ./install
Esperamos a que la instalación termine.

Después procedemos a configurar las variables de entorno para que NS y NAM funcionen correctamente, son 3 variables de entorno que hay que configurar.

  • PATH
  • LD_LIBRARY_PATH
  • TCL_LIBRARY

Ahora, todas las variables de entorno de configuran de acuerdo a la ubicación de la instalación, en mi caso corresponde a /home/juancarlos/Downloads/ , ustedes ubiquen la propia. El directorio de instalación lo identificaremos más adelante con la abreviación [install_path]

Para configurar las variables de entorno nos vamos a nuestro home tecleando cd en la terminal, ahí editaremos el archivo .bashrc

Abrimos el archivo con nuestro editor favorito y nos vamos hasta el final del archivo, ahí comenzaremos a escribir. Las variables de entorno las configuramos añadiendo las siguientes líneas al .bashrc:

export PATH=[install_path]/ns-allinone-2.35/bin:[install_path]/ns-allinone-2.35/tcl8.5.10/unix:[install_path]/ns-allinone-2.35/tk8.5.10/unix:$PATH

export LD_LIBRARY_PATH=[install_path]/ns-allinone-2.35/otcl-1.14:[install_path]/ns-allinone-2.35/lib:$LD_LIBRARY_PATH

export TCL_LIBRARY=[install_path]/ns-allinone-2.35/tcl8.5.10/library:$TCL_LIBRARY

Hay que tener cuidado en esta parte de no escribir nada mal para evitar romper algo en el sistema operativo, verifiquen bien los datos antes de guardarlos. Después solo reiniciamos.

Si todo funciona bien, al teclear en la terminal el comando ns se abrirá una consola especial que solo mostrará el símbolo % que indica que NS ha iniciado en modo interactivo.
Si tecleamos nam se abrirá la ventana del visualizador.

ns nam

Práctica

Para ésta semana la actividad fue documentar una práctica utilizando cualquiera se los simuladores NS. En mi caso utilicé el simulador NS-2 y NAM para visualizar los resultados. La topología de la red se define mediante scripts TCL de una forma muy simple.

El modelo de red que simulé tiene las siguientes característica:

  • Topología de estrella
  • 4 nodos, uno central y tres hoja
  • Todos se conectan al nodo central mediante una conexión full duplex
El flujo de datos tuvo las siguientes características:
  • Dos flujos UDP con tasa de transferencia constante (CBR)
  • Un flujo TCP de tipo FTP.
  • El flujo TCP y UDP en cierto momento corren paralelos.
Todos los scripts siempre comienzan con la línea: 

set ns [new Simulator]
con la que se define un nuevo objeto simulador. A partir de aquí podemos comenzar a definir toda las características de la topología de red que queremos simular.
Primero definimos los archivos de salida, para poder guardar las trazas producidas por la simulación y ver la simulación en NAM 

set myFile [open out.tr w]
$ns trace-all $myFile

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

Despues, para cuestiones de visualización, coloreamos cada flujo de tráfico de diferente color. No es necesario indicar cuál flujo va de cuál color, NS-2 lo hace automáticamente.

$ns color 0 blue
$ns color 1 red
$ns color 2 green

Ahora definimos la topología, son 4 nodos: 

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

Y conectamos los nodos entre sí definiendo los enlaces. En este caso todas las conexiones son de tipo full duplex, las conexiones entre el nodo 0 y el nodo 2, así como la del nodo 1 con nodo 2 tienen las mismas características, la entre el nodo 2 y nodo 3 es más rápida pero tiene más delay. Todas tienen una queue de tipo Tail Drop. NS-2 ofrece una gran variedad de enlaces

$ns duplex-link $n0 $n2 1.5Mb 2ms DropTail
$ns duplex-link $n1 $n2 1.5Mb 2ms DropTail
$ns duplex-link $n2 $n3 3.0Mb 10ms DropTail
Ahora, para cuestiones de visualización nuevamente, posicionamos cada nodo en un layout que se vea bonito, 2 nodos a la izquierda, arriba y abajo, un nodo al centro y un nodo a la derecha en el centro.
Creamos también un monitor en cada conexión para mantener una queue de paquetes y evitar desbordamientos y pérdida de paquetes.

$ns duplex-link-op $n0 $n2 orient right-up
$ns duplex-link-op $n1 $n2 orient right-down
$ns duplex-link-op $n2 $n3 orient right

$ns duplex-link-op $n0 $n2 queuePos 0.5
$ns duplex-link-op $n1 $n2 queuePos 0.5
$ns duplex-link-op $n2 $n3 queuePos 0.5
Ahora definimos las conexiones UDP, debemos crear un agente UDP por cada una, crear un "sink" que no es más que un agente que recibe el flujo de tráfico UDP, y también es necesario colocarle a cada conexión UDP una fuente de tráfico constante CBR.
Las conexiones UDP van del nodo 0 al nodo 3 y del nodo 1 al nodo 3, pasando forzozamente por el nodo 2 aunque esto último no es necesario especificarlo.
La primera conexión UDP comienza en el segundo 0.2 y la segunda conexión UDP comienza en el segundo 0.5, ambas permanecen activas durante toda la simulación. 

set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
$udp0 set class_ 0

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

$ns connect $udp0 $null0

set cbr0 [new Application/Traffic/CBR]
$cbr0 attach-agent $udp0

$ns at 0.2 "$cbr0 start"


set udp1 [new Agent/UDP]
$ns attach-agent $n3 $udp1
$udp1 set class_ 1

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

$ns connect $udp1 $null1

set cbr1 [new Application/Traffic/CBR]
$cbr1 attach-agent $udp1

$ns at 0.5 "$cbr1 start"
Por último creamos una fuente de tráfico TCP de tipo FTP, la cual va del nodo 1 al nodo 3. La conexión TCP comienza en el segundo 1 de simulación y finaliza en el segundo 2.

set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0
$tcp0 set class_ 2

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

$ns connect $tcp0 $fin0

set ftp [new Application/FTP]
$ftp attach-agent $tcp0

$ns at 1.0 "$ftp start"

$ns at 2.0 "$ns detach-agent $n0 $tcp0 ; $ns detach-agent $n3 $fin0"
Finalmente siguen las instrucciones para la simulación, indicamos que la misma durara 3 segundos. Después declaramos el procedimiento de finalización donde limpiamos la memoria, cerramos los archivos y ejecutamos NAM para visualizar los resultados.

$ns at 3.0 "finish"

proc finish {} {
    global ns myFile myNamFile
    $ns flush-trace
    close $myFile
    close $myNamFile
        puts "Simulacion terminada"
    exec nam out.nam &
    exit 0
}
Los scripts finalizan con la instrucción para indicar cuándo la simuación debe correr, hasta que terminan de configurarse todos los parámetros. 

$ns run

Script completo


Los dejo el script completo, comentado, con el que corrí la simulación de la topología definida.

Video de la simulación.


El video muestra la visualización de la simulación en NAM, los momentos interesantes del video son:
  • 0:30 comienza a correr la simulación
  • 0:33 comienza el primer tráfico UDP
  • 0:39 comienza el segundo tráfico UDP
  • 0:50 comienza el tráfico TCP, podemos ver como los monitores comienzan a enviar los paquetes a las queues debido a que el nodo 2 esta a capacidad máxima debido a que ya tiene 2 conexiones activas. La queue de la conexión entre los nodos n0 y n2 es la que se hace más grande.
  • 1:14 Finaliza el tráfico TCP


Ésta fue una implementación muy sencilla utilizando NS-2 pero se puede leer la documentación del simulador para lograr topologías mas complejas.
Las ligas están en las referencias al final de la entrada.

 Referencias

Publicado por en
Etiquetas:

3 comentarios:

Suscribirse a: Enviar comentarios (Atom)