La simulación es el proceso de aprender haciendo . Cada vez que hay algo nuevo en el mundo, primero tratamos de analizarlo examinándolo y en el proceso aprendemos muchas cosas. Todo este curso se llama Simulación .
En correlación con este proceso, para comprender todas las complejidades que se necesitan para modelar todo el juego de roles en forma de simulación por computadora, es necesario construir objetos artificiales y asignarles roles dinámicamente.
La simulación por computadora es el diseño de un sistema físico teórico en una computadora digital con énfasis en el diseño, ejecución y análisis de modelos. Después de la creación del modelo matemático, el paso más importante es crear un programa de computadora para actualizar las variables de estado y evento a través del tiempo (por división de tiempo o programación de eventos). Si esta simulación se realiza sucesivamente en ordenadores paralelos, se denomina simulación Paralela o Distribuida .
Simulación de red(NS) es uno de los tipos de simulación, que se utiliza para simular las redes, como en MANET, VANET, etc. Proporciona simulación para protocolos de enrutamiento y multidifusión para redes cableadas e inalámbricas. NS tiene licencia para su uso bajo la versión 2 de GNU (General Public License) y se conoce popularmente como NS2 . Es un simulador controlado por eventos discretos, orientado a objetos, escrito en C++ y Otcl/Tcl.
NS-2 se puede utilizar para implementar protocolos de red como TCP y UPD, comportamiento de fuente de tráfico como FTP, Telnet, Web, CBR y VBR, mecanismo de gestión de colas de enrutador como Drop Tail, RED y CBQ, algoritmos de enrutamiento y mucho mas. En ns2, C++ se usa para la implementación detallada del protocolo y Otcl se usa para la configuración. Los objetos C++ compilados se ponen a disposición del intérprete Otcl y, de esta forma, los objetos C++ listos para usar se pueden controlar desde el nivel OTcl.
Instale NS-2 usando este comando:
sudo apt-get install ns2
Nam también es necesario para instalar. Nam ( Network Animator ) es una herramienta de animación para representar gráficamente la red y los rastros de paquetes. Utilice este comando:
sudo apt-get install nam
Algunas sintaxis básicas del script Otcl:
Comando básico:
Python
set a 8 set b [expr $a/8]
Explicación: En la primera línea, a la variable a se le asigna el valor 8. En la segunda línea, el resultado del comando [expr $a/8], que es igual a 1, se usa como argumento para otro comando, que en turn asigna un valor a la variable b . El signo “$” se usa para obtener un valor contenido en una variable y los corchetes son una indicación de sustitución de comando.
Defina nuevos procedimientos con el comando proc :
Python
proc factorial fact {
if {$fact <= 1} {
return 1
}
expr $fact * [factorial [expr $fact-1]]
}
Para abrir un archivo para lectura:
Python
set testfile [open hello.data r]
De manera similar, el comando put se usa para escribir datos en el archivo
Python
set testfile [open hello.data w] puts $testfile “hello1”
Para llamar a subprocesos dentro de otro proceso, se usa exec , que crea un subproceso y espera a que se complete.
Python
exec rm $testfile
Para poder ejecutar un escenario de simulación, primero se debe crear una topología de red. En ns2, la topología consta de una colección de Nodes y enlaces.
Python
set ns [new Simulator]
El objeto simulador tiene funciones miembro que permiten la creación de los Nodes y definen los vínculos entre ellos. El simulador de clases contiene todas las funciones básicas. Dado que ns se definió para manejar el objeto Simulator, el comando $ns se usa para usar las funciones que pertenecen a la clase del simulador.
En la topología de la red, los Nodes se pueden agregar de la siguiente manera:
Python
set n0 [$ns node] set n1 [$ns node]
Los agentes de tráfico (TCP, UDP, etc.) y las fuentes de tráfico (FTP, CBR, etc.) deben configurarse si el Node no es un enrutador. Permite crear una fuente de tráfico CBR utilizando UDP como protocolo de transporte o una fuente de tráfico FTP utilizando TCP como protocolo de transporte.
Fuente de tráfico CBR usando UDP:
Python
set udp0 [new Agent/UDP] $ns attach-agent $n0 $udp0 set cbr0 [new Application/Traffic/CBR] $cbr0 attach-agent $udp0 $cbr0 set packet_size_ 512
Fuente de tráfico FTP usando TCP:
Python
set tcp0 [new Agent/TCP] $ns attach-agent $n0 $tcp0 set ftp0 [new Application/FTP] $ftp0 attach-agent $tcp0 $tcp0 set packet_size_ 512
A continuación se muestra la implementación de la creación de enlaces entre el origen y el destino utilizando FTP y TCP:
Python
# 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
Producción :
Características de NS2:
- Es un simulador de eventos discretos de investigación de redes.
- Tiene muchas características para simular protocolos que incluyen TCP, FTP, UDP, HTTPS y DSR.
- Es capaz de simular redes cableadas e inalámbricas.
- Se basa principalmente en Unix.
- Su lenguaje de programación es TCL.
- Tclcl es un lenguaje de enlace C++ y otcl.
- Programador de eventos discretos.
Publicación traducida automáticamente
Artículo escrito por Chinmoy Kalita y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA