Actividad 5: Simulación de Redes

Laboratorio de Redes de Telecomunicaciones
Actividad 5

Esta semana hicimos una simulación con el programa Network Simulator, que ofrece actualmente dos versiones estables, 2 y 3, conocidas mejor como NS-2 Y NS-3, con las cuales se pueden hacer simulaciones de redes.

La versión que yo he instalado es la NS-2 la cual he logrado instalar de dos formas distintas, la primera involucra escribir varios comandos en una terminal, y la segunda con los comandos de siempre para instalar paquetes en Ubuntu, en mi caso la versión 12.04.

Página del simulador: The Network Simulator: NS-2

Instalación

Estoy usando Ubuntu 12.04 versión de 64 bits para la instalación de este paquete. Veamos el método clásico para la instalación más reciente de este simulador, en este caso la versión 2.35.

Primero hay que descargar la carpeta comprimida de NS-2, de la siguiente liga: Descarga de ns-allinone-2.35.tar.gz

Una vez descargado, hay que asegurarse de que tenemos instaladas todas las actualizaciones:

~$ sudo apt-get update

Instalamos paquetes necesarios:

~$ sudo apt-get install build-essential autoconf automake libxmu-dev

Descomprimimos el paquete descargado:

~$ tar zxvf ns-allinone-2.35.tar.gz

Entramos a la carpeta creada:

~$ cd ns-allinone-2.35

Y una vez adentro ejecutamos el archivo install:

~/ns-allinone-2.35$ ./install

Si todo resulta bien, podemos entrar a la carpeta ns-2.35 y ejecutar el simulador ns:

~/ns-allinone-2.35$ cd ns-2.35
~/ns-allinone-2.35/ns-2.35$ ./ns
%

Cuando se despliega el signo % significa que ya estamos dentro de la consola interactiva del simulador. Se recomienda agregar el path de este comando al archivo .bashrc, para no tener que estar siempre dentro de la carpeta para ejecutar el simulador.

La segunda forma de instalación, que es la forma más fácil y rápida, se hace escribiendo y ejecutando las siguientes dos líneas:

~$ sudo apt-get install ns2
~$ sudo apt-get install nam

El último sirve para poder ver la simulación en la consola gráfica de nam. Cabe mencionar que con estos últimos comandos la versión que tendremos instalada es la 2.34, que parece funcionar bien.

Correr un programa en NS-2

Como sucede con varios lenguajes, por ejemplo python, es posible entrar en la consola de forma interactiva o ejecutar archivos con el código escrito.

Veamos un ejemplo desde la consola de forma interactiva. Esta sería una versión del clásico Hola Mundo.

ramon@pavilion:~$ ns
% set ns [new Simulator]
_o4
% $ns at 1 "puts \"Hola Mundo!\""
1
% $ns at 1.5 "exit"
2
% $ns run
Hola Mundo!
ramon@pavilion:~$

Inmediatamente despupes de escribir $ns run se ejecuta lo escrito e imprime el resultado.

La forma más habitual es escribir por separado el código en un archivo con la extensión .tcl, y ejecutarlo directamente en la consola.

ramon@pavilion:~$ ns ejemplo.tcl
Hola Mundo!
ramon@pavilion:~$

Simulación de prueba

Para ver como era el funcionamiento del simulador NS-2 junto con NAM busqué en Internet un ejemplo, para poder probar y entender que significa cada acción, así que de la siguiente liga descargue el ejemplo y lo probé.

Página de donde obtuve el ejemplo: Simple Simulation Example

