Universidad Central de Venezuela

Facultad de Ciencias
Escuela de Computación

Lecturas en Ciencias de la Computación

ISSN 1316-6239

Estrategias del Manejo del Tiempo

en Simulación Dinámica
Prof. Eliezer Correa
Prof. Sergio Rivas

ND 2010-01

Centro de Investigación de Operaciones y Modelos Matemáticos (CIOMMA)

Caracas, Enero 2010.
9&"41&-)
Cada vez es más frecuente el uso de la simulación para estudiar el comportamiento
de un sistema frente a distintas situaciones o escenarios. En la mayoría de los casos, la
simulación se realiza sobre los sistemas dinámicos, es decir, sistemas donde las variables de
interés van cambiando a través del tiempo (simulación dinámica).

En este documento se presentan estrategias y enfoques para manejar el tiempo como

la variable fundamental en la simulación, así como también, representar la dinámica de las
otras variables del sistema en función de dicha variable tiempo.

Las distintas estrategias sirven, para dar respuesta a la necesaria sincronización de

las distintas situaciones que cambian el estado del sistema a través del tiempo.

Se presenta con más detalle el mecanismo de simulación basada en eventos

discretos, considerado como uno de los mecanismos con más eficiencia en el manejo del
tiempo de simulación en la mayoría de los sistemas dinámicos.

!"#"$%"&'(#")*''
Simulación basada en eventos discretos, DES, Interacción de Procesos, Exploración de
Actividades.

(+,-".-+&'
• Prof. Sergio Rivas (sergio.rivas@ciens.ucv.ve)

• Prof. Eliezer Correa (elcorrea@gmail.com)

/*.0"'
Enero de 2010

!"
0%:+%)*&);/-#&-(*/)
!"#$%&'()**+,$ ------------------------------------------------------------------------------------------------------------------------------!!
."#$%&'()**+,$"/"0/"1+2)0/*+,$"3+$42+*/ ---------------------------------------------------------------------------.!
5"1+2)0/*+,$"6/7/(/"8$"9:8$%'7"3+7*&8%'7 ------------------------------------------------------------------------5!
5-!";8&2+$'0'<=/"8$"1+2)0/*+,$">/7/(/"8$"9:8$%'7"3+7*&8%'7 ---------------------------------------------?!
5-."97@)82/"(8"%&/>/A'"<8$8&/0"8$"7+2)0/*+,$">/7/(/"8$"8:8$%'7"(+7*&8%'7------------------B!
"#$#%!&'()*+,!-(+!./01,!-(!20/!3/425++/ ################################################################################################## 6!
?"9$C'@)87"(8"387/&&'00'"8$"1+2)0/*+,$">/7/(/"8$"8:8$%'7"3+7*&8%'7----------------- !D!
?-!"1+2)0/*+,$">/7/(/"8$"E0/$+C+*/*+,$"(8"9:8$%'7 --------------------------------------------------------------- !D!
?-5"1+2)0/*+,$"6/7/(/"8$"E&'*87'7 --------------------------------------------------------------------------------------------- !D!
?-?"1+2)0/*+,$"6/7/(/"8$"0/"8FG0'&/*+,$"(8"/*%+:+(/(87 ----------------------------------------------------- !.!
7#7#%!&'()*+,8!9:,;+()/!-(+!./01,!1,0!(<*+,:/15=0!-(!/1>5?5-/-(@######################################### %"!
7#7#$!&<*+,:/15=0!-(!/1>5?5-/-(@!(0!>:(@!A/@(@ #################################################################################### %B!
H"I'$*0)7+'$87--------------------------------------------------------------------------------------------------------------------------- !J!
6+>0+'<&/C=/--------------------------------------------------------------------------------------------------------------------------------- !K!

"
"

!!"
<-*(5&)*&)=('4$%")
Figura 1: Estado de un Sistema Discreto................................................................................ 2!

Figura 2: Estado de un Sistema Continuo .............................................................................. 3!

Figura 3: Esquema de Trabajo en Simulación de Eventos Discretos ..................................... 6!

Figura 4: Ejemplo de un proceso.......................................................................................... 11!

Figura 5: Enfoque de exploración de actividades................................................................. 13!

!!!"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

>)?-#$/*455(6-)
Hoy en día, el estudio de sistemas con dinámicas complejas se hace en muchos
casos con simulación. La idea es poder imitar el comportamiento de un sistema diseñando e
implantando un modelo computacional del sistema en cuestión.

En la mayoría de los sistemas, el tiempo juega un rol fundamental, y en su

transcurso las entidades del sistema generan cambios que representan la dinámica del
sistema.

Este trabajo muestra formas de avanzar el tiempo de la simulación de un sistema, de

manera de poder sincronizar adecuadamente la interacción temporal de las entidades que
intervienen en el sistema.

Se presentan en este trabajo algunas definiciones generales de simulación, luego se

presenta el tema del manejo del tiempo en simulaciones basadas en eventos discretos el
cual es el tópico interés. También se mostrarán distintos enfoques según el nivel de
abstracción para implementar un modelo basado en eventos discretos. Por último, se
mostrarán algunos ejemplos de este manejo del tiempo en un contexto previamente
definido.

8"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

@)?-#$/*455(6-)%)+%)3(14+%5(6-)7(-81(5%)
Una Simulación es la imitación de la operación o funcionamiento de algún sistema
del mundo real (a través del tiempo) (Banks Jerry, 2005). La simulación es usada para
probar nuevas ideas o estrategias basadas en un modelo que representa una abstracción
particular de ese sistema.

Una clasificación de los tipos de simulación según el modelo y su forma de

implementarlo es:

• Determinística: cuando acciones sobre el modelo arrojan consecuencias predecibles

en las variables de estado que describen el comportamiento del sistema.

• Estocástica: cuando acciones sobre el modelo arrojan consecuencias que dependen

de distribuciones probabilísticas en las variables de estado que describen el
comportamiento del sistema.

La simulación también puede ser divida en dos categorías según la dependencia con el
tiempo:

• Simulación Estática: Es una simulación donde el variables de estado no dependen

del tiempo y generalmente consiste en la resolución de las ecuaciones de estado del
sistema en un instante dado.

• Simulación Dinámica: Este tipo de simulación a diferencia del anterior; las

variables de estado si dependen del tiempo.

Dentro de la simulación dinámica tenemos una subdivisión relacionada a como se

maneja la variable tiempo.

• Simulación Discreta: Aquí el sistema cambia en puntos discretos del tiempo; un

ejemplo simple de simulación discreta aplicaría en un banco con taquillas, donde las
condiciones del sistema cambian sólo cuando entra o sale un cliente.

• Simulación Continua: Aquí el sistema cambia de forma continua a través del

tiempo, por ejemplo, si el sistema se concentra en observar la temperatura de un
componente.

Figura 1: Estado de un Sistema Discreto

9"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

En la Figura 1 se ve un ejemplo que muestra como el estado del sistema X(t)

cambia en ciertos puntos definidos del tiempo t.

Figura 2: Estado de un Sistema Continuo

En la Figura 2 se ve un ejemplo que muestra como el estado del sistema X(t)

cambia de forma continua en el tiempo t.

En nuestro caso, nos interesa estudiar las simulaciones del tipo dinámica y discreta.

A)3(14+%5(6-)B%"%*%)&-)!C&-#/")7("5$&#/")
Cuando en una situación donde es necesario mover el tiempo como variable
mientras se simula, existen diferentes estrategias para avanzar el reloj (emular el transcurso
del tiempo), permitiendo así simular la dinámica de las entidades en el sistema.

Una estrategia ineficiente consiste en mover el reloj en intervalos fijos del tiempo.
El tamaño de estos intervalos se definen según la precisión que se quiera tener a fin de
resolver ciertas interrogantes, por ejemplo: Simular clientes en un restaurante, situación en
la cual se avanza el reloj en segundos. Esta estrategia sencilla que parece al transcurso del
tiempo en el mundo real puede ser inadecuada, ya que avanzar el reloj sobre intervalos en
donde no sucede ninguna acción que cambie el estado del sistema estaría usando
inútilmente recursos computacionales (memoria y/o unidades de procesamiento).

Una estrategia más eficiente consiste en ubicar el próximo momento del tiempo
en donde cambiará el sistema, y luego, avanzar el reloj del sistema a ese momento del
tiempo; en este principio se fundamenta la simulación basada en eventos discretos.

La simulación basada en eventos discretos permite emular el transcurso del tiempo

en saltos, evitando esperas o ejecuciones innecesarias. A continuación se describirá en
detalle esta estrategia:

La simulación basada en eventos discretos, permite capturar los cambios y sus

consecuencias en el sistema en puntos separados en el tiempo (Law, 2007), es decir, el
estado del sistema va cambiando en determinados puntos en el tiempo; y la lógica de
simulación solo se concentra en observar esos puntos para poder representar la situación
modelada.

:"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

Con esta estrategia se identifican y planifican los puntos donde cambia el estado del
sistema, para así poder saltar el reloj a través de esos puntos en el tiempo, ejecutando
acciones que reflejan el cambios del sistema en dichos puntos.

En la simulación basada en eventos discretos se propone un esquema de trabajo.

Para explicar esa forma de trabajo se definen a continuación algunos términos.

123'4*%56,+#+78"'*,'965:#".6;,'$"&"<"'*,'=)*,-+&'>6&.%*-+&'
Según (Banks Jerry, 2005):

• Sistema: Colección de entidades (ejemplo: personas y máquinas) que interactúan en

el tiempo para cumplir un objetivo.

• Modelo: Una representación abstracta del sistema, que suele contener elementos,
relaciones, estructura, que describen el sistema en función de sus atributos, eventos,
actividades, etc.

• Entidad: Cualquier objeto o componente que requiere una representación explícita

en el modelo.

• Atributos: Propiedades de las entidades.

• Actividad: Cualquier cosa que consuma tiempo y recursos. Una actividad consume
tiempo, el cual se sabe cuando comienza (ejemplo: el servicio de un cliente en un
cajero).

• Retardo: Una duración de tiempo de largo no definido, el cual se sabe hasta que se
termina (ejemplo: el tiempo de espera por un cliente en un banco en la línea).

Según (Law, 2007)

• Estado del sistema: Conjunto de variables necesarias para describir el sistema en un

tiempo determinado.

• Reloj de simulación: Una variable que contiene el valor actual del tiempo de
simulación.

• Lista de eventos: Una lista que contiene los eventos a ocurrir en el futuro y su tipo.

• Indicadores estadísticos: Conjunto de variables necesarias para almacenar la

información estadística del sistema.

• Rutina de inicialización: Un subprograma que inicializa el reloj de simulación y

genera los primeros eventos en la lista de eventos.

• Rutina del tiempo: Una rutina que determina el próximo evento a ocurrir, adelanta
el Reloj de Simulación, y procesa el evento próximo.

;"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

• Rutina de eventos: Es una rutina que actualiza el estado del sistema según el tipo de
evento, esta rutina puede crear nuevos eventos y planificarlos.

• Rutinas de librerías: Runitas de librerías varias para la simulación, de estas librerías

se resaltarán dos funcionalidades generalmente implementadas como:

o Rutinas para generar números pseudo-aleatorios, o valores de variables

aleatorias usados para modelar el comportamiento del sistema.

o Rutinas para estadísticas y sus cálculos.

o Rutinas varias: En versiones de lenguajes de programación nuevos existen

rutinas para graficar, y generar interfaces, depurar el sistema, etc.

• Generador de reportes: Un subprograma que genera los reportes y/o resultados de

la simulación.

• Programa principal: Un programa que llama a la rutina de inicialización, la rutina

de tiempo, y luego le da el control a la rutina de eventos para iniciar la simulación.

<"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

A continuación se mostrará el esquema general de funcionamiento de una

simulación basada en eventos discretos.

12?'=&@:*5"'<*'-%"$"A+'7*,*%"#'*,'&65:#".6;,'$"&"<"'*,'*)*,-+&'<6&.%*-+&'
La Figura 3 muestra el esquema de trabajo para el manejo del avance del reloj en
una simulación manejada por eventos discretos.

Figura 3: Esquema de Trabajo en Simulación de Eventos Discretos

El esquema consiste en:

1. Llamar a la rutina de inicialización donde:
1.1. Se coloca el reloj del sistema en 0
1.2. Se inicia el estado del sistema
1.3. Se Inicializan los estimadores estadísticos
1.4. Se Inicia la lista de eventos: Colocar los eventos iniciales en la lista
2. Llamar a la rutina del tiempo donde:

="
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

2.1. Se determinar el próximo evento y el instante i en donde se ejecutará

2.2. Se avanza el reloj hasta el instante i
3. Llamar a la rutina de eventos con el evento determinado en el paso 2.1; y de acuerdo a las
consecuencias de ocurrencia de ese tipo de evento:
3.1. Se actualiza el estado del sistema
3.2. Se actualizan estadísticos que se deseen obtener al final de la corrida
3.3. Se generan los futuros eventos consecuencia de la ejecución de este tipo de evento y se colocan en
la lista de eventos
4. Si la simulación no ha terminado de acuerdo a algún criterio (por ejemplo tiempo o número de
transacciones) ir al paso 2 sino:
4.1. Se calcula los indicadores de interés finales
4.2. Se muestran resultados

AD@D>)!.&12+/)*&+)B%-5/)*&)4-%)0%E4(++%)
Supongamos que se presenta una situación del banco con una taquilla con las siguientes
reglas:

• Llegan clientes cada cierto tiempo en forma aleatoria.

• Existe una sola taquilla. Si la taquilla está ocupada, el cliente se encola y cuando la
taquilla se desocupa se atiende al próximo cliente en orden de llegada) se atiende.

• Cada cliente al ser atendido consume un tiempo aleatorio de servicio.

Si vemos el estado del sistema como el número de clientes en un instante determinado en

el banco, existen dos situaciones que modifican esta variable: en primer lugar cada vez que
llega un cliente esta variable se incrementa en una unidad, y en segundo lugar cada vez que
un cliente se termina la atención de un cliente esta variable se decrementa en una unidad.
Por ello, si intentamos implementar el sistema del banco con eventos discretos es necesario
definir dos eventos: LLEGADA, SALIDA, y el proceso de la rutina de eventos para cada
tipo de evento es el siguiente:

Cuando llega un evento del tipo LLEGADA, su rutina consistirá en:

1. Incrementar en una unidad el número de clientes en el sistema
2. Planificar el próximo evento LLEGADA donde se genera un tiempo aleatorio para que llegue el próximo
cliente y se agrega a la lista de eventos un evento del tipo LLEGADA con el instante que corresponda.
3. Si la taquilla está libre ir a 4 sino ir a 5
4. Ejecutar la rutina de cuando esta vacía la cola ENTRAR con el cliente que llega y salgo de la rutina del
tipo LLEGADA
5. Agregar el cliente a la cola

Cuando llega un evento del tipo SALIDA, su rutina consistirá en:

1. Disminuir en una unidad el número de clientes en el sistema
2. Si la cola está vacía ir 3 sino ir a 4

>"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

3. Colocar la taquilla en estado libre y salir de la rutina del tipo SALIDA

4. Ejecutar la rutina de cuando hay clientes en la cola donde:
4.1. Se saca a el próximo cliente de la cola
4.2. Se llama a la rutina ENTRAR del cliente sacado

La rutina ENTRAR
1. Colocar la taquilla en estado ocupado
2. Programar el evento SALIDA generando un tiempo aleatorio de ocupación y agregar a la lista de eventos
un evento del tipo SALIDA con el instante que corresponda salir a ese cliente en la taquilla

9A82G0'"(80">/$*'"+2G0828$%/('"8$"&)>L"
=begin
Rutina del banco por eventos discretos
Se tienen dos tipos de eventos LLEGADA, SALIDA
2009/07/08
=end

#variables de la simulacion
@reloj = 0
@lista_eventos = []

#variables del modelo

@cola = []
@taquilla_ocupada = false
@clientes_en_el_sistema = 0
@id_cliente_actual= 0

# rutinas de simulacion
def principal
rutina_inicializacion
while !termina_simulacion?
rutina_tiempo
rutina_eventos
end
calcular_estadisticos
mostrar_resultados
end

def rutina_inicializacion
@reloj = 0
primer_evento = { :tipo => 'LLEGADA', :tiempo=> 0, :id => (@id_cliente_actual+=1) } #crea evento
@lista_eventos << primer_evento #agrega el 1er evento
end

def termina_simulacion?
@reloj > 60 || @lista_eventos.size==0 #condicion de fin
end

def rutina_tiempo
@lista_eventos = @lista_eventos.sort_by{|x| x[:tiempo]} #ordena por el tiempo
@reloj = @lista_eventos.first[:tiempo] #adelanta el reloj al proximo
end

def rutina_eventos
@proximo_evento = @lista_eventos.first #toma el primer evento
@lista_eventos.delete_at(0) #elimina el evento de la lista
if @proximo_evento[:tipo] == 'LLEGADA'
rutina_llegada
elsif @proximo_evento[:tipo] == 'SALIDA'
rutina_salida
end
end

?"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

def calcular_estadisticos
puts "calculando"
end

def mostrar_resultados
puts "fin"
end

#rutinas de cada tipo de evento

def rutina_llegada
puts "#{@reloj}: Llega cliente C-#{@proximo_evento[:id]}"
@clientes_en_el_sistema += 1
if @taquilla_ocupada
@cola << @id_cliente_actual
else
@taquilla_ocupada = true
entrar(@id_cliente_actual)
end

#creando nueva llegada

tiempo = tiempo_aleatorio_entre_llegadas
proxima_llegada = { :tipo => 'LLEGADA', :tiempo=> @reloj+tiempo, :id => (@id_cliente_actual+=1) }
@lista_eventos << proxima_llegada
end

def rutina_salida
puts "#{@reloj}: Sale cliente C-#{@proximo_evento[:id]}"
@clientes_en_el_sistema -= 1
if @cola.size > 0
#sacando el proximo cliente
prox_cliente = @cola.first
@cola.delete_at(0)
entrar(prox_cliente)
else
@taquilla_ocupada = false
end
end

def entrar(cte)
#programando la salida
tiempo = tiempo_aleatorio_servicio
evento_salida = { :tipo => 'SALIDA', :tiempo=> @reloj+tiempo, :id => cte }
@lista_eventos << evento_salida
end

def tiempo_aleatorio_entre_llegadas
rand(5)+1 #aleatorio uniforme 1 a 6
end

def tiempo_aleatorio_servicio
rand(3)+1 #aleatorio uniforme 1 a 4
end

#programa principal
principal

@"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

F) !-G/E4&") *&) 7&"%$$/++/) &-) 3(14+%5(6-) :%"%*%) &-) &C&-#/")

7("5$&#/")
Para implementar un simulador basado en eventos discretos existen distintos
enfoques o niveles de abstracción.

B23'965:#".6;,'$"&"<"'*,'!#",6C6.".6;,'<*'=)*,-+&'
Este es el esquema más simple o de bajo nivel de la Simulación Basada en Eventos,
consiste en planificar los eventos que se presentan o pueden presentarse en el sistema. Las
características de este enfoque son:

1. Describir los eventos que cambian el estado del sistema

2. Prever y ordenar los cambios futuros a través de una lista de eventos futuros.

El enfoque de esta simulación es considerado de bajo nivel ya que se deben describir

los eventos y manejarlos a través del tiempo. En una simulación que involucre muchas
entidades interactuando entre sí, el número de eventos puede ser muy grande.

Un ejemplo de herramientas para implementar Simulación basada en planificación de

eventos es CSIM1.

A continuación se mostrarán los enfoques de alto nivel también llamados worldviews en

este contexto.

B21'965:#".6;,'D"&"<"'*,'!%+.*&+&'
La simulación basada en planificación de eventos requiere que el usuario maneje los
conceptos de eventos y el esquema del tiempo muy bien, de hecho, el desarrollador debe
estar conciente de cada uno de los eventos que existen en la situación que quiere
representar.

Hoy en día, los programadores están más enfocados en el sistema y la interacción

entre las entidades que en los eventos; la programación orientada a objetos que proveen los
lenguajes de programación de la actualidad y la tendencia de este enfoque orientado a
objetos en la resolución de problemas computacionales estimula a poder simular en un
nivel de abstracción donde el programador defina a alto nivel las entidades y su interacción.

Un Proceso es el ciclo de vida de una entidad y consiste en un conjunto de eventos,

actividades y retardos que incluyen demanda sobre los recursos del sistema.

1
CSIM: Librería de Simulación basada en eventos discretos. Sitio oficial
http://sourceforge.net/projects/csim/

8A"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

Figura 4: Ejemplo de un proceso

En la Figura 4, se muestra un ejemplo de un cliente en una línea de espera donde se

le brinda un servicio.

La simulación basada en procesos o llamada también de interacción de procesos

abstrae los eventos en la simulación de eventos discretos y permite concentrarse en los
procesos y su interacción. Los aspectos a tomar en cuenta en este enfoque son:

1. La interacción de las entidades en el sistema.

2. La identificación de cada proceso y las actividades que definen su ciclo de vida en

el sistema.

3. No existen explícitamente los eventos.

A su vez bajo este enfoque se han hecho herramientas de uso específico y de alto
nivel que permiten definir los procesos gráficamente o de forma esquemática, tal es el caso
de WebGPSS2, y por otro lado se tienen herramientas como librerías de simulación o
lenguajes de simulación en el cual se pueden definir procesos, y modelar los retrasos y
actividades tal es el caso de SimPy3 y MODSIM4.

9A82G0'"(80">/$*'"*'$"8$C'@)8">/7/('"8$"G&'*87'7")7/$('"1+2EL"
#-------------------------------------------------------------------------------
# Nombre: banco.py
# Escenario: Rutina del banco en enfoque de interaccion de procesos
#!/usr/bin/env python
from random import *
from SimPy.Simulation import *

servidor = Resource(capacity=1)
id_cliente_actual= 0

2
WEBGPSS: Sistema de simulación versión Web de GPSS. Sitio oficial
http://www.webgpss.com/
3
SimPy: Librería de Simulación basada en Python. Sitio oficial
http://simpy.sourceforge.net/
4
MODSIM: Lenguaje de Simulación.

88"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

class Cliente(Process):
def entrar(self):
print"%i: Llega cliente %s"%(now(),self.name)
yield request,self,servidor
yield hold,self,tiempo_aleatorio_servicio()
yield release,self,servidor
print"%i: Sale cliente %s"%(now(),self.name)

class GeneradorCliente(Process):
def generar(self):
global id_cliente_actual
while True:
c = Cliente(name=("C-%i"%id_cliente_actual))
id_cliente_actual += 1
activate(c,c.entrar())
yield hold,self,tiempo_aleatorio_entre_llegadas()

def tiempo_aleatorio_entre_llegadas():
return randint(1,6) #aleatorio uniforme 1 a 6

def tiempo_aleatorio_servicio():
return randint(1,4) #aleatorio uniforme 1 a 4

def principal():
initialize()
g = GeneradorCliente()
activate(g,g.generar())
simulate(until=60)

principal()

B2B'965:#".6;,'D"&"<"'*,'#"'*EF#+%".6;,'<*'".-6)6<"<*&'
La simulación basada en la exploración de actividades (Udo W. Pooch, 1993)
consiste en ver cómo las entidades se relacionan para llevar a cabo una actividad, pero el
enfoque está en las actividades que hay que realizar mas no en el ciclo de vida de la
entidad.

En este enfoque el reloj del sistema se va cambiando en pequeños incrementos del

tiempo, el inicio de un actividad se ejecuta si existen todos los recursos y condiciones para
comenzar; el algoritmo general evalúa si comienza o termina una actividad en cada
quantum de tiempo.

Este enfoque puede ser mejor cuando se tienen eventos auto-programados y

predecibles ya que ejecuta las acciones cuando existen las condiciones necesarias para
llevarlas a cabo. El enfoque basado en procesos es poco eficiente si se tienen muchos
eventos auto-programados y predecibles, ya que se deben agregar estos eventos a la lista de
eventos ocupando así mucho espacio, en la simulación basada en actividades por el
contrario lo que se almacena es la condición para iniciar una actividad.

En este enfoque se toman los siguientes aspectos:

1. Incrementar el tiempo en intervalos de tiempo fijos

2. Verifica si existe una actividad a ejecutar dadas las condiciones para iniciarla

89"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

Figura 5: Enfoque de exploración de actividades

En la Figura 5 se muestra el enfoque con incrementos fijos del tiempo y exploración

de las condiciones a ver si se inicia una actividad o no.

A continuación se mostrará un ejemplo de este enfoque tomado de (Tyszer, 1999)

FDFD>)!.&12+/H)I$/:+&1%)*&+)B%-5/)5/-)&J2+/$%5(6-)*&)%5#(C(*%*&")
Se identifican 3 eventos:

1. LLEGADA_DE_UN_CLIENTE: Cuando llega un cliente.

2. INICIO_DE_SERVICIO: Inicio del servicio por la taquilla

3. SERVICIO_COMPLETADO: Cuando se termina el servicio

Los primeros 2 eventos son eventos relacionados con el tiempo, mientras que el último
es un evento de estado.

También se tendrán 2 atributos para cada entidad cliente: TIEMPO_LLEGADA y

TIEMPO_SALIDA que son las cantidades de tiempo que faltan para la próxima llegada /
salida respectivamente, y que se van disminuyendo a medida que avanza el reloj.

El Algoritmo quedaría de la siguiente forma:

Programa Principal
1. Inicializar los eventos y otras variables
2. Si expira el reloj de simulación, entonces terminar la simulación
3. Si TIEMPO_LLEGADA=0, invocar a la rutina LLEGADA
4. Si TIEMPO_SALIDA=0, invocar a la rutina SALIDA
5. Si hay al menos un cliente en la cola y la taquilla está ociosa invocar a la rutina SERVICIO
6. Actualizar el reloj del sistema e ir al paso 2

Rutina LLEGADA
1. Colocar al cliente al final de la cola

2. Generar el próximo arribo y colocarlo en TIEMPO_LLEGADA

8:"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

Rutina SALIDA
1. Colocar la taquilla en modo ocioso

Rutina de SERVICIO
2. Sacar el primer cliente de la cola

3. Colocar la taquilla en estado ocupado

4. Generar el tiempo de Servicio y colocarlo en la variable TIEMPO_SALIDA

En general este enfoque explora todas las actividades posibles y las llama a medida que
estén las condiciones dadas para iniciar o terminar una actividad.

Este enfoque puede ser complejo cuando existen muchas entidades interactuando. Por
otro lado, este enfoque incrementa el tiempo en pequeños quantum y revisa si existe una
actividad por realizar lo cual puede ser ineficiente en instantes donde no se inicia ninguna
actividad.

9A82G0'"(80"6/$*'"*'$"8FG0'&/*+,$"(8"/*%+:+(/(87"8$"M)>L"
=begin
Rutina del banco por exploracion de actividades
Se tienen dos tipos de eventos LLEGADA, SALIDA
2009/07/08
=end

#variables de la simulacion
@reloj = 0

#variables del modelo

@cola = []
@taquilla_ocupada = false
@id_cliente_actual= 0
@tiempo_llegada = 1000000
@tiempo_salida = 1000000

# rutinas de simulacion
def principal
rutina_inicializacion
while !termina_simulacion?
rutina_tiempo
rutina_exploracion_actividades
end
calcular_estadisticos
mostrar_resultados
end

def rutina_inicializacion
@reloj = 0
@tiempo_llegada = 1 #generar la proxima llegada en el proximo decremento
end

def termina_simulacion?
@reloj > 60 #condicion de fin
end

def rutina_tiempo
@reloj += 1 #se incrementa fijo
@tiempo_llegada -= 1
@tiempo_salida -= 1

8;"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

end

def rutina_exploracion_actividades
if @tiempo_llegada == 0 #llegada
rutina_llegada
end
if @tiempo_salida == 0 #salida
rutina_salida
end
if @cola.size>0 && !@taquilla_ocupada #servicio
rutina_servicio
end
end

def calcular_estadisticos
puts "calculando"
end

def mostrar_resultados
puts "fin"
end

def rutina_llegada
puts "#{@reloj}: Llega cliente C-#{@id_cliente_actual}"
@cola << @id_cliente_actual
@id_cliente_actual += 1
#creando nueva llegada
tiempo = tiempo_aleatorio_entre_llegadas
@tiempo_llegada = tiempo
end

def rutina_salida
puts "#{@reloj}: Sale cliente"
@taquilla_ocupada = false
end

def rutina_servicio
#programando la salida
cliente = @cola.first
@cola.delete_at(0)
tiempo = tiempo_aleatorio_servicio
@tiempo_salida = tiempo
end

def tiempo_aleatorio_entre_llegadas
rand(5)+1 #aleatorio uniforme 1 a 6
end

def tiempo_aleatorio_servicio
rand(3)+1 #aleatorio uniforme 1 a 4
end

#programa principal
principal

FDFD@)!J2+/$%5(6-)*&)%5#(C(*%*&")&-)#$&")G%"&")
Una de las mejoras para evitar avanzar el reloj a instantes de tiempo en los cuales no se
inicia ninguna actividad, es mezclar la lógica del enfoque de interacción de procesos en el
cual se avanza el reloj a los instantes donde se necesita cambiar el estado del sistema, con la
inicio de actividades por condición.

En la exploración de actividades en tres fases se toman en cuenta los siguientes aspectos

(Banks Jerry, 2005):

8<"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

1. Los eventos se consideran actividades de duración 0 (cero)

2. Existen dos tipos de actividades:

a. Las actividades B: todos los eventos y actividades que se ejecutan sin

condición alguna.

b. Las actividades C: son actividades que se inician bajo alguna condición.

3. Las actividades B se planifican en una lista de eventos igual que en la simulación

basada en eventos. Estas actividades avanzan el reloj hasta la próxima actividad tipo B.
(El reloj no se incrementará en tiempos fijos)

4. Todas las actividades C son evaluadas cada vez que se avanza el reloj por una actividad
tipo B y se inician al presentarse su condición de activación.

El algoritmo de tres fases de este enfoque es:

• Fase 1: Buscar el próximo evento en la lista de eventos (Actividad B) y avanzar el

reloj hasta ese instante.

• Fase 2: Ejecutar todas las actividades tipo B que correspondan con ese instante y
modificar el estado del sistema.

• Fase 3: Explorar todas las condiciones de actividades tipo C que puedan activarse e
iniciarlas si es el caso.

El algoritmo de tres fases permite combinar los beneficios de planificar eventos y saltar
a instantes cuando se necesita cambiar el estado del sistema, y por otro lado, mantener la
lógica de inicio de actividades dada una condición.

Uno de los lenguajes para usar este en enfoque es STROBOSCOPE5, usado para la
simulación de sistemas de construcción.

5
STROBOSCOPE: Lenguaje de Simulación basado en exploración de actividades de tres
fases. Sitio oficial: http://www.cem.umich.edu/Ioannou/StrobWeb/index.html

8="
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

K);/-5+4"(/-&")
En esta investigacíon se mostraron los enfoques de simulación basada en eventos
discretos, donde se explica como la simulación puede ser llevada a cabo procesando sólo
los instantes donde el sistema cambia de estado.

Además, los distintos enfoques permiten ver niveles de abstracción y estrategias

para implementar un modelo en un contexto dado. Hoy en día la simulación orientada a
procesos parece una buena opción para desarrolladores que se centran más en las entidades
que en las actividades, mientras que por otro lado en un problema donde las actividades son
más fáciles de identificar que las entidades, parece más adecuado usar el enfoque de
exploracíon de actividades.

El enfoque de exploración de actividades en tres fases parece tomar las buenas

características de los 2 enfoques de alto nivel (procesos y actividades), sin embargo sería
conveniente estudiar usando métricas de software para evaluar cada una de las técnicas.

8>"
#$%&'"()"*'%+&%),!&'"()-".&/)0$"()-"1!)23$")/"4!25-&6!7/"

B(:+(/'$%GL%)
Banks J. Discrete event system simulation. Prentice Hall. 2005.

Law A. Simulation modeling & analysis. Mc Graw Hill. 2007.

Martínez J. State and resource based simulation of construction processes. Phd. Thesis.
University of Michigan. 1996.

Tyszer J. Object-oriented computer simulation of discrete-event systems. Kluwer Academic

Plenum Publishers. 1999.

Pooch J. Discrete event simulation: a practical approach. CRC Press. 1993.

8?"