Clase 04 Archivo

Simulación a Eventos Discretos
Clase 4: EOSimulator y Pascal SIM
Introducción
Una vez construido el modelo de simulación, debe ser traducido a un
programa de computador.
Diferentes opciones:
1. Lenguajes de programación de propósito general.
2. Lenguajes o bibliotecas para la programación de simulaciones.
3. Paquetes de simulación.
En este curso adoptamos la alternativa 2.
2
Introducción
Utilizamos EOSimulator (basado en C++), desarrollado por el
Departamento de Investigación Operativa del Instituto de Computación.
Alternativamente se podrá utilizar Pascal SIM (basado en Pascal y utilizado
en el texto de Davies y O’Keefe), desarrollado por la Universidad de
Southampton.
Ambas bibliotecas permiten la programación de modelos basados en los
enfoques orientados a eventos de dos o tres fases.
3
Conceptos importantes
• Modelo
• Evento (fijo y condicionado)
• Entidad
• Recurso
• Calendario
• Ejecutivo
4
EOSimulator
• Biblioteca para ser utilizada desde un programa en C++.
• Conjunto de clases que brindan servicios y requieren la definición de
operaciones prefijadas.
• Código fuente disponible (no se recomienda modificarlo).
5
Implementación en EOSimulator
• Entidades: Se pueden utilizar las brindadas por defecto, o se pueden
crear nuevas subclases.
• Recursos: Brindados por la biblioteca.
• Eventos: Son clases abstractas, con operaciones cuyo método debe
definirse en clases derivadas.
• Modelo: Deriva de una clase abstracta y debe contener todos los
atributos relevantes del sistema que se modela.
6
Arquitectura de EOSimulator
• core: Estructura de la
simulación.
• dist: Números aleatorios y
distribuciones.
• statics: Recolección de
datos.
• utils: Utilidades varias.
7
Entidades
Poseen atributos para indicar su próximo evento fijo y su instante de
ocurrencia. Deben crearse de forma dinámica (utilizando new). Pueden
crearse entidades especı́ficas, derivadas de Entity.
class Entity {
private:
BEvent* bEv;
double clock;
public:
Entity ();
virtual ~Entity ();
void setBEvent (BEvent* bEv_);
void setClock (double clock_);
double getClock ();
void processEvent ();
};
8
Recursos
Clase base abstracta Bin; clases concretas Renewable y NonRenewable.
class Bin {
public:
virtual ~Bin();
void acquire (double amount_);
bool isAvailable (double amount_);
};
9
Recursos
class Renewable: public Bin {
public:
Renewable (double quantity_, double max_);
~Renewable ();
void returnBin (double amount_);
};
class NonRenewable: public Bin {
public:
NonRenewable (double quantity_);
~NonRenewable ();
void addBin (double amount_);
};
10
Colas
Interfaz EntityQueue, con implementaciones de colas fifo, lifo y de prioridad
(dada por un comparador).
class EntityQueue {
public:
EntityQueue() {};
virtual ~EntityQueue() {};
virtual void push(core::Entity* ent_) = 0;
virtual core::Entity* pop() = 0;
virtual void remove(unsigned int i_) = 0;
virtual bool empty() = 0;
virtual core::Entity* operator[] (unsigned int i_) = 0;
virtual unsigned int size() = 0;
};
11
Eventos
• Clases abstractas BEvent y CEvent.
• Un evento pertenece a un modelo y tiene una referencia al mismo
(owner).
• Para eventos concretos, debe implementarse la operación eventRoutine.
12
Eventos fijos
class BEvent {
protected:
Model& owner;
public:
BEvent (std::string name_, Model& owner_);
virtual ~BEvent ();
std::string getName();
virtual void eventRoutine (Entity* who_) = 0;
};
El nombre de los BEvent es el identificador utilizado para agendar las
entidades. Es de tipo std::string.
13
Eventos condicionados
class CEvent {
protected:
Model& owner;
public:
CEvent (Model& owner_);
virtual ~CEvent ();
virtual void eventRoutine () = 0;
};
14
Modelo
Es una clase abstracta. Define el modelo del sistema que se quiere simular.
Posee como atributos: eventos (B y C), recursos, entidades globales, colas,
histogramas y distribuciones. En un modelo concreto se deben implementar
las operaciones de inicialización init y doInitialSchedules.
class Model {
private:
Experiment* exp;
utils::BEventMap bEvs;
public:
Model();
virtual ~Model();
virtual void init () = 0;
virtual void doInitialSchedules () = 0;
void connectToExp (Experiment *exp_);
void registerBEvent (BEvent* bEv_);
void registerCEvent (CEvent* cEv_);
void registerDist (dist::Distribution* dist_);
void registerHistogram (statics::Histogram* hist_);
void schedule (double offset_, Entity* who_, std::string what_);
double getSimTime();
};
15
Calendario
Dos tipos: eventos B (entidades agendadas a un evento fijo) y C (eventos
condicionados registrados).
class BCalendar {
private:
double simTime, endSim;
utils::EntityQueueOrdered ents;
public:
BCalendar ();
~BCalendar ();
void bPhase ();
bool isStopped();
void schedule (double offset_, Entity* who_);
void setEndTime (double when_);
double getSimTime();
};
16
Calendario
class CCalendar {
private:
utils::CEventVector cEvs;
public:
CCalendar ();
~CCalendar ();
void cPhase ();
void registerCEvent (CEvent* cEv_);
};
17
Ejecutivo
• Clase Experiment contiene los calendarios B y C.
• Las fases A y B usan BCalendar; la fase C usa CCalendar.
• Para correr la simulación, se conecta la instancia de Model con la
instancia de Experiment y luego se ejecuta mediante la operación run.
18
Ejecutivo
class Experiment {
private:
bool running;
dist::DistManager distMan;
BCalendar bCal;
CCalendar cCal;
Model* currModel;
public:
Experiment ();
~Experiment();
void run (double simTime_);
void setModel (Model* model_);
void schedule (double offset_, Entity* who_);
void setSeed (unsigned long seed_);
void registerDist (dist::Distribution* dist_);
void registerCEvent (CEvent* cEv_);
double getSimTime();
};
19
Pascal SIM
• Biblioteca para ser utilizada desde un programa en Pascal.
• Conjunto de variables, constantes, funciones y procedimientos agrupadas
en una unit de Pascal.
• Código fuente disponible; usualmente debe modificarse y recompilarse.
20
Implementación en Pascal SIM
• Entidades: Se utilizan las brindadas por la biblioteca.
especializarlas, se debe cambiar el código.
Para
• Recursos: Brindados por la biblioteca.
• Eventos: Son procedimientos, tanto los eventos B como los C.
• Modelo: Implı́cito en el programa final.
21
Entidades
Poseen atributos para indicar su disponibilidad (para participar en una
actividad), clase, identificación, próximo evento fijo y su instante de
ocurrencia.
entity = ^an_entity;
an_entity = packed record
avail
class
col
attr, next_B
time
end;
:boolean;
:class_num;
:color;
:cardinal;
:real;
Operaciones de creación y eliminación:
function new_entity (c :class_num; a :cardinal):entity;
procedure make_class (var c :queue; n, size :cardinal);
procedure dis_entity (e :entity);
22
Recursos
Son de tipo renovable, una vez utilizados deben ser devueltos.
bin = record
number, num_avail :cardinal;
end;
Operaciones de creación, adquisición y retorno:
procedure make_bin (var from :bin; n :cardinal);
procedure acquire(var from :bin; n :cardinal);
procedure return (var from :bin; n :cardinal);
23
Colas
Son listas circulares doblemente encadenadas. Sus elementos son entidades.
No manejan prioridades.
procedure make_queue (var q :queue);
procedure give_top (q :queue; i :entity);
procedure give_tail (q :queue; i :entity);
function take_top (q :queue):entity;
function take_tail (q :queue):entity;
function empty (q :queue):boolean;
function count (q :queue):cardinal;
24
Eventos
• Son procedimientos definidos por el modelador.
• No tienen ninguna forma particular de definición.
• Para los eventos fijos: la entidad sobre la cual actúan se encuentra
almacenada en la variable global current.
• Los eventos fijos se agendan mediante la operación:
procedure cause (nb :cardinal; e :entity; t :real);
25
Modelo
• El modelo del sistema a simular está implı́cito. Es el archivo .pas y la
memoria que este ocupa en el tiempo de ejecución.
• Para inicializar un modelo se utiliza el procedimiento initialize
(convención), donde se crean las colas, las entidades globales, los
recursos, los histogramas y los torrentes de números aleatorios.
26
Calendario
• Es una lista global de entidades ordenada por el campo time.
• Contiene todas las entidades agendadas a algún evento fijo.
• Se insertan elementos con el procedimiento cause.
• Para tomar la entidad que se debe procesar, se utiliza calendar top.
Esta función deja la entidad a procesar en la variable global current. El
calendario se crea con el procedimiento make sim.
27
Ejecutivo
• Algoritmo que corre una simulación.
• Debe ser implementado por el usuario.
procedimiento run.
Por convención se utiliza el
• Ejecuta las fases A (avance del tiempo), B (ejecución de los eventos
fijos) y C (ejecución de los eventos condicionados).
28
Estructura general del programa
{bound events}
{conditional events}
procedure run;
procedure initialize;
procedure report;
begin
...
initialize;
run;
report;
...
end.
29
Preguntas
1. Plantear las principales semejanzas y diferencias en el tratamiento de los
conceptos de SED en EOSimulator y Pascal SIM.
2. Enumerar ventajas y desventajas de ambas bibliotecas.
30