El código descargado fue el siguiente, y como pueden ver es de gran ayuda ya que explica para que sirve cada línea:

	#Create a simulator object
	set ns [new Simulator]
	#Define different colors for data flows (for NAM)
	$ns color 1 Blue
	$ns color 2 Red
	#Open the NAM trace file
	set nf [open out.nam w]
	$ns namtrace-all$nf
	#Define a 'finish' procedure
	proc finish {} {
	global ns nf
	$ns flush-trace
	#Close the NAM trace file
	close $nf
	#Execute NAM on the trace file
	exec nam out.nam &
	exit 0
	}
	#Create four nodes
	set n0 [$ns node]
	set n1 [$ns node]
	set n2 [$ns node]
	set n3 [$ns node]
	#Create links between the nodes
	$ns duplex-link$n0 $n2 2Mb 10ms DropTail
	$ns duplex-link$n1 $n2 2Mb 10ms DropTail
	$ns duplex-link$n2 $n3 1.7Mb 20ms DropTail
	#Set Queue Size of link (n2-n3) to 10
	$ns queue-limit$n2 $n3 10
	#Give node position (for NAM)
	$ns duplex-link-op$n0 $n2 orient right-down
	$ns duplex-link-op$n1 $n2 orient right-up
	$ns duplex-link-op$n2 $n3 orient right
	#Monitor the queue for link (n2-n3). (for NAM)
	$ns duplex-link-op$n2 $n3 queuePos 0.5
	#Setup a TCP connection
	set tcp [new Agent/TCP]
	$tcp set class_ 2
	$ns attach-agent$n0 $tcp
	set sink [new Agent/TCPSink]
	$ns attach-agent$n3 $sink
	$ns connect$tcp $sink
	$tcp set fid_ 1
	#Setup a FTP over TCP connection
	set ftp [new Application/FTP]
	$ftp attach-agent$tcp
	$ftp set type_ FTP
	#Setup a UDP connection
	set udp [new Agent/UDP]
	$ns attach-agent$n1 $udp
	set null [new Agent/Null]
	$ns attach-agent$n3 $null
	$ns connect$udp $null
	$udp set fid_ 2
	#Setup a CBR over UDP connection
	set cbr [new Application/Traffic/CBR]
	$cbr attach-agent$udp
	$cbr set type_ CBR
	$cbr set packet_size_ 1000
	$cbr set rate_ 1mb
	$cbr set random_ false
	#Schedule events for the CBR and FTP agents
	$ns at 0.1 "$cbr start"
	$ns at 1.0 "$ftp start"
	$ns at 4.0 "$ftp stop"
	$ns at 4.5 "$cbr stop"
	#Detach tcp and sink agents (not really necessary)
	$ns at 4.5 "$ns detach-agent $n0$tcp ; $ns detach-agent$n3 $sink"
	#Call the finish procedure after 5 seconds of simulation time
	$ns at 5.0 "finish"
	#Print CBR packet size and interval
	puts "CBR packet size = [$cbr set packet_size_]"
	puts "CBR interval = [$cbr set interval_]"
	#Run the simulation
	$ns run

view raw ns-simple.tcl hosted with ❤ by GitHub

La visualización del mismo es la siguiente.

Y claro, se ve muy bien la simulación pero que significa estos cuadros de color pasando de un nodo a otro. Bueno como podemos ver tenemos 4 nodos, el 0 envía paquetes mediante conexión TCP visualizados como cuadros azules, y el 1 envía paquetes mediante conexión UDP visualizados con cuadros rojos. EL nodo 2 los recibe y retransmite al nodo 3, donde el nodo 3 es el que, para el caso de los paquetes que vienen a través de TCP, envía una respuesta ACK hasta el nodo 0 cuando recibe estos cuadros azules. En el nodo 3 también podemos ver como se forma una cola por la llegada de muchos paquetes, y en el transcurso algunos de ellos se pierden, y se visualiza como cuadros grandes cayendo.

Cuando tenemos la visualización de la simulación en NAM se crean archivos de salida con el nombre de out.tr y out.nam, con un resumen de la simulación. Yo estoy usando el archivo out.tr porque la estructura del archivo es más entendible. Este archivo tiene las siguientes columnas:

Del resultado obtenido de la simulación obtuve los tiempos para poder conocer el tiempo que tardaba entre un paquete y otro, y después hice esta gráfica.

Una prueba más que hice fue calcular el número de paquetes enviados y recibidos mediante el protocolo TCP, y calculando la diferencia obtenemos el número de paquetes perdidos.

Referencias:
Instalar NS-2.35 en Ubuntu 12-04
Tutorial NS-2