Network Simulator ns-2

Esta poderosa herramienta open source para simular redes desde cableadas hasta inalámbricas (local y satelital) permite estudiar y simular protocolos TCP y analizar diferentes topologías.
El ns-2 está escrito en C++ y utiliza el lenguaje Tcl/OTcl como interfase de comando y configuración. Los programas o scripts escritos en lenguaje Tcl/OTcl describen la topología de red, los parámetros y los eventos a simular.
Para su instalación en cualquier distro de GNU/Linux, y así evitar problemas durante la instalación, se deben tener todos estos paquetes instalados:

• autoconf
• automake
• gcc-c++
• libX11-devel
• xorg-x11-proto-devel
• libXt-devel
• libXmu-devel

La última versión de este simulador se puede encontrar en el siguiente link: http://www.isi.edu/nsnam/ns/ns-build.html

Adjunto un script para que puedan probar el simulador. El lenguaje OTcl es intuitivo, si se tienen conocimientos de programación. La topologia del scritp 'nssimulation.tcl' tiene 5 fuentes TCP CUBIC sobre un enlace de cuello de botella.

#Script: nssimulation.tcl
#Autor: Rodolfo Ledesma
#Licencia: GPLv3

#Programa

#Crear la instancia del simulador
set ns [new Simulator]

#Definir las variables y archivos de salida
set tf [open output.tr w]
set window(1) [open win1 w]
set window(2) [open win2 w]
set window(3) [open win3 w]
set window(4) [open win4 w]
set window(5) [open win5 w]
set param [open parameters w]

#Orden para trazar todos los eventos de la simulación
$ns trace-all $tf

#Tres archivos de análisis del enlace
#qsize, qlost [paquetes], qbw [Kbps], VS tiempo
set qsize [open queuesize.tr w]
set qbw [open queuebw.tr w]
set qlost [open queuelost.tr w]

#Definir un proceso de finalización 'finish'
proc finish {} {
global ns tf qsize qbw qlost
$ns flush-trace
close $qsize
close $qbw
close $qlost
close $tf
exit 0
}

#Crear un cuello de botella y nodos de destino
#y el enlace entre ellos
set n0 [$ns node]
set n1 [$ns node]
$ns duplex-link $n0 $n1 2Mb 10ms DropTail

#Configurar número de flujos y duración de la simulación
set NumbSrc 5
set Duration 150

#Nodos fuentes
for {set j 1} {$j<=$NumbSrc} {incr j} {
set S($j) [$ns node]
}

#Definir 2 parámetros para cada conexión
#Inicio de transmisión y el retardo de propagación

set startT(1) 1
set startT(2) 2
set startT(3) 3
set startT(4) 2
set startT(5) 5

set dly(1) 0
set dly(2) 40
set dly(3) 40
set dly(4) 90
set dly(5) 90

#Asignación de parámetros a cada nodo fuente
for {set i 1} {$i<=$NumbSrc} {incr i} {
puts $param "dly($i) $dly($i) ms"
puts $param "startT($i) $startT($i) seg" }

#Enlace entre fuente y cuello de botella
for {set j 1} {$j<=$NumbSrc} {incr j} {
$ns duplex-link $S($j) $n0 100Mb $dly($j)ms DropTail
$ns queue-limit $S($j) $n0 300
}

#Tamaño de cola n0-n1
$ns queue-limit $n0 $n1 150

#Fuentes TCP
for {set j 1} {$j<=$NumbSrc} {incr j} {
set tcp_src($j) [new Agent/TCP/Linux]
$tcp_src($j) set timestamps_ true
$tcp_src($j) set window_ 100000
$ns at 0 "$tcp_src($j) select_ca cubic"
}

#Destinos TCP
for {set j 1} {$j<=$NumbSrc} {incr j} {
set tcp_snk($j) [new Agent/TCPSink/Sack1]
$tcp_snk($j) set ts_echo_rfc1323_ true
}

#Conexiones
for {set j 1} {$j<=$NumbSrc} {incr j} {
$ns attach-agent $S($j) $tcp_src($j)
$ns attach-agent $n1 $tcp_snk($j)
$ns connect $tcp_src($j) $tcp_snk($j)
}

#Fuentes FTP
for {set j 1} {$j<=$NumbSrc} {incr j} {
set ftp($j) [$tcp_src($j) attach-source FTP]
}

#Definir tamaño de paquetes de las fuentes TCP
for {set j 1} {$j<=$NumbSrc} {incr j} {
$tcp_src($j) set packetSize_ 1040
}

#Cronograma de eventos para los agentes FTP
for {set i 1} {$i<=$NumbSrc} {incr i} {
$ns at $startT($i) "$ftp($i) start"
$ns at $Duration "$ftp($i) stop"
}

#Proceso de salida del tamaño de ventana
proc plotWindow {tcpSource file k} {
global ns
set time 0.005
set now [$ns now]
set cwnd [$tcpSource set cwnd_]
puts $file "$now $cwnd"
$ns at [expr $now+$time] "plotWindow $tcpSource $file $k"}

#Guardar salidas de tamaño de ventana en winX
for {set j 1} {$j<=$NumbSrc} {incr j} {
$ns at 0.1 "plotWindow $tcp_src($j) $window($j) $j"
}

#Muestrear la cola del cuello de botella a 100 Hz.
#y guardarlo en qm.tr
set qmon [$ns monitor-queue $n0 $n1 [open qm.tr w] 0.01]
[$ns link $n0 $n1] queue-sample-timeout;
proc record {} {
global ns qmon qsize qbw qlost n0 n1
set time 0.01
set now [$ns now]
$qmon instvar parrivals_ pdepartures_ bdrops_ bdepartures_ pdrops_
puts $qsize "$now [expr $parrivals_-$pdepartures_-$pdrops_]"
puts $qbw "$now [expr $bdepartures_*8/1024/$time]"
set bdepartures_ 0
puts $qlost "$now [expr $pdrops_/$time]"
$ns at [expr $now+$time] "record"
}

#Orden de inicio y finalización de eventos
$ns at 0.0 "record"
$ns at [expr $Duration] "finish"
$ns run