Tutorial NS 2

Tutorial NS-2
Juan Gallardo Casero

6272132-D

Redes y Servicios Mviles
Ingeniera Informtica 5
9 Abril 2010

E. S. de Informtica de Ciudad Real
Universidad de Castilla-La Mancha
Tutorial NS-2 Redes y Servicios Mviles

Juan Gallardo Casero 2
ndice

1. Prctica n1: Instalacin ...................................................................................................... 3
1.1. Introduccin a NS-2 ........................................................................................................ 3
1.2. Instalacin de NS-2 ......................................................................................................... 3
1.3. Ejemplo inicial ................................................................................................................ 3
1.4. Ejemplo MobileIP ........................................................................................................... 5
1.5. Otros ejemplos sencillos .................................................................................................. 9
1.6. Instalacin de Eclipse .................................................................................................... 12
1.7. Ejemplo NAM ............................................................................................................... 12
1.8. Otros animadores de trfico de red ............................................................................... 17
2. Prctica n2: Redes satelitales, ad hoc, WPAN ............................................................... 18
2.1. Red estructurada ............................................................................................................ 18
2.2. Modificacin de la red estructurada .............................................................................. 20
2.3. Red ad-hoc ..................................................................................................................... 24
2.4. Red satelital ................................................................................................................... 27
2.5. Red WPAN .................................................................................................................... 31
2.6. Otros simuladores de redes de sensores ........................................................................ 37
3. Prctica n3: Realizacin de mtricas .............................................................................. 38
3.1. Mtricas de la red WPAN ............................................................................................. 38
4. Prctica n4: Estructura interna de NS-2 ........................................................................ 41
4.1. Objetos TclObject, NsObject, Connector, Classifier y Node ........................................ 41
4.2. Extensiones de NS-2 usando herencia de objetos OTcl ................................................ 46
4.3. Extensiones de NS-2 usando herencia de objetos C++ ................................................. 50
5. Prctica n5: Depuracin ................................................................................................... 53
5.1. Depuracin a nivel de OTcl/C++ .................................................................................. 53


1. Prctica n1: Instalacin

1.1. Introduccin a NS-2

NS-2
1
es un simulador de eventos discreto destinado al estudio y anlisis del trfico en
redes fijas y mviles. Proporciona soporte para la simulacin de diferentes protocolos (entre
ellos TCP), enrutamiento, comunicacin unicast y multicast e interfaces de red cableadas e
inalmbricas, incluyendo redes satelitales.

NS-2 est escrito en C++ y en una versin orientada a objetos de Tcl llamada OTcl,
que es el lenguaje utilizado para definir los escenarios y las topologas. El simulador est
disponible bajo la licencia GPL y es un proyecto de cdigo abierto, lo cual permite extenderlo
fcilmente para crear o probar nuevos protocolos. Este hecho es uno de los principales que ha
provocado que NS-2 est entre los simuladores de redes ms utilizados en la actualidad.

Junto con NS-2 se suele distribuir tambin NAM, un animador de redes en el que se
puede visualizar grficamente la topologa y el trfico de las redes simuladas a partir de las
trazas generadas por el simulador.

1.2. Instalacin de NS-2

Para la realizacin de este tutorial se ha utilizado la versin 2.34 del paquete ns-
allinone, en lugar de la 2.32, porque era la versin ms reciente de la aplicacin que se poda
encontrar en el repositorio Sourceforge
2
.

Conviene resaltar que, al ejecutar el script de instalacin, aparecieron una serie de
errores debido a que no estaban instalados en la distribucin de Linux algunos paquetes
necesarios para compilar los programas de NS-2 (como los compiladores gcc y g++ y algunas
libreras de desarrollo). Tras la instalacin y configuracin de estos paquetes, se pudieron
compilar correctamente todas las aplicaciones incluidas en el paquete ns-allinone.

1.3. Ejemplo inicial

A continuacin se muestra el cdigo del fichero de ejemplo example1b.tcl tomado del
tutorial de Marc Greis, que es el primero que se ha probado y analizado.

# Se crea una nueva instancia del simulador.
set ns [new Simulator]

# Creacin de los archivos donde se escribirn trazas

1
http://nsnam.isi.edu/nsnam/index.php/Main_Page
2
http://downloads.sourceforge.net/nsnam/

# cuyos datos sern visualizados en NAM.
set nf [open out.nam w]
$ns namtrace-all $nf

# Procedimiento ejecutado al final de la simulacin donde
# se escriben las trazas y se llama al animador de red NAM.
proc finish {} {
global ns nf
$ns flush-trace
#Close the trace file
close $nf
#Execute nam on the trace file
exec nam out.nam &
exit 0
}

# Se crean dos nodos.
set n0 [$ns node]
set n1 [$ns node]

# Se crean dos link duplex con un ancho de banda de 1Mb,
# con un retardo de 10 ms, el tipo de cola usado ser DropTail.
$ns duplex-link $n0 $n1 1Mb 10ms DropTail

# Se crea un Agente UDP y se lo adjunta al nodo 0 (n0).
set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0

# Se crea una fuente de trfico tipo CBR (Constant
# Bit Rate) y se adjunta al nodo 1 (n1).
set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp0
# Se crea un agente Nulo (sink) y se adjunta al nodo 1 (n1).
set null0 [new Agent/Null]
$ns attach-agent $n1 $null0

# Conexin del fuente de trfico con el agente Nulo (sink).
$ns connect $udp0 $null0

# Cronograma de eventos para el agente CBR
$ns at 0.5 "$cbr0 start"
$ns at 4.5 "$cbr0 stop"
# Llamada al procedimiento finish, creado al inicio
# de este script despus de 5s de iniciada la simulacin.
$ns at 5.0 "finish"

# Ejecucin de la simulacin
$ns run

La red de este ejemplo est formada por dos nodos (n0 y n1), entre los cuales se ha
colocado un enlace bidireccional full-duplex de 10 ms de retardo y 1 Mb de ancho de banda.
El nico trfico que tiene la red, definido con la variable cbr0, est compuesto por paquetes
UDP de 500 bytes que se envan de forma constante, con un intervalo de tiempo de 0.005 s
entre cada paquete, del nodo n0 al n1. Este trfico est activo solamente entre los instantes 0.5
y 4.5 segundos, finalizando la simulacin a los 5 segundos.


La siguiente pantalla muestra un momento de la simulacin de la red en el animador
de redes NAM despus de generar la traza con NS-2 y guardar los resultados en out.nam.

1.4. Ejemplo MobileIP

En el tutorial se propone la ejecucin del ejemplo miptest.tcl incluido en el simulador
NS-2, que contiene una implementacin sencilla del protocolo Mobile IP. El cdigo de este
ejemplo es el siguiente (ignorando algunos comentarios):

# miptest.tcl
#
# To show mobileIP activities.
# Modified from a SUN's original example script

set opt(tr) out
set opt(namtr) "miptest.nam"
set opt(seed) 0
set opt(stop) 20

set opt(qsize) 100
set opt(bw) 2Mb
set opt(delay) 1ms
set opt(ll) LL
set opt(ifq) Queue/DropTail
set opt(mac) Mac/Csma/Ca
set opt(chan) Channel
set opt(tcp) TCP/Reno
set opt(sink) TCPSink


set opt(source) FTP

proc Usage {} {
global opt argv0
puts "Usage: $argv0 \[-stop sec\] \[-seed value\] \[-node numNodes\]"
puts "\t\[-tr tracefile\] \[-g\]"
puts "\t\[-ll lltype\] \[-ifq qtype\] \[-mac mactype\]"
puts "\t\[-bw $opt(bw)] \[-delay $opt(delay)\]"
exit 1
}

proc Getopt {} {
global opt argc argv
if {$argc == 0} Usage
for {set i 0} {$i < $argc} {incr i} {
set key [lindex $argv $i]
if ![string match {-*} $key] continue
set key [string range $key 1 end]
set val [lindex $argv [incr i]]
set opt($key) $val
if [string match {-[A-z]*} $val] {
incr i -1
continue
}
switch $key {
ll { set opt($key) LL/$val }
ifq { set opt($key) Queue/$val }
mac { set opt($key) Mac/$val }
}
}
}

proc finish {} {
exit 0
}

proc create-trace {} {
global ns opt

if [file exists $opt(tr)] {
catch "exec rm -f $opt(tr) $opt(tr)-bw [glob $opt(tr).*]"
}

set trfd [open $opt(tr) w]
$ns trace-all $trfd
if {$opt(namtr) != ""} {
$ns namtrace-all [open $opt(namtr) w]
}
return $trfd
}

proc create-topology {} {
global ns opt
global lan node source
$ns instvar link_

set node(s) [$ns node]

set node(g) [$ns node]
Simulator set node_factory_ Node/MIPBS
set node(ha) [$ns node]
$node(ha) shape "hexagon"
set node(fa) [$ns node]
$node(fa) shape "hexagon"
Simulator set node_factory_ Node/MIPMH
set node(mh) [$ns node]
$node(mh) shape "circle"

$ns duplex-link $node(s) $node(g) 2Mb 5ms DropTail
$ns duplex-link-op $node(s) $node(g) orient right
$ns duplex-link $node(g) $node(ha) 2Mb 5ms DropTail
$ns duplex-link-op $node(g) $node(ha) orient up
$ns duplex-link $node(g) $node(fa) 2Mb 5ms DropTail
$ns duplex-link-op $node(g) $node(fa) orient right-up

$ns duplex-link $node(ha) $node(mh) 2Mb 5ms DropTail
$ns duplex-link-op $node(ha) $node(mh) orient right
$ns duplex-link $node(fa) $node(mh) 4Mb 5ms DropTail
$ns duplex-link-op $node(fa) $node(mh) orient left

set mhid [$node(mh) id]
set haid [$node(ha) id]
set faid [$node(fa) id]
$link_($mhid:$faid) dynamic
$link_($faid:$mhid) dynamic
$link_($mhid:$faid) down
$link_($faid:$mhid) down
$link_($mhid:$haid) dynamic
$link_($haid:$mhid) dynamic

[$node(ha) set regagent_] add-ads-bcast-link $link_($haid:$mhid)
[$node(fa) set regagent_] add-ads-bcast-link $link_($faid:$mhid)

[$node(mh) set regagent_] set home_agent_ $haid
[$node(mh) set regagent_] add-sol-bcast-link $link_($mhid:$haid)
[$node(mh) set regagent_] add-sol-bcast-link $link_($mhid:$faid)

$ns at 0.0 "$node(ha) label HomeAgent"
$ns at 0.0 "$node(fa) label ForeignAgent"
$ns at 0.0 "$node(mh) label MobileHost"

$ns at 0.0 "$node(ha) color gold"
$ns at 0.0 "$node(mh) color gold"

$ns rtmodel-at 0.1 down $node(mh) $node(fa)

set swtm [expr 3.0+($opt(stop)-3.0)/4.0]
$ns rtmodel-at $swtm down $node(mh) $node(ha)
$ns rtmodel-at $swtm up $node(mh) $node(fa)
$ns at $swtm "$node(ha) color black"
$ns at $swtm "$node(fa) color gold"

set swtm [expr 3.0+($opt(stop)-3.0)/2.0]
$ns rtmodel-at $swtm down $node(mh) $node(fa)
$ns rtmodel-at $swtm up $node(mh) $node(ha)
$ns at $swtm "$node(ha) color gold"
$ns at $swtm "$node(fa) color black"


set swtm [expr 3.0+($opt(stop)-3.0)*3.0/4.0]
$ns rtmodel-at $swtm down $node(mh) $node(ha)
$ns rtmodel-at $swtm up $node(mh) $node(fa)
$ns at $swtm "$node(ha) color black"
$ns at $swtm "$node(fa) color gold"
}

proc create-source {} {
global ns opt
global lan node source

set tp [$ns create-connection $opt(tcp) \
$node(s) $opt(sink) $node(mh) 0]
set source [$tp attach-source $opt(source)]
$ns at 0.0 "$source start"
}

## MAIN ##
Getopt
if {$opt(seed) >= 0} { ns-random $opt(seed) }
if [info exists opt(qsize)] { Queue set limit_ $opt(qsize) }

set trfd [create-trace]

create-topology
create-source

#$lan trace $ns $trfd

$ns at $opt(stop) "finish"
$ns run

Bsicamente, esta red est formada por un host mvil (4); dos agentes, uno local (2) y
otro externo (3); y otros dos nodos intermedios (0 y 1). El trfico que se genera en esta red
son, simplemente, paquetes que enva el nodo 0 y tienen como destino el host mvil.

Al principio, el host mvil est conectado y registrado en el agente local, por lo que
recibe los paquetes enviados por el nodo 0 a travs de dicho host. Sin embargo, en mitad de la
simulacin, el host mvil deja de estar al alcance del agente local y se conecta con el agente
externo. A partir de ese momento, los paquetes que enva el nodo 0 siguen llegando al agente
local, porque el nodo de partida no sabe que el host mvil se ha desplazado, pero este agente
los reenva al agente externo para que los acabe recibiendo el host mvil igual que si estuviera
conectado con el host local. Este es el funcionamiento esencial de Mobile IP.

Esta figura obtenida con el animador de redes NAM muestra el escenario al visualizar
la traza de la simulacin cuando el host mvil (4) est conectado al agente externo (3).



1.5. Otros ejemplos sencillos

Como en el tutorial se recomienda explorar otros ejemplos del directorio ns-x.xx/tcl/ex,
se han buscado algunos escenarios sencillos para probarlos en el simulador NS-2 y ver los
resultados en el animador de redes NAM.

Uno de los escenarios que se ha analizado ha sido el definido en el archivo lantest.tcl,
cuyo cdigo se reproduce a continuacin:

#!/bin/sh
# the next line finds ns \
nshome=`dirname $0`; [ ! -x $nshome/ns ] && [ -x ../../ns ] && nshome=../..
# the next line starts ns \
export nshome; exec $nshome/ns "$0" "$@"

if [info exists env(nshome)] {
set nshome $env(nshome)
} elseif [file executable ../../ns] {
set nshome ../..
} elseif {[file executable ./ns] || [file executable ./ns.exe]} {
set nshome "[pwd]"
} else {
puts "$argv0 cannot find ns directory"
exit 1
}
set env(PATH) "$nshome/bin:$env(PATH)"

set opt(tr) out

set opt(namtr) "lantest.nam"
set opt(seed) 0
set opt(stop) 5
set opt(node) 8

set opt(qsize) 100
set opt(bw) 10Mb
set opt(delay) 1ms
set opt(ll) LL
set opt(ifq) Queue/DropTail
set opt(mac) Mac/802_3
set opt(chan) Channel
set opt(tcp) TCP/Reno
set opt(sink) TCPSink

set opt(app) FTP

proc finish {} {
global env nshome pwd
global ns opt trfd

$ns flush-trace
close $trfd

exec ../../../nam-1/nam lantest.nam

exit 0
}

proc create-trace {} {
global ns opt

if [file exists $opt(tr)] {
catch "exec rm -f $opt(tr) $opt(tr)-bw [glob $opt(tr).*]"
}

set trfd [open $opt(tr) w]
$ns trace-all $trfd
if {$opt(namtr) != ""} {
$ns namtrace-all [open $opt(namtr) w]
}
return $trfd
}

proc create-topology {} {
global ns opt
global lan node source node0

set num $opt(node)
for {set i 0} {$i < $num} {incr i} {
set node($i) [$ns node]
lappend nodelist $node($i)
}

set lan [$ns newLan $nodelist $opt(bw) $opt(delay) \
-llType $opt(ll) -ifqType $opt(ifq) \
-macType $opt(mac) -chanType $opt(chan)]

set node0 [$ns node]

$ns duplex-link $node0 $node(0) 2Mb 2ms DropTail

$ns duplex-link-op $node0 $node(0) orient right

}

## MAIN ##

set trfd [create-trace]

create-topology
set tcp0 [$ns create-connection TCP/Reno $node0 TCPSink $node(7) 0]
$tcp0 set window_ 15
$ns color 1 green
$tcp0 set fid_ 1
set ftp0 [$tcp0 attach-app FTP]

$ns at 0.0 "$ftp0 start"

$ns at $opt(stop) "finish"
$ns

En este fichero se crea una red LAN (802.3) de 10 Mb/s con topologa de bus formada
por 8 nodos, uno de los cuales est conectado a otro nodo origen con un enlace de 2 Mb/s.
Para crear la red LAN se utiliza el comando $ns newLan, al que se le pasa una lista de nodos,
el ancho de banda del bus, el retardo, el tipo de MAC y el tipo de cola, entre otros parmetros.
En esta captura de pantalla se puede ver cmo representa NAM las redes LAN en bus del
simulador.


El nico trfico que tiene esta red lo genera una aplicacin FTP que enva paquetes del
nodo origen (9) al ltimo nodo de la red LAN (7). Para ello, el nodo 0, que es el que est
conectado al nodo origen, reenva los paquetes por la LAN para que los reciba el nodo 7,
aunque como se utiliza una topologa de bus, estos paquetes ocupan el bus completo de la red,
impidiendo que se pueda realizar cualquier otra comunicacin mientras se estn enviando.

1.6. Instalacin de Eclipse

Durante la realizacin del tutorial se instal el entorno de desarrollo Eclipse junto con
el plugin CDT (C/C++ Development Tooling) tal y como se indicaba, pero no se ha utilizado
en las siguientes prcticas, sino que se ha preferido compilar, depurar y ejecutar todos los
scripts utilizando la lnea de comandos con un terminal.

1.7. Ejemplo NAM

Este es el cdigo del archivo nam-example.tcl que se indica en el tutorial que debe
estudiarse en la segunda parte de la primera prctica:

#
# example of new ns support for nam trace, adapted from Kannan's srm2.tcl
#
# $Header: /cvsroot/nsnam/ns-2/tcl/ex/nam-example.tcl,v 1.18 2000/03/24 19:52:46
haoboy Exp $
# updated by Lloyd Wood

if [string match {*.tcl} $argv0] {
set prog [string range $argv0 0 [expr [string length $argv0] - 5]]
} else {
set prog $argv0
}

if {[llength $argv] > 0} {
set srmSimType [lindex $argv 0]
} else {
set srmSimType Adaptive
}

#source ../mcast/srm-nam.tcl ;# to separate control messages.
#source ../mcast/srm-debug.tcl ;# to trace delay compute fcn. details.
ns-random 1

set ns [new Simulator -multicast on]
#Node expandaddr

#$ns trace-all [open out.tr w]
$ns namtrace-all [open out.nam w]
# To test piping ns output in realtime to nam, comment the above line and
# uncomment the following line and use:
# ns nam-example.tcl | nam -
#$ns namtrace-all stdout
set srmStats [open srm-stats.tr w]


# define color index
$ns color 0 red
$ns color 1 blue
$ns color 2 chocolate
$ns color 3 red
$ns color 4 brown
$ns color 5 tan
$ns color 6 gold
$ns color 7 black

# create node with given shape and color
set n(0) [$ns node]
$n(0) color "black"
$n(0) shape "circle"
set n(1) [$ns node]
$n(1) color "blue"
set n(2) [$ns node]
$n(2) color "chocolate"
set n(3) [$ns node]
$n(3) color "gold"
set n(4) [$ns node]
$n(4) color "tan"
set n(5) [$ns node]
$n(5) color "red"

# create links and layout
$ns duplex-link $n(0) $n(1) 1.5Mb 10ms DropTail
$ns duplex-link-op $n(0) $n(1) orient right
$ns duplex-link-op $n(3) $n(4) orient 60deg
$ns duplex-link-op $n(3) $n(5) orient 300deg

$ns duplex-link-op $n(3) $n(4) color "green"
$ns duplex-link-op $n(3) $n(4) label "abced"

$ns queue-limit $n(0) $n(1) 2 ;# q-limit is 1 more than max #packets in q.
$ns queue-limit $n(1) $n(0) 2

# set routing
set group [Node allocaddr]
#XXX do *NOT* use DM here, it won't work with rtmodel!
#set mh [$ns mrtproto DM {}]
#$ns at 0.0 "$ns run-mcast"
set cmc [$ns mrtproto CtrMcast {}]
$ns at 0.3 "$cmc switch-treetype $group"

# set group members
set fid 0
for {set i 0} {$i <= 5} {incr i} {
set srm($i) [new Agent/SRM/$srmSimType]
$srm($i) set dst_addr_ $group

$srm($i) set dst_port_ 0
$srm($i) set fid_ [incr fid]
$srm($i) trace $srmStats
$ns at 1.0 "$srm($i) start"

$ns attach-agent $n($i) $srm($i)
$ns add-agent-trace $srm($i) srm($i)
$ns monitor-agent-trace $srm($i) ;# turn nam monitor on from the start
$srm($i) tracevar C1_
$srm($i) tracevar C2_
}

# set traffic source
set packetSize 800
set s [new Application/Traffic/CBR]
$s set packetSize_ $packetSize
$s set interval_ 0.02
$s attach-agent $srm(0)
$srm(0) set tg_ $s
$srm(0) set app_fid_ 0
$srm(0) set packetSize_ $packetSize
$ns at 3.5 "$srm(0) start-source"

$ns at 3.5 "$n(0) color red"
$ns at 3.5 "$ns trace-annotate \"node 0 changed color\""

$ns at 3.6 "$n(0) label abc"

$ns at 4.0 "$n(0) label def"

# add/remove node marks (concentric circles around nodes)
$ns at 4.0 "$n(0) add-mark m1 blue circle"
$ns at 4.0 "$ns trace-annotate \"node 0 added one mark\""
$ns at 4.5 "$n(0) add-mark m2 purple hexagon"
$ns at 4.5 "$ns trace-annotate \"node 0 added second mark\""

$ns at 5.0 "$n(0) delete-mark m1"
$ns at 5.0 "$ns trace-annotate \"node 0 deleted one mark\""
$ns at 5.5 "$n(0) delete-mark m2"
$ns at 5.5 "$ns trace-annotate \"node 0 deleted second mark\""

# Fake a dropped packet by incrementing seqno.
#$ns rtmodel-at 3.519 down $n(0) $n(1) ;# this ought to drop exactly one
#$ns rtmodel-at 3.621 up $n(0) $n(1) ;# data packet?
$ns rtmodel Deterministic {2.61 0.98 0.02} $n(0) $n(1)

$ns at 3.7 "$n(0) color cyan"
$ns at 3.7 "$ns trace-annotate \"node 0 changed color again\""
$ns at 10.0 "$ns trace-annotate \"simu finished\""
$ns at 10.0 "finish"

proc finish {} {
global s srm
$s stop

global ns srmStats
$ns flush-trace ;# NB> Did not really close out.tr...:-)
close $srmStats

global argv0
if [string match {*.tcl} $argv0] {
set prog [string range $argv0 0 [expr [string length $argv0] - 5]]

} else {
set prog $argv0
}

for {set i 0} {$i <= 5} {incr i} {
$ns delete-agent-trace $srm($i)
}

puts "running nam..."
exec nam -f dynamic-nam.conf out.nam &
exit 0
}

$ns at 0.0 "$ns set-animation-rate 0.1ms"
$ns run

En este ejemplo se pretende mostrar cmo utilizar muchos de los comandos explicados
hasta ahora en el tutorial. Algunos de estos comandos son:
set ns [new Simulator -multicast on]: inicializa el simulador de NS-2 y adems
habilita el trfico de paquetes multicast, que se utiliza en este ejemplo concreto.
$ns namtrace-all [open out.nam w]: indica a NS-2 que debe almacenar la traza de
la simulacin en el fichero out.nam para que luego pueda ser utilizada por el animador
NAM.
$ns color 0 red: asocia al color rojo el ndice 0, para poder referirse a dicho color
ms adelante a travs de ese nmero.
set n(0) [$ns node]: crea un nuevo nodo llamado n(0).
$n(0) color "black": dibuja el nodo n(0) de color negro.
$n(0) shape "circle": representa el nodo n(0) con un crculo.
$ns duplex-link $n(0) $n(1) 1.5Mb 10ms DropTail: crea un nuevo enlace full-
duplex entre los nodos n(0) y n(1), con una capacidad de 1.5 Mb/s, un retardo de 10 ms
y una cola de tipo DropTail, es decir, una cola en la que no se hace distincin entre los
paquetes y se descartan todos los paquetes entrantes cuando se alcanza la capacidad
mxima.
$ns duplex-link-op $n(0) $n(1) orient right: solicita a NAM que, al dibujar el
esquema de la red, el enlace entre los nodos n(0) y n(1) se coloque horizontalmente. Si
no se utilizan estas instrucciones, NAM organiza los nodos automticamente.
$ns duplex-link-op $n(3) $n(4) color "green": dibuja el enlace entre los nodos
n(3) y n(4) de color verde
$ns duplex-link-op $n(3) $n(4) label "abced": escribe el texto abced sobre el
enlace entre los nodos n(3) y n(4).
set s [new Application/Traffic/CBR]: crea una nueva fuente de trfico constante
CBR llamada s.
$s set packetSize_ $packetSize: establece el tamao, en bytes, de los paquetes
que generar la fuente s. En este caso se utiliza la variable $packetSize, que se define en
una lnea anterior con el comando set packetSize 800.
$s set interval_ 0.02: indica el intervalo de tiempo, en segundos, que esperar la
fuente s entre el envo de un paquete y el siguiente.

$ns at 3.5 $ns trace-annotate \node 0 changed color\: indica que,
cuando hayan pasado 3.5 segundos desde el comienzo de la simulacin, se debe ejecutar
el comando $ns trace-annotate \node 0 changed color\, que simplemente
muestra un mensaje en la pantalla de NAM.
$ns at 4.5 "$n(0) add-mark m2 purple hexagon": a los 4.5 segundos del inicio
de la simulacin, aade un hexgono de color violeta alrededor del nodo n(0), y guarda
este marca con el nombre m2.
$ns at 5.5 "$n(0) delete-mark m2": transcurridos 5.5 segundos de la simulacin,
elimina la marca llamada m2 del esquema de la red.
$ns at 10.0 "finish": ejecuta el mtodo finish cuando se alcanzan los 10 segundos
de la simulacin.
$ns at 0.0 "$ns set-animation-rate 0.1ms": cambia la velocidad utilizada en el
animador de redes NAM a 0.1 ms (el valor por defecto es 2 ms) nada ms comenzar la
simulacin.
$ns run: comienza la simulacin inmediatamente.

La siguiente figura muestra una imagen del esquema de red en un instante intermedio
de la simulacin del archivo nam-example.tcl.


1.8. Otros animadores de trfico de red

Aparte de NAM, existen otros animadores de redes que tambin son compatibles con
las trazas generadas por NS-2. Este es el caso de Javis
3
, un programa escrito en Java y basado
en NAM. Javis se utiliza principalmente con JNS
4
, que es una versin para Java del simulador
NS-2, aunque tambin se puede usar con el propio NS-2, ya que ambos formatean las trazas
de la misma manera.

En la captura de pantalla mostrada a continuacin se ve al animador Javis ejecutando
la traza generada por el fichero example1b.tcl utilizando en el primer apartado del tutorial.
Como se puede observar, Javis es bastante ms simple que NAM, y carece de algunas de sus
funcionalidades, como la posibilidad de desplazarse a cualquier instante de la simulacin o la
colocacin automtica de los nodos (el algoritmo que utiliza Javis para colocar los nodos es
peor que el usado por NAM).

3
http://www.cs.technion.ac.il/~gabik/Jist-Swans/javis/index.html
4
http://jns.sourceforge.net/

2. Prctica n2: Redes satelitales, ad hoc, WPAN

2.1. Red estructurada

A continuacin se muestra el cdigo del script simple.tcl que define la red estructurada
comentada en el tutorial. Se han aadido comentarios marcados en azul al listado del cdigo
que explican la funcin de cada una de las lneas del script.

# --- Fichero 'simple.tcl' con comentarios ---

# Inicializamos el simulador de NS-2

# Asociamos ndices a los colores para usarlos ms adelante
$ns color 0 blue
$ns color 1 red
$ns color 2 yellow

# Creamos los 4 nodos de la red
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

# Guardamos las trazas generadas en los ficheros 'out.tr' y 'out.nam' (para NAM)
set f [open out.tr w]
$ns trace-all $f

# Creamos los enlaces entre los nodos
$ns duplex-link $n2 $n3 1.5Mb 10ms DropTail

# Establecemos la colocacin de los enlaces en el esquema de la red
$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

# Permitimos ver la cola de paquetes del enlace entre los nodos n2 y n3
$ns duplex-link-op $n2 $n3 queuePos 20

# Creamos un agente productor de paquetes UDP y lo adjuntamos al nodo n0
# Creamos una aplicacin que genera trfico constante y la asociamos al agente UDP

# Creamos otro agente productor de paquetes UDP y lo adjuntamos al nodo n3
# Dibujamos los mensajes de este productor con el color 1 (rojo)
$udp1 set class_ 1
# Creamos otra aplicacin que genera trfico constante y la asociamos al ltimo agente


# Creamos un agente nulo consumidor de paquetes y lo asociamos al nodo n3

# Creamos otro agente nulo consumidor de paquetes y lo asociamos al nodo n1

# Relacionamos los agentes productores con sus correspondientes consumidores

# Indicamos el instante de comienzo de las aplicaciones generadoras de paquetes UDP

# Creamos un agente productor de paquetes TCP
set tcp [new Agent/TCP]
# Dibujamos los mensajes de este productor con el color 2 (amarillo)
$tcp set class_ 2
# Creamos un agente sink consumidor de paquetes TCP
set sink [new Agent/TCPSink]
# Asociamos los agentes con los nodos n0 y n3 respectivamente
$ns attach-agent $n0 $tcp
$ns attach-agent $n3 $sink
# Conectamos el agente productor TCP con su correspondiente consumidor
$ns connect $tcp $sink
# Creamos una aplicacin que genera paquetes TCP y la asociamos al agente TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
# Indicamos el instante de comienzo de la aplicacin generadora de paquetes TCP
$ns at 1.2 "$ftp start"

# Indicamos el instante de finalizacin de la conexin TCP
$ns at 1.35 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink"

# Mostramos por lnea de comandos el tamao e intervalo de los paquetes CBR
puts [$cbr0 set packetSize_]
puts [$cbr0 set interval_]

# Ejecutamos el mtodo 'finish' al terminar la simulacin
$ns at 3.0 "finish"

# Definicin del mtodo 'finish'
proc finish {} {
global ns f nf
# Guardamos y cerramos los archivos que contienen las trazas
$ns flush-trace
close $f
close $nf

# Ejecutamos el animador NAM con la traza recin generada
exec nam out.nam &
# Cerramos el simulador
exit 0
}

# Iniciamos la simulacin
$ns run

La red especificada en este archivo est compuesta por cuatro nodos (0, 1, 2 y 3), y
tres enlaces full-duplex. En este caso, los enlaces no son todos de las mismas caractersticas,
sino que los que conectan los nodos 0 2 y 1 2 tienen una capacidad de 5 Mb/s, y el que
conecta los nodos 2 3 tiene slo 1.5 Mb/s.

Inicialmente, no hay ningn trfico en la red, hasta que se alcanza el segundo 1 de la
simulacin, momento en el que comienza el flujo de paquetes UDP desde el nodo 0 al nodo 3
pasando por el 2 (color azul). En el instante 1.1 segundos, empieza otro flujo constante de
paquetes UDP que va desde el nodo 3 al nodo 1 pasando tambin por el 2 (color rojo).

Posteriormente, se activa la aplicacin FTP que genera un trfico TCP cuyo origen es
el nodo 0 y destino es el nodo 3. Debido a que estos paquetes TCP son ms numerosos y de
mayor tamao que los UDP, y que el enlace 2 3 tiene menor ancho de banda que el 0 2,
llega un momento en el que se tienen que encolar los paquetes (TCP y UDP) en el enlace 2
3 para dar tiempo a enviar todos los paquetes. En el animador de redes NAM, esta situacin
se representa de la siguiente forma:

2.2. Modificacin de la red estructurada

Para probar algunas de las caractersticas que ofrece el simulador NS-2, se han hecho
tres modificaciones a la red estructurada del ejemplo anterior:
Se han aadido cuatro nuevos nodos (4, 5, 6 y 7) con varios enlaces entre ellos y con el
nodo 3 de la red original, todos ellos dibujados de color marrn.

Se ha provocado la cada del enlace entre los nodos 2 y 3 durante 0.2 segundos en mitad
de la simulacin. En ese tiempo, el enlace se pinta de color blanco.
Se ha aadido un nuevo trfico FTP (TCP) entre los nodos 6 y 7.
Se ha incluido un nuevo trfico constante UDP entre los nodos 6 y 0.

A continuacin se presenta el cdigo del ejemplo modificado. Se han eliminado todos
los comentarios aadidos en el apartado anterior y slo se han explicado las modificaciones
que se han hecho.

# --- Fichero 'simple.tcl' modificado ---


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

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

$ns trace-all $f

$ns duplex-link $n2 $n3 1.5Mb 10ms DropTail


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


$udp1 set class_ 1






$tcp set class_ 2


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

# --- Modificaciones ---

# Creamos 4 nuevos nodos
set n4 [$ns node]
set n5 [$ns node]
set n6 [$ns node]
set n7 [$ns node]

# Dibujamos los nuevos nodos de color marrn
$n4 color chocolate
$n5 color chocolate
$n6 color chocolate
$n7 color chocolate

# Creamos enlaces entre los nuevos nodos y conectamos algunos al nodo n3

# Establecemos el color y la orientacin de los nuevos enlaces
$ns duplex-link-op $n4 $n6 color chocolate
$ns duplex-link-op $n5 $n7 color chocolate

# Provocamos que el enlace entre n2 y n3 se caiga durante 0.2 segundos
$ns duplex-link-op $n2 $n3 dynamic
$ns at 3.4 "$ns duplex-link-op $n2 $n3 color white"
$ns at 3.4 "$ns duplex-link-op $n2 $n3 down"
$ns at 3.6 "$ns duplex-link-op $n2 $n3 color black"
$ns at 3.6 "$ns duplex-link-op $n2 $n3 up"

# Creamos un nuevo agente productor de paquetes TCP y lo adjuntamos al nodo n6
set tcpNuevo [new Agent/TCP]
$ns attach-agent $n6 $tcpNuevo
# Dibujamos los mensajes de este productor de color amarillo
$tcpNuevo set class_ 2
# Creamos un nuevo agente sink consumidor de paquetes TCP y lo adjuntamos al nodo n7
set sinkNuevo [new Agent/TCPSink]
$ns attach-agent $n7 $sinkNuevo
# Conectamos los dos agentes creados
$ns connect $tcpNuevo $sinkNuevo

# Creamos una nueva aplicacin generadora de paquetes TCP y la asociamos al agente
set ftpNuevo [new Application/FTP]
$ftpNuevo attach-agent $tcpNuevo
# Indicamos los instantes de comienzo y finalizacin de esta aplicacin
$ns at 2.5 "$ftpNuevo start"
$ns at 3.5 "$ftpNuevo stop"

# Creamos un nuevo agente productor de paquetes UDP y lo adjuntamos al nodo n6
set udpNuevo [new Agent/UDP]
$ns attach-agent $n6 $udpNuevo
# Dibujamos los mensajes de este productor de color verde
$ns color 4 green
$udpNuevo set class_ 4
# Creamos un agente nulo consumidor de paquetes y lo asociamos al nodo n0
set nullNuevo [new Agent/Null]
$ns attach-agent $n0 $nullNuevo
# Creamos una aplicacin que genera trfico constante y la asociamos al agente
set cbrNuevo [new Application/Traffic/CBR]
$cbrNuevo attach-agent $udpNuevo
# Relacionamos el agente productor con el consumidor
$ns connect $udpNuevo $nullNuevo
# Indicamos los instantes de comienzo y finalizacin del trfico CBR
$ns at 3.0 "$cbrNuevo start"
$ns at 4.0 "$cbrNuevo stop"

# ----------------------

$ns at 5.0 "finish"

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

exec nam out.nam &
exit 0
}

$ns run

De este ejemplo modificado merece destacar lo que sucede cuando se cae el enlace
entre los nodos 2 y 3 en el instante 3.4 segundos. Como en ese momento hay varios paquetes
de diferentes aplicaciones que estn siendo enviados por el enlace, en el animador de redes se
representa la prdida de los paquetes con cuadrados cayendo del enlace como se observa en
la siguiente captura de pantalla:



En este escenario, los paquetes azules y rojos son el trfico constante UDP definido en
el archivo original simple.tcl, mientras que los mensajes verdes representan el nuevo trfico
entre el nodo 6 y el 0. Los paquetes amarillos muestran el trfico TCP entre el nodo 6 y el 7.

Conviene decir que, cuando se cae el enlace entre los nodos 2 y 3, el nodo 0 sigue
enviando paquetes al 2 para que se los reenve al 3, a pesar de que es imposible porque el
nico camino que haba para llegar al nodo 3 se ha cado. Esto se debe a que el protocolo
UDP no es orientado a conexin y no conoce si el nodo 3 est recibiendo sus mensajes o no.

2.3. Red ad-hoc

Este es el cdigo del fichero simple-wireless.tcl que define una red ad-hoc, comentado
con explicaciones de lo que hace cada una de las lneas y comandos del simulador NS-2:

# --- Fichero 'simple-wireless.tcl' comentado ---

# Definimos los parmetros de los nodos mviles
set val(chan) Channel/WirelessChannel ;# Canal inalmbrico
set val(prop) Propagation/TwoRayGround ;# Tipo de propagacin
set val(netif) Phy/WirelessPhy ;# Capa fsica de red inalmbrica
set val(mac) Mac/802_11 ;# MAC 802.11 (wifi)
set val(ifq) Queue/DropTail/PriQueue ;# Cola con prioridades
set val(ll) LL ;# Capa de enlace predeterminada
set val(ant) Antenna/OmniAntenna ;# Antena omnidireccional
set val(ifqlen) 50 ;# Mximo nmero de paquetes en cola
set val(nn) 2 ;# Nmero de nodos mviles
set val(rp) DSDV ;# Protocolo de enrutamiento ad-hoc


# Inicializamos el simulador
set ns_ [new Simulator]
# Guardamos la traza del simulador en el archivo 'simple.tr'
set tracefd [open simple.tr w]
$ns_ trace-all $tracefd

# Creamos una nueva topografa para mantener los nodos mviles
set topo [new Topography]

# Definimos el espacio mximo de la topografa (500 m x 500 m)
$topo load_flatgrid 500 500

# Creamos el objeto General Operations Director (aunque no lo usaremos)
create-god $val(nn)

# Establecemos la configuracin de los nodos mviles
$ns_ node-config -adhocRouting $val(rp) \
-llType $val(ll) \
-macType $val(mac) \
-ifqType $val(ifq) \
-ifqLen $val(ifqlen) \
-antType $val(ant) \
-propType $val(prop) \
-phyType $val(netif) \
-channelType $val(chan) \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON \
-macTrace OFF \
-movementTrace OFF

# Creamos los dos nodos mviles node(0) y node(1) con la configuracin anterior
for {set i 0} {$i < $val(nn) } {incr i} {
set node_($i) [$ns_ node]
$node_($i) random-motion 0 ;# disable random motion
}

# Establecemos las coordenadas iniciales X e Y de los nodos mviles
$node_(0) set X_ 5.0
$node_(0) set Y_ 2.0
$node_(0) set Z_ 0.0
$node_(1) set X_ 390.0
$node_(1) set Y_ 385.0
$node_(1) set Z_ 0.0

# Provocamos en t = 50 s que el nodo 1 se mueva a la posicin (25, 20) a 15 m/s
$ns_ at 50.0 "$node_(1) setdest 25.0 20.0 15.0"


# Creamos un agente productor TCP asociado al nodo 0 y un consumidor asociado al nodo 2
$tcp set class_ 2
$ns_ attach-agent $node_(0) $tcp
$ns_ attach-agent $node_(1) $sink
$ns_ connect $tcp $sink

# Creamos una aplicacin generadora de trfico TCP asociada a los agentes
anteriores
$ns_ at 10.0 "$ftp start"

# Indicamos que la simulacin terminar en el instante t = 150 s
$ns_ at 150.0 "$node_($i) reset";
}
$ns_ at 150.0 "stop"
$ns_ at 150.01 "puts \"NS EXITING...\" ; $ns_ halt"
proc stop {} {
global ns_ tracefd
# Guardamos el archivo de traza al terminar la simulacin
$ns_ flush-trace
close $tracefd
}

puts "Starting Simulation..."
$ns_ run

Analizando el archivo de trazas simple.tr generado por el script anterior, se observan
varios eventos destacables que se citan a continuacin:
M 10.00000 0 (5.00, 2.00, 0.00), (20.00, 18.00), 1.00
Este evento producido a los 10 segundos de comenzar la simulacin est asociado a la
lnea del script $ns_ at 10.0 "$node_(0) setdest 20.0 18.0 1.0". Indica que
el nodo 0 va a empezar a moverse desde la posicin (5, 2, 0) a la (20, 18, 0) con una
velocidad de 1 m/s.
s 10.000000000 _0_ AGT --- 2 tcp 40 [0 0 0 0] ------- [0:0 1:0 32 0] [0 0] 0 0
Este evento, tambin generado en el instante t = 10 s, representa que el agente productor
de paquetes TCP asociado al nodo 0 quiere enviar su primer paquete al nodo 1. El
evento se produce a los 10 segundos porque en el script se indic que la aplicacin FTP
comenzara en ese instante: $ns_ at 10.0 "$ftp start".
No obstante, como los nodos 0 y 1 estn bastante lejos en la topografa, los paquetes no
pueden llegar a su destino y el nodo 0 los intenta reenviar varias veces sin xito.
M 50.00000 1 (390.00, 385.00, 0.00), (25.00, 20.00), 15.00
Cuando pasan 50 segundos de la simulacin, tiene efecto el comando $ns_ at 50.0
"$node_(1) setdest 25.0 20.0 15.0" del script, y el nodo 1 comienza a moverse
de la posicin inicial (390, 385, 0) a la (25, 20, 0) con una velocidad de 15 m/s.
D 76.430670539 _0_ IFQ ARP 2 tcp 80 [0 0 0 800] ------- [0:0 1:0 32 1] [0 0] 0 0
En el instante 76.43 se observa un paquete ARP generado por el nodo 0, lo cual indica
que el nodo 0 y el 1 (despus de moverse) estn lo suficientemente cerca como para
constituir una red ad-hoc entre ellos. Con este paquete y los siguientes los nodos se
intercambian la informacin necesaria para formar la red.
s 76.438053447 _1_ AGT --- 18 ack 40 [0 0 0 0] ------- [1:0 0:0 32 0] [0 0] 0 0
Como resultado de que los nodos se vean entre s y formen una red ad-hoc, el nodo 1
puede recibir los paquetes TCP enviados por el nodo 0 y responder con un mensaje ack.

Esto sucede unas centsimas de segundo despus de que la red se haya configurado y el
nodo 0 haya reintentado el envo de un paquete TCP.
A partir de este momento, se establece una comunicacin entre los nodos 0 y 1 y todos
los paquetes TCP enviados por el nodo 0 llegan a su destino.
M 100.00000 1 (25.00, 20.00, 0.00), (490.00, 480.00), 15.00
En el instante 100, como consecuencia de la lnea $ns_ at 100.0 "$node_(1)
setdest 490.0 480.0 15.0" del script NS-2, el nodo 1 comienza a alejarse del nodo
0 movindose hacia la posicin (490, 480, 0) a 15 m/s.
D 116.371814159 _1_ RTR CBK 6455 ack 60 [13a 0 1 800] ------- [1:0 0:0 32 0]
[3214 0] 0 0
Por culpa del movimiento del nodo 1, en un momento dado este nodo se ha separado lo
suficiente del nodo 0 como para que dejen de verse entre s y abandonen la red ad-hoc.
Este mensaje del instante 116.37 representa esa situacin.
A partir de entonces, el nodo 0 sigue enviando paquetes TCP pero ya no pueden llegar
al nodo 1 porque no es visible, no recibiendo nunca las confirmaciones como ocurra al
principio, antes de los 76.43 segundos.

2.4. Red satelital

El siguiente cdigo es el contenido del fichero sat-mixed.tcl que se usa en la prctica
para analizar la simulacin de redes satelitales. Al igual que en los apartados anteriores, tras la
revisin y el estudio del script se han escrito de color azul comentarios que explican lo que
hace cada lnea del cdigo.

# --- Fichero 'sat-mixed.tcl' comentado ---

global ns

# -----------------------

# Configuramos algunos parmetros de la red satelital
HandoffManager/Term set elevation_mask_ 8.2
HandoffManager/Term set term_handoff_int_ 10
HandoffManager set handoff_randomization_ false
global opt
set opt(chan) Channel/Sat ;# Canal inalmbrico por satlite
set opt(bw_down) 1.5Mb ;# Ancho de banda de bajada
set opt(bw_up) 1.5Mb ;# Ancho de banda de subida
set opt(bw_isl) 25Mb ;# Ancho de banda de los enlaces ISL polares
set opt(phy) Phy/Sat ;# Capa fsica para red por satlite
set opt(mac) Mac/Sat ;# MAC satelital
set opt(ifq) Queue/DropTail ;# Cola de paquetes normal
set opt(qlim) 50
set opt(ll) LL/Sat ;# Capa de enlace satelital
set opt(wiredRouting) OFF

set opt(alt) 780 ;# Altitud de los satlites polares (Iridium)
set opt(inc) 90 ;# Inclinacin de la rbita polar


# Guardamos la traza generada por NS-2 en el archivo 'out.tr'
set outfile [open out.tr w]
$ns trace-all $outfile

# -----------------------

# Establecemos la configuracin de los satlites polares
$ns node-config -satNodeType polar \
-llType $opt(ll) \
-ifqType $opt(ifq) \
-ifqLen $opt(qlim) \
-macType $opt(mac) \
-phyType $opt(phy) \
-channelType $opt(chan) \
-downlinkBW $opt(bw_down) \
-wiredRouting $opt(wiredRouting)

# Creamos los 11 nodos que representan los satlites polares
set n0 [$ns node]; set n1 [$ns node]; set n2 [$ns node]; set n3 [$ns node]
set n4 [$ns node]; set n5 [$ns node]; set n6 [$ns node]; set n7 [$ns node]
set n8 [$ns node]; set n9 [$ns node]; set n10 [$ns node]

# Establecemos la posicin de los 11 satlites polares en un nico plano
set plane 1
$n0 set-position $opt(alt) $opt(inc) 0 0 $plane
$n1 set-position $opt(alt) $opt(inc) 0 32.73 $plane

# Indicamos cul es el siguiente satlite polar a cada uno
$n0 set_next $n10; $n1 set_next $n0; $n2 set_next $n1; $n3 set_next $n2
$n4 set_next $n3; $n5 set_next $n4; $n6 set_next $n5; $n7 set_next $n6
$n8 set_next $n7; $n9 set_next $n8; $n10 set_next $n9

# Creamos y configuramos un satlite geostacionario en posicin 100 oeste
$ns node-config -satNodeType geo
set n11 [$ns node]
$n11 set-position -100

# Creamos dos estaciones terrestres sobre los Estados Unidos
$ns node-config -satNodeType terminal
set n100 [$ns node]; set n101 [$ns node]
$n100 set-position 37.9 -122.3; # Berkeley
$n101 set-position 42.3 -71.1; # Boston
# Creamos otras dos estaciones terrestres cerca de la posicin (0, 0)
set n200 [$ns node]; set n201 [$ns node]
$n200 set-position 0 10
$n201 set-position 0 -10

# -----------------------

# Creamos enlaces que conectan las estaciones terrestres n100 y n101
# con el satlite geostacionario n11
$n100 add-gsl geo $opt(ll) $opt(ifq) $opt(qlim) $opt(mac) $opt(bw_up) \
$opt(phy) [$n11 set downlink_] [$n11 set uplink_]

$n101 add-gsl geo $opt(ll) $opt(ifq) $opt(qlim) $opt(mac) $opt(bw_up) \

# Creamos enlaces que conectan las estaciones terrestres n200 y n201
# con los satlites polares (se ha escogido como satlite inicial uno
# que no es visible para las estaciones, pero este problema se
# solucionar automticamente al comenzar la simulacin)
$n200 add-gsl polar $opt(ll) $opt(ifq) $opt(qlim) $opt(mac) $opt(bw_up) \
$n201 add-gsl polar $opt(ll) $opt(ifq) $opt(qlim) $opt(mac) $opt(bw_up) \

# Definimos los enlaces ISLs para los satlites polares
$ns add-isl intraplane $n0 $n1 $opt(bw_isl) $opt(ifq) $opt(qlim)

# -----------------------

# Guardamos la traza de los satlites en el archivo 'out.tr'
$ns trace-all-satlinks $outfile

# -----------------------

# Creamos un agente generador de trfico UDP y lo asociamos a la estacin n100

# Creamos un agente generador de trfico UDP y lo asociamos a la estacin n200
$udp1 set class_ 1

# Creamos agentes nulos consumidores de paquetes UDP para las estaciones n101 y n201

# Asociamos los agentes productores y consumidores de trfico UDP

# -----------------------

# Establecemos el enrutamiento entre satlites
set satrouteobject_ [new SatRouteObject]
$satrouteobject_ compute_routes


# Indicamos los instantes de comienzo de los agentes generadores de trfico

# Establecemos el instante final de la simulacin
$ns at 9000.0 "finish"

# Mtodo ejecutado al terminar la simulacin que guarda la traza y termina
proc finish {} {
global ns outfile
$ns flush-trace
close $outfile

exit 0
}

$ns run

Analizando la traza generada por este script, se pueden ver las lneas correspondientes
a la transmisin y recepcin de los mensajes entre las estaciones terrenales. En el caso de las
estaciones 12 (n100) y 13 (n101), que se comunican mediante el satlite geoestacionario 11
(n11), los paquetes enviados siempre siguen el mismo camino, porque el satlite se encuentra
en una posicin fija. As pues, cuando la estacin 12 enva un paquete al satlite 11, ste lo
redirige inmediatamente a la estacin 13, lo cual viene representado por estas lneas de la
traza:

+ 3001.5000 12 11 cbr 210 ------- 0 12.0 13.0 50 80 37.90 -122.30 0.00 -100.00
- 3001.5000 12 11 cbr 210 ------- 0 12.0 13.0 50 80 37.90 -122.30 0.00 -100.00
r 3001.6272 12 11 cbr 210 ------- 0 12.0 13.0 50 80 37.90 -122.30 0.00 -100.00
+ 3001.6272 11 13 cbr 210 ------- 0 12.0 13.0 50 80 0.00 -100.00 42.30 -71.10
- 3001.6272 11 13 cbr 210 ------- 0 12.0 13.0 50 80 0.00 -100.00 42.30 -71.10
r 3001.7563 11 13 cbr 210 ------- 0 12.0 13.0 50 80 0.00 -100.00 42.30 -71.10

En cambio, en el caso de las estaciones 14 (n200) y 15 (n201), que hacen uso de los
satlites polares, el camino que siguen los paquetes vara con el tiempo, porque los satlites se
van moviendo y no siempre son visibles los mismos para las estaciones. Para demostrarlo, a
continuacin se muestran dos fragmentos de la traza en los que se observa que, para enviar un
paquete del nodo 14 al 15, en un momento se enruta a travs de los satlites 10 y 0, y en otro
momento slo pasa por el satlite 9.

+ 305.0000 14 10 cbr 210 ------- 1 14.0 15.0 0 6 0.00 10.00 -14.51 -1.27
- 305.0000 14 10 cbr 210 ------- 1 14.0 15.0 0 6 0.00 10.00 -14.51 -1.27
r 305.0088 14 10 cbr 210 ------- 1 14.0 15.0 0 6 0.00 10.00 -14.51 -1.27
+ 305.0088 10 0 cbr 210 ------- 1 14.0 15.0 0 6 -14.51 -1.27 18.22 -1.27
- 305.0088 10 0 cbr 210 ------- 1 14.0 15.0 0 6 -14.51 -1.27 18.22 -1.27
r 305.0224 10 0 cbr 210 ------- 1 14.0 15.0 0 6 -14.51 -1.27 18.22 -1.27
+ 305.0224 0 15 cbr 210 ------- 1 14.0 15.0 0 6 18.22 -1.27 0.00 -10.00
- 305.0224 0 15 cbr 210 ------- 1 14.0 15.0 0 6 18.22 -1.27 0.00 -10.00
r 305.0319 0 15 cbr 210 ------- 1 14.0 15.0 0 6 18.22 -1.27 0.00 -10.00


+ 938.5000 14 9 cbr 210 ------- 1 14.0 15.0 7 23 0.00 10.00 -9.39 -3.92
- 938.5000 14 9 cbr 210 ------- 1 14.0 15.0 7 23 0.00 10.00 -9.39 -3.92
r 938.5083 14 9 cbr 210 ------- 1 14.0 15.0 7 23 0.00 10.00 -9.39 -3.92
+ 938.5083 9 15 cbr 210 ------- 1 14.0 15.0 7 23 -9.39 -3.92 0.00 -10.00
- 938.5083 9 15 cbr 210 ------- 1 14.0 15.0 7 23 -9.39 -3.92 0.00 -10.00
r 938.5146 9 15 cbr 210 ------- 1 14.0 15.0 7 23 -9.39 -3.92 0.00 -10.00

2.5. Red WPAN

El siguiente cdigo comentado se corresponde con el fichero wpan_demo1.tcl que
define la red WPAN (Wireless Personal Area Network) referida en el tutorial de NS-2.

# --- Fichero 'wpan_demo1.tcl' ---

# Definimos opciones relacionadas con los nodos mviles
set val(chan) Channel/WirelessChannel ;# Canal inalmbrico
set val(prop) Propagation/TwoRayGround ;# Propagacin inalmbrica
set val(netif) Phy/WirelessPhy/802_15_4 ;# Capa fsica inalmbrica 802.15.4
set val(mac) Mac/802_15_4 ;# MAC 802.15.4
set val(ifq) Queue/DropTail/PriQueue ;# Cola con prioridades
set val(ll) LL ;# Capa de enlace predeterminada
set val(ant) Antenna/OmniAntenna ;# Antena omnidireccional
set val(ifqlen) 50 ;# Mximos paquetes en cola
set val(nn) 25 ;# Nmero de nodos mviles
set val(rp) AODV ;# Protocolo de enrutado

# Definimos otras opciones
set val(x) 50 ;# Anchura de la topografa
set val(y) 50 ;# Altura de la topografa
set val(nam) wpan_demo1.nam ;# Archivo de trazas
set val(traffic) ftp ;# Trfico (CBR, Poission o FTP)

# Leemos los argumentos de la lnea de comandos
proc getCmdArgu {argc argv} {
global val
for {set i 0} {$i < $argc} {incr i} {
set arg [lindex $argv $i]
if {[string range $arg 0 0] != "-"} continue
set name [string range $arg 1 end]
set val($name) [lindex $argv [expr $i+1]]
}
}
getCmdArgu $argc $argv

# Establecemos los tiempos de la simulacin, en segundos
set appTime1 0.0
set appTime2 0.3
set appTime3 0.7
set stopTime 100

set ns_ [new Simulator]

# Guardamos las trazas en los archivos 'wpan_demo1.tr' y 'wpan_demo1.nam'
set tracefd [open ./wpan_demo1.tr w]

$ns_ trace-all $tracefd
if { "$val(nam)" == "wpan_demo1.nam" } {
set namtrace [open ./$val(nam) w]
$ns_ namtrace-all-wireless $namtrace $val(x) $val(y)
}

# Activamos algunas opciones necesarias para que NAM reconozca las redes WPAN
$ns_ puts-nam-traceall {# nam4wpan #}
Mac/802_15_4 wpanNam namStatus on

# Definimos lmites de potencia para la transmisin/recepcin de la capa fsica
set dist(5m) 7.69113e-06
set dist(9m) 2.37381e-06
set dist(10m) 1.92278e-06
set dist(11m) 1.58908e-06
set dist(12m) 1.33527e-06
set dist(13m) 1.13774e-06
set dist(14m) 9.81011e-07
set dist(15m) 8.54570e-07
set dist(16m) 7.51087e-07
set dist(20m) 4.80696e-07
set dist(25m) 3.07645e-07
set dist(30m) 2.13643e-07
set dist(35m) 1.56962e-07
set dist(40m) 1.20174e-07
Phy/WirelessPhy set CSThresh_ $dist(15m)
Phy/WirelessPhy set RXThresh_ $dist(15m)

# Creamos una nueva topografa de 50 m x 50 m para albergar los nodos mviles
set topo [new Topography]
$topo load_flatgrid $val(x) $val(y)

# Creamos el objeto General Operations Director (aunque no lo usaremos)
set god_ [create-god $val(nn)]

# Establecemos la configuracin de los nodos mviles
set chan_1_ [new $val(chan)]
$ns_ node-config -adhocRouting $val(rp) \
-llType $val(ll) \
-macType $val(mac) \
-ifqType $val(ifq) \
-ifqLen $val(ifqlen) \
-antType $val(ant) \
-propType $val(prop) \
-phyType $val(netif) \
-topoInstance $topo \
-agentTrace OFF \
-routerTrace OFF \
-macTrace ON \
-movementTrace OFF \
-channel $chan_1_

# Creamos los 25 ($nn) nodos mviles con la configuracin anterior
set node_($i) [$ns_ node]
$node_($i) random-motion 0
}

# Establecemos la ubicacin de los nodos, que est guardada en otro archivo
source ./wpan_demo1.scn

# Proceso de configuracin de trfico constante (UDP)

proc cbrtraffic { src dst interval starttime } {
global ns_ node_
set udp($src) [new Agent/UDP]
eval $ns_ attach-agent \$node_($src) \$udp($src)
set null($dst) [new Agent/Null]
eval $ns_ attach-agent \$node_($dst) \$null($dst)
set cbr($src) [new Application/Traffic/CBR]
eval \$cbr($src) set packetSize_ 70
eval \$cbr($src) set interval_ $interval
eval \$cbr($src) set random_ 0
#eval \$cbr($src) set maxpkts_ 10000
eval \$cbr($src) attach-agent \$udp($src)
eval $ns_ connect \$udp($src) \$null($dst)
$ns_ at $starttime "$cbr($src) start"
}

# Proceso de configuracin de trfico Poisson
proc poissontraffic { src dst interval starttime } {
global ns_ node_
set udp($src) [new Agent/UDP]
eval $ns_ attach-agent \$node_($src) \$udp($src)
set null($dst) [new Agent/Null]
eval $ns_ attach-agent \$node_($dst) \$null($dst)
set expl($src) [new Application/Traffic/Exponential]
eval \$expl($src) set packetSize_ 70
eval \$expl($src) set burst_time_ 0
eval \$expl($src) set idle_time_ [expr $interval*1000.0-70.0*8/250]ms ;#
idle_time + pkt_tx_time = interval
eval \$expl($src) set rate_ 250k
eval \$expl($src) attach-agent \$udp($src)
eval $ns_ connect \$udp($src) \$null($dst)
$ns_ at $starttime "$expl($src) start"
}

# Proceso de configuracin de trfico FTP (TCP)
proc ftptraffic { src dst starttime } {
global ns_ node_
set tcp($src) [new Agent/TCP]
eval \$tcp($src) set packetSize_ 60
set sink($dst) [new Agent/TCPSink]
eval $ns_ attach-agent \$node_($src) \$tcp($src)
eval $ns_ attach-agent \$node_($dst) \$sink($dst)
eval $ns_ connect \$tcp($src) \$sink($dst)
set ftp($src) [new Application/FTP]
eval \$ftp($src) attach-agent \$tcp($src)
$ns_ at $starttime "$ftp($src) start"
}

# Configuramos el trfico elegido
if { ("$val(traffic)" == "cbr") || ("$val(traffic)" == "poisson") } {
puts "\nTraffic: $val(traffic)"
#Mac/802_15_4 wpanCmd ack4data on
puts [format "Acknowledgement for data: %s" [Mac/802_15_4 wpanCmd ack4data]]
set lowSpeed 0.5ms
set highSpeed 1.5ms
Mac/802_15_4 wpanNam PlaybackRate $lowSpeed
$ns_ at [expr $appTime1+0.1] "Mac/802_15_4 wpanNam PlaybackRate $highSpeed"
$ns_ at $appTime2 "Mac/802_15_4 wpanNam PlaybackRate $lowSpeed"
eval $val(traffic)traffic 19 6 0.2 $appTime1

Mac/802_15_4 wpanNam FlowClr -p AODV -c tomato
Mac/802_15_4 wpanNam FlowClr -p ARP -c green
if { "$val(traffic)" == "cbr" } {
set pktType cbr
} else {
set pktType exp
}
Mac/802_15_4 wpanNam FlowClr -p $pktType -s 19 -d 6 -c blue
Mac/802_15_4 wpanNam FlowClr -p $pktType -s 10 -d 4 -c green4
Mac/802_15_4 wpanNam FlowClr -p $pktType -s 3 -d 2 -c cyan4
$ns_ at $appTime1 "$node_(19) NodeClr blue"
$ns_ at $appTime1 "$ns_ trace-annotate \"(at $appTime1) $val(traffic) traffic
from node 19 to node 6\""
$ns_ at $appTime2 "$node_(10) NodeClr green4"
$ns_ at $appTime3 "$node_(3) NodeClr cyan3"
}
if { "$val(traffic)" == "ftp" } {
puts "\nTraffic: ftp"
#Mac/802_15_4 wpanCmd ack4data off
puts [format "Acknowledgement for data: %s" [Mac/802_15_4 wpanCmd ack4data]]
set lowSpeed 0.20ms
set highSpeed 1.5ms
Mac/802_15_4 wpanNam PlaybackRate $lowSpeed
$ns_ at [expr $appTime3+0.2] "Mac/802_15_4 wpanNam PlaybackRate 1ms"
ftptraffic 19 6 $appTime1
Mac/802_15_4 wpanNam FlowClr -p AODV -c tomato
Mac/802_15_4 wpanNam FlowClr -p ARP -c green
Mac/802_15_4 wpanNam FlowClr -p tcp -s 19 -d 6 -c blue
Mac/802_15_4 wpanNam FlowClr -p ack -s 6 -d 19 -c blue
Mac/802_15_4 wpanNam FlowClr -p tcp -s 10 -d 4 -c green4
Mac/802_15_4 wpanNam FlowClr -p ack -s 4 -d 10 -c green4
Mac/802_15_4 wpanNam FlowClr -p tcp -s 3 -d 2 -c cyan4
Mac/802_15_4 wpanNam FlowClr -p ack -s 2 -d 3 -c cyan4
$ns_ at $appTime1 "$ns_ trace-annotate \"(at $appTime1) ftp traffic from node
19 to node 6\""
10 to node 4\""
3 to node 2\""
}


# Cambiamos el tamao de los nodos
for {set i 0} {$i < $val(nn)} {incr i} {
$ns_ initial_node_pos $node_($i) 2
}

# Indicamos que la simulacin terminar a los 100 ($stopTime) segundos
$ns_ at $stopTime "$node_($i) reset";
}
$ns_ at $stopTime "stop"
$ns_ at $stopTime "puts \"\nNS EXITING...\""
$ns_ at $stopTime "$ns_ halt"

# Proceso de finalizacin de la simulacin
proc stop {} {
global ns_ tracefd val env
$ns_ flush-trace
close $tracefd
set hasDISPLAY 0
foreach index [array names env] {
#puts "$index: $env($index)"
if { ("$index" == "DISPLAY") && ("$env($index)" != "") } {
set hasDISPLAY 1
}
}
if { ("$val(nam)" == "wpan_demo1.nam") && ("$hasDISPLAY" == "1") } {
exec nam wpan_demo1.nam &
}
}

puts "\nStarting Simulation..."
$ns_ run

En esta red se definen 25 nodos sobre una topografa de 50 m x 50 m en la que se
simulan varios paquetes de trfico FTP. Observando la animacin que muestra NAM con la
traza generada por el simulador, se puede ver que cada vez que un nodo quiere enviar un
paquete a otro por primera vez se realizan una serie de pasos fijos, que seguramente vengan
descritos en el protocolo de enrutamiento.

Por ejemplo, en el primer instante de la simulacin, el nodo 19 quiere comunicarse con
el 6, que no es visible directamente para el 19. Entonces, ocurre lo siguiente:
El nodo 19 enva a los nodos que hay a su alrededor una peticin de bsqueda del nodo
6 (broadcast).
Los nodos que reciben esa peticin la vuelven a enviar a los nodos visibles para ellos,
consiguiendo que el mensaje se propague ms all de los nodos visibles por el nodo 19.
Esta peticin se reenva por toda la red hasta que llega al nodo destino, el 6. Entonces,
el nodo 6 enva una confirmacin al nodo que le envo la peticin (que no es el 19), para
establecer la comunicacin con el nodo 19.
Esta confirmacin ya no se reenva a todos los nodos, sino que va pasando por los nodos
a travs de los cuales se consigui llegar del nodo 19 al 6 (unicast). De esta forma, se
configura el enrutamiento necesario para enviar un mensaje entre estos dos nodos.

Una vez que la confirmacin llega al nodo final, el 19, ste puede enviar los paquetes
destinados al nodo 6, los cuales sern redirigidos adecuadamente por los otros nodos
intermedios hasta llegar a su destino.

Esta es una captura de pantalla que muestra un paso intermedio en la configuracin del
enrutamiento para ir del nodo 19 al nodo 6 (marcados en azul en el esquema).

2.7. Otras redes WPAN

Adems del ejemplo propuesto en el tutorial, se ha probado otro escenario de red
WPAN, en concreto la del archivo wpan_demo3.tcl. La red que se define en este fichero, al
contrario que la anterior, es jerrquica, por lo que dispone de un coordinador que determina
cundo puede transmitir cada nodo y, adems, todos los nodos tienen un nodo padre.


El resultado de ejecutar el animador NAM con la traza generada por la simulacin es
el siguiente. El nodo 0, de color rojo, es el coordinador, mientras que los dems nodos tienen
encima, entre corchetes, cul es su nodo padre.

2.6. Otros simuladores de redes de sensores

El simulador Tossim que se hace referencia en el tutorial es un simulador para redes
de sensores creadas con TinyOS
5
. TinyOS es un sistema operativo de cdigo abierto con el
que se pueden construir redes de sensores inalmbricas. Dispone de una arquitectura basada
en componentes para facilitar la implementacin de redes y soportar las restricciones de
memoria y potencia que se dan en este tipo de redes. Para ello, las aplicaciones se escriben en
una versin del lenguaje C optimizada llamada nesC.

5
http://www.tinyos.net/

3. Prctica n3: Realizacin de mtricas

3.1. Mtricas de la red WPAN

Para calcular varias mtricas comunes en el estudio de redes se tomar como base el
escenario de red WPAN visto en el apartado 2.6 (fichero wpan_demo1.tcl), pero sustituyendo
el trfico FTP (TCP) que vena por defecto por trfico constante UDP. La siguiente pantalla
se corresponde con la red que se va a estudiar.

Dado que en las prcticas anteriores se han tenido que estudiar algunas trazas descritas
con el formato antiguo, se ha preferido no activar el nuevo formato de trazas y mantener el
viejo. Adems, como los resultados con ambos formatos deben ser los mismos, no se va a
perder informacin sobre las mtricas.


Conviene destacar que, para poder obtener estadsticas reales del trfico de la red, ha
sido necesario hacer algunas modificaciones importantes al script avgStats.awk proporcionado
en el tutorial, ya que no es compatible con las trazas generadas por NS-2 (al menos la versin
2.34) y si se utiliza sin modificarlo no reconoce los paquetes enviados y recibidos.

En la red WPAN del fichero wpan_demo1.tcl, slo se definen tres trficos CBR, que
se pueden extraer de las lneas de cdigo indicadas en el tutorial:
Desde el comienzo de la simulacin, entre el nodo 19 y el 6 con paquetes de 70 bytes
enviados cada 0.2 segundos.
A partir de los 0.3 segundos, entre el nodo 10 y el 4 con paquetes de 70 bytes enviados
cada 0.2 segundos.
A partir de los 0.7 segundos, entre el nodo 3 y el 2, con paquetes de 70 bytes enviados
cada 0.2 segundos.

Utilizando el script avgStats.awk convenientemente modificado para analizar las trazas
de NS-2, se obtienen las siguientes estadsticas:

Anlisis 1
Nodo de origen: 19
Nodo de destino: 6
Instante inicial: 0
Instante final: 100
Paquetes recibidos: 500
Rendimiento medio: 2.807 kbps
Latencia media: 22.380 ms
Jitter medio: 1.44 ms, 3.25 ms, 1.45 ms, 3.19 ms

Anlisis 2
Nodo de origen: 10
Nodo de destino: 4
Instante inicial: 0.3
Instante final: 100

Anlisis 3
Nodo de origen: 3
Nodo de destino: 2
Instante inicial: 0.7
Instante final: 100

De estos resultados, merece la pena resaltar que la latencia es mayor en el primer caso
porque, aunque la distancia fsica (en lnea recta) entre los nodos 19 y 6 no es mayor que, por
ejemplo, la que hay entre los nodos 10 y 4, el camino mnimo que deben seguir los paquetes
para ir del nodo 19 al 6 pasando por las estaciones intermedias s es ms largo que el camino
mnimo en los otros dos casos.

Por otro lado, ntese que el rendimiento es igual en los tres casos porque en todos
ellos se envan paquetes del mismo tamao con intervalos peridicos fijos, obteniendo al final
la misma relacin datos/tiempo.


4. Prctica n4: Estructura interna de NS-2

4.1. Objetos TclObject, NsObject, Connector, Classifier y Node

Tal y como se especifica en el tutorial, se ha examinado el contenido del archivo de
cabecera tclcl.h y el fichero de cdigo C++ Tcl.cc del directorio tclcl-1.19 para buscar la
declaracin y definicin de las funciones command, trace y bind de la clase TclObject. A
continuacin se muestra la parte de los dos archivos referidos a estos mtodos, que se utilizan
para enlazar los mtodos y las variables de los ficheros de cdigo C++ con los de OTcl.

Declaracin de los mtodos de la clase TclObject (tclcl.h)
class TclObject {
public:
//
virtual int command(int argc, const char*const* argv);
virtual void trace(TracedVar*);
void bind(const char* var, TracedInt* val);
void bind(const char* var, TracedDouble* val);
void bind(const char* var, double* val);
void bind_bw(const char* var, double* val);
void bind_time(const char* var, double* val);
void bind(const char* var, unsigned int* val);
void bind(const char* var, int* val);
void bind_bool(const char* var, int* val);
void bind(const char* var, TclObject** val);
void bind_error(const char* var, const char* error);
//
protected:
//
};

Definicin del mtodo command (Tclcl.cc)
int TclObject::command(int argc, const char*const* argv)
{
#ifdef notdef
Tcl& t = Tcl::instance();
char* cp = t.buffer();
sprintf(cp, "%s: ", t.application());
cp += strlen(cp);
const char* cmd = argv[0];
if (cmd[0] == '_' && cmd[1] == 'o' && class_name_ != 0)
sprintf(cp, "\"%s\" (%s): ", class_name_, cmd);
else
sprintf(cp, "%s: ", cmd);
cp += strlen(cp);
if (argc >= 2)
sprintf(cp, "no such method (%s)", argv[1]);
else
sprintf(cp, "requires additional args");

t.result(t.buffer());
#endif

if (argc > 2) {

if (strcmp(argv[1], "trace") == 0) {
TclObject* tracer = this;
if (argc > 3)
tracer = TclObject::lookup(argv[3]);
return traceVar(argv[2], tracer);
}
}
return (TCL_ERROR);
}

Definicin del mtodo trace (Tclcl.cc)
void TclObject::trace(TracedVar*)
{
fprintf(stderr, "SplitObject::trace called in the base class of %s\n",
name_);
}

Definicin del mtodo bind y sus sobrecargas (Tclcl.cc)
#define TOB(FUNCTION, C_TYPE, INSTVAR_TYPE, OTHER_STUFF) \
void TclObject::FUNCTION(const char* var, C_TYPE* val) \
{ \
create_instvar(var); \
OTHER_STUFF; \
init(new INSTVAR_TYPE(var, val), var); \
}

TOB(bind, double, InstVarReal, ;)
TOB(bind_bw, double, InstVarBandwidth, ;)
TOB(bind_time, double, InstVarTime, ;)
TOB(bind, int, InstVarInt, ;)
TOB(bind, unsigned int, InstVarUInt, ;)
TOB(bind_bool, int, InstVarBool, ;)
TOB(bind, TclObject*, InstVarTclObject, ;)
TOB(bind, TracedInt, InstVarTracedInt, val->name(var); val->owner(this);)
TOB(bind, TracedDouble, InstVarTracedReal, val->name(var); val->owner(this);)

En los archivos object.h y object.cc del directorio ns-2.34/common se encuentra la
especificacin y la implementacin de la clase NsObject, que es la base para todos los objetos
utilizados en el simulador NS-2 (como colas, agentes, clasificadores, etc.). Los siguientes
fragmentos de cdigo muestran la declaracin y definicin de los mtodos resaltados en el
tutorial (recv, handle y reset), que no implementan ninguna funcionalidad concreta porque
deben ser sobrescritos por las clases derivadas.

Declaracin de los mtodos de la clase NsObject (object.h)
class NsObject : public TclObject, public Handler {
public:
//
virtual void recv(Packet*, Handler* callback = 0) = 0;
virtual void recv(Packet* p, const char* s);
//
protected:
virtual void reset();
void handle(Event*);
//
};


Definicin del mtodo recv (object.cc)
void NsObject::recv(Packet *p, const char*)
{
Packet::free(p);
}

Definicin del mtodo handle (object.cc)
void NsObject::handle(Event* e)
{
recv((Packet*)e);
}

Definicin del mtodo reset (object.cc)
void NsObject::reset()
{
}

La clase Connector, derivada de NsObject, se define en los archivos connector.h y
connector.cc del mismo directorio en el que estaba la implementacin de NsObject. Esta clase
sirve para conectar dos objetos NsObject, de manera que los paquetes recibidos por uno de los
objetos se reenviarn al otro y lo mismo ocurrir al contrario. Este comportamiento se puede
ver en la definicin de los mtodos send, drop y recv que se indica a continuacin.

Declaracin de los mtodos de la clase Connector y definicin de send (connector.h)
class Connector : public NsObject {
public:
//
virtual void drop(Packet* p);
protected:
//
virtual void drop(Packet* p, const char *s);
void recv(Packet*, Handler* callback = 0);
inline void send(Packet* p, Handler* h) { target_->recv(p, h); }
NsObject* target_;
//
};

Definicin del mtodo recv (connector.cc)
void Connector::recv(Packet* p, Handler* h)
{
send(p, h);
}

Definicin del mtodo drop y sus sobrecargas (connector.cc)
void Connector::drop(Packet* p)
{
if (drop_ != 0)
drop_->recv(p);
else
Packet::free(p);
}
void Connector::drop(Packet* p, const char *s)
{
if (drop_ != 0)

drop_->recv(p, s);
else
Packet::free(p);
}

Otra clase que tambin hereda de NsObject es Classifier, cuya implementacin se
puede consultar en los archivos classifier.h y classifier.cc del directorio ns-2.34/common. Esta
clase sirve para distribuir los paquetes recibidos por varios nodos en funcin de su cabecera,
es decir, realiza una clasificacin de los paquetes recibidos. Los mtodos install, find y recv,
algunos de los ms importantes de la clase, se muestran a continuacin.

Declaracin de los mtodos de la clase Classifier (classifier.h)
class Classifier : public NsObject {
public:
//
virtual void recv(Packet* p, Handler* h);
virtual NsObject* find(Packet*);
virtual void install(int slot, NsObject*);
//
protected:
//
NsObject** slot_; /* table that maps slot number to a NsObject */
NsObject *default_target_;
//
};

Definicin del mtodo install (classifier.cc)
void Classifier::install(int slot, NsObject* p)
{
if (slot >= nslot_)
alloc(slot);
slot_[slot] = p;
if (slot >= maxslot_)
maxslot_ = slot;
}

Definicin del mtodo find (classifier.cc)
NsObject* Classifier::find(Packet* p)
{
NsObject* node = NULL;
int cl = classify(p);
if (cl < 0 || cl >= nslot_ || (node = slot_[cl]) == 0) {
if (default_target_)
return default_target_;
/*
* Sigh. Can't pass the pkt out to tcl because it's
* not an object.
*/
Tcl::instance().evalf("%s no-slot %ld", name(), cl);
if (cl == TWICE) {
/*
* Try again. Maybe callback patched up the table.
*/
cl = classify(p);
if (cl < 0 || cl >= nslot_ || (node = slot_[cl]) == 0)
return (NULL);
}

}
return (node);
}

Definicin del mtodo recv (classifier.cc)
void Classifier::recv(Packet* p, Handler*h)
{
NsObject* node = find(p);
if (node == NULL) {
/*
* XXX this should be "dropped" somehow. Right now,
* these events aren't traced.
*/
Packet::free(p);
return;
}
node->recv(p,h);
}

Finalmente, la ltima clase que se ha analizado es Node, cuyo cdigo se encuentra en
los ficheros node.h y node.cc del directorio ns-2.34/common. Esta clase deriva de ParentNode,
quien a su vez hereda directamente de TclObject, y contiene los datos bsicos de un nodo de
una red, como la direccin, el identificador nico, la lista de interfaces fsicas, las tablas de
enrutado o la ubicacin (en el caso de nodos mviles). Como en el tutorial no se indica que se
examine algn mtodo en particular, a continuacin se presenta la declaracin completa de la
clase que se puede ver en el archivo node.h.

Declaracin de la clase Node (node.h)
class Node : public ParentNode {
public:
Node(void);
~Node();

inline int address() { return address_;}
inline int nodeid() { return nodeid_;}
inline bool exist_namchan() const { return (namChan_ != 0); }

virtual int command(int argc, const char*const* argv);
virtual void namlog(const char *fmt, ...);

NsObject* intf_to_target(int32_t);

static struct node_head nodehead_; // static head of list of nodes
inline void insert(struct node_head* head) {
LIST_INSERT_HEAD(head, this, entry);
}
inline Node* nextnode() { return entry.le_next; }

// The remaining objects handle a (static) linked list of nodes
// Used by Tom's satallite code and the wireless code
inline const struct if_head& ifhead() const { return ifhead_; }
inline const struct linklist_head& linklisthead() const {
return linklisthead_;
}

//neighbor list maintenance
neighbor_list_node* neighbor_list_;

void addNeighbor(Node *node);

static Node* get_node_by_address(nsaddr_t);

//routines for supporting routing
void route_notify (RoutingModule *rtm);
void unreg_route_notify(RoutingModule *rtm);
void add_route (char *dst, NsObject *target);
void delete_route (char *dst, NsObject *nullagent);
void set_table_size(int nn);
void set_table_size(int level, int csize);

protected:
LIST_ENTRY(Node) entry; // declare list entry structure
int address_;
int nodeid_; // for nam use

// Nam tracing facility
Tcl_Channel namChan_;
// Single thread ns, so we can use one global storage for all
// node objects
static char nwrk_[NODE_NAMLOG_BUFSZ];
void namdump();

struct if_head ifhead_; // list of phys for this node
struct linklist_head linklisthead_; // list of link heads on node

// pointer to head of rtmodule chain
RoutingModule* rtnotif_;

#ifdef HAVE_STL
NixNode* nixnode_; // used for nix routing (on-demand source routing for
simulator performance)
#endif /* STL */

public:
// XXX Energy related stuff. Should be moved later to a wireless
// routing plugin module instead of sitting here.
inline EnergyModel* energy_model() { return energy_model_; }
inline Location* location() { return location_; }
protected:
EnergyModel* energy_model_;
// XXX Currently this is a placeholder only. It is supposed to
// hold the position-related stuff in MobileNode. Yet another
// 'Under Construction' sign :(
Location* location_;
};

4.2. Extensiones de NS-2 usando herencia de objetos OTcl

Despus de seguir los pasos indicados en el tutorial, el fichero test.tcl al que se le ha
aadido la definicin de un agente emisor Sender y otro receptor Receiver y el escenario en el
que se van a probar dichos agentes, ha quedado de esta forma (se han aadido comentarios
que explican la generacin del escenario):

# Definicin del agente emisor personalizado Sender
Class Sender -superclass Agent/Message
Sender instproc send-next {} {

$self instvar seq_ agent_addr_
$self send "$agent_addr_ send $seq_"
incr seq_
global ns
$ns at [expr [$ns now]+0.1] "$self send-next"
}
Sender instproc recv msg {
$self instvar agent_addr_
set sdr [lindex $msg 0]
set seq [lindex $msg 2]
puts "Sender gets ack $seq from $sdr"
}

# Definicin del agente receptor personalizado Receiver
Class Receiver -superclass Agent/Message
Receiver instproc recv msg {
$self instvar agent_addr_
set sdr [lindex $msg 0]
set seq [lindex $msg 2]
puts "Receiver gets seq $seq from $sdr"
$self send "$agent_addr_ ack $seq"
}


# Guardamos las trazas generadas en los archivos 'message.tr' y 'message-nam.nam'
set fd [open message.tr w]
$ns trace-all $fd
set fdnam [open message-nam.nam w]
$ns namtrace-all $fdnam

for {set i 0} {$i < 6} {incr i} {
set n($i) [$ns node]
}

# Creamos enlaces full-duplex entre los nodos
$ns duplex-link $n(0) $n(1) 128kb 50ms DropTail
$ns duplex-link $n(1) $n(4) 10Mb 1ms DropTail

# Limitamos los tamaos de las colas de algunos enlaces

# Establecemos el protocolo de enrutamiento del vector distancia
$ns rtproto DV

# Creamos un agente receptor de paquetes UDP y lo asociamos al nodo 2
$ns attach-agent $n(2) $udp0
# Creamos un agente consumidor de paquetes UDP y lo asociamos al nodo 4
$ns attach-agent $n(4) $null0
# Relacionamos los dos agentes creados

# Creamos una aplicacin que generar trfico UDP exponencial
set exp0 [new Application/Traffic/Exponential]

$exp0 set rate_ 128k
$exp0 attach-agent $udp0
# Indicamos el instante de comienzo del trfico
$ns at 1.0 "$exp0 start"

# Creamos un nuevo agente personalizado Sender y otro Receiver
set sdr [new Sender]
$sdr set seq_ 0
$sdr set packetSize_ 1000
set rcvr [new Receiver]
$rcvr set packetSize_ 40

# Asociamos los agentes a los nodos 3 y 5 respectivamente
$ns attach-agent $n(3) $sdr
$ns attach-agent $n(5) $rcvr
# Relacionamos los dos agentes personalizados
$ns connect $sdr $rcvr
# Indicamos el instante en el que comenzar el trfico de Sender
$ns at 1.1 "$sdr send-next"

# Establecemos el instante final de la simulacin
$ns at 2.0 finish
proc finish {} {
global ns fd
$ns flush-trace
close $fd
exit 0
}

$ns run

El escenario de red definido por este script est formado por 6 nodos y 5 enlaces entre
ellos dispuestos como se indica en la siguiente figura, y adems posee dos parejas de agentes
generadoras de trfico.

Si ejecutamos el script anterior con el simulador de redes NS-2, se obtiene esta salida,
que se compone exclusivamente de mensajes escritos por los agentes personalizados Sender y
Receiver.

Receiver gets seq 0 from 3
Sender gets ack 0 from 5
n0 n1
n4
n5
n2
n3
128Kb, 50ms
10Mb, 1ms 10Mb, 1ms
C C
cross
traffic
S R
msg agent


Como se puede observar, el agente Sender del nodo 3 enva al menos 8 paquetes al
agente Receiver del nodo 5, identificados con los nmeros de secuencia 0 a 7. Sin embargo,
los paquetes 3, 5 y 6 enviados por Sender no llegan a su destino y la confirmacin de envo
(ACK) del paquete 7 enviada por Receiver no llega a Sender.

Ntese que, cuando alguno de los agentes recibe un paquete (ya sea un paquete de
datos o una confirmacin), muestra un mensaje por la salida estndar, porque se ejecutan las
lneas puts "Sender gets ack $seq from $sdr" y puts "Receiver gets seq $seq
from $sdr" del cdigo fuente de los agentes.

Para ver mejor lo que suceda durante la simulacin, se aadieron al archivo test.tcl las
lneas necesarias para generar las trazas del animador NAM. La captura de pantalla que se
muestra posteriormente se corresponde con un instante intermedio de la simulacin, en el que
se puede observar que el enlace entre los nodos 0 y 1, al tener un ancho de banda muy inferior
al de los dems enlaces, est saturado. Esto es lo que provoca que no todos los paquetes que
envan los mensajes Sender y Receiver lleguen a su destino.


4.3. Extensiones de NS-2 usando herencia de objetos C++

Antes de crear los ficheros necesarios para extender el protocolo TCP usando C++, se
observ y estudi el contenido de los diferentes ficheros indicados en el tutorial, como tcp.h,
tcp.cc, etc. Debido a su gran tamao, no se va a copiar el contenido de los ficheros en este
documento, sino que simplemente se comentar brevemente qu hay en cada uno de ellos:
tcp.h/tcp.cc: en estos archivos se encuentra la definicin de la cabecera TCP (hdr_tcp);
los temporizadores que se utilizan en el protocolo de transmisin TCP (DelSndTimer,
RtxTimer); el propio agente TCP, que es la clase ms extensa (TcpAgent); y otras
implementaciones de agentes basados en el TCP (RenoTcpAgent, VegasTcpAgent).
ns-agent.tcl: en este fichero Tcl se definen diversos mtodos de la clase Agent, sobre
todo para la inicializacin y configuracin de los agentes. Por ejemplo, es en este
archivo donde se declara la clase del agente nulo Agent/Null y el mtodo inicial init del
agente TCP.
ns-default.tcl: este fichero Tcl posee una gran cantidad de asignacin de valores por
defecto a las clases de NS-2, como colas, aplicaciones, interfaces de red, protocolos y,
por supuesto, agentes. Para la clase Agent/TCP, se establece el tamao de la ventana de
envo, el lmite de los temporizadores o el tamao por defecto de los paquetes, entre
otras muchas variables.

Siguiendo el tutorial, se han creado los ficheros tcp-js.h y tcp-js.cc en el directorio ns-
2.34/tcp con el contenido que se muestra a continuacin. Ntese que se ha aadido un printf al
mtodo que crea el agente personalizado para comprobar realmente que el simulador crea e
inicializa un agente de ese tipo.

Archivo tcp.h
#include "tcp.h"

class JSTcpAgent : public TcpAgent {
public:
JSTcpAgent();
virtual void set_initial_window() {
cwnd_ = MAXWIN_;
}
private:
int MAXWIN_;
};

Archivo tcp.cc
#include <tclcl.h>
#include "tcp.h"
#include "tcp-js.h"
#include <stdio.h>

static class JSTcpClass : public TclClass {
public:
JSTcpClass() : TclClass("Agent/TCP/JS") {}
TclObject* create(int , const char*const*) {
printf("Agente TCP JS creado.\n");
return (new JSTcpAgent());

}
} tcpjs_agent;

JSTcpAgent::JSTcpAgent() {
bind("MAXWIN_", &MAXWIN_);

}

Despus de modificar el Makefile y recompilar el simulador, para probar este nuevo
agente se ha utilizado un sencillo script basado en el fichero simple.tcl estudiado en uno de los
apartados anteriores de la documentacin, cuyo cdigo se presenta a continuacin.

# Inicializamos el simulador de NS-2

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

# Guardamos las trazas generadas en los ficheros 'out.tr' y 'out.nam' (para NAM)
$ns trace-all $f

# Creamos los enlaces entre los nodos

# Establecemos la colocacin de los enlaces en el esquema de la red

# Permitimos ver la cola de paquetes del enlace entre los nodos n2 y n3
$ns duplex-link-op $n2 $n3 queuePos 0.5

# Creamos un agente productor de paquetes TCP del tipo personalizado JS
set tcp [new Agent/TCP/JS]
# Establecemos el tamao mximo de la ventana
$tcp set MAXWIN_ 10
# Creamos un agente sink consumidor de paquetes TCP
# Asociamos los agentes con los nodos n1 y n3 respectivamente
# Conectamos el agente productor TCP con su correspondiente consumidor
# Creamos una aplicacin que genera paquetes TCP y la asociamos al agente TCP
# Indicamos el instante de comienzo de la aplicacin generadora de paquetes TCP

# Indicamos el instante de finalizacin de la conexin TCP


# Ejecutamos el mtodo 'finish' al terminar la simulacin
$ns at 2.0 "finish"

# Definicin del mtodo 'finish'
proc finish {} {
global ns f nf
# Guardamos y cerramos los archivos que contienen las trazas
$ns flush-trace
close $f
close $nf

# Ejecutamos el animador NAM con la traza recin generada
exec nam out.nam &
# Cerramos el simulador
exit 0
}

$ns run

Como se puede observar en el script, en este escenario se crea un agente TCP del tipo
JS creado con los ficheros tcp-js.h y tcp-js.cc, y se establece su tamao inicial de ventana en
10. Si simulamos este script y lo representamos grficamente con el animador de redes NAM,
se puede ver que, efectivamente, en la conexin TCP se utiliza inicialmente un tamao de
ventana de 10, ya que la primera vez que se transfieren datos entre los nodos se envan justo
10 paquetes, como demuestra esta captura de pantalla:


5. Prctica n5: Depuracin

5.1. Depuracin a nivel de OTcl/C++

Para instalar el depurador tcl-debug-2.0 se siguieron paso a paso las instrucciones que
venan en el tutorial, aunque fue necesario hacer algunos cambios menores porque la versin
del simulador NS-2 que se estaba utilizando era la 2.34 y no la 2.32. Al compilar el depurador
se produjo el error Cant find Tcl private headers, que se pudo solucionar modificando el
archivo configure como se explica en el tutorial.

Una vez instalado correctamente el depurador y recompilado el simulador, se prob su
funcionamiento aadiendo la lnea debug 1 al script wireless-test.tcl. Al ejecutar el script,
como se esperaba, apareci el shell del depurador:

$ ns wireless-test.tcl
2: lappend auto_path $dbg_library
dbg2.0>

Para obtener ayuda sobre los comandos disponibles en el depurador se puede utilizar
la opcin h. En la versin del tcl-debug que se est usando, los comandos permitidos son:

dbg2.0> h
s [#] step into procedure
n [#] step over procedure
N [#] step over procedures, commands, and arguments
c continue
r continue until return to caller
u [#] move scope up level
d [#] move scope down level
go to absolute frame if # is prefaced by "#"
w show stack ("where")
w -w [#] show/set width
w -c [0|1] show/set compress
b show breakpoints
b [-r regexp-pattern] [if expr] [then command]
b [-g glob-pattern] [if expr] [then command]
b [[file:]#] [if expr] [then command]
if pattern given, break if command resembles pattern
if # given, break on line #
if expr given, break if expr true
if command given, execute command at breakpoint
b -# delete breakpoint
b - delete all breakpoints
dbg2.1>


Pulsando ENTER en la lnea de comandos del depurador, se puede ir ejecutando paso
a paso el script, mientras que con la opcin c se contina la ejecucin sin usar el depurador.
Como en el tutorial no se pide hacer nada concreto con el depurador, a continuacin se ensea
una traza de la ejecucin del script, en la que se puede ver cmo se ejecuta paso a paso cada
lnea hasta que se introduce la opcin c.

dbg2.1>
2: new $opt(chan)
dbg2.2>
1: set chan [new $opt(chan)]

dbg1.3>
2: new $opt(prop)
dbg2.4>
1: set prop [new $opt(prop)]

dbg1.5>
2: new Topography
dbg2.6>
1: set topo [new Topography]

dbg1.7>
2: open $opt(tr) w
dbg2.8>
1: set tracefd [open $opt(tr) w]

dbg1.9>
2: open nam-out-test.nam w
dbg2.10>
1: set nf [open nam-out-test.nam w]

dbg1.11>
2: open trace-out-test.tr w
dbg2.12>
1: set f [open trace-out-test.tr w]

dbg1.13>
1: $ns_ namtrace-all-wireless $nf $opt(x) $opt(y)

dbg1.14>
1: $ns_ trace-all $f

dbg1.15>
1: $topo load_flatgrid $opt(x) $opt(y)

dbg1.16>
1: $prop topography $topo

...

15: Mac/802_11 set dataRate_
dbg15.36>
3: incr i
dbg3.37>

1: for {set i 0} {$i < $opt(nn)} {incr i} {
$node_($i) namattach $nf
# ...
dbg1.38>
2: set i 0
dbg2.39>
2: $node_($i) namattach $nf
dbg2.40>
2: $ns_ initial_node_pos $node_($i) 20
dbg2.41> w
*0: application
2: _o4 {initial_node_pos} {_o15} {20}
dbg2.42> c
Loading connection pattern...
Loading scenario file...
Load complete...
Starting Simulation...
channel.cc:sendUp - Calc highestAntennaZ_ and distCST_
highestAntennaZ_ = 1.5, distCST_ = 550.0
SORTING LISTS ...DONE!
NS EXITING...

Tutorial NS 2

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Tutorial NS 2

Загружено:

Авторское право:

Доступные форматы

Tutorial NS-2

Juan Gallardo Casero

Вам также может понравиться