Transcript Iniciación a Omnet++ José Daniel García Sánchez Grupo de Arquitectura Comunicaciones y Sistemas Universidad Carlos III de Madrid.

Iniciación a Omnet++
José Daniel García Sánchez
Grupo de Arquitectura Comunicaciones y Sistemas
Universidad Carlos III de Madrid
Contenido
Pasos

Definir la estructura de la red.


Completar el comportamiento.


Lenguaje NED.
Lenguaje C++.
Configurar la simulación

Archivo ini
Ejemplo 1




1 Servidor.
El tiempo entre llegadas tiene una
distribución exponencial con media de 1
segundo.
El tiempo de servicio tiene una distribución
exponencial de 0.99 segundos.
¿Cuál es el tiempo medio que una
petición permanece en la cola?
Cola M/M/1


Evidentemente, este sistema tiene solución
analítica.
Simplemente se usa como ejemplo muy
sencillo para ilustrar Omnet++.
Lenguaje NED Básico

Definición de módulos simples.

Definición de módulos compuestos.

Definición de redes.
Módulos simples

Parámetros:


numeric, numeric const
(o const), bool, string,
xml.
Puertas.


in o out.
Pueden ser arrays.
simple Modulo
parameters:
p1 : tipo,
p2 : tipo;
gates:
in: g1;
out: g2;
out: g3[];
endsimple;
Generador de peticiones
simple Generador
parameters:
tiempoEntreLlegadas :
numeric;
gates:
out: salidaPeticiones;
endsimple;
Servidor
simple Servidor
parameters:
tiempoServicio: numeric;
gates:
in: entradaPeticiones;
endsimple;
Módulos compuestos



Permiten componer
módulos complejos a
partir de otros.
Se usan para
interconectar módulos.
Se pueden realizar
múltiples niveles de
composición.
module nombre
parameters:
//...
gates:
//...
submodules:
//...
connections:
//...
endmodule;
Conexión de módulos
module Red
parameters:
tiempoLlegadas : numeric,
tiempoServicio : numeric;
submodules:
gen : Generador;
parameters:
tiempoEntreLlegadas = tiempoLlegadas;
svr : Servidor;
parameters:
tiempoServicio = tiempoServicio;
connections:
gen.salidaPeticiones --> svr.entradaPeticiones;
endmodule;
Red


Instanciación de la
red.
Puede contener
asignación de
parámetros.
network red : Red
endnetwork;
Programación de módulos
simples

Es necesario definir el comportamiento
de los módulos simples.




Iniciación
Finalización.
Tratamiento de mensajes.
Cada módulo simple se programa como
una clase C++.

Hereda de cSimpleModule
Modelos de tratamiento de
mensajes

Síncrono




Se define un bucle
completo de
tratamiento.
Más sencillo de
comprender
inicialmente.
Requiere espacio de
pila.
Otros problemas.

Asíncrono



Disparado por
eventos.
Más costoso de
comprender.
No requiere espacio
de pila.
Clase generador
#include <omnetpp.h>
class Generador : public cSimpleModule
{
Module_Class_Members(Generador, cSimpleModule, 4096); 
private:
virtual void initialize();
virtual void activity();
virtual void finish();
private:
int salida_;
private:
int enviados_;
};
Generador: Iniciación y
Finalización
#include "generador.h"
Define_Module(Generador); 
void Generador::initialize()
{
salida_ = findGate("salidaPeticiones");
if (salida_ < 0)
opp_error("puerta de salida no encontrada");
enviados_ = 0;
}
void Generador::finish()
{
ev << "Mensajes enviados: " << enviados_ << endl;
}
Generador: Actividad
void Generador::activity()
{
cPar
tiempo_entre_llegadas=par("tiempoEntreLlegadas");
for (;;) {
double tiempo = tiempo_entre_llegadas;
wait(tiempo);
cMessage * msg = new cMessage("peticion");
send(msg, salida_);
enviados_++;
}
}
Clase servidor
#include <omnetpp.h>
class Servidor : public cSimpleModule
{
Module_Class_Members(Servidor, cSimpleModule, 4096);
private:
virtual void initialize();
virtual void activity();
virtual void finish();
private:
int procesados_;
};
Servidor: Iniciación y Finalización
#include "servidor.h"
Define_Module(Servidor);
void Servidor::initialize()
{
procesados_ = 0;
}
void Servidor::finish()
{
ev << "Peticiones procesadas: "
<< procesados_ << endl;
}
Servidor: Actividad
void Servidor::activity()
{
cPar tiempo_servicio =
par("tiempoServicio");
for (;;) {
cMessage * msg = receive();
delete msg;
double tiempo = tiempo_servicio;
wait(tiempo);
procesados_++;
}
}
Vale ¿Y ahora qué?

Se pueden generar dos tipos de
ejecutables:


Interfaz de usuario gráfico: Útil para
depurar y comprender.
Interfaz de consola: Más eficaz para
realizar las simulaciones por lotes.
Proceso de compilación
Compilación


Omnet++ permite generar
automáticamente los Makefile.
Ejemplo para Windows:



opp_nmakemake –u Cmdenv –f –o simred
opp_nmakemake –u Tkenv –f –o simred
nmake –f Makefile.vc
Configuración: omnetpp.ini
[General]
network=red
sim-time-limit = 10s
[Parameters]
red.tiempoLlegadas=1
red.tiempoServicio=0.99
Seamos realistas



No se puede sustituir una distribución por su
media.
Hace falta asignar distribuciones aleatorias a
los parámetros.
Y además:

No se puede recibir un mensaje mientras se está
en un wait.
Uso de una cola de peticiones
class Servidor : public
cSimpleModule
{
//...
private:
cQueue * cola_peticiones_;
//...
};
activity()
void Servidor::activity()
{
cPar tiempo_servicio = par("tiempoServicio");
for (;;) {
cMessage * msg;
if (cola_peticiones_->empty()) {
msg = receive();
}
else {
msg = check_and_cast<cMessage*>(cola_peticiones_->pop());
}
ev << "Enviado: " << msg->sendingTime()
<< ", procesando: " << simTime() << endl;
delete msg;
double tiempo = tiempo_servicio;
waitAndEnqueue(tiempo,cola_peticiones_);
procesados_++;
}
}
Generación de números
aleatorios

Un generador de números
pseudoaleatorios




Genera números enteros.
Basado en un algoritmo determinista.
Parte de una semilla inicial.
Necesarios para generar distribuciones
aleatorias.
Generadores de números
aleatorios

Congruencial lineal.


Mersenne-Twister [1998]


Periodo 231
Periodo de 219937-1.
Akaroa.

Para ejecutar replicaciones paralelas en clusters.
Distribuciones aleatorias



Basadas en generadores de números
aleatorias.
Disponibles las más típicas.
Se pueden añadir nuevas (si uno sabe
matemáticas suficientes).
Importante


Cuidado con las variables
autocorreladas.
Mucho cuidado con generar dos
distribuciones a partir de una misma
fuente aleatoria.
Configuración de parámetros
[General]
network=red
sim-time-limit = 1m
num-rngs=2
**.rng-0=0
**.rng-1=1
[Parameters]
red.tiempoLlegadas=exponential(1,0);
red.tiempoServicio=exponential(0.9,1);
Recogida de estadísticas


Omnet++ ofrece herramientas para
recoger estadísticas de los resultados.
La más sencilla es cStdDev que permite
recoger estadísticos sencillos de una
muestra.
Generador: Recogida de
estadísticas
class Servidor : public
cSimpleModule
{
//...
private:
cStdDev tiempo_espera_;
};
Generador: Recogida de
estadísticas
void Servidor::activity()
{
//...
tiempo_espera_.collect(simTime() - msg->sendingTime());
//...
}
void Servidor::finish()
{
delete cola_peticiones_;
ev << "Peticiones procesadas: "
<< tiempo_espera_.samples() << endl;
ev << "Tiempo medio: " << tiempo_espera_.mean() << endl;
ev << "Varianza: " << tiempo_espera_.variance() << endl;
}
Recogida de estadísticas más
detallada

cWeightedStdDev


cLongHistogram, cDoubleHistogram,
cVarHistogram


Pesos en las medidas  Longitud media.
Histogramas
cPSquare

Cuantiles
Grabación de datos vectoriales



Posibilidad de guardar una serie
temporal para posterior análisis.
Archivo con extensión vec.
Se puede procesar con herramienta
plove.
Servidor: Grabación de
vectores
class Servidor : public
cSimpleModule
{
//...
private:
cOutVector vec_tiempo_espera_;
cOutVector vec_longitud_cola_;
};
Servidor: Grabación de datos
vectoriales
void Servidor::activity()
{
//...
vec_tiempo_espera_.record(
simTime()-msg->sendingTime());
vec_longitud_cola_.record(
cola_peticiones_->length());
//...
}
Estimación del tiempo de
espera


Sea Ti el tiempo de espera de la i-ésima
petición.
¿Puedo usar T para estimar el tiempo
de espera de las peticiones?


No porque Ti no son independientes ni
idénticamente distribuidas.
Pero podría estimar las distribuciones
de cada uno de los Ti.


Si solamente ejecuto la simulación una vez
solamente tengo una muestra de cada
variable aleatoria Ti.
Solución:




Realizar m ejecuciones independientes.
Tij: Tiempo de espera de la i-ésima petición en la
j-ésima replicación.
Cada ejecución usa las mismas condiciones
inciales.
Solo cambian las semillas de generación de
números aleatorios.
Independencia entre
ejecuciones



T11,T12,...,T1n son muestras de la
variable aleatoria Ti.
Cada Ti puede seguir una distribución
distinta.
Pero ¿Cómo se determina m?

¿Depende del tipo de simulación?
Simulaciones con finalización
predefinida

Se sabe cuando terminan.


Un sistema que se reinicia pasado un cierto
tiempo.
Un sistema que tiene una condición de
terminación.

Simular la transmisión de un video.
Preguntas para simulaciones
con finalización predefinida


Estimación del intervalo de confianza a
partir de n realizaciones de simulación
estocástica.
¿Cuántas realizaciones tengo que hacer
si quiere obtener una precisión
determinada?
Simulación sin terminación
definida


No existe un evento de terminación de
la simulación.
Nos interesan el comportamiento del
sistema en su estado estacionario.

Hay que detectar y eliminar el estado
transitorio.
Estado transitorio y estado
estacionario
Preguntas


¿Cómo elimino la parte de la simulación
que se corresponde con el estado
transitorio?
Finalización de la simulación:


Si termino demasiado pronto  resultados
con variabilidad dependiente de las
semillas.
Si termino demasiado tarde  estoy
desperdiciando tiempo y recursos.
Compliquemos el problema

El cliente y el servidor están conectados
por un canal:



Ancho de banda de 128 Kbps.
El retraso sigue una distribución normal de
media 1us y sigma 0.01.
Los tamaños de los mensajes tienen
una distribución lognormal mu=6 y
sigma=0.4
Definición de canales

Omnet permite
definir un tipo de
canal a partir de:



Ancho de banda.
Tasa de errores.
Retraso.
channel nombre
delay valor
error valor
datarate valor
endchannel;
Ejemplo de canal
channel conexion
datarate 128000
delay normal(1e-6,0.01,3)
endchannel
module Red
//...
connections:
gen.salidaPeticiones --> conexion -->
svr.entradaPeticiones;
endmodule;
Generación de mensajes con
tamaño
void Generador::activity()
{
cPar tiempo_entre_llegadas =
par("tiempoEntreLlegadas");
cPar tam_mensaje = par("longitudMensaje");
for (;;) {
double tiempo = tiempo_entre_llegadas;
wait(tiempo);
cMessage * msg = new cMessage("peticion");
long longitud = tam_mensaje;
msg->setLength(longitud);
send(msg, salida_);
enviados_++;
}
}
Y aún hay más ...





Implementación asíncrona de módulos.
Mensajes definidos por el usuario.
Enrutamiento automático.
Recogida de datos no vectoriales para
múltiples realizaciones.
Simulación paralela:


Realizaciones paralelas.
Partición del modelo.
Y todavía más ...



INET Framework.
Mobility Framwork.
IPV6.