Universidad Politécnica de Valencia

Universidad Politécnica de Valencia
Departamento de Informática de Sistemas y Computadores
TESIS DOCTORAL
Técnicas para el aprovechamiento
de redes de computadores heterogéneos
en la ejecución paralela
de modelos de simulación por eventos discretos
Presentada por:
D. Ángel F. Perles Ivars
Dirigida por:
Dr. D. Juan José Serrano Martín
Valencia, julio de 2003
A la meua família
A la meua dona Alícia,
per donar-me força en els pitjors moments
i estar ahí quan l’he necessitada.
Als meus fills Ana, Jorge, Miguel Ángel i Pablo,
que han donat un sentit nou a la meua vida,
fent-me entendre què és el primer
i vore les coses d’altra manera.
Als meus pares,
que m’han proporcionat el camí que m’ha portat fins ací.
Als pares d’Alícia,
perqué m’han fet sentir com un fill.
A Juanjo,
que m’ha donat aquesta oportunitat,
un treball apassionant.
A Maria Pilar,
que m’ha ajudat tant amb l’anglés.
Als companys,
que han fet més agradable el meu treball,
Alberto, Manolo, María Engracia, Miquel, Toni i Ximo.
A José Carlos, Toni, Xavi i Rafa,
que han revisat la meua feina
i m’han permés millorar el text final de la tesi amb els seus consells.
Resumen
La simulación por eventos discretos es una herramienta fundamental para el diseño y desarrollo de todo tipo de sistemas informáticos. Sin embargo, los nuevos sistemas son cada vez más complejos, lo que provoca que los modelos de simulación
resultantes sean más costosos de resolver, requiriendo más potencia de computación
para su evaluación y provocando largos tiempos de espera de los resultados.
Esta tesis ofrece una solución para disminuir los tiempos de ejecución de modelos
de simulación por eventos discretos en los que se pretenda hacer una estimación
puntual de una variable estadística de salida del modelo en régimen permanente.
Se aportan las técnicas que permiten aplicar el paralelismo a los modelos de simulación mediante la ejecución concurrente de réplicas de dichos modelos. Para la
ejecución de las réplicas se aprovecha la gran cantidad de computadores heterogéneos de Universidades y centros de investigación que están desocupados gran parte
del tiempo.
Se ha desarrollado el entorno paralelo capaz de gestionar este conjunto de computadores heterogéneos y se han diseñado y probado las técnicas que permiten adaptar fácilmente un modelo escrito en cualquier lenguaje de simulación para que pueda
emplearse en el entorno.
Para el análisis de los datos de salida de las simulaciones se ha diseñado un nuevo
analizador paralelo basado en el método estadístico de las réplicas independientes. El
diseño de la gestión de las réplicas permite sacar el máximo partido a los computadores, reduciendo considerablemente el tiempo de ejecución de los modelos.
Para aumentar la calidad estadística de los datos de salida se han propuesto y probado nuevos criterios de parada, que producen coberturas estadísticas superiores a
los criterios clásicos. Además, el desarrollo de un método de reducción del efecto del
transitorio inicial de las simulaciones de régimen permanente permite incrementar
más esta calidad sin incrementar el coste de la simulación.
Resum
La simulació per events discrets és una eina fonamental per al disseny i
desenvolupament de tot tipus de sistemes informàtics. Però, els nous sistemes són
cada vegada més complexos, fet que ocasiona que els models siguen més costosos de
resoldre, requerint més potència de computació per tal d’avaluar-los i provocant
llargs temps d’espera pels resultats.
Aquesta tesi ofereix una solució per a disminuir els temps d’execució de models
de simulació per events discrets en els quals es pretenga fer una estimació puntual
d’una variable estadística d’eixida del model en règim permanent.
Aquest treball aporta les tècniques que permeten aplicar paral·lelisme als models
de simulació mitjançant l’execució concurrent de rèpliques dels models. Per a la
execució de les rèpliques s’aprofita la gran quantitat d’ordinadors heterogenis
d’universitats i centres d’investigació que estan lliures gran part del temps.
S’ha desenvolupat l’entorn paral·lel capaç de gestionar aquest conjunt
d’ordinadors heterogenis i s’han dissenyat i provat les tècniques que permeten
adaptar fàcilment un model escrit en qualsevol llenguatge de simulació perquè puga
utilitzar-se dins l’entorn.
Per a l’anàlisi de les dades d’eixida de les simulacions s’ha dissenyat un nou
analitzador paral·lel basat en el mètode estadístic de les rèpliques independents. El
disseny de la gestió de les rèpliques permet traure el màxim profit als ordinadors,
reduint molt el temps d’execució dels models.
Per augmentar la qualitat estadística de les dades d’eixida s’han proposat i provat
nous criteris de parada de la simulació, que produeixen millors cobertures
estadístiques que els criteris clàssics. A més a més, el desenvolupament d’un métode
de reducció de l’efecte del transistori inicial de les simulacions de règim permanent
permet incrementar més aquesta qualitat sense pujar el cost de la simulació.
Abstract
Discrete-event simulation is an important tool for the design and development of
computer based systems. New systems based on computers are complex, so equivalent simulation models are big and they require a lot of computer time for its evaluation, causing long execution time.
This work offers a solution to diminish the execution time of the discrete–event
based models where the pourpose is to get a steady-state point estimator of an output
variable of the model.
In this work we provide methods to apply parallel techniques to simulation models. This is based on the execution of concurrent replications of such models. To run
the replications we benefit of lots of idle computers available at desk and laboratories
of universities and research centers.
A parallel environment has been developed to manage this set of heterogeneous
computers, and the techniques for adapting any simulation program for the environment have been designed and successfully tested.
In order to analyse the output data of the simulations, it has been designed a parallel analizator based on the statistical output analysis method of independent replications. The design of the management of the concurrent replications lets to get the
maximum benefit of computers, reducing considerably the execution time of the
models.
To increase the statistical quality of the output analysis method they have been
proposed and tested new stopping criteria. These criteria produce better coverage
results than the classical ones. Moreover, the design of a new method to reduce initial transient’s effect of the steady-state simulations lets to increase the statistical
quality of the parallel analizator without increasing the execution cost.
Índice
1. Introducción ............................................................................................................1
1.1 Motivación .........................................................................................................1
1.2 Objetivos ............................................................................................................5
1.3 Organización de la tesis .....................................................................................5
2. Estudio de las técnicas de aceleración de simulaciones por eventos discretos ..7
2.1 Bases de la simulación por eventos discretos ....................................................7
2.1.1 Qué es la simulación por eventos discretos................................................8
2.1.2 La entrada del modelo: números aleatorios..............................................11
2.1.3 La salida del modelo: variables aleatorias................................................15
2.1.4 Intervalos de confianza.............................................................................17
2.1.5 El efecto de la normalidad........................................................................19
2.1.6 Métodos para el análisis de la salida en régimen permanente..................19
2.1.6.1 El problema del arranque (warm-up)................................................20
2.1.6.2 Réplicas ............................................................................................22
2.1.6.3 Lotes (batch-means)..........................................................................27
2.1.6.4 Regeneración ....................................................................................29
2.1.6.5 Autorregresión ..................................................................................30
2.1.6.6 Espectral ...........................................................................................31
2.1.6.7 Series temporales estandarizadas......................................................33
2.1.7 Comentarios a los métodos de análisis de la salida..................................34
2.2 Técnicas de reducción de la varianza para acelerar simulaciones ...................36
2.2.1 Números aleatorios comunes....................................................................37
2.2.2 Variables antitéticas .................................................................................40
2.3 Técnicas paralelas para acelerar simulaciones .................................................41
2.3.1 Introducción..............................................................................................41
2.3.2 Descomposición de modelos de simulación.............................................43
2.3.2.1 Entornos disponibles.........................................................................49
2.3.2.2 Crítica a la simulación paralela por eventos .....................................50
2.3.3 Réplicas paralelas de modelos de simulación ..........................................54
2.3.3.1 Réplicas independientes terminantes................................................55
2.3.3.2 Réplicas independientes en régimen permanente .............................55
xiv
2.3.3.3 Regeneración ....................................................................................61
2.3.3.4 Lotes (batch-means) .........................................................................61
2.3.3.5 Espectral ........................................................................................... 61
2.3.3.6 Entornos disponibles ........................................................................62
2.3.3.7 Crítica a los métodos basados en réplicas paralelas .........................64
2.4 Conclusiones....................................................................................................66
3. Propuesta de un entorno paralelo para la ejecución de simulaciones .............71
3.1 Introducción .....................................................................................................72
3.2 Criterios de diseño del entorno paralelo de simulación...................................73
3.3 Elección de PVM como entorno de programación distribuida........................76
3.4 Propuesta de entorno de simulación paralela basada en réplicas..................... 82
3.4.1 Esquema de CSX......................................................................................83
3.4.2 Planteamiento de la interacción entre procesos distribuidos mediante
mensajes ............................................................................................................ 85
3.4.3 Instrumentación de los programas de simulación ....................................87
3.4.3.1 Resultados de las pruebas de sobrecarga de los modelos instrumentados..............................................................................................................92
3.4.4 Reparto de la carga...................................................................................95
3.4.4.1 Medida del potencial de simulación de una máquina.......................96
3.4.4.2 Medida de la velocidad de simulación de un modelo ......................97
3.4.4.3 Consideraciones sobre el efecto de los canales aleatorios..............100
3.4.5 La interfaz de usuario.............................................................................101
3.4.5.1 Prototipo de interfaz visual para Windows ....................................102
3.5 Introducción a la instrumentación de modelos SMPL y CSIM ..................... 110
3.5.1 Funciones comunes de instrumentación................................................. 110
3.5.2 Instrumentación específica para SMPL .................................................113
3.5.3 Instrumentación específica para CSIM ..................................................114
3.5.4 Ejemplo de modelo CSIM......................................................................114
3.6 Ejemplos de modelos instrumentados............................................................115
3.6.1 Modelo SMPL de una red Ethernet........................................................115
3.6.2 Plan factorial 23 equilibrado aplicado a un modelo SMPL de servidor
central..............................................................................................................117
3.6.3 Modelo CSIM de una cola M/M/3//k.....................................................125
3.6.4 Modelo CSIM de un servidor central mixto ..........................................127
3.7 Conclusiones..................................................................................................132
4. Desarrollo de un analizador paralelo basado en réplicas independientes.....135
4.1 Criterio de selección del método y propuesta básica de funcionamiento ......136
4.2 Propuesta de algoritmos para gestionar la ejecución de las réplicas independientes ..................................................................................................................137
4.3 Criterios de parada. Propuestas y su análisis .................................................144
4.3.1 Criterio 1: Comprobación de la precisión relativa del intervalo de confianza ...............................................................................................................145
4.3.2 Criterio 2: Comprobación del error relativo y su decrecimiento ........... 145
4.3.3 Criterio 3: Comprobación del error relativo y la pendiente de la media 146
4.3.4 Criterio 4: Combinación de los criterios 2 y 3 ....................................... 147
Índice
xv
4.3.5 Evaluación de los criterios .....................................................................148
4.3.5.1 Metodología....................................................................................148
4.3.5.2 Modelos con solución analítica ......................................................151
4.3.5.3 Resultados de cobertura y rendimiento en el modelo M/M/1 ........157
4.3.5.4 Resultados de cobertura y rendimiento en el modelo del servidor
central abierto .............................................................................................162
4.3.5.5 Resultados de cobertura y rendimiento en el modelo M/M/3//K ...166
4.3.5.6 Resultados de cobertura y rendimiento en el modelo del servidor
central cerrado ............................................................................................171
4.4 Técnica para la reducción del efecto del transitorio inicial............................178
4.4.1 Implementación ......................................................................................181
4.4.2 Resultados de cobertura y rendimiento ..................................................185
4.5 Técnica para el ajuste automático del punto de comprobación basado en tiempo simulado ..........................................................................................................190
4.6 Conclusiones ..................................................................................................191
5. Experimentos aplicando CSX a un modelo de red de almacenamiento ........197
5.1 El modelo de simulación SAN.......................................................................198
5.2 Estrategias de simulación...............................................................................200
5.2.1 Método A: ejecución secuencial.............................................................200
5.2.2 Método B: ejecución paralela.................................................................201
5.2.3 Método C: ejecución paralela ajustando el número de réplicas independientes..............................................................................................................202
5.2.4 Método D: ejecución paralela ajustando el número de réplicas y reduciendo el efecto del transitorio inicial .............................................................203
5.3 Resultados experimentales .............................................................................204
5.3.1 Método A: ejecución secuencial.............................................................205
5.3.2 Método B: ejecución paralela.................................................................205
5.3.3 Método C: ejecución paralela ajustando el número de réplicas independientes..............................................................................................................207
5.3.4 Método D: ejecución paralela ajustando el número de réplicas y reduciendo el efecto del transitorio inicial .............................................................209
5.4 Conclusiones ..................................................................................................211
6. Conclusiones ........................................................................................................213
6.1 Conclusiones generales y contribuciones.......................................................213
6.2 Publicaciones..................................................................................................216
6.2 Líneas de investigación abiertas.....................................................................217
Bibliografía ..............................................................................................................221
1. Introducción
1
Introducción
1.1 Motivación
Nadie discute hoy en día que la simulación es una herramienta fundamental en el
desarrollo de nuevos sistemas y en la sintonización y mejora de los existentes. Desde
el punto de vista de este trabajo, se entiende como simulación la explotación de un
modelo de un sistema real o ficticio construido como un programa que deberá ser
“ejecutado” en un computador.
Dado un problema a resolver, es necesario obtener un modelo de éste para poder
realizar la simulación, y así poder estudiar su comportamiento. El desarrollo de este
modelo puede realizarse desde distintos puntos de vista y enfoques matemáticos,
dependiendo mucho de cuáles sean las características a evaluar.
Para el desarrollo del modelo se pueden utilizar distintas aproximaciones que se
resuelven de manera diferente. Por ejemplo, se puede modelar un sistema utilizando
formalismos como redes de Petri, cadenas de Markov, redes de colas, métodos de
Monte-Carlo, elementos finitos, simulación discreta por eventos, sistemas de ecuaciones diferenciales, etc. Cada formalismo “ve” el sistema de forma determinada,
pero distintos formalismos pueden servir para obtener el mismo resultado e incluso
algunos formalismos pueden transformase automáticamente en otros.
Uno de los formalismos para la especificación y resolución de modelos es la simulación por eventos discretos, basada en técnicas numéricas. Un modelo por eventos discreto especifica la respuesta del sistema a determinados eventos que se producen en instantes definidos en el tiempo. La ejecución del modelo consiste en hacer
evolucionar el sistema en el tiempo mediante el procesamiento de los eventos que se
2
Introducción
van produciendo en instantes determinados de tiempo, y que harán que dicho tiempo
evolucione.
Los objetivos de este tipo de modelos pueden ser diferentes, en concreto:
•
Comprender el comportamiento de un sistema.
•
Obtener estimaciones medias de rendimiento.
•
Guiar en la selección de parámetros de diseño y/o estrategias de operación.
•
Ajustar un modelo sencillo de rendimiento a las medidas del sistema.
Los objetivos tienen un impacto en cómo se debe ejecutar la simulación. Por
ejemplo, si el objetivo es comprender el comportamiento del sistema, entonces se
podría desear una salida de presentación agradable y velocidad de simulación controlable con condiciones y parámetros iniciales ajustables. Si la simulación se hace
para hacer estimaciones de variables de salida, entonces se deben proveer intervalos
de confianza de determinada precisión, y la simulación se debe ejecutar tan rápido
como sea posible. En la selección de parámetros, la simulación se puede ver como
parte de un bucle de optimización. La información a ser obtenida por la simulación
puede consistir en estimaciones aleatorias correspondientes a los parámetros dados y
ser usados en algún método de aproximación estocástico, o consistir también de gradientes de estimaciones y ser usados en algoritmos de gradientes estocásticos. Las
propiedades estadísticas han de ser comparadas antes de seleccionar la metodología
apropiada. En el caso del ajuste de un modelo, se necesitará ejecutar una cantidad de
simulaciones con diferentes parámetros y las variables de salida de interés y sus propiedades estadísticas también necesitarán ser investigadas.
Los eventos que ocurren en el sistema modelado pueden tener su origen en una
“traza” tomada de un sistema real o pueden generarse probabilísticamente. En el segundo caso, estamos ante un problema que necesita de herramientas estadísticas para
su análisis, siendo un ingrediente fundamental un buen generador de números pseudoaleatorios para la generación probabilística de los eventos [L’Ecuyer 1999].
Suponiendo que el modelo de simulación por eventos discretos es “alimentado”
con un generador de números aleatorios, la salida de dicho modelo será una respuesta
a la entrada, produciéndose muestras estadísticas de una población desconocida. En
el presente trabajo interesa estimar el valor medio de una muestra E[X] (o esperanza
matemática) de una variable aleatoria de salida del modelo, es decir, hacer lo que se
denomina una estimación puntual. Sin embargo, la única manera de obtener dicha
Motivación
3
esperanza es teniendo una muestra de infinitos valores, lo cual no es posible con un
tiempo limitado de computación. Como máximo se podrá ofrecer una estimación
X de la verdadera esperanza E[X] dentro de un intervalo de confianza, es decir, dentro de un intervalo ( X − H , X + H ) donde hay una determinada probabilidad normalmente alta de que E[X] esté dentro de ese rango.
La estimación de la esperanza y de los intervalos de confianza no es un problema
estadístico totalmente resuelto. Hay diferentes maneras de resolverlo, cada una con
sus ventajas e inconvenientes, pero siempre se tendrá una mayor o menor duda sobre
la validez del resultado (ver [Banks 1996], [Law y Kelton 2000]).
Los modelos de simulación por eventos discretos son ampliamente utilizados en
muchas disciplinas (economía, modelos sociales, control de tráfico, electrónica, informática, etc.). Todo aquello que pueda ser representado mediante sucesos que tienen lugar en instantes concretos en el tiempo puede ser modelado utilizando esta
técnica. Un área donde se aplica con profusión es el diseño y evaluación de sistemas
hardware y software, por lo que es y será una herramienta imprescindible en la investigación que se realiza en el Departamento de Informática de Sistemas y Computadores (DISCA) de la Universidad Politécnica de Valencia.
En el DISCA, el grupo de investigación de Sistemas Tolerantes a Fallos está aplicando esta técnica de modelado al diseño y evaluación de redes de área local industriales, sistemas de tiempo real, etc. Lo mismo ocurre en otros grupos de investigación, con modelos de redes de almacenamiento, redes de comunicación para multimedia, sistemas de almacenamiento en disco, etc.
Como se ha dicho, una vez desarrollado el modelo hay que ejecutarlo, y para ello
se suele recurrir a un computador, que invertirá un tiempo en su resolución. La resolución consistirá en generar una determinada cantidad de muestras que serán tratadas
estadísticamente, por lo que cuanto más complejo y detallado sea el modelo más
tiempo de computación será necesario invertir para generar suficientes muestras.
La complejidad y detalle de los modelos de simulación que se desarrollan en los
grupos de investigación del Departamento obligan al uso de potentes computadores
para su resolución en un tiempo relativamente razonable. Los investigadores suelen
competir por la última y más potente máquina para “resolver” su modelo de simulación, quedando rápidamente saturado el recurso y quedando muchas veces en desuso
recursos menos potentes. Cada grupo de investigación resuelve “como puede” el
problema, muchas veces a título individual por parte de cada investigador.
4
Introducción
Queda patente que la simulación discreta por eventos suele requerir gran cantidad
de recursos computacionales, por lo que dicho recurso es de primera importancia en
este contexto.
Por otra parte, en las Universidades y Centros de Investigación hay una gran cantidad de computadores de pequeña y mediana potencia, de arquitecturas y sistemas
operativos diferentes que están desocupados la mayor parte del tiempo. La cuestión
es: ¿se podrían usar esos computadores, de forma sencilla, para acelerar la obtención
de resultados de simulaciones discretas por eventos?.
La mayoría de los computadores de los entornos nombrados están conectados a
redes de bajas o medias prestaciones, por lo que parece factible que cooperen de alguna manera para que se puedan aplicar técnicas de simulación en paralelo para acelerar las simulaciones.
Esta idea no es nueva y el aprovechamiento de este enorme potencial de cálculo
es el objetivo de muchos trabajos de investigación. En la actualidad se está investigando mucho en el campo de las redes de estaciones de trabajo (NOW, network of
workstations) y han aparecido paquetes software que intentan aprovechar el enorme
potencial de cálculo de un conjunto de máquinas para ejecutar de forma sencilla aplicaciones distribuidas. Ejemplos ampliamente establecidos son PVM [Geist et al.
1994] y MPI [MPI 1994].
El propósito de este trabajo es encontrar una forma de acelerar la obtención de resultados de modelos de simulación discretos por eventos de manera que los investigadores puedan acortar los tiempos de respuesta de sus modelos. Las carácteristicas a
conseguir son:
•
Los resultados de las simulaciones deben ofrecer las máximas garantías estadísticas en cuanto a cobertura de las medias.
•
Los modelos se ejecutarán usando técnicas paralelas para poder acelerarlos.
•
La técnica debe ser aplicable a cualquier simulador que se emplee en el grupo
de trabajo.
•
El uso del entorno debe ser sencillo y no exigir una curva de aprendizaje
complicada.
Objetivos
5
1.2 Objetivos
Para alcanzar el propósito descrito en el apartado de motivaciones y ser una contribución al mundo de la simulación discreta por eventos se ha seguido el siguiente
plan de trabajo:
1. Estudio del estado del arte de las técnicas de análisis estadístico de la salida
de modelos de simulación para conocer cuáles presentan mejor comportamiento y/o son más susceptibles de aplicarse en paralelo.
2. Estudio del estado del arte de las distintas opciones disponibles para acelerar
las simulaciones discretas por eventos utilizando técnicas de paralelismo.
3. A partir de las conclusiones obtenidas en los puntos anteriores y las características definidas en el apartado de motivación, plantear la estructura y comportamiento del entorno paralelo para la ejecución de los modelo de simulación.
4. Desarrollar el conjunto mínimo de módulos que permitan comprobar el rendimiento de los aspectos más críticos de la manipulación de los modelos de
simulación.
5. Desarrollo en el entorno de la técnica de análisis de la salida con más opciones de robustez estadística y posibilidades de buen comportamiento en paralelo.
6. Análisis de resultados de cobertura estadística y aceleración sobre una batería
sencilla de modelos de simulación.
7. Comprobación de la superioridad de las técnicas desarrolladas con respecto a
las disponibles sobre un modelo de gran complejidad.
1.3 Organización de la tesis
En el capítulo 2 se introduce la teoría de la simulación por eventos discretos y se
detallan las técnicas estadísticas para el análisis de la salida de los modelos de simulación. También se describen las técnicas que permiten acelerar las simulaciones;
unas basadas en propiedades estadísticas y otras en paralelismo. En las concusiones
del capítulo se explica el camino elegido para el desarrollo de la investigación.
6
Introducción
El capítulo 3 describe las técnicas desarrolladas para obtener un entorno paralelo
eficiente donde ejecutar simulaciones por el método de las réplicas paralelas. El entorno propuesto permite emplear estaciones heterogéneas conectadas mediante una
red de comunicaciones estándar para crear una “máquina virtual de simulación” donde ejecutar los experimentos. Se explica como se hace la adaptación de los modelos
de simulación escritos en cualquier lenguaje de simulación habituales. Esta adaptación es sencilla, por lo que fácil aprovechar la propuesta.
El capítulo 4 describe el desarrollo de un analizador paralelo basado en el método
de las réplicas independientes. Se describe un mecanismo de gestión asíncrona de las
comunicaciones de las réplicas que permite obtener un gran rendimiento a la propuesta. Se describen también nuevos criterios de parada de la simulación y una técnica para la reducción del efecto del transitorio inicial.
El capítulo 5 muestra los resultados de rendimiento sobre un modelo complejo de
red de almacenamiento (SAN). Se proponen distintas estrategias de gestión de las
réplicas paralelas y se comparan con estrategias clásicas secuenciales empleando el
método de análisis de lotes (batch-means).
Finalmente, el capítulo 6 ofrece las conclusiones generales y los caminos futuros
abiertos.
2. Estudio de las técnicas de aceleración de simulaciones por eventos discretos
2
Estudio de las técnicas de
aceleración de simulaciones
por eventos discretos
El modelado de sistemas por eventos discretos y su simulación es un tema amplio
debido a que hay distintas formas de resolución en función de los objetivos del estudio que se pretenda hacer. El propósito de este capítulo es presentar los aspectos básicos de la simulación por eventos discretos en el contexto de este trabajo.
Se presentan también las técnicas más destacables para permitir acelerar la obtención de resultados de las simulaciones. En el apartado 2.2 se presentan aquellas técnicas que se basan en la aplicación de principios estadísticos, mientras que en el
apartado 2.3 se presentan aquellas que emplean diferentes estrategias de paralelismo
usando simultáneamente varios procesadores.
Como conclusión del capítulo, se elige la estrategia a desarrollar para alcanzar el
objetivo básico de la tesis, que es reducir los tiempos de ejecución de los modelos de
simulación por eventos discretos que se desarrollan en el grupo de investigación.
Este capítulo es un extracto de [Perles 1994] y [Perles 1997].
2.1
Bases de la simulación por eventos discretos
Este apartado describe los conceptos básicos de la simulación por eventos discretos, destacando los aspectos relacionados con el análisis estadísticos de las variables de salida de los modelos.
8
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
2.1.1 Qué es la simulación por eventos discretos
Simular consiste en imitar la evolución temporal de la operación de un proceso o
de un sistema real. El comportamiento del sistema y cómo evoluciona se estudia desarrollando un modelo. Este modelo se construye a partir de asunciones sobre el sistema expresadas como relaciones matemáticas, lógicas o simbólicas entre las entidades del sistema. Una vez desarrollado y validado, un modelo se puede usar para investigar una gran cantidad de cuestiones sobre qué ocurriría en un sistema real si se
hiciese esto o aquello, o también se puede utilizar para predecir el rendimiento de
sistemas no desarrollados físicamente durante las etapas de diseño.
En algunos casos, un modelo puede ser lo suficientemente simple como para que
pueda ser resuelto mediante métodos matemáticos, lo que proporciona una solución
denominada analítica. Cuando no sea posible aplicar una solución analítica es necesario recurrir a métodos numéricos que, básicamente, imitan la evolución del estado
del sistema en el tiempo. Para ello es necesario construir un modelo de simulación
que se deberá ejecutar. La ejecución de estos modelos se refiere a intentar imitar situaciones inferidas mediante una historia artificial. Durante la ejecución del modelo
se observa su comportamiento para analizarlo y estimar medidas de rendimiento del
sistema.
Exclusivamente desde el punto de vista del modelado de sistemas, éstos se pueden clasificar en discretos o continuos (ver Figura 2-1). Un sistema continuo es aquel
en el que las variables que representan el estado evolucionan continuamente en el
tiempo. Por ejemplo, la temperatura de un líquido o el caudal de un río (Figura 2-1).
Un sistema discreto es aquel en el que las variables cambian únicamente en puntos discretos en el tiempo. Por ejemplo, las llamadas telefónicas a un servicio de información del estado de carreteras.
(a)
(b)
Figura 2-1. Una función continua (a) y una discreta (b).
Una de las técnicas para la resolución de este tipo de sistemas es la simulación
por eventos discretos basada en técnicas numéricas. En esta aproximación, los sucesos del modelo tienen lugar en puntos discretos del tiempo, y la “ejecución” cada
Bases de la simulación por eventos discretos
9
suceso provoca la evolución del modelo. La Figura 2-2 muestra una representación
temporal de los eventos del sistema.
eventos
0
1
2
3
4
N
2
3,5
6,1
11,8
4.537,1
tiempo simulado
Figura 2-2. Actualización del tiempo simulado guiada por los eventos.
Todo modelo desarrollado para hacer una simulación discreta tiene una estructura
común con independencia de lo que se esté modelando. Entre otras cosas, se tendrá
normalmente:
•
Un planificador de eventos, que contendrá la lista de los eventos esperando a
ocurrir en el futuro y que podrán manipularse de diferentes formas.
•
Un reloj de tiempo simulado y un mecanismo de avance de tiempo. Toda simulación tiene una variable global que representa el tiempo simulado. Para
avanzar el tiempo, una de las aproximaciones, llamada guiada por evento,
consiste en avanzar el tiempo hasta el tiempo de ocurrencia del evento más
cercano en el tiempo.
•
Rutinas de eventos. Cada evento es simulado por la ejecución de un fragmento de código que actualizará el estado del modelo simulado.
Hay dos aproximaciones para realizar la generación de los eventos en el sistema
simulado: se pueden obtener externamente mediante una traza de ejecución del sistema real, dando lugar a una simulación orientada por traza, o probabilísticamente
mediante la generación interna de distribuciones estadísticas producidas a partir de
números aleatorios.
La ventaja de una simulación dirigida mediante una traza es el hecho de que los
sucesos que conducen la entrada del modelo se corresponden con un comportamiento
real, por lo que los resultados que se obtienen de la simulación serán un fiel reflejo
de lo que se obtendría en la realidad. La desventaja está en la dificultad de obtener
trazas de calidad y las necesidades de almacenamiento que puede requerir una traza
moderadamente representativa. Además, puede que el sistema de partida no exista,
por lo que será imposible obtener una traza real.
10
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
La ventaja de dirigir una simulación mediante la generación probabilística de sucesos es la facilidad de esta generación empleando algoritmos matemáticos sencillos,
y la facilidad para probar el efecto de diferentes “cargas” de entrada. La problemática
principal es asegurar que la distribución probabilística de los sucesos sea representativa de las condiciones reales del sistema modelado, pues, normalmente, los resultados serán fieles al comportamiento real si la carga de entrada “sintética” es también
fiel a una carga real. Este método es el más empleado para el desarrollo de sistemas
empleando modelado y simulación, por lo que es el utilizado en este trabajo.
Las entidades que se utilizan para describir y construir la dinámica del sistema
forman tres grupos: actividades, procesos y eventos. Un sistema se ve dinámicamente como una colección de procesos interactuando, con las interacciones controladas y coordinadas por los eventos. Ésta es una forma jerárquica de ver al proceso. Un
sistema se expresa a un nivel dado de abstracción como un conjunto de descripciones
de procesos, cada una especificando las actividades de ese proceso.
Las medidas de rendimiento están relacionadas con la velocidad a la que el sistema realiza el trabajo y, por tanto, tiene al tiempo como una variable independiente.
El trabajo se realiza mediante la ejecución de actividades. Una actividad es la unidad
más pequeña de trabajo desde el punto de vista del sistema. Al ser una unidad de
trabajo, cada actividad tiene un tiempo de ejecución asociado. Un conjunto de actividades relacionadas lógicamente constituyen un proceso.
Los métodos numéricos para la resolución de estos modelos de simulación suelen
requerir la ayuda del computador. Para especificar los modelos se recurre a los lenguajes de simulación, que pueden expresar las anteriores entidades desde distintos
puntos de vista. Así, los lenguajes de simulación se clasifican en orientados a actividad, orientados a eventos y orientados a procesos, basándose en la organización de
los procedimientos escritos en este lenguaje. Un procedimiento de un programa de
simulación puede describir una actividad, un evento o un proceso, dependiendo del
lenguaje que se utilice.
La mayoría de los actuales lenguajes de simulación son orientados a procesos o a
eventos. Los lenguajes orientados a procesos como CSIM [CSIM 1998] se recomiendan para implementar modelos de simulación de gran escala. Los programas
escritos en estos lenguajes se pueden construir como una descripción directa de las
operaciones del sistema. Esta similitud de modelo y sistema permite asegurar con
más facilidad que el modelo seaes una representación válida del sistema.
Bases de la simulación por eventos discretos
11
Los lenguajes de simulación orientados a eventos como SMPL [MacDougall
1987] se acoplan mejor a modelos de pequeña o mediana escala. Estos lenguajes
tienden a imponer una visión global y mononivel del sistema a modelar, propiciando
que se junten acciones de actividades que no tienen relación entre ellas en una única
rutina de eventos. Como consecuencia, el modelo puede perder toda identidad con la
estructura del sistema y hacerse difícil de modificar. Se puede minimizar este problema si se estructura cuidadosamente el modelo, tomando una visión orientada a
procesos del sistema y organizando el modelo de acuerdo a ello.
2.1.2 La entrada del modelo: números aleatorios
Cuando se prescinde del uso de trazas reales, los números aleatorios son el ingrediente fundamental en la simulación por eventos discretos. Así, los lenguajes de simulación generan números aleatorios que se emplean para calcular los tiempos para
los eventos y otras variables aleatorias.
La generación de estos números no es obvia. Paradójicamente, suelen ser adecuados los generadores deterministas, donde se conoce cuál es la secuencia de números
que se va a producir. Ello permitirá comprobar su correcto funcionamiento y aprovechar propiedades estadísticas que permitan resolver el modelo más rápidamente.
Para obtener estos números aleatorios se emplean generadores de números pseudoaleatorios, término que únicamente implica su generación siguiendo un método
recursivo conocido que elimina la verdadera aleatoriedad. Como el método es conocido, el conjunto de números aleatorios podrá ser reproducido. Por contra, cuando se
generan números pseudoaleatorios pueden aparecer serios problemas debidos precisamente a esta falta de verdadera aleatoriedad.
Para comprobar la calidad de un generador de números aleatorios es imprescindible aplicar una serie de pruebas de aleatoriedad que permitan detectar defectos. El
satisfacer estas pruebas no implica que el algoritmo sea adecuado, pero tampoco se
podrá afirmar lo contrario. Muchos de los generadores aleatorios que proveen los
lenguajes de programación pueden ser defectuosos y no cumplir las condiciones de
las pruebas, por lo que es importante recurrir a generadores aleatorios bien diseñados. La importancia de la generación de números aleatorios hace que sea un área de
investigación muy importante y en continuo desarrollo, y que se apliquen y desarrollen nuevas pruebas de aleatoriedad [Knuth 1997, L'Ecuyer and Hellekalek 1998].
12
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
El propósito final del generador será que cada número aleatorio generado Ri, sea
una muestra independiente de una distribución continua uniforme entre 0 y 1, U(0,1).
Normalmente estos números se generan por programa como una parte de la simulación. Hay una gran cantidad de métodos para conseguir esto, y que deberían seguir
las siguientes consideraciones:
• La rutina debe ser rápida. Cálculos individuales pueden ser rápidos, pero una
simulación suele requerir muchos cálculos. Se puede mejorar el coste total de
la simulación empleando un generador aleatorio adecuado.
• La rutina debe ser portable a diferentes computadores y a diferentes lenguajes
de programación.
• La rutina debe tener un ciclo suficientemente largo. La longitud del ciclo o periodo representa la longitud de la secuencia de números aleatorios antes de que
la secuencia previa de números vuelva a repetirse en el mismo orden. La complejidad de los modelos de simulación y la velocidad de los computadores actuales hacen que los generadores con un ciclo corto puedan ser agotados rápidamente.
• Los números aleatorios deben ser reproducibles. Dado un punto de partida (o
condición) debe ser posible generar el mismo conjunto de números aleatorios,
independientemente del sistema que se esté simulando. Por la misma razón,
debe ser fácil especificar diferentes puntos de partida.
• Los números aleatorios generados deben aproximarse lo más posible a las propiedades estadísticas ideales de uniformidad e independencia.
Con las restricciones apuntadas, la mayoría de los generadores usados en la práctica en simulación se fundamentan en recursiones lineales basadas en aritmética modular denominados generadores congruenciales lineales [L'Ecuyer 1990]. Estos generadores producen una secuencia de números enteros, R1, R2, ... entre 0 y m − 1 de
acuerdo con la siguiente relación recursiva,
Ri +1 = (aRi + c) mod m, i = 0, 1, 2, ...
Al valor inicial R0 se le llama semilla, a es la constante multiplicativa y c es el incremento. Si c≠0 se le denomina generador congruencial mixto. Cuando c = 0 se le
conoce por generador congruencial multiplicativo. La elección de los valores para a,
c, m y R0 afecta drásticamente a las propiedades estadísticas y a la longitud del ciclo.
Bases de la simulación por eventos discretos
13
Por ejemplo, el lenguaje de simulación SMPL utiliza un generador congruencial
llamado minimal standard cuya expresión recursiva es,
Ri +1 = 7 5 Ri mod (2 31 − 1)
Como estos generadores producen números enteros entre 0 y m-1, es necesario
convertirlos a la distribución uniforme U(0,1) deseada. Para ello existen diferentes
técnicas, por ejemplo dividir por m o por m + 1 para garantizar que el número generado está en el conjunto [0,1).
En el presente trabajo se ha recurrido a utilizar una familia de generadores más
complejos que, a pesar de su mayor coste computacional, proveen números aleatorios
de mayor calidad que los anteriores. En particular, se ha utilizado una combinación
de dos generadores múltiples recursivos. Un generador múltiple recursivo se define
por la expresión recursiva,
Ri +1 = (a1 Ri + K + a k Ri − k ) mod m
U i +1 = X i +1 / m
donde el módulo m y el orden k son enteros positivos y cada Ri pertenece al conjunto {0, 1, …, m-1}.
Para la realización de los experimentos de este trabajo se ha seleccionado el generador implementado con aritmética flotante denominado MRG32k5a propuesto por
[L'Ecuyer 1999], que emplea la combinación de dos generadores múltiples recursivos
de orden 5, proporcionando un ciclo aproximado de 2319 números. La Figura 2-3 lista
su código en C.
double s10, s11, s12, s13, s14;
double s20, s21, s22, s23, s24;
#define
#define
#define
#define
#define
#define
#define
#define
#define
norm 2.3283163396834613e-10
m1
4294949027.0
m2
4294934327.0
a12
1154721.0
a14
1739991.0
a15n
1108499.0
a21
1776413.0
a23
865203.0
a25n
16410520
double MRG32k5a ()
{
long
k;
double p1, p2;
/* Component 1 */
p1 = a12 * s13 - a15n * s10;
if (p1 > 0.0) p1 -= a14 * m1;
p1 += a14 * s11;
k = p1 / m1;
if (p1 < 0.0) p1 += m1;
p1 -= k * m1;
14
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
s10 = s11;
s11 = s12;
s12 = s13; s13 = s14; s14 = p1;
/* Component 2 */
p2 = a21 * s24 - a25n * s20;
if (p2 > 0.0) p2 -= a23 * m2;
p2 += a23 * s22;
k = p2 / m2;
p2 -= k * m2;
if (p2 < 0.0) p2 += m2;
s20 = s21;
s21 = s22;
s22 = s23; s23 = s24; s24 = p2;
/* Combination */
if (p1 <= p2) return ((p1 - p2 + m1) * norm);
else return ((p1 - p2) * norm);
}
Figura 2-3. Generador MRG32k5a, de orden 5 y 2 componentes.
A partir de la posibilidad de generar números aleatorios de una distribución uniforme entre 0 y 1 se generan las distintas variables aleatorias que precise cada modelo particular, estas variables pueden seguir distintos tipos de distribuciones aleatorias para expresar el comportamiento a representar (como tasas de llegada a una cola,
tiempo de servicio de una petición en un disco, etc). Técnicas adecuadas para esto
son las de la transformada inversa, la convolución y la aceptación-rechazo. Todas
estas técnicas parten de números aleatorios generados uniformemente entre 0 y 1. La
técnica de la transformada inversa es la más directa, pero no siempre la más eficiente
computacionalmente, y suele ser la que emplean la mayoría de los lenguajes de simulación.
Por ejemplo, para una distribución exponencial se tiene que la función de densidad de probabilidad es,
λe − λx ,
f ( x) = 
 0,
x≥0
x<0
y la función de distribución acumulada,
1 − e − λx , x ≥ 0
=
f
(
t
)
dt

∫
x<0
 0,
−∞
x
F ( x) =
donde λ se puede interpretar como el número medio de sucesos por unidad de
tiempo.
Para obtener un valor R, muestra de una distribución exponencial, se partirá de un
valor U de la distribución U(0,1) de manera que se aplique la transformada inversa
X=F-1(U), que en este caso se calcula como,
F ( x) = 1 − e − λx , x ≥ 0
1 − e − λx = U
Bases de la simulación por eventos discretos
R=
−1
λ
15
ln(1 − U )
Las propiedades de la técnica de la transformada inversa hacen que, a pesar de su
mayor coste computacional, haya sido la empleada en este trabajo para generar las
distribuciones aleatorias necesarias en los modelos de simulación empleados.
2.1.3 La salida del modelo: variables aleatorias
En este trabajo, se considera que la entrada de la simulación se dirige generando
muestras obtenidas a partir de distribuciones aleatorias. Como la salida de la simulación será función de estas entradas, los resultados se obtendrán a partir de la aplicación de técnicas estadísticas.
La longitud de la simulación es, en algunos casos, determinada por el problema
en sí. La medida de interés es definida desde el punto de vista del tiempo requerido
para realizar un conjunto específico de actividades o, quizás, en función del número
de actividades necesarias para alcanzar un estado determinado, dando condiciones
iniciales determinadas por el problema. Desde la perspectiva del análisis de la salida,
a este tipo de simulación se le llama simulación de transitorio.
Cuando las condiciones iniciales y la longitud de la simulación son determinados
por el modelador, y la medida de interés es definida en términos de un valor límite
que se obtiene cuando la ejecución tiende a infinito, hablamos de simulaciones de
régimen permanente. Este es el tipo de simulación de interés para el presente trabajo.
En la práctica, la longitud de las simulaciones de régimen permanente es finita y
los resultados son un conjunto de muestras de la distribución de las medias. Uno de
los problemas a resolver es saber lo cerca que están estos valores de las verdaderas
distribuciones de las medias. En estas simulaciones, por definición, los valores de
salida son independientes de las condiciones iniciales.
Como la salida de los modelos de simulación suele ser un problema de análisis
estadístico, hay una serie de medidas estadísticas fundamentales con las que se tratan
dichas salidas, siendo los datos de salida de las simulaciones las muestras de variables aleatorias a tratar.
La mayoría de las veces, la medida de rendimiento que interesa es el valor medio
de una variable aleatoria de salida de la simulación. Esta variable puede representar
un proceso aleatorio de tiempo discreto o de tiempo continuo. Para un proceso de
16
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
tiempo discreto, la simulación produce una secuencia de N muestras X1... XN cuya
media es,
N
X =∑
i =1
Xi
N
(2.1)
Para un proceso de tiempo continuo, la variable de salida X tiene un valor de
muestra Xt en cualquier instante t de tiempo, y la media es,
X=
∫
T
0
X t dt
T
(2.2)
donde T es el período de tiempo simulado. A X se le llama media de la muestra.
Como es una función de variables aleatorias, también es una variable aleatoria. Diferentes secuencias de muestras o períodos de tiempo producen diferentes valores de
X . Sin embargo, cuando el valor de N en las ecuaciones (2.1) o de T en (2.2) se
aproximan a ∞, X converge al valor límite E[X], llamado el valor esperado de X. A
E[X] (o µ) se le considera el valor medio verdadero de la distribución de X.
Los tiempos medios de espera en cola o el tiempo medio de residencia en el sistema son ejemplos de medias de procesos de tiempo discreto. La longitud media de
una cola o la utilización de una facilidad son ejemplos de medias de procesos de
tiempo continuo.
El estimador de la media X se dice que es no sesgado para µ si su valor esperado
es µ. En general se tiene que,
E [X ] = µ + b
donde a b = E [X ] − µ se le denomina sesgo en el estimador puntual X . Lo ideal
será tener estimadores sin sesgo o con un sesgo mínimo en relación con la magnitud
de µ.
Para medir la dispersión de la distribución de X se emplea la varianza. Para un
conjunto de N muestras X1, X2, ..., XN es,
N
s2 = ∑
i =1
(X i − X )2
N −1
Bases de la simulación por eventos discretos
17
donde a s2 se le llama varianza de la muestra. Cuando N se aproxima a ∞, s2 converge al valor límite E[s2]=E[(X-µ)2] (o σ2). Por tanto, X y s2 son la media y la varianza de la muestra, y µ y σ2 son la media y la varianza de la distribución.
2.1.4 Intervalos de confianza
Un problema de las simulaciones de longitud finita es estimar lo cerca que está la
media de la muestra X de la media esperada E[X]; o, también, lo largas que deben
ser las simulaciones para obtener una media de la muestra arbitrariamente cercana a
E[X].
Se puede resolver este problema calculando una medida denominada intervalo de
confianza. Supóngase que se tiene un conjunto de N muestras X1, X2, ... , XN de una
distribución con un valor medio verdadero E[X] desconocido. La media de las
muestras es la expresada por la ecuación (2.1).
Se define 1 − α como la probabilidad de que el valor absoluto de la diferencia
entre la media de la muestra y E[X] sea menor o igual que un valor H. Un intervalo
de confianza para la media se define como,
P[X − H ≤ E [X ] ≤ X + H ] = 1 − α
Al intervalo X − H hasta X + H se le denomina intervalo de confianza, y a 1-α
nivel de significación, cuyos valores típicos son 0,90 ó 0,95. El nivel de significación
1 − α lo proporciona el analista; H se determina por los valores de las muestras, el
número de muestras y el valor de α.
Un intervalo de confianza que contiene el valor esperado E[X] de la distribución
se dice que cubre la media, y a 1 − α se le denomina probabilidad de cobertura nominal o, simplemente, cobertura nominal.
Cuando X1, X2, ... , XN son variables aleatorias independientes de una distribución
normal con media E[X], y la varianza verdadera no se conoce, H se puede calcular
mediante,
H =t
s
α
1− ; N −1
2
N
donde t1−α / 2; N −1 es el α/2 cuartil inferior de la distribución t de Student con N − 1
grados de libertad y s es la desviación típica de la muestra.
18
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
En el caso de que se conozca la varianza se puede aplicar,
H = Zα
2
σ
N
con Z≈Ν(0,1).
La expresión anterior puede aplicarse también para calcular un intervalo de confianza aproximado cuando la población no es normal y la muestra es grande. En el
caso de que σ no sea conocido se puede sustituir por s.
La suposición de normalidad se basa en el teorema central del límite, del cual se
deduce que la media de muestras aleatorias de tamaño N de cualquier distribución
con varianza finita se distribuye normalmente para valores grandes de N.
Esta suposición puede ser problemática en algunas simulaciones. Por ejemplo,
efectos de correlación que pueden falsear los resultados finales. Así, la autocorrelación puede hacer difícil estimar σ 2 ( X ) , dando lugar a 3 posibles efectos:
•
Si las Xi son independientes, la estimación no estará sesgada. Las Xi serán
siempre independientes si se obtienen de simulaciones independientes (ver
método de las réplicas en la sección 2.1.6.2).
•
Si la correlación es principalmente positiva, s2/N está sesgado por debajo como estimador de σ 2 ( X ) . Si se ignorase esta correlación, el intervalo de confianza medido como 100(1-α)% sería demasiado estrecho y su verdadero coeficiente de confianza podría ser menor que 1-α. Si las correlaciones son grandes, podrían dar lugar a una subestimación importante del intervalo de confianza.
•
Si la correlación es principalmente negativa, entonces s2/N está sesgado por
arriba para σ 2 ( X ) . Ello significará que el estimador puntual X debería ser
mayor que lo indicado por su estimador de la varianza, con lo que el intervalo
de confianza calculado tendría menor probabilidad de cometer un error. Este
problema es menos serio que el del caso anterior.
La problemática que implica una correlación positiva es, básicamente, que la estimación de la varianza usando la expresión s2/N puede ser mucho menor que la real,
por lo que es importante utilizar estrategias que lo eviten.
Bases de la simulación por eventos discretos
19
2.1.5 El efecto de la normalidad
El teorema central del límite asegura que la media deN variables aleatorias independientes e idénticamente distribuidas sigue aproximadamente una distribución
normal para valores grandes de N. Las variables de salida de una ejecución individual de una simulación pueden estar idénticamente distribuidas, pero no suelen ser
independientes. Por ello es importante preguntarse cómo la falta de independencia
afecta a esta asunción, cuánto se aproxima N a la normalidad, y cuál es la precisión
alcanzada por los intervalos de confianza.
En cuanto a la primera cuestión, se asume que se cumple la normalidad asintótica
aunque la salida del proceso está correlada, lo cual ha sido demostrado para un cierto
grupo de procesos y para algunos modelos de colas [Law 1983]. En cuanto a la segunda cuestión, los problemas más serios parecen estar en el efecto del calentamiento
inicial en el caso de ejecuciones individuales y en el efecto de la correlación en el
caso de técnicas de lotes (batch-means, etc.). Cuando N es lo suficientemente grande
para solventar esto, también será lo bastante grande como para aportar una normalidad aproximada.
La normalidad de las medias de ejecuciones individuales se puede examinar analíticamente utilizando pruebas como la Shapiro-Wilk o gráficamente. La estimación
de los intervalos para µ basados en la normalidad de la media de la muestra son robustos, es decir, insensibles a moderados desvíos de la normalidad.
2.1.6 Métodos para el análisis de la salida en régimen permanente
En el caso que interesa, la salida de una ejecución del modelo de simulación producirá observaciones X1, X2, …, XN que generalmente son muestras de una serie temporal autocorrelada y cuya medida de rendimiento µ se estima en régimen permanente como,
1
N →∞ N
µ = lim
∑X
i
En el proceso de simulación de régimen permanente hay que preguntarse, tarde o
temprano, cómo debe ser de larga para conseguir una determinada precisión. Es una
cuestión difícil de responder que a menudo se tiende a ignorar. Muchas veces se hacen las simulaciones tan largas como determine la intuición o la paciencia del usua-
20
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
rio, y los valores obtenidos con una sola ejecución son tomados como la verdadera
solución, sin tener en cuenta su precisión.
El propósito de este apartado es revisar las consideraciones y las aproximaciones
para estimar y controlar la precisión de la salida, pues uno o varios de estos métodos
deberán emplearse en este trabajo para realizar el análisis de la salida de los modelos.
Los métodos más extendidos para estimar el intervalo de confianza para la media
de una variable de salida de una simulación son: réplicas, medias batch, regeneración, autorregresión, análisis espectral y series temporales estandarizadas. Los tres
primeros métodos intentan eliminar los efectos de la correlación, mientras que el
cuarto y el quinto intentan estimarla; el último método calcula el intervalo de confianza basándose en propiedades de una transformación de la secuencia de salida de
la simulación.
Las implementaciones para la estimación del intervalo de confianza se pueden
clasificar en procedimientos con tamaño de muestra fija o procedimientos secuenciales. La mayoría de los métodos de análisis se pueden adaptar a cualquiera de los
procedimientos. En un procedimiento de tamaño de muestra fija, se realiza una simulación de longitud total prefijada, y el intervalo de confianza se estima de los resultados una vez completado el experimento, lo cual no permite controlarlo. En un
procedimiento secuencial, se especifica la precisión deseada, y el experimento continúa hasta que se obtiene esta precisión.
Aquí se describen los métodos más extensamente aplicados y aceptados. Sin embargo, al no ser un problema totalmente resuelto, se siguen desarrollando nuevos
métodos de análisis de la salida. Otras contribuciones se describen en [Fox et al.
1991], [Goldsman y Kang 1991], [Howard et al. 1992], [Fishman 2001] y [Alexopoulos y Kim 2002].
2.1.6.1
El problema del arranque (warm-up)
Por conveniencia, es costumbre iniciar la simulación con todos sus componentes
desocupados. Esto es, probablemente, un estado anormal para el sistema, y el modelo
necesita de un cierto tiempo para "calentarse" y superar este transitorio inicial o
warm-up (ver Figura 2-4). Los valores recogidos de las variables de la salida durante
este período pueden no ser representativos del estado estacionario y, si la ejecución
no es lo suficientemente larga, pueden enmascarar el valor de X .
Bases de la simulación por eventos discretos
21
Tres son las aproximaciones para superar este problema:
•
Prevenirlo, estableciendo condiciones iniciales representativas del estado
continuo
•
Eliminar su efecto, borrando los l valores iniciales de una ejecución
•
Reducir su efecto a un nivel insignificante, haciendo la ejecución suficientemente grande
Condiciones del
"régimen permanente"
Tiempo simulado
Condiciones
iniciales
0
l ó Tl
m ó Tm
Figura 2-4. Evolución típica de un estimador puntual en una simulador.
Hay dos dificultades para establecer condiciones iniciales representativas. Primero, no siempre está claro como deben ser definidas, y segundo, puede suponer un
gran esfuerzo de programación establecer estas condiciones (en [Murray y Kelton
1988] y [Kelton 1989] se analizan algunas posibilidades). La forma más fácil de
abordar ambas dificultades sería correr el modelo lo suficiente para alcanzar el estado continuo. Esto sugiere que la segunda aproximación, borrar los valores iniciales,
puede ser más satisfactoria.
La dificultad para la segunda aproximación está en determinar el número de valores a borrar o, equivalentemente, saber cuándo se ha alcanzado el estado estable. Para
una ejecución que genera m muestras y un borrado l, se recogen m-l muestras. Si l es
demasiado pequeño, se reducirá la cobertura, pues la media de la muestra estará sesgada y, por tanto, el intervalo de confianza tendrá menos probabilidad de contener a
E[X]. Si l es mayor de lo necesario, la varianza de la muestra se incrementa, incrementando a su vez el ancho del intervalo de confianza. Esto es claramente indeseable, pero es menos arriesgado que reducir la cobertura. Si no hay forma de asegurar
cuándo se alcanza el estado estable, la mejor táctica será ser generoso tanto con l
como con m.
Existen diferentes técnicas, más o menos generales, para intentar detectar el tamaño del transitorio, por ejemplo estudiando la estabilización de los valores medios.
La técnica a aplicar dependerá también del método particular de análisis de la salida
22
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
y no siempre funcionan bien (ver [Glynn 1995], [Ockerman y Glodsman 1997], [Tokol et al. 1997] y [Fishman 2001]).
La gran cantidad de artículos sobre la problemática del transitorio inicial da una
idea de la importancia de este efecto. Aún así, sigue siendo un tema pendiente de
resolver satisfactoriamente.
2.1.6.2
Réplicas
Las réplicas son, al menos conceptualmente, el método más sencillo para el análisis de la salida. Según se justifica más adelante, sus propiedades lo han hecho el mejor candidato para este trabajo, por lo que se describe con mayor amplitud que otros
métodos.
Supóngase que se hacen k ejecuciones (réplicas), cada una generando m muestras
de una variable de salida y utilizando diferentes generadores aleatorios para cada
ejecución. Las medias X1, X2, ... , Xk de las k ejecuciones son independientes, pues se
han utilizado secuencias de números aleatorios independientes para cada ejecución, y
para un valor suficientemente grande de m se distribuyen normalmente. Se puede
obtener un intervalo de confianza, como ya se ha descrito anteriormente, utilizando
la expresión,
H =t
s
α
1− ; N −1
2
N
Xi representa la media de la ejecución individual i, y X es la media de todas estas
medias. La varianza se calcula normalmente utilizando la siguiente fórmula, que presenta la ventaja de poder ir evaluándose según corre la ejecución de la simulación
∑ (X ) − kX
k
2
i
s2 =
2
i =1
k −1
En un procedimiento de tamaño fijo, el número total de observaciones n = mk se
determina por adelantado. Comúnmente, esto se hace construyendo el programa de
simulación con el modelo como un subprograma, que realiza una ejecución de longitud m y devuelve una media Xi. Llamando a este subprograma k veces con una secuencia de números aleatorios diferentes, se pueden aplicar los cálculos expuestos en
esta sección. Es mejor mantener k relativamente pequeño (de 5 a 10), y m relativamente grande. Valores grandes de m tienden a reducir s2 y compensan el efecto de un
número pequeño de réplicas; además, se reducen los efectos del sesgo en el arranque
Bases de la simulación por eventos discretos
23
(warm-up) y se mejora la normalidad, lo cual mejora la cobertura del intervalo de
confianza. En [MacDougall 1987] y en [Law 1983] se pueden ver ejemplos de estos
efectos. El incrementar indiscriminadamente el número de réplicas puede dar lugar a
intervalos de confianza pequeños alrededor del punto erróneo.
Las réplicas también se pueden emplear en un procedimiento secuencial, incrementando m o k hasta que se obtiene el valor deseado de H.
La forma adecuada de hacer esto es realizando k ejecuciones de una longitud inicial m = m0, guardar el estado de las simulaciones, calcular H, y si H es mayor que la
deseada, se incrementa m, se rearranca cada ejecución, y se calcula H otra vez. Esto
mantiene a k pequeño, pero tiene la desventaja de que necesita un mecanismo de salvado/rearrancado. También es posible ir añadiendo réplicas hasta que se obtiene el
valor deseado de H. Si se utiliza esta aproximación, los resultados deben interpretarse con cautela, pues la cobertura generalmente será menor que 1 − α debido muchas
veces al efecto del arranque.
No hay reglas fijas para utilizar este método, por ejemplo [MacDougall 1987] hace las siguientes recomendaciones: suponiendo que se desea una precisión del 10% al
95% de nivel de confianza para una variable de salida X, se recomienda:
1. Utilizar una longitud básica de 2.500 muestras. Si las principales variables de
entrada que contribuyen al valor de X tienen coeficientes de variación (σ/µ)
mayores que 1, incrementar a 4.000. Para sistemas abiertos con alta utilización (intensidad de tráfico entre 0,6 y 0,9), incrementar la longitud a 5.000.
2. Hacer 5 réplicas y calcular el intervalo de confianza H5.
3. Si H5 < 0,1 X , se ha obtenido la precisión buscada. En caso contrario, hacer
k + − 5 replicas adicionales, donde
k + = 5( H 5 / 0.1X ) 2 
y calcular un nuevo intervalo de confianza. Si k + > 20 y no se ha logrado el
intervalo requerido se recomienda empezar de nuevo con longitudes de la ejecución del doble o más.
4. En un proceso en tiempo continuo, donde la longitud de la ejecución se expresa en términos de tiempo, se establecerá los tiempos de forma que equivalgan a una cantidad de operaciones similares a las propuestas.
24
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
Un importante problema del método de las réplicas es la influencia negativa de
los transitorios iniciales en la cobertura, pues ésta se verá sesgada por el efecto de las
muestras tomadas en esta fase.
La aplicación de técnicas de detección del transitorio inicial implica que parte de
las muestras de cada réplica deberán ser descartadas, con el consiguiente desperdicio
de recursos informáticos. Así, si tenemos k réplicas con m muestras cada una y el fin
del transitorio corresponde a l muestras, entonces kl muestras se habrán desperdiciado, quedando k (m − l ) muestras para estimar X .
Una de las formas para estimar el tamaño del transitorio consiste en observar gráficamente la tendencia de los datos debida al sesgo y encontrar cuando desaparece
[Welch 1983]. Para ello, las muestras generadas por cada réplica se dividen en lotes
contiguos de tamaño fijo de los que se calcula la media del conjunto de lotes en la
misma posición para cada réplica. Estas medias entre lotes se trazan gráficamente
para saber a partir de qué lote se aprecia que las medias empiezan a oscilar alrededor
de una media. En la Figura 2-5 se muestra un representación del procedimiento.
El uso de las medias acumuladas para la detección del transitorio no se recomienda debido al sesgo inicial que enmascara la detección del transitorio.
Desgraciadamente no existe un método ampliamente aceptado, objetivo y demostrado para determinar cuántas muestras hay que eliminar para evitar el sesgo
inicial. Algunas mejoras y propuestas son:
•
Cuando se incrementa el número de réplicas se obtiene una tendencia en la
gráfica más suave y precisa. Se puede añadir un intervalo de confianza basado
en la distribución t-Student a cada punto (por ser la media de variables i.i.d.) y
juzgar si el trazo es lo suficientemente preciso para considerar que el sesgo ha
disminuido. Este suele ser el método preferido para determinar un punto de
borrado.
•
Se pueden lograr mejores suavizados trazando medias móviles en lugar de las
medias entre lotes. En la media móvil, cada punto es la media de varias medias entre lotes contiguos. La cantidad de lotes contiguos a seleccionar se elige normalmente por prueba y error hasta que se obtiene un trazado suave.
•
Las medias acumuladas son menos variables cuantos más datos son promediados. Por tanto, se espera que el lado izquierdo de la curva sea siempre menos suave que el lado derecho. Por ésta y otras razones las medias acumula-
Bases de la simulación por eventos discretos
25
dos deberían usarse sólo si no es posible calcular medias entre lotes; por
ejemplo, en el caso de una sola ejecución.
•
Cuando interesa más de una variable de salida hay que tener en cuenta que
normalmente alcanzan el régimen permanente a diferente ritmo, por lo que se
deberá examinar cada uno por separado y elegir un punto de borrado adecuado para todos.
p muestras
…
R1
R2
R3
…
Rk
X1
X2
X3
X4
X5
X
j
X3
X4
X5
X
j
transitorio a
eliminar
X1
X2
Figura 2-5. Representación del procedimiento de Welch
para la detección del transitorio.
Cada solución que funciona bien en unos casos puede funcionar mal en otros.
Hay estudios para intentar detectar el sesgo ([Kelton y Law 1983], [Schruben 1980],
[Goldsman et al. 1985]), para modelarlo ([Snell y Schruben 1985]) y para muestrear
aleatoriamente las condiciones iniciales en cada réplica ([Kelton 1991]).
En cualquier caso, siempre es interesante intentar que el tamaño del transitorio
inicial sea lo menor posible (ver apartado 2.1.6.1) por lo que, si es sencillo de im-
26
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
plementar, se pueden aplicar técnicas para reducirlo. Por ejemplo, en [Kelton y Law
1984] y [Kelton 1985] se estudia el efecto de la reducción del transitorio en colas
M/M/s, M/Em/1 y Em/M/1 cuando se inicializan con una cantidad de clientes. Como
resultado se dice que la inicialización de las colas como vacías y el servidor desocupado no es una buena idea, a pesar de ser práctica habitual, y el estado óptimo de
inicialización tiende a ser un valor mayor que la media. Como consecuencia de una
inicialización correcta se estará reduciendo el sesgo y acortando las simulaciones.
Según [Gafarian et al. 1978] los métodos hasta la época funcionaban bien para la
elección del transitorio inicial. El procedimiento de Welch está ampliamente aceptado, pero hay otros. [Schhruben 1982], [Schruben et al. 1983] desarrollan un método
general basado en series temporales estandarizadas para determinar si una serie de
observaciones tienen un sesgo con respecto al valor en régimen permanente. En
[Kelton y Law 1983] se propone un algoritmo que trabaja bien para la elección de l y
m sobre una amplia variedad de modelos estocásticos; sin embargo, una limitación
teórica del algoritmo es que hace una asunción de que E(Xi) es una función monótona
de i. [Gallagher et al. 1996] proponen un método alternativo basado en los filtros de
Kalman.
En cuanto a la longitud de las réplicas en función del tamaño del transitorio eliminado, en [Banks 1996] se recomienda como regla que la longitud de la simulación
más allá del transitorio debería ser al menos 10 veces la cantidad de datos borrados.
Dada esta longitud, el número de réplicas debería ser tantas como lo permitiese el
tiempo y hasta un máximo de 25 [Kelton 1986].
Dado un tiempo de computación disponible [Glynn 1987] muestra que, según
este tiempo tiende a infinito, es mejor ir incrementando el número de réplicas que
hacer que crezcan un número fijo de réplicas.
En [Glynn 1995] se muestra que es asintóticamente mejor un número bajo de réplicas, lo que se prueba con un conjunto de modelos bastante general. La calidad de
la simulación se estima a partir del error cuadrático medio. Para ello supóngase que
se dispone de un tiempo t para simular. Con el método de las réplicas se proporciona
t/m unidades de tiempo a cada una de m réplicas. La media obtenida αm(t) es una
estimación de la verdadera α. En el trabajo se llega a la siguiente proposición,
E (α m (t ) − α ) =
2
σ2
t
+
m
(mb 2 + c) + O(e −γt / m )
2
t
Bases de la simulación por eventos discretos
27
según t → ∞ y donde b y c son constantes desconocidas y γ es una constante positiva.
Según esta expresión, no es nunca óptimo elegir m estrictamente mayor que
max(1,c/b2). Como c y b son desconocidas, una aproximación conservativa es elegir
m=1. La idea es que si elegimos m demasiado grande, la penalización por hacerlo
puede ser arbitrariamente mala.
2.1.6.3
Lotes (batch-means)
El método de lotes se basa en la división de una ejecución larga en un conjunto de
k subejecuciones de longitud m, llamadas lotes (batch), calculando una media de la
muestra para cada lote, y utilizándola para calcular una media global y el intervalo de
confianza. Como ventaja adicional, este método reduce el problema del transitorio
inicial al solo necesitar eliminar uno.
Asumiendo que se emplea el borrado para conseguir las condiciones para el estado estable, cada lote empezará con el sistema en este estado. Si el tamaño del lote es
suficientemente grande, las medias serán aproximadamente independientes y distribuidas normalmente. Se puede calcular un intervalo de confianza igual que para las
réplicas, con las medias de lote tomando el lugar de las medias de las ejecuciones, es
decir,
1 k
X = ∑ Xi
k i =1
∑ (X ) − kX
k
2
i
s2 =
2
i =1
k −1
donde Xi es la media de las m muestras de cada lote.
Como se ha dicho, el efecto de la dependencia dentro de cada lote implica sesgos
en X i y, por lo tanto, también en X , que se reduce al aumentar m, por lo que si m es
suficientemente grande, la dependencia no tiene prácticamente efecto dentro del lote.
Aunque se espera cierta dependencia entre los estimadores de lotes, ésta será menor
que la dependencia entre observaciones.
El efecto del arranque sólo se debe de tener en cuenta una vez, mientras que en el
caso de las réplicas debe ser k veces. El método por lotes es potencialmente más eficiente, pues se necesitará menor número de muestras para conseguir una precisión
28
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
dada. El mayor problema consiste en determinar el tamaño adecuado del batch para
garantizar que cada lote es independiente. Desgraciadamente no hay un método sencillo para elegir un tamaño del lote o el número de lotes. Algunas líneas generales
son:
•
Es aconsejable utilizar ente 10 y 30 lotes como máximo [Schmeiser 1982]. En
el caso de autocorrelaciones grandes es mejor un tamaño de lote grande que
muchos lotes.
•
Aunque suele haber autocorrelaciones entre lotes a todas las distancias, sólo
se suele estudiar la autocorrelación de distancia 1, Corr(Xj,Xj+1), para comprobar la independencia entre lotes. Cuando la autocorrelación de distancia 1
es cercana a 0 entonces se trata al lote como independiente.
•
La autocorrelación no debería estimarse a partir de un número pequeño de
lotes (10 ≤ k ≤ 30 como se recomienda) debido al sesgo del estimador. [Law y
Carson 1979] sugieren estimar la autocorrelación a partir de un número grande de lotes de tamaño pequeño (por ejemplo 100 ≤ k ≤ 400) y cuando la autocorrelación sea pequeña (cercana a 0) se agrupan los lotes para tener 10 ≤ k ≤
30, lo que posiblemente disminuya también la autocorrelación.
Se han desarrollado diferentes métodos para afrontar esta problemática, algunos
se pueden ver en [Adam 1983], [Fishman y Yarberry 1994], [Law y Kelton 2000].
Comúnmente, estos algoritmos empiezan con tamaños de lote pequeños, recogen una
cantidad relativamente grande de lotes y calculan un estimador de la correlación de
las medias. Si la correlación no es significativa entonces se asume que se satisface la
condición de independencia. Si las correlaciones son significativas, el tamaño del
lote se duplica y se recogen más muestras. Cuando se consigue un tamaño de lote
que satisface la condición de independencia de las medias, se pasa aplicar un método
secuencial para obtener la precisión adecuada. En esta metodología, el aspecto crítico
está en la naturaleza sesgada de los estimadores de correlación.
La forma de trabajo descrita en el párrafo anterior tiene un inconveniente: un valor pequeño de k tiende a aumentar la varianza, por lo que sería deseable un método
que permitiese aumentar k sin disminuir m para una cantidad de muestras fija. Una
idea para resolver esta problemática es el método denominado lotes solapantes
(overlapping batchs) que puede verse en [Meketon y Schmeiser 1984]. En este caso
se utilizan n-m+1 lotes para obtener el estimador
Bases de la simulación por eventos discretos
29
n − m +1 ( X − X ) 2
1
j
s =
∑
n − m + 1 i =1 n / m − 1
2
con Xj calculado a partir del lote de tamaño m que va de xj a xj+m-1. Hay soluciones intermedias con estimadores de menor solapamiento que el anterior.
Existe una posibilidad adicional a las aproximaciones anteriores propuesta en
[Fox et al. 1991] que consiste en eliminar un conjunto de datos de salida entre cada
lote, lo que, en principio, disminuye el peligro de correlación entre lotes a costa de
perder muestras.
2.1.6.4
Regeneración
El método de las regeneraciones fue desarrollado por Crane e Iglehart [Crane e
Iglehart 1974a, Crane e Iglehart 1974a, Crane e Iglehart 1975], y Fishman [Fishman
1973, Fishman 1974].
El principio básico de este método proviene de considerar que el proceso de salida de interés es regenerativo. Un proceso es regenerativo si existen instantes de
tiempo en los que el proceso recomienza probabilísticamente. La aplicación del método consiste entonces en dividir la longitud de la simulación en intervalos sucesivos
de forma que el comportamiento del modelo en cada intervalo sea estadísticamente
equivalente e independiente.
Habrá tantas subsimulaciones independientes como intervalos, y los resultados de
cada subejecución se considerarán como muestras de variables aleatorias independientes y con la misma distribución.
El tamaño de cada subintervalo será diferente, por lo que en este método se calcula la esperanza deseada µ como el ratio de dos esperanzas matemáticas,
µ=
E [Z ]
E [N ]
donde las esperanzas E[Z] y E[N] se estiman a partir de Z i = ∑ X i de las muestras de la i-ésima regeneración y Ni el tamaño de la i-ésima regeneración.
Cuando la muestra es grande se podrá calcular un intervalo de confianza utilizando la expresión,
H = Zα
2
s
k
, con Z≈Ν(0,1).
30
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
En la práctica, la hipótesis de independencia se puede satisfacer si el modelo corresponde a un proceso estocástico regenerativo. En estos casos, el modelo tiene uno
o más estados especiales a los que se llama estados regenerativos. Siempre que el
sistema vuelve a uno de estos estados se tiene un punto de regeneración. Éste podría
ser, por ejemplo, el punto donde el comportamiento pasado del sistema ya no va a
tener influencia sobre su futuro, pudiéndose aprovechar estos puntos para hacer la
división de la simulación.
La determinación de los puntos de regeneración no suele ser factible en la mayoría de modelos razonablemente complejos. El caso más simple es el de un proceso de
Markov, donde cada estado es un punto de regeneración. Del mismo modo, en un
modelo de una red abierta donde la llegada de clientes es un proceso de Poisson, un
punto de regeneración suele ser el que todos los servidores estén vacíos.
Una forma habitual de trabajar con este método es que sea explícitamente el
usuario el que compruebe el estado del sistema y localice el punto de regeneración
para que se hagan los cálculos estadísticos necesarios sobre la subejecución una vez
localizado este punto.
En muchas ocasiones se pueden conseguir puntos de regeneración aproximados
partiendo de una versión del modelo más sencilla. Sin embargo, es necesario establecer la validez de los intervalos de confianza obtenidos así. Antes de tomar los resultados como buenos será aconsejable utilizar un test de correlación para cerciorarse de
la independencia de las muestras.
De todas formas, siempre se puede recurrir a puntos de regeneración artificiales.
Por ejemplo, es posible dividir la simulación en subejecuciones de igual longitud y
afirmar que son independientes, siempre y cuando la longitud de cada subejecución
sea lo suficiente larga y se hagan suficientes subejecuciones. Éste sería el método por
lotes ya descrito.
2.1.6.5
Autorregresión
El método de la autorregresión se basa en la estimación de ciertos parámetros
pertenecientes a las estructuras de autocorrelación de los procesos. Este método fue
propuesto en [Fishman 1971].
Supóngase que se tienen X1,..Xn observaciones de la ejecución de una simulación,
que no se pretende que sean independientes. Se utilizará de forma habitual X como
estimador de E(X) y queda por estimar σ2 para calcular el intervalo de confianza.
Bases de la simulación por eventos discretos
31
Se asume que el proceso es estacionario respecto a la covarianza y se puede representar por un modelo autorregresivo de p-ésimo orden
p
∑b (X
s
s =0
t −s
− E ( X )) = ε t
(2.3)
donde b0=1 y es una secuencia de variables aleatorias no correladas con media
común 0 y varianza σ2. Si
∑
∞
s = −∞
γ s < ∞ , entonces se puede ver que para n grande,
s ( n) ≅
2
σ2
 p 
n ∑ bs 
 s =0 
(2.4)
2
Manipulando (2.3) y ajustando secuencialmente los datos para diferentes elecciones de p se consiguen estimaciones de σ2, p y bs, y sustituyendo en (2.4) se obtiene el
estimador autorregresivo s2A(n) para σ2(n). Para formar el intervalo de confianza se
usa el ratio [ X (n) –E(X)]/ s2A(n) como una distribución t de Student (ver [Fishman
1973] y una posterior mejora en [Yuan y Nelson 1994]).
Una posible fuente de error para este método es que generalmente los procesos no
son estacionarios respecto a la covarianza, con lo que (2.3) no se cumple y se estará
fallando en la estimación de t.
2.1.6.6
Espectral
Este método se aplica a muestras correladas siempre que éstas estén idénticamente distribuidas, que sean estacionarias respecto a la covarianza y, por tanto, no se
basa en la asunción de independencia.
La correlación se toma en cuenta en la estimación de los intervalos de confianza,
proporcionando normalmente intervalos de confianza mayores que los estimados por
otros métodos debido a la estimación añadida del efecto de la correlación.
Bajo la hipótesis de que el proceso es estacionario respecto a la covarianza se tiene que

j =1 
m
m
Var [X (m)] =
donde γi es la covarianza.
γ 0 + 2 ∑ 1 −
j
γ
m
j
(2.5)
32
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
El método utiliza esta relación como punto de partida para estimar la varianza de
la muestra. Suponiendo que se cumple,
∞
∑γ
j
<∞
j = −∞
entonces
Var [X (m)] → 2πg (0) según m → ∞
donde a g(τ) se le llama espectro del proceso a frecuencia τ, y se define por la
transformada de Fourier,
g (τ ) =
1
2π
∞
∑γ
j
e − i γj ,
|τ| ≤ π
i = −1
j = −∞
Por tanto, para valores de m grandes, Var [X (m)] ≈ 2πg (0) / m , y el problema de
estimar Var [X (m)] se puede considerar como la estimación del espectro a frecuencia
0.
Una estimación de la varianza consiste entonces en sustituir γj en (2.5) por una
estimación γˆ j a partir de las observaciones. El problema es que para valores grandes
de m y para j cercano a m, la estimación de γj tendrá una varianza grande porque se
calcula a partir de pocas observaciones. Por ello se suele recurrir a utilizar la expresión,
q −1
Vˆar [X (m)] =
γˆ 0 + 2∑ Wq ( j )γˆ j
j =1
m
donde q determina el número γˆ j s en el estimador, y que se debe especificar; y la
función de ponderación Wq(j) se diseña para mejorar las propiedades de muestreo de
Vˆar [X (m)]. Entonces se puede tener un intervalo de confianza medido como 100(1-
α)% a partir de,
X (m) ± t f ,1−α / 2 Vˆar [X (m)]
donde f depende de m, q y de la elección de la función de ponderación.
Bases de la simulación por eventos discretos
33
La principal ventaja de este método es que el usuario no debe preocuparse con la
elección de parámetros como números de réplicas, puntos de regeneración, etc., pues
se aplica el análisis directamente al comportamiento del modelo simulado en régimen
estacionario. Sin embargo, no hay un procedimiento definitivo para la elección de q,
y la técnica requiere un profundo conocimiento por parte del analista.
La información sobre el método se puede ampliar en [Damerdji 1991], [Heidelberger y Welch 1981], [Heidelberger y Welch 1981b].
2.1.6.7
Series temporales estandarizadas
Los procedimientos anteriores para el cálculo de los intervalos de confianza se
suelen basar en el teorema central del límite, que describe el comportamiento asintótico de un estimador para un parámetro estandarizado. Los métodos difieren en la
forma de estimar la desviación estándar del estimador del parámetro.
La técnica de las series temporales estandarizadas difiere del resto en un aspecto
fundamental: en lugar de basarse en un único estimador, trabaja sobre el total de las
series temporales. En este caso, se utiliza un proceso estocástico limitador para modelar la conducta de las series temporales estandarizadas. Este proceso limitante es el
proceso estándar de Wiener, W(t), en el intervalo condicionado a empezar y terminar
en cero (también se le llama puente Browniano).
La base teórica de este método se puede consultar en [Schruben 1983], y se aplica
al diseño de diferentes procedimientos para el cálculo del intervalo de confianza.
Por ejemplo, se puede estimar el intervalo de confianza utilizando una suma de
series temporales. Supóngase como partida un conjunto de réplicas independientes o
lotes de observaciones de una única ejecución. Dada la variable aleatoria de salida
asintóticamente normal, Ai, si se divide por su desviación estándar y se aplica la raíz
cuadrada se tendrá una distribución chi2 (χ2) con un grado de libertad. Se usará esta
transformación para obtener un χ2 para cada una de las b réplicas independientes o
lotes. La suma de variables aleatorias χ2 independientes tiene una distribución χ2 con
los grados de libertad sumados. Para longitudes m grandes de la ejecución, la suma
de los Ai (después de escalar y hacer la raíz) tendrá aproximadamente una distribución χ2 con b grados de libertad. Así se tendrá que,
b
12
H= 3
Ai2
∑
m − m i =1
34
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
estará distribuida asintóticamente como σ2 veces una variable aleatoria χ2 con b
grados de libertad. H es una función de la serie temporal que es asintóticamente independiente de la media de la muestra. Se llega a un cálculo para el intervalo de confianza según la fórmula,
H = tη ,b 12∑ i =1
b
Ai2
n 2 ( m2 − 1)
donde tη,b es el cuartil 100(1+η)/2 de una distribución t con b grados de libertad.
2.1.7 Comentarios a los métodos de análisis de la salida
El problema fundamental de las simulaciones es que en la mayoría de casos no
producen observaciones que sean independientes e idénticamente distribuidas de
manera normal. Como ejemplo, [Goldsman y Tokol 2000] comentan este problema
aplicado al tiempo de espera de clientes consecutivos en un complejo sistema de colas diciendo:
•
No son independientes. Típicamente están correlados en serie. Si un cliente
en la oficina de correos espera en la cola mucho tiempo, entonces el siguiente
cliente probablemente también esperará mucho tiempo.
•
No están idénticamente distribuidos. Los clientes que vayan pronto deberían
esperar menos que los que llegan a última hora.
•
No están normalmente distribuidos. Habitualmente están deformados hacia la
derecha y nunca son menores que 0.
El método ideal para el análisis secuencial de la salida debería evitar en lo posible
el sesgo producido por los efectos antes descritos, pero además no debería requerir
una parametrización por parte del modelador, sino que, automáticamente, debería ser
capaz de detectar y eliminar el transitorio inicial, y hacer el control de la longitud de
la simulación hasta alcanzar el error relativo deseado a un determinado nivel de confianza.
Por ejemplo, en [Heidelberger y Welch 1983] se aplica el método espectral con
diferentes estadísticos y detección automática del transitorio inicial basados en
[Schruben et al. 1983] sobre un modelo NEAR(1) [Lawrence y Levis 1981] que puede tener un grado muy grande de autocorrelación positiva, y el tiempo en espera en
una cola M/M/1 con intensidad de tráfico ρ=0,90. Como resultado, el procedimiento
Bases de la simulación por eventos discretos
35
con detección automática del transitorio funciona muy bien, comportándose casi
siempre mejor que la versión sin detección del transitorio. El método con borrado del
transitorio produce estimaciones puntuales con menos sesgo e intervalos de confianza más estrechos y mejor cobertura de las simulaciones más cortas que sin borrado
del transitorio inicial. Sin embargo, el método tiene problemas en la detección de
algunos transitorios fuertes que se traducen en crecimientos lentos y que fuerzan al
algoritmo a terminar prematuramente.
Los buenos resultados obtenidos se enfrentan con la necesidad de unos profundos
conocimientos del analista de esta técnica y de su adecuada aplicación a cada tipo de
modelo. De [Law y Kelton 2000] se extrae la Tabla 2-1, que resume la problemática
de cada uno de los métodos de análisis de la salida descritos.
Método
Número
de réplicas
Problema de
sesgo principal
Réplicas/borrado
n (n≥ 2)
X (n)
Lotes (batch means)
1
Vˆar [X (n)]
Autorregresivo
1
Vˆar [X (n)]
Espectral
1
Vˆar [X (n)]
Regeneración
1
Vˆar [X (n)]
Series temporales
estandarizadas
1
Vˆar [X (n)]
Mayor dificultad
Elección del periodo de calentamiento
Elección del tamaño de lote
para obtener lotes sin correlación
Calidad del modelo
autorregresivo
Elección del número de saltos
de covarianza
Existencia de ciclos con tamaño
de la media
“pequeño”
Elección del tamaño del lote
Tabla 2-1. Problemática principal de los diferentes métodos para el análisis de la salida.
En [Law y Kelton 2000] se puede ver una comparativa de los métodos descritos
cuando se aplican con un tamaño de muestra fijo. En este caso se emplea un modelo
de cola M/M/1 y un modelo de computador de tiempo compartido. Para el caso de la
cola M/M/1 los resultados de cobertura están muy por debajo de la pronosticada teóricamente, mientras que en el otro modelo los resultados son muy cercanos al teórico.
En cualquier caso, de los resultados se desprende que el tamaño ideal de muestra no
es fijo y depende del modelo, y que la cobertura no está en función de la complejidad
del modelo, pues un modelo sencillo como la cola M/M/1 da peores resultados que el
modelo complejo.
El propósito de esta tesis es proveer una metodología de explotación paralela de
modelos de simulación aplicable a cualquier tipo de modelo y que proporcione ga-
36
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
rantías estadísticamente contrastadas en los resultados. En ese camino, la técnica de
análisis basada en réplicas independientes parece la más intuitiva y universal para
cualquier tipo de modelo de simulación y, además, se adapta bien a diferentes tipos
de objetivos de explotación del modelo de simulación.
En este sentido, [Law y Kelton 2000] da las siguientes razones para utilizar este
método:
1. Si se aplica adecuadamente, este método suele dar un rendimiento estadístico
razonablemente bueno.
2. Es la aproximación más fácil de entender e implementar.
3. Se puede aplicar a todos los tipos de parámetros de salida.
4. Se puede usar con facilidad para estimar diferentes parámetros de un mismo
modelo de simulación.
5. Se puede usar para comparar diferentes configuraciones de un sistema.
2.2 Técnicas de reducción de la varianza para acelerar
simulaciones
Un punto a tener en cuenta cuando se trabaja con simulaciones dirigidas mediante
variables de entrada aleatorias es que las variables de salida resultantes también serán
aleatorias. Por tanto, se deberán aplicar las técnicas estadísticas apropiadas a las variables resultantes si se desea analizarlas, interpretarlas y usarlas adecuadamente.
Como las simulaciones complejas suelen requerir grandes cantidades de tiempo
de computación, los métodos estadísticos vistos en apartados anteriores suelen ser
bastante costosos. Por tanto, el analista usar algún medio para incrementar la eficacia
computacional, vista tanto como la adecuada codificación de la aplicación como de
los adecuados métodos estadísticos.
Por ejemplo en [Law y Kelton 2000] se orienta a la eficacia estadística desde el
punto de vista de la varianza de las variables de salida. Si se puede de alguna forma
reducir la varianza de una variable de salida aleatoria de interés sin alterar su esperanza, será posible obtener mayor precisión. Esto se puede traducir en intervalos de
confianza más pequeños para la misma cantidad de simulación o, alternativamente,
conseguir la precisión deseada con menos esfuerzo computacional.
Técnicas de reducción de la varianza para acelerar simulaciones
37
Los métodos para aplicar estas técnicas dependen normalmente del modelo particular a estudiar y, por tanto, requieren un conocimiento profundo del modelo de trabajo. Aún más, en general es imposible conocer de antemano la reducción de varianza a conseguir o, peor aún, si se reducirá la varianza en comparación con los métodos
directos.
La aplicación de estas técnicas puede suponer un incremento del coste de desarrollo de la aplicación y del coste computacional, por lo que en ocasiones es interesante hacer pruebas piloto para comprobar si se obtienen ventajas.
Por otra parte, en [Pawlikowsky 1990] se destaca que "a pesar de que se han estudiado teóricamente y con profundidad distintas técnicas de reducción de la varianza, la mayoría de ellas ha tenido una aplicación práctica limitada". Se pueden ver
ejemplos de aplicación y otros métodos en [Ríos et al. 1997] y [Law y Kelton 2000].
A continuación se describen las técnicas que, por su generalidad y su fácil aplicación, pueden ser adecuadas a nuestro objetivo.
2.2.1 Números aleatorios comunes
El método de los números aleatorios comunes se utiliza cuando se comparan dos
o más configuraciones alternativas de un sistema en lugar de investigar una única
configuración. A pesar de su simplicidad, es probablemente la más útil y popular de
todas las técnicas de reducción de la varianza.
La idea básica es que se deberían comparar configuraciones alternativas bajo experimentos con condiciones similares, de forma que se esté más seguro de que las
diferencias en rendimiento se deben a las diferencias en la configuración del sistema
y no a fluctuaciones en las condiciones del experimento.
El nombre de esta técnica proviene de la posibilidad de que en muchas ocasiones
se pueden conducir los diferentes experimentos con los mismos números aleatorios
pues, en simulación, las condiciones del experimento se generan mediante variables
aleatorias.
Para ver el razonamiento de la técnica más claramente, considérese el caso de dos
configuraciones alternativas, donde X1j y X2j son las observaciones de la primera y la
segunda configuración en la j-ésima réplica independiente, y se quiere estimar E(Zj)
= E(X1j)-E(X2j). Si se hacen n réplicas de cada sistema y suponiendo Zj = X1j - X2j
para j=1, 2, ...,n, entonces para E(Zj) se tiene que,
38
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
n
∑Z
Z (n) =
j =1
j
n
es una estimación no sesgada de E(Zj). Como las Zj son variables aleatorias independientes e idénticamente distribuidas (i.i.d.),
Var[ Z ( n )] =
Var ( Z j )
n
=
Var( X 1 j ) + Var( X 2 j ) − 2Cov ( X 1 j , X 2 j )
n
Si la simulación de las dos configuraciones se hace independiente, por ejemplo
con diferentes números aleatorios, X1j y X2j serán independientes y por tanto
Cov(X1j,X2j)=0. Por otra parte, si se pudiese hacer que en la simulación de las configuraciones 1 y 2, X1j y X2j estén correladas positivamente, entonces Cov(X1j, X2j) > 0,
y por tanto la varianza del estimador Z ( n ) se reducirá.
En esta técnica se intenta inducir esta correlación positiva utilizando cuidadosamente los mismos números aleatorios para simular todas las configuraciones. Esto es
posible gracias a la naturaleza reproducible y determinista de los generadores de números aleatorios.
Desgraciadamente, no hay una prueba general para demostrar que el método funciona, y por tanto que reduce siempre la varianza. La eficacia del método depende de
los modelos particulares que se comparan, y su uso presupone que el analista piensa
que los diferentes modelos responderán de forma similar a grandes o pequeños valores de las variables aleatorias de entrada. Por ejemplo, se debería esperar que tiempos
entre llegadas pequeños, para la mayoría de los diseños con colas, suelen dar mayores retardos y longitudes de las colas.
La Figura 2-6 muestra esquemáticamente este concepto, donde el eje horizontal
muestra los posibles valores de un Uk (U(0,1)) utilizado para un propósito particular
en ambas simulaciones. Por ejemplo este Uk podría ser usado para generar un tiempo
de servicio. Las curvas indican cómo podrían reaccionar los resultados de la simulación para posibles valores de éste Uk. En las situaciones (a), X1j y X2j reaccionan monotónicamente en la misma dirección para Uk, y se debería esperar que el método
indujese la deseada correlación positiva y, por tanto, redujese la varianza. Sin embargo, en (b) X1j y X2j reaccionan en direcciones opuestas para Uk, por tanto, debería
inducir correlaciones negativas y fallar, llevando a que Cov(X1j y X2j) < 0 y un incremento de la varianza.
Técnicas de reducción de la varianza para acelerar simulaciones
39
X1j
X 2j
X 2j
X1j
0
1
0
1
X 1j
X1j
X 2j
X 2j
0
1
(a)
0
1
(b)
Figura 2-6. Ejemplos de posibles respuestas de modelos de simulación para números
aleatorios comunes. Para (a) la técnica debe suele funcionar, para (b) no.
Normalmente, los números aleatorios se usan para generar otras distribuciones,
que se emplean a su vez para conducir los modelos de simulación. Para dar a la técnica las mejores posibilidades de funcionamiento, se debería intentar primero garantizar que las distribuciones generadas reaccionasen monotónicamente a Uk en el paso
intermedio; entonces se podrá asumir que las medidas de rendimiento reaccionan
monotónicamente a las distribuciones generadas. Por esta razón, se recomienda el
método de la transformada inversa para la generación de variables aleatorias, pues
garantiza monotonicidad. Como este método suele ser lento, puede ocurrir que su
coste computacional desplace su eficacia estadística. Por esta razón algunos autores
han desarrollado métodos no basados en la transformada inversa que todavía inducen
una correlación positiva en las variables requeridas.
Para una implementación adecuada se debe sincronizar los números aleatorios para las diferentes configuraciones del sistema en cada réplica. Lo ideal es que un número aleatorio específico usado para un propósito específico en una configuración se
use exactamente para el mismo propósito en las otras configuraciones.
40
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
2.2.2 Variables antitéticas
El método de las variables antitéticas, introducida por [Hammersley y Morton
1956], es una técnica de reducción de la varianza aplicable a la simulación de un
único sistema. Como en el método de los números aleatorios comunes, se intenta
inducir correlación entre diferentes ejecuciones, pero ahora se buscan correlaciones
negativas.
La idea principal es hacer pares de ejecuciones del modelo de forma que una "pequeña" observación en una de las ejecuciones del par, tiende a ser un desplazamiento
de una "gran" observación en el otro; es decir, las dos observaciones están correladas
negativamente. Entonces si se usa la media en el par de observaciones, esta tenderá a
ser más cercana a la esperanza común E(X) de una observación que la que se tendría
si las dos observaciones del par fuesen independientes.
En su forma más simple el método intenta inducir esta correlación negativa empleando números aleatorios complementarios para manejar las dos ejecuciones en
parejas. Esto es, si Uk es un número aleatorio particular empleado para un propósito
particular en la primera ejecución (por ejemplo para generar el i-ésimo tiempo de
servicio), entonces se usará 1- Uk para este mismo propósito en la segunda ejecución.
Un punto importante es que el uso de un Uk en una réplica y su complementario
1- Uk en la réplica emparejada debe estar sincronizado, es decir, usado para el mismo
propósito. En caso contrario se pierden los beneficios del método o pueden llegar a
ser contraproducentes.
Como en otros métodos, no se puede estar completamente seguro de que funcionará, y su aplicabilidad y eficacia son quizás más dependientes del modelo. El requerimiento fundamental que un modelo debe satisfacer para que funcione es que su
respuesta a un número aleatorio empleado para un propósito particular sea monotónico en cualquier dirección.
Hay una base matemática para este método. Supóngase que se hacen n pares de
ejecuciones de la simulación, dando las observaciones (X1(1), X1(2)),...,(Xn(1),Xn(2)),
donde Xj(1) es la j-ésima observación de la primera ejecución (la que usa U) y Xj(2) es
la de la segunda (que usa 1-U). Xj(1) y Xj(2) son legítimas observaciones del modelo de
simulación, y por tanto, E(Xj(1)) = E(Xj(2)) = E(X). También se tiene que cada pareja
es independiente de las otras. Para j = 1, 2, ..., n, sea Xj = (Xj(1) + Xj(2))/2, y sea la
Técnicas paralelas para acelerar simulaciones
41
media de Xj, X ( n ) , el estimador (sin sesgo) para E(X) = E(Xj(1)) = E(Xj) = E( X ( n ) ).
Como las Xj son i.i.d. se tiene,
Var [X (n)] =
Var ( X j )
n
=
Var ( X (j1) ) + Var ( X (j 2 ) ) + 2Cov( X (j1) , X (j 2) )
4n
Si las dos ejecuciones entre pares se hubiesen hecho independientemente, entonces Cov ( X (j1) , X (j 2 ) ) = 0. De todas maneras si se desea inducir una correlación negativa entre Xj(1) y Xj(2), entonces Cov ( X (j1) , X (j 2 ) ) < 0, lo cual reduce Var[ X ( n )] , que
es el objetivo.
Este método puede ser difícil de aplicar en modelos complejos. Además, no funciona siempre, e incluso puede incrementar la varianza, por lo que no puede ser usado sistemáticamente.
2.3
Técnicas paralelas para acelerar simulaciones
2.3.1 Introducción
Uno de los importantes inconvenientes de la simulación discreta por eventos es el
coste temporal de ejecución de los modelos. Este paradigma permite modelar todo
tipo de sistemas. En particular, es una herramienta imprescindible en el área del desarrollo de sistemas hardware y software, que está evolucionando mucho en la actualidad con diseños cada vez más complejos. Esta complejidad se traduce en modelos
con un alto coste de evaluación, lo que obliga a intentar reducir este coste desde dos
frentes: la mejora de las técnicas de análisis estadístico y la mejora de la velocidad de
ejecución de los modelos.
Este apartado pretende analizar y resumir las características de las opciones que
permiten acelerar la velocidad de ejecución de los modelos de simulación. En principio hay cinco aproximaciones posibles:
a) Descomponer el modelo en submodelos o subprocesos menores que puedan
ejecutarse concurrentemente en un grupo de máquinas.
b) Ejecución de réplicas del mismo modelo en diferentes máquinas para poder
generar más muestras estadísticas en menos tiempo (paralelismo estadístico).
42
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
c) Utilizar un compilador paralelizante para encontrar paralelismo en un programa de simulación secuencial.
d) Colocar diferentes funcionalidades del simulador en procesadores separados.
Por ejemplo, el generador de números aleatorios, el procesamiento de la lista
de eventos, etc.
e) Mantener una lista global de eventos, y que cuando un procesador esté libre,
procese el siguiente evento de la lista.
Por supuesto una última alternativa es combinar alguna de las propuestas. Pero,
en principio, las dos primeras opciones son las que permiten obtener mejores resultados y las que se eligen para describir en más detalle en apartados separados. Como se
explicará en el apartado de conclusiones, tienen sus ventajas y sus inconvenientes, y
obligan a elegir una opción.
Si se elige la opción de utilizar un compilador paralelizante aplicado a un programa secuencial, el compilador intenta localizar secuencias de código que se pueden
hacer en paralelo y planificar entonces en procesadores separados. Esta aproximación
es transparente al usuario y se puede aplicar al cuerpo de un programa de simulación
existente. Sin embargo, tal aproximación ignora la estructura del problema y sólo
puede explotar una pequeña porción del paralelismo disponible.
Otra aproximación es diseñar las tareas de soporte para simulación de manera que
estén en procesadores separados. Por ejemplo, puede haber un procesador o conjunto
de procesadores dedicados a alguna de las siguientes funciones: generación de variables aleatorias, procesamiento del conjunto de eventos, recolección de estadísticas,
E/S, generación de gráficos, etc. La ventaja de esta aproximación es que evita problemas de bloqueo y es transparente al usuario. La desventaja es que no explota nada
del paralelismo del sistema modelado. Ejemplos en esta línea se pueden ver en
[Krishnamurcirthi et al 1985, Reese 1985, Sheppard et al 1988]. Como ejemplo destacable [Comfort y Gopal 1988] utiliza transputers para simular un sistema de colas
M/M/k/c. La máxima eficiencia que obtiene es alrededor del 60% en un sistema con 2
procesadores (host y un procesador de red), con el procesador de red haciendo la
generación de números aleatorios. Parece que la aproximación de Comfort para la
simulación distribuida proporciona un aceleración (speed-up) significativa cuando
sólo se utilizan pocos procesadores, pero la aceleración marginal cae rápidamente
según se añaden procesadores.
Técnicas paralelas para acelerar simulaciones
43
Otra aproximación es mantener una lista de eventos global, como en la simulación secuencial clásica, y cuando un procesador quede libre, hacer que procese el
evento que está planificado como el siguiente en tiempo de simulación. Se necesitan
protocolos para preservar la consistencia, pues el siguiente evento en la lista puede
ser afectado por eventos que se están procesando. Esta aproximación es particularmente adecuada para sistemas de memoria compartida, pues la lista de eventos puede
ser accedida por todos los procesadores. [Cota y Sargent 1988] describe un algoritmo
para determinar eventos “seguros”, por ejemplo, eventos que no dependen de otros
previos sin procesar. [Chandy 1988] introduce el concepto de conocimiento condicional e incondicional y describe una aproximación maestro/esclavo para distribuir
eventos. La aproximación de eventos distribuidos puede ser razonable cuando hay un
número pequeño de procesos y cuando hay una gran cantidad de información global
utilizada por los componentes del sistema.
2.3.2 Descomposición de modelos de simulación
En la simulación discreta por eventos distribuida, se pretende ejecutar un conjunto de eventos sobre una arquitectura paralela. Esta línea de investigación ha adquirido en los últimos años un gran impulso, debido a que la simulación secuencial
convencional de modelos medianamente complejos consume enormes cantidades de
tiempo. El propósito de la investigación en esta área es, reducir el tiempo de ejecución de los modelos e incrementar el tamaño potencial del problema.
En los últimos años se ha generado una gran cantidad de documentación sobre las
investigaciones en el tema, siendo fuentes destacables las actas del “Workshop on
Parallel and Distributed Simulation (PADS)”, las de “SCS Multiconference on Distributed Simulation” y las de “Winter Simulation Conference” que se celebran
anualmente. Una descripción de las técnicas se puede ver en [Reynolds 1988], [Fujimoto 1990], [Nicol y Fujimoto 1994], [Fujimoto 2000].
La plataforma hardware para las simulaciones distribuidas está formada, potencialmente, por una gran cantidad de procesadores interconectados mediante una red
de comunicaciones. En general, hay dos tipos de plataformas: las formadas por un
conjunto homogéneo de procesadores alojados en un mismo armario donde las comunicaciones entre procesadores son rápidas, y las formadas por máquinas heterogéneas distribuidas en un área mayor y donde los retardos de transmisión de la red de
comunicaciones son relativamente altos.
44
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
¿Cómo se introduce el paralelismo?. En un modelo de simulación discreta por
eventos se asume de antemano que el sistema ejecutará acciones sólo en los puntos
donde deben producir cambios de estado durante el tiempo de simulación. Cuando se
produce un evento, el modelo de simulación pasa de un estado a otro, avanzado el
reloj de tiempo simulado global.
En la simulación paralela por eventos discretos, la aproximación más ampliamente trabajada consiste en descomponer el modelo en componentes débilmente
acoplados llamados procesos lógicos (LP, logic process) y poner cada uno o un grupos de estos componentes en un procesador donde se mantendrá una lista privada de
eventos. Cada LP tiene un reloj de simulación independiente llamado reloj local, que
muestra el tiempo hasta el que el proceso ha sido simulado. Si un LP necesita planificar un evento para otro LP en un procesador diferente, este otro será informado
mediante un mensaje con el tiempo de ocurrencia del evento. Esta aproximación tiene un gran potencial para explotar el paralelismo inherente a un modelo, pero requiere una cuidadosa sincronización porque los eventos ocurren a intervalos irregulares
de tiempo y no son sincronizados por un reloj global.
Lo dicho se puede ver de otra manera más concreta. En la simulación secuencial
el paradigma de una ejecución global es seleccionar el evento que tenga un tiempo de
ocurrencia más pequeño, Emin, de forma que ese evento será el siguiente en ser procesado. Esto es así porque si se selecciona otro evento que tenga un tiempo de ocurrencia mayor, Ex, podría pasar que Ex modificara las variables de estado usadas por el
evento Emin. Esto daría lugar a una simulación en la que un evento que se debe ejecutar instantes de tiempo después podría afectar a uno que se tenga que ejecutar antes. Esto es totalmente inaceptable, ya que produce claros errores.
Pásese ahora a considerar una paralelización de un programa de simulación. Para
tener un aumento de paralelismo se tienen que procesar eventos de forma concurrente sobre distintas máquinas. Si se considera la ejecución concurrente de dos
eventos El y E2, con tiempos de ocurrencia T1 y T2 respectivamente, con T1 < T2. Si
E1 tiene que escribir sobre una variable de estado que será leída por E2, entonces,
para asegurar que no se produzcan errores, E1 deberá ser ejecutado antes que E2. En
otras palabras, se debe asegurar el orden secuencial para que la simulación llevada a
cabo sea la correcta. La mayor parte de las estrategias de simulación distribuida pretenden evitar escenarios como el descrito.
Si se considera un modelo de un sistema físico, el cual puede ser visto como un
conjunto de procesos físicos que interactúan sobre varios instantes del tiempo de
Técnicas paralelas para acelerar simulaciones
45
simulación. La simulación se construye como un conjunto de procesos lógicos LP0,
LP1, ... LPn, uno por cada proceso físico. Todas los interacciones entre los procesos
físicos están modeladas por el tiempo de ocurrencia de los distintos eventos correspondientes a los procesos lógicos. Cada proceso lógico contiene una parte del estado
correspondiente al proceso físico que modela, por ejemplo, un reloj local (que denota
como el proceso está evolucionando). Para estas premisas se puede asegurar que no
habrá errores si se cumple la siguiente restricción:
Una simulación de eventos discretos, consiste en un conjunto de procesos lógicos
que interactúan exclusivamente para cambiar mensajes de tiempo de ocurrencia si y
solo si, cada LP procesa eventos con tiempo de ocurrencia en orden creciente.
Esta condición es suficiente, pero para garantizar que no se produzcan errores no
siempre es necesaria. No es necesaria debido a que dos eventos que estén en un mismo LP pueden ser independientes uno del otro, en ese caso procesarlos fuera de la
secuencia de tiempo de ocurrencia no tiene por qué producir error alguno.
Sin embargo, si se consideran dos eventos: El en un proceso lógico LP1, con
tiempo de ocurrencia de 10, y E2 con un tiempo de ocurrencia de 20. Si El planifica
un nuevo evento E3 para LP2, E3 contiene un tiempo de ocurrencia menor que 20,
entonces E3 podría afectar a E2, necesitando una ejecución secuencial para los tres
eventos. Si no se tiene ninguna información relativa a qué evento puede ser planificado por otros eventos, se está en la situación de concluir que el único evento que es
seguro para ser procesado es aquel que contiene el tiempo de ocurrencia más pequeño, lo que conduce a una ejecución secuencial.
Si se considera esta situación desde la perspectiva del sistema físico, la causa debe preceder siempre al efecto. Esta relación causa-efecto en un sistema físico obliga
al simulador a convertirlo en una secuencia. El mecanismo de simulación se debe
responsabilizar de que esta secuencia se realice y no se viole cuando un programa de
simulación se ejecuta sobre máquinas paralelas.
Operacionalmente se puede decidir si E1 puede o no ser ejecutado concurrentemente con E2. Pero, ¿cómo se puede conocer a priori si E1 afecta o no a E2 sin que E1
se llegue a procesar?. Esto es el dilema fundamental de la simulación distribuida. El
escenario en el que E1 afecta a E2 puede ser una compleja secuencia de eventos, y
cada evento depende del crítico tiempo de ocurrencia.
En este tipo de simulación es fundamental que el evento causa sea previo al
efecto. El dilema está en determinar que un evento afecta a otros sin realizar la si-
46
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
mulación, lo cual es difícil y dependiente del modelo. En la simulación secuencial
esto no es un problema por tener una única lista ordenada de eventos y un único reloj
global. Como esto no es así en la simulación paralela y se tienen listas y relojes independientes, puede llegar a ocurrir que se procese el evento efecto antes que el evento
causa, lo que supone una violación de la lógica de la simulación, y que se denomina
error causal.
La metodología para aplicaciones de procesos lógicos requiere programación para particionar el estado de las variables del simulador en un conjunto disjunto de estados, y debe asegurar que no se simulan eventos que acceden directamente a más de
un estado.
La exclusión de variables compartidas puede o no ser un problema, dependiendo
de la aplicación. Por ejemplo, la exclusión de variables compartidas no es una restricción cuando se trata de realizar una simulación de una red de colas. En este caso,
es natural crear procesos lógicos por cada servidor. Debido a que el comportamiento
de un servidor es independiente del estado de otros servidores, la exclusión de variables compartidas no crea problema alguno.
Supóngase ahora que se considera, por ejemplo, una simulación del tráfico en una
ciudad, en el que los vehículos se desplazan por todo el territorio e interactúan. Una
aproximación a la modelización de este sistema será particionar el territorio en redes
bidimensionales, y utilizar estructuras de datos bidimensionales en las cuales cada
elemento de la matriz tiene información acerca del estado, por ejemplo, el número de
vehículos que residen en un sector de la red correspondiente. La información sobre la
proximidad espacial es también importante debido a la actividad común que realizan
grupos de vehículos próximos. La información que indica quién reside en cada sector
de la red debe ser compartida entre varias zonas. Un enfoque a la esencia de las variables compartidas, podría ser emular memoria compartida para la construcción de
procesos lógicos de cada sector de la red, y enviar "lecturas" y "escrituras" de mensajes de eventos para acceder a la información compartida. Sin embargo, a menudo
esta aproximación tiene pocas implementaciones, debido principalmente a dos motivos: el primero es la sobrecarga que conlleva el paso de mensajes y el segundo los
procesos de la red que contienen esta información pueden convertirse en el cuello de
botella. Incluso si la arquitectura de la máquina soporta memoria compartida, acceder
al estado de una variable que reside en otro proceso lógico es bastante caro, ya que el
proceso que contiene la variable generalmente se encuentra en un instante de tiempo
de la simulación; y se produce una sobrecarga para asegurar la sincronización con
Técnicas paralelas para acelerar simulaciones
47
otro simulador de eventos. Sin embargo, la operación equivalente en una simulación
secuencial es una simple referencia a memoria.
En simulación paralela hay dos aproximaciones básicas para evitar este problema:
métodos de sincronización conservativos y métodos optimistas. En la aproximación
conservativa se evitan los errores de causalidad determinando el tiempo seguro hasta
el que se pueden procesar eventos. En la aproximación optimista los errores son detectados y se emplea un mecanismo de vuelta atrás para recuperar un estado consistente. Existen métodos con soluciones intermedias que se pueden agrupar en híbridos
y adaptativos.
Los primeros mecanismos de simulación distribuida se han basado en la propuesta conservativa. El problema fundamental de los mecanismos conservativos es
determinar cuándo es seguro procesar un evento. Si un proceso contiene un evento
con tiempo de ocurrencia T1, y no hay otro con un tiempo de ocurrencia más pequeño, si este proceso puede determinar a priori que no va ha recibir más tarde otro
evento con tiempo de ocurrencia más pequeño que T1, entonces el proceso podrá con
seguridad procesar el evento E1 porque puede garantizar que no se va a violar la restricción antes indicada. Si el proceso contiene un evento que no es seguro de procesar
entonces se debe bloquear. Esto puede conducir a situaciones de interbloqueo si no
se tienen precauciones.
Los primeros algoritmos se proponen en [Chandy y Misra 1979] y [Bryant 1977],
y se trata de técnicas para evitar el interbloqueo. Otra técnica desarrollada por
[Chandy y Misra 1981] consiste en detectar y recuperarse de bloqueos. [Misra 1986]
propone alternativas menos costosas para detectar y recuperarse de interbloqueos
locales, (por ejemplo, situaciones donde únicamente una parte de la red ha sido bloqueada). Una propuesta alternativa para detectar cierto tipo de ciclos se puede ver en
[Liu y Tropper 1990]. Muchas investigaciones han propuesto algoritmos de sincronización [Ayani 1989, Nicol 1989] en los que se determina iterativamente cuáles de los
eventos son seguros de procesar y entonces se pueden procesar. La sincronización
mediante barreras se emplea para salvaguardar iteraciones, hay diferentes aproximaciones como las barreras centralizadas, barreras en árbol o las barreras de mariposa
[Nicol 1995]. Un algoritmo con un planteamiento diferente al resto es bounded lag
[Lubachevsky 1989b], que establece una ventana temporal conservativa en la que
sólo los eventos contenidos en la ventana son procesados.
En estos y otros algoritmos conservativos existe un concepto fundamental denominado lookahead que se refiere a la habilidad de predecir qué sucederá o, más im-
48
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
portante, qué no sucederá en una simulación futura. Si un proceso está simulando con
un tiempo igual a clock y puede predecir con completa certeza todos los eventos que
se generarán en un tiempo de simulación clock + L, entonces el proceso indica que ha
habido un lookahead igual a L. Si el incremento del tiempo de ocurrencia mínimo no
es cero, es la forma más obvia de lookahead: un incremento mínimo de tiempo de
ocurrencia de M se traduce directamente en un "lookahead" de (al menos) M, debido
a que el proceso puede garantizar que no se crearán nuevos mensajes de eventos con
un tiempo de ocurrencia menor que clock + M.
Los mecanismos optimistas detectan y recuperan errores de causalidad, pero no
los evitan. En contraste con los mecanismos conservativos, las estrategias optimistas
no necesitan determinar cuándo es seguro procesar; en cambio, determinan cuándo se
ha producido un error e invocan a un procedimiento para recuperarse. Una ventaja de
esta aproximación es que permite al simulador explotar situaciones de paralelismo
donde podrían ocurrir errores causales, pero de hecho no ocurren. También se facilita
la creación dinámica de procesos.
El mecanismo de time warp, basado en el paradigma de tiempo virtual [Jefferson
1985], es el protocolo optimista más conocido. En este mecanismo el tiempo virtual
es sinónimo de tiempo de simulación. El algoritmo lazy cancellation [Gafni 1988] es
una optimización para reparar los daños causados por una computación incorrecta.
Otra técnica de optimización de time warp es lazy reevaluation o jump forward
[West 1988]. El algoritmo wolf calls [Madisetti et al. 1988] propone que un evento
extraviado provoque el envío inmediato de una orden de parada a los procesos lógicos para que no continúen procesando y se evite la propagación del error.
Existe un gran número de enfoques híbridos que se suelen basar en introducir características de los métodos optimistas a los mecanismos de simulación conservativos. [Lubachevsky et al. 1989] propone un algoritmo basado en bounded lag que se
llama filtered rollbacks. En [Dickens y Reynolds 1990] se propone un algoritmo
aplicable a las técnicas conservativas denominado local roll-backs. El algoritmo
breathing time buckets [Steinman 1991] utiliza una combinación de procesamiento
síncrono con barreras, ventanas temporales y local roll-back.
Existen muchos más algoritmos híbridos y adaptativos y consideraciones de los
anteriores que no se han comentado por no haber lugar en el presente trabajo. [Fujimoto 2000] y [Zarei 2000] contienen abundantes referencias para poder conocerlos.
Técnicas paralelas para acelerar simulaciones
49
2.3.2.1
Entornos disponibles
Hay bastantes entornos disponibles para desarrollar modelos de simulación paralelos. La Tabla 2-2 resume las características de algunas de las herramientas disponibles. No se pretende profundizar en las características de cada herramienta ya que, en
definitiva, este no es el camino a seguir en este trabajo. Algunos de ellos son resultado de la implementación de la propuesta de un grupo de investigación. Un ejemplo
de entorno de propósito general de esta naturaleza es Masie.
A pesar de la dificultad de la aplicación de estas técnicas, su rendimiento ha hecho que algunos de los entornos se hayan desarrollado específicamente para resolver
un tipo de problemas. Por ejemplo, TWOS (Time Warp Operating System) [Rich y
Michelsen 1991] se ha desarrollado para soportar el desarrollo de simulaciones paralelas de batallas.
PORTS [Ghosh et al. 1994] es interesante porque ofrece ejecución sin riesgos para entornos de tiempo real porque posee propiedades favorables para predecir tiempos de ejecución de simulaciones.
Las herramientas paralelas disponibles suelen estar lejos de las herramientas secuenciales comerciales, aunque hay entornos como UPS (Utilitarian Parallel Simulator) [Nicol y Heidelberger 1996] que pretende extender el paralelismo a una herramienta comercial secuencial como es CSIM [CSIM 1998].
Nombre
Protocolo
Programación
Mapeado
Estadística
Estructurada
Manual
Sí
Estructurada
Manual
Sí
Objetos
Manual
Sí
Objetos
Manual
No
Varios
Punto de vista
Procesos/
Eventos
Procesos/
Eventos
Procesos/
Eventos
Procesos/
Eventos
Procesos
Especificación
Sí
CPSim
Conservativo
Eventos
Estructurada
Sí
[GTU 1994]
GTW
Optimista
Eventos
Estructurada
Manual
Manual y
automático
Manual
[Wonnacott y
Bruce 1995]
[Preiss 1989]
Sí
ParaSol
Optimista
Procesos
Objetos
Manual
No
PORTS
PSK
SimKit
SpaDES
SPEEDES
Optimista
Optimista
Optimista
Optimista
Optimista
[Das et al. 1994]
[Edward et al.
1995]
[Ghosh et al. 1994]
Eventos
Eventos
Procesos
Eventos
Objetos
Objetos
Objetos
Objetos
No
No
No
No
TWOS
Optimista
Eventos
Objetos
WARPED
Optimista
Eventos
Objetos
Automático
Manual
Manual
Manual
Manual y
automático
Manual
Maisie
Varios
Parsec
Varios
Moose
Varios
APPOSTLE
YADDES
Optimista
Referencia
[Bagrodia y Lio
1995]
Actualización de
Maisie
[Teo et al. 1996]
[Steinman 1992]
Sí
No
Tabla 2-2. Algunos entornos para simulación paralela por eventos discretos.
50
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
2.3.2.2
Crítica a la simulación paralela por eventos
El grado en el que los procesos pueden predecir los futuros eventos juegan un rol
crítico en la realización de la estrategia conservativa. Actualmente, más importante
que predecir eventos futuros es el hecho de que un proceso con lookahead de L pueda garantizar que ningún evento de los que él puede predecir, serán generados con un
tiempo clock + L. Con esto se asegura que otros procesos que ya han recibido mensajes de eventos, los puedan procesar de forma segura.
La desventaja más obvia del mecanismo conservativo es que no puede explotar al
máximo el paralelismo disponible en la simulación de una aplicación. Si se tiene un
evento EA que puede afectar directamente o indirectamente a otro EB empleando los
métodos conservativos, los eventos EA y EB se ejecutarán secuencialmente. Si la simulación es tal que el evento EA raramente afecta a EB, estos dos eventos podrían
haber sido procesados concurrentemente la mayor parte del tiempo. En general, si se
encuentra en el peor caso para determinar cuándo es seguro procesar, el enfoque conservativo será generalmente pesimista y forzará a una ejecución secuencial cuando
ello no es necesario. Si no se tiene en cuenta el lookahead, para el evento que tenga
en una simulación el tiempo de ocurrencia más pequeño, la dependencia que tenga
con otro evento puede afectar mucho, forzando a una ejecución secuencial.
La mayoría de los esquemas conservativos requieren por parte del programador
un conocimiento concienzudo sobre el comportamiento de los procesos lógicos para
poder suministrar un protocolo de sincronización. Los algoritmos de detección y recuperación del interbloqueo son quizás los únicos enfoques conservativos que no
requieren explícitamente tales conocimientos por parte del usuario. Información como el incremento del tiempo de servicio mínimo o la garantía de que ciertos eventos
no afecten a otros (por ejemplo, la llegada de un evento a una red de colas puede no
afectar a la tarea que actualmente está siendo servida) puede ser difícil de determinar
cuando se tienen simulaciones complejas.
Realizar un programa de simulación paralela por eventos conservativo requerirá
seguir las guías que se aplican a la programación paralela para desarrollar el código
de la simulación paralela: seleccionar la apropiada granularidad y maximizar el paralelismo. Pero, además, el programador requiere estar bastante familiarizado con el
mecanismo de sincronización y con el programa de la aplicación para maximizar su
efectividad que, a menudo, producirá como resultado un código frágil que será difícil
de modificar y mantener. Una solución a este problema es definir o utilizar un len-
Técnicas paralelas para acelerar simulaciones
51
guaje de simulación donde la información esencial necesaria para el mecanismo de
simulación pueda ser extraída automáticamente desde las primitivas de simulación.
En cuanto al rendimiento de las estrategias conservativas, el grado en el que los
procesos pueden mirar adelante y predecir eventos futuros (lookahead) juega un papel fundamental. Actualmente, lo que es más importante que predecir eventos futuros
es el hecho de que un proceso con lookahead L pueda garantizar que ningún evento,
a excepción de los que pueda predecir, se generará a partir de reloj+L. Esto permite a
otros procesos tratar mensajes de eventos pendientes que ya se han recibido.
Programar adecuadamente el modelo de simulación para explotar el lookahead
puede mejorar el rendimiento drásticamente. En [Fujimoto 1990] se puede ver el
rendimiento de un modelo de servidor central realizado con el algoritmo de detección
y recuperación de bloqueos ejecutado sobre un multiprocesador BBN Butterfly y el
modelo particionado en tres LP. Cuando el número de clientes aumenta en el modelo,
se alcanza una aceleración cercana al ideal de 3. Este buen comportamiento se debe
al buen aprovechamiento del lookahead y a que el modelo es ideal para explotarlo,
cosa que no sucede en muchos modelos.
Mediante el uso de cargas sintéticas, en [Fujimoto 1989] se caracteriza el lookahead cuantitativamente y se presentan resultados empíricos para demostrar la importancia de este factor para obtener buen rendimiento. En función del lookahead, las
aceleraciones (speed-up) para estas cargas sintéticas fueron desde tan lento como la
ejecución secuencial hasta cercano al ideal (N en N procesadores) sobre 16 procesadores en un BBN Butterfly. Incluso se muestra que el mal rendimiento obtenido en
un artículo se solventa reprogramando adecuadamente el lookahead.
En general, los mecanismos conservativos necesitan predecir lo que no va a ocurrir para funcionar satisfactoriamente. La explotación efectiva del lookahead parece
ser la clave para obtener un buen rendimiento con estos métodos.
Los métodos optimistas basados en time warp han demostrado buenos resultados
de rendimiento, por lo que son una buena solución en problemas reales. Un problema
de este protocolo es el consumo de memoria, que intentan controlar propuestas posteriores, de las cuales se han descrito los fundamentos de algunas.
La experiencia práctica con la simulación paralela optimista mostrada en diversos
artículos indica que es posible que el optimismo desmedido se puede controlar y que
se pueden diseñar entornos de simulación paralelos eficientes.
52
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
Se observa que en la mayor parte de los problemas prácticos que tienen algún interés, el lookahead que aparece es esencial para obtener una mayor rapidez empleando algoritmos conservativos. ¿Sucede de igual forma en algoritmos optimistas? La
evidencia empírica indica que el rendimiento de los algoritmos optimistas mejoran el
lookahead, pero esto no es un prerrequisito para obtener un buen rendimiento.
El problema más serio del mecanismo de time warp es que necesita periódicamente salvar el estado de cada proceso lógico, lo que conlleva tener una sobrecarga
en el rendimiento, incluso si se tiene un vector de estado pequeño. La sobrecarga de
salvar el estado limita la efectividad del time warp a aplicaciones donde la cantidad
de computación requerida para procesar un evento sea más significativo que el coste
de salvar el estado del vector.
Se han desarrollado algunos trabajos para crear modelos analíticos que permiten
estudiar el comportamiento del time warp [Wagner y Lazowska 1989]. Todos los
modelos existentes requieren de asunciones simplificadoras. Por ejemplo, los costes
de la sobrecarga de la comunicación y los costes de salvar el estado a menudo se
asume que son cero. Sin embargo, empleando dichos modelos se obtienen conocimientos para poder implementar time warp. Una de las asunciones delicada de estos
modelos es el coste de realizar la vuelta atrás en un proceso lógico; se puede obtener
resultados radicalmente diferentes dependiendo de lo que se haya asumido. La conclusión es que dependiendo de dichas asunciones relacionadas con el coste del
rollback, no hay ningún tiempo de ejecución óptimo, ya que se pueden obtener tiempos que son arbitrariamente mayores que los obtenidos en una computación secuencial.
En cuanto al rendimiento del algoritmo optimista time warp y algunas de sus variantes se han obtenido resultados satisfactorios con problemas reales. Aceleraciones
importantes se han obtenido en escenarios de guerra, redes de comunicaciones, sistemas biológicos y simulaciones de fenómenos físicos. También ha mostrado resultados prometedores en simulaciones productor-consumidor y simulación de hardware
digital.
En el caso de los algoritmos conservativos, el lookahead es esencial para obtener
aceleraciones significativas. Las evidencias empíricas indican que mientras el lookahead mejora el rendimiento de los algoritmos optimistas, no es un prerrequisito
para obtener un buen rendimiento. En [Fujimoto 2000] se describe un claro ejemplo.
En [Loucks y Preiss 1990] se demuestra que se pueden obtener mejoras del rendi-
Técnicas paralelas para acelerar simulaciones
53
miento significativas si se emplean conocimientos específicos de la aplicación para
optimizar la ejecución.
Se han hecho estudios comparativos del rendimiento de time warp, evitación de
bloqueo, y, detección de bloqueo y recuperación sobre diferentes modelos de colas.
El rendimiento de time warp ha sido comparable o muy superior al de los algoritmos
conservativos.
Los diferentes resultados parecen soportar lo que proclaman los que defienden el
optimismo: que time warp puede explotar transparentemente cualquier paralelismo
disponible en el modelo de simulación sin necesidad de información específica del
usuario.
Aunque los resultados son muy esperanzadores, es necesario destacar que la sobrecarga debida a la salvaguarda del estado puede degradar notablemente el rendimiento. Se debe asegurar que la granularidad de la computación del evento es significativamente mayor que la sobrecarga de salvaguardar el estado para conseguir un
buen rendimiento.
Los defensores del enfoque conservativo indican que time warp es más complejo
de implementar, sobre todo en los aspectos de manipulación de errores. Los implementadores pueden cometer errores de diseño aparentemente pequeños que pueden
dar lugar a un rendimiento extremadamente pobre. Además, la depuración puede ser
muy difícil debido a los complejos escenarios de vuelta atrás. En definitiva, para implementar modelos "time warp" es necesaria experiencia y buena suerte.
Los años de investigación en los protocolos de sincronización no revelan un claro
vencedor para todas las aplicaciones. El hecho queda en que el protocolo ideal para
cada situación es dependiente del problema. La Tabla 2-3, extraída de [Fujimoto
2000], da unas líneas generales para decidir que aproximación es adecuada a cada
caso.
Aspecto
Sobrecarga
Paralelismo
Protocolo conservativo
Protocolo optimista
Entornos de ejecución complejos que
Entorno de ejecución sencillo.
requieren salvaguarda del estado,
Puede necesitar mecanismos esperecolección de memoria no usada.
ciales para topologías de LP dináMecanismos especiales para gestión
micas. Menor sobrecarga si hay un
de memoria dinámica, E/S y errores
buen lookahead.
de ejecución.
Limitado por escenario corresponLimitado por las dependencias acdiente al peor caso. Requiere un
tuales más que por las dependencias
buen lookahead para la ejecución
potenciales.
concurrente y la escalabilidad.
54
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
Desarrollo de la
aplicación
Potencialmente complejo. Código
frágil para explotar el lookahead.
Más robusto. Menos dependiente del
lookahead. Mayor transparencia de
los métodos de sincronización.
Adaptación de
simulaciones
existentes
Inclusión directa en federaciones.
Requiere mecanismos adicionales
para soportar la vuelta atrás.
Tabla 2-3. Comparación de los métodos de sincronización conservativos y optimistas.
2.3.3 Réplicas paralelas de modelos de simulación
Una aproximación sencilla y obvia para aprovechar el potencial de varios computadores o de un multiprocesador consiste en ejecutar réplicas del modelo de simulación en cada procesador y promediar al final de la ejecución. En principio, esta
aproximación es extremadamente eficiente, al no necesitarse coordinación entre procesadores hasta el final de la simulación, lo que supone una sobrecarga apenas perceptible.
Un primer paso en este sentido es hacer ejecuciones independientes con parámetros distintos. [Biles et al. 1985] considera la posibilidad de asignar experimentos de
simulación a una red de computadores. Se usa una configuración jerárquica de procesadores en la que cada procesador del nivel inferior utiliza el mismo modelo con diferentes parámetros. Los resultados pueden ser usados para optimización o cribado
de factores cuando se hace el análisis en los procesadores de niveles superiores. Sin
embargo, ninguna simulación se ejecuta más rápido, y las decisiones sobre todos los
parámetros de todas las ejecuciones a realizar en paralelo deben hacerse antes de que
cualquier procesamiento tenga lugar. Por tanto, no permite una toma de decisiones
interactiva, en la que los parámetros de una ejecución depende de los resultados de
una previa. La toma de decisión secuencial es importante para optimización. Además, a menudo es mejor pocas ejecuciones muy rápidas que muchas lentas para la
toma de decisiones en tiempo real.
En nuestro contexto interesan las técnicas de réplicas que permitan disminuir el
tiempo de ejecución de una simulación, por lo que la propuesta anterior sólo puede
ser un complemento. Prácticamente todos los métodos secuenciales de análisis de la
salida de simulaciones se pueden adaptar, con mayor o menor éxito, a un entorno
paralelo. Todos ellos se basan en la posibilidad de generar más muestras estadísticas
por unidad de tiempo, con lo que, en principio, se reduce el tiempo de simulación
necesario. A continuación se describen las implementaciones paralelas de algunos de
los métodos de análisis de la salida.
Técnicas paralelas para acelerar simulaciones
55
Las simulaciones de los modelos medianamente complejos suelen ser largas y,
como los nuevos computadores van teniendo capacidades de procesamiento y de
memoria mayores, los modelos completos caben en un computador por lo que parece
viable seguir la línea de las réplicas en paralelo.
2.3.3.1
Réplicas independientes terminantes
Este método se aplica a simulaciones terminantes. Por ejemplo, tiempo necesario
en atender a 10 personas en una cola. Se fundamentan en lanzar simulaciones independientes en un grupo de máquinas e ir promediando resultados hasta que se alcancen las condiciones de finalización.
Esta aproximación se estudia, desde el punto de vista de la calidad estadística, en
[Glynn y Heidelberger 1991] cuando hay una restricción en el tiempo de terminación. Intuitivamente, se puede usar un conjunto paralelo de procesadores por un
tiempo t, lanzar réplicas en ellos y promediar los resultados observados al final de la
ejecución. Si se dispone de un conjunto grande de procesadores, se podría hacer t
pequeño, quizá ejecutando pocas simulaciones en cada procesador. Por tanto, se puede obtener estimadores muy precisos en un periodo muy corto de tiempo. Sin embargo, hay una serie de importantes problemas estadísticos con esta aproximación, sobre
todo si se usan muchos procesadores. Estos problemas se deben principalmente al
sesgo que implica la limitación de tiempo t. La primera pregunta que se plantea en el
artículo es qué hacer con las simulaciones que se están ejecutando cuando se alcanza
t. La solución menos arriesgada consiste en dejar que terminen antes de promediar,
pero en el caso de que no se pueda admitir esta condición, se ofrecen una serie de
políticas alternativas para intentar reducir el riesgo, siendo menos arriesgado aumentar t que aumentar el número de procesadores.
2.3.3.2
Réplicas independientes en régimen permanente
En [Glynn y Heidelberger 1992] se consideran los efectos de diferentes estrategias de borrado del transitorio inicial en réplicas en paralelo para la estimación en
régimen permanente, determinándose los ritmos de crecimiento relativos críticos
para: el número de procesadores (réplicas), la longitud de cada réplica, y la longitud
del borrado. Se consideran dos aproximaciones, una basada en el tiempo de simulación y otra basada en el tiempo de procesador. Se resumen a continuación los resultados que interesan a este trabajo.
56
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
Dado p el número de procesadores y t(p) la longitud de cada réplica, el propósito
es estimar α como la media en régimen permanente de un proceso X. A partir de las
asunciones descritas en el artículo se tiene,
T
1
X ( s )ds ⇒ α
T ∫0
1
C (T ) ⇒ λ−1
T
cuando T→∞, donde ⇒ denota convergencia fuerte hacia una distribución y C(T)
representa el tiempo de CPU acumulado en función de T, y s es tiempo simulado. λ-1
se puede interpretar como el promedio de tiempo de CPU que se invierte por unidad
de tiempo simulado.
La primera aproximación estudiada consiste en simular el proceso X hasta un
tiempo t en cada uno de los p procesadores disponibles. Se demuestra para una generalidad de procesos que,
σ1
D
α s ( p, t ( p )) ≈
pt ( p )
N (0,1)
D
donde ≈ denota aproximadamente igual en distribución y α s ( p, t ( p )) es el promedio de la observaciones de los p procesadores en donde se simula durante t(p).
Para un procesador se tiene,
D
α s (1, t ) ≈
σ1
t
N (0,1)
lo que significa un speed-up p que debiera ser el máximo obtenible. Por ejemplo,
D
α s (1, pt ( p)) ≈ α s ( p, t ( p))
Este teorema dado en el artículo se debe interpretar suponiendo que el horizonte
temporal t=t(p) en cada procesador p debería satisfacer que t>>p para que el algoritmo paralelo obtenga la máxima eficacia.
En el mismo artículo se enuncia otro teorema que considera la situación en la que
se elimina el transitorio inicial. Así, si βs(p)/t(p) es la fracción del total de tiempo
Técnicas paralelas para acelerar simulaciones
57
simulado que se borra y esta cantidad es asintóticamente una inapreciable fracción
del tiempo, entonces se llega a que,
pt ( p) (α 1 ( p) − α ) ⇒ σ 1 N (0,1) según p→∞
Dicho teorema muestra que eliminando un modesto transitorio inicial se puede
reducir la longitud del horizonte temporal significativamente sin afectar al factor p de
speed-up. En particular, si t(p)=pr(r>0), el speed-up p se retiene con tal que
βs(p)=pε(0<ε<r). Por tanto, cuando se implementa adecuadamente el borrado del
transitorio inicial, las p veces en que se incrementa la eficiencia se mantiene para
horizontes temporales que crecen, esencialmente, arbitrariamente lentos con respecto
a p. Un resultado similar se deriva si el sesgo decae rápidamente de forma polinómica.
Otro teorema interesante que se enuncia se refiere a la eliminación de una fracción fija del tamaño de la simulación y, por tanto, la fracción no es despreciable. Esta
regla, aunque es una implementación razonable, tiene un coste en términos de mayor
variabilidad.
Suponiendo que el sesgo b(t)→0 exponencialmente rápido, si βs(p)=βt(p)
(0<β<1) y t(p)=pr(r>0) entonces
pt ( p) (α s ( p) − α ) ⇒ (1 − β ) − (1 / 2 ) σ 1 N (0,1) según p→∞
Igual que para el resultado del teorema anterior, éste propone que el horizonte
temporal sobre el que se consigue el incremento p en eficiencia es ampliado considerablemente utilizando borrado inicial de valores. Sin embargo, debido a que se elimina una fracción fija del total de observaciones, el coste que se paga es que la varianza
es asintóticamente incrementada por un factor de (1-β)-1. Por otra parte, para β=0,1,
el incremento en la varianza es de solo un 11% aproximadamente, con lo que el coste
que implica tal procedimiento es bastante modesto.
Según el artículo, el inconveniente de usar el tiempo de simulación para controlar
el tamaño de la réplica implica que, si los procesadores se utilizan en exclusiva para
este trabajo, el tiempo de procesador sea distinto, siendo la duración de la simulación, el de la réplica con un mayor tiempo de procesador, y quedando flecos de tiempo de procesador libres en el resto de procesadores que pueden llegar a ser importantes. Todo ello lleva a proponer estimadores basados en el tiempo de procesador,
destacando los autores un estimador con borrado inicial que es el que, según los auto-
58
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
res, es el más adecuado del artículo. El razonamiento que se aplica a estos estimadores permite su aplicación a otros tipos de medida del tiempo, por ejemplo, tiempo
real, número total de eventos procesados, número total de eventos de un cierto tipo
procesados, etc.
Los dos estimadores más adecuados utilizan un borrado de tamaño fijo del transitorio inicial, de igual forma que en la propuesta anterior, pero medido en tiempo de
computación. El primer estimador es,
α T ( p, c ) ≡
1 p Yi (c)
∑
p i =1 τ i (c)
donde Yi(c) es la estimación de la réplica i, y τi(c) es el tiempo de réplica que
queda tras eliminar un tamaño fijo del comienzo de la réplica.
El segundo estimador es,
p
α R ( p, c) ≡
∑ Y (c )
i
i =1
p
∑ τ (c )
=
Y (c )
τ (c )
i
i =1
donde Y (c) = (1 / p)∑i =1 Yi (c) y τ (c) = (1 / p)∑i =1τ i (c) . Obsérvese que se trata
p
p
de un estimador de la relación entre dos variables, como el que se usa para el método
de las regeneraciones.
La cobertura de estos dos estimadores es evaluada experimentalmente con varios
modelos en [Gynn y Heidelberger 1992b]. Para el cálculo de los intervalos de confianza se emplea la distribución t-Student para αT(p,c) y la distribución normal Ζ
para αR(p,c), llegándose a la conclusión de que αR(p,c) es muy superior a αT(p,c)
cuando el número de procesadores crece (se emplean de 8 a 512 procesadores).
La problemática de αT(p,c) es que contiene dos fuentes de sesgo que tienen el
mismo orden de magnitud: el sesgo de inicialización y el sesgo de la relación entre
dos variables, pues el denominador también es una variable aleatoria. Mientras un
adecuado borrado del comienzo de cada simulación elimina el primer sesgo, el segundo no es afectado. Cuando se emplean muchos procesadores, este sesgo da lugar
a una estimación sesgada y a la correspondiente pérdida de cobertura del intervalo de
confianza. Ello se manifiesta en los experimentos realizados con una cantidad moderada de procesadores (entre 32 y 64).
Técnicas paralelas para acelerar simulaciones
59
El efecto de usar αR(p,c) en lugar de αT(p,c) permite utilizar muchos procesadores durante un tiempo de computación dado o hacer muchas ejecuciones cortas dado
un número de procesadores.
Los resultados del artículo también tienen sus implicaciones en el método de las
réplicas con un solo procesador. En este método, la longitud de la réplica se determina a menudo ya sea por el número total de eventos, un tiempo de simulación, un
tiempo de computación, o el número de eventos de un tipo particular (por ejemplo, el
número de salidas de una cola). Cuando se estiman varios parámetros en un modelo
de colas habrá casi siempre parámetros que son estimados en distintas escalas temporales. Por tanto, el denominador de las estimaciones de algunos parámetros serán
aleatorios, dando lugar a sesgos por ratios. Por ejemplo, si el tiempo de simulación es
utilizado para controlar la longitud de la réplica, la estimación del tiempo de respuesta tendrá denominador aleatorio (el número de clientes que salen de la cola). Por
otra parte, si se utiliza la contabilización de eventos para controlar la longitud de la
réplica, entonces la estimación de las longitudes de cola tendrán denominador aleatorio (el tiempo de simulación). Por tanto, el sesgo por ratios puede ser un problema,
incluso en simulaciones monoprocesador. Sin embargo, suele haber pocos motivos
para correr muchas réplicas cortas en un solo procesador, pues ya sea usando el método lotes (batch-means) o ejecutando pocas réplicas largas, será menos sensible al
sesgo por inicialización.
En [Lin 1994] se estudia el rendimiento de las políticas de planificación para réplicas de tamaño fijo ejecutadas en paralelo. Dicho trabajo es interesante porque estas políticas pueden afectar significativamente a la complejidad temporal y a las propiedades estadísticas del método. El estudio pretende utilizar procesadores compartidos por otras aplicaciones y donde la carga puede cambiar dinámicamente. Las políticas inicialmente descritas son:
•
FRP (fixed number of replications per processor). Suponiendo que se desean
ejecutar N=MP réplicas en P procesadores, entonces se lanzan M en cada
uno. Los problemas básicos de esta aproximación estática son que se debe
calcular N antes de empezar a simular (lo cual es un inconveniente si se pretende calcular el error según van llegando resultados de simulaciones), y los
procesadores que quedan libres no pueden usarse para ejecutar réplicas asignadas a otros procesadores.
60
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
•
FNC (first N replications completed). Política dinámica sencilla que lanza réplicas en los procesadores y, cuando un procesador termina, se le asigna una
nueva réplica. La condición de fin de la simulación se reevalúa con cada nueva llegada de un resultado de una réplica, y cuando la condición se satisface,
se finalizan el resto de réplicas en marcha. Este esquema tiende a recoger los
resultados de las réplicas con menores tiempos de ejecución, que pueden estar
correlados con el valor de salida obtenido, pudiendo llevar a un resultado incorrecto en la estimación como se comenta en [Heidelberger 1988] y se obtine en un resultado experimental desarrollado en el artículo ahora comentado.
•
FNI (first N replications initiated) es una política dinámica propuesta en
[Bhavsar e Isaac 1987] y [Heidelberger 1988] que pretende evitar los problemas de sesgo de políticas como la anterior, al intentar que los resultados recogidos sean independientes del tiempo de ejecución. En este caso las réplicas
se numeran (por ejemplo en numeración ascendente) y los resultados de una
réplica j que haya terminado no se pueden utilizar hasta que hayan llegado los
i<j resultados de réplicas previas.
Debido a los problemas de las otras propuestas, se estudia un entorno para FNI
donde tienen especial importancia los aspectos de tolerancia a fallos y equilibrado de
carga, pues se pretende trabajar con redes de estaciones de trabajo compartidas y
heterogéneas. El entorno es capaz de seleccionar estaciones con poca carga y realizar
una monitorización de la misma de manera que, en caso de cargase una estación,
migrar el trabajo a otra. También es capaz de detectar las estaciones que fallan y rearrancar los trabajos en otra.
Desde este punto de vista, se hace un estudio analítico de los efectos de la carga y
la tolerancia a fallos concluyéndose que es necesario limitar los recursos computacionales para esta técnica por dos razones: primero, ejecutar una réplica en una estación lenta puede incrementar mucho la carga que afecta a otras aplicaciones, y segundo, añadir una estación lenta extra puede aumentar la complejidad temporal del
método.
Para limitar el uso de los recursos computacionales se emplea un umbral de carga; así, seleccionando un umbral de carga pequeño, el rendimiento del método puede
mejorar si:
1. El número total de réplicas a ejecutar es pequeño.
2. El nivel de carga no cambia con frecuencia.
Técnicas paralelas para acelerar simulaciones
61
3. Los tiempos de ejecución en una situación de carga alta son mucho mayores
que en situaciones de carga baja.
4. Una estación está en una situación de baja carga más a menudo que en alta
carga.
En un experimento realizado, cuando se hace control de carga (no se usan estaciones con carga superior al 70%) se obtiene un 30% más de rendimiento que sin
control de carga. Estos son resultados particulares para el experimento hecho, pero
parecen indicar el beneficio de usar el control de carga.
2.3.3.3
Regeneración
También en [Glynn y Heidelberger 1991] se estudian las simulaciones regenerativas desde este mismo punto de vista. Ya en un trabajo previo ([Heidelberger 1988])
se mostraban los riesgos de la aproximación paralela, donde algunos estimadores
podían llevar a la convergencia hacia el valor incorrecto con gran probabilidad, sobre
todo si se incrementa el número de procesadores. Así se proponen otros estimadores
con convergencia más correcta, que relajan la penalización temporal al permitir que
todas o parte de las regeneraciones terminen.
2.3.3.4
Lotes (batch-means)
Otra posibilidad es utilizar la técnica de lotes (batch-means) en paralelo, ya sea el
estándar [Law y Carson 1979] o con lotes solapantes [Meketon y Schmeiser 1984].
En este método se deben tomar bastantes observaciones de régimen permanente
en cada réplica para determinar un buen tamaño de lote y este proceso se deberá realizar secuencialmente en cada réplica. Estas observaciones de régimen permanente se
deberán recoger después del transitorio inicial, por lo que será necesario detectarlo y
eliminarlo también en cada réplica.
Basándose en los resultados obtenidos en [Mota et al. 2000c], la versión con lotes
solapantes parece tener una buena aplicabilidad en este tipo de entorno.
2.3.3.5
Espectral
Otra posibilidad es utilizar el método espectral [Heidelberger y Welch 1981] en
paralelo. En [Raatikainen 1994], los resultados indican una disminución de la cobertura en la versión paralela propuesta aplicada a un buen conjunto de modelos de
prueba, sobre todo cuando el error relativo deseado es grande (20% en un experimento). Una crítica al artículo es el hecho de que cada experimento se repite sólo 100
62
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
veces para el análisis de cobertura, por lo que el estudio se debe tomar con reserva.
En cualquier caso, se recomienda el método sólo cuando se usen pocos procesadores
o se quiera un error relativo pequeño (por ejemplo, del 5%). Por los resultados se
piensa que el efecto se debe a que una cantidad de procesadores no muy pequeña y
un error relativo grande no fuerza a la simulación a continuar hasta que se cumplen
las condiciones de la distribución t-Student aplicada. Siempre en los casos en que se
requiere un nivel de confianza alto (por ejemplo, del 95%) y un error relativo pequeño (por ejemplo, del 5%) algunos modelos alcanzan una buena aceleración (speedup) cercana a la lineal (cuando se eliminan los tiempos de gestión) ofreciendo una
eficiencia del 85% para 5 procesadores que va disminuyendo según se aumenta el
número de procesadores.
En [Pawlikowski 1990] y [Yau 1999] se muestra otra implementación de [Heidelberger y Welch 1981] donde se presentan aceleraciones lineales y se hacen pruebas con hasta 8 procesadores. En este caso la cobertura es muy buena, posiblemente
porque se tiene especial precaución en eliminar el sesgo inicial aplicando un filtrado
doble basado en heurísticos [Gafarian et al. 1978] y [Schruben et al. 1983] y eliminando el sesgo por ratio según [Heidelberger 1988].
2.3.3.6
Entornos disponibles
A pesar de lo interesante de esta aproximación es destacable la falta de trabajo y
de entornos desarrollados en esta área. Algunos paquetes como QNAP [QNAP 1994]
incorporan alguna de estas posibilidades, pero siempre en formas muy sencillas y
guiadas por el usuario.
Los más destacables son EcliPSe [Rego y Sunderam 1992, Knop et al. 1994b,
Knop et al. 1995] y AKAROA [Pawlikowski et al. 1994].
El entorno EcliPSe tiene como principal propósito beneficiarse de redes heterogéneas de computadores para permitir obtener grandes prestaciones en la ejecución
paralela de simulaciones estocásticas. Se diseña para poderlo aplicar a gran variedad
de arquitecturas de procesamiento paralelo y distribuido. Según los autores ha demostrado su viabilidad práctica en la ejecución basada en réplicas paralelas en simulaciones que usan la descomposición en dominios.
EcliPSe forma parte de un sistema denominado ACES que tiene la arquitectura
mostrada en la Figura 2 - 1.
Técnicas paralelas para acelerar simulaciones
63
El nivel Conch provee a los niveles superiores de un multiprocesador virtual con
unas bibliotecas potentes para comunicaciones entre procesadores. Ariadne es un
proceso ligero diseñado para proporcionar diversas construcciones concurrentes para
Conch, EcliPSe y Sol. EcliPSe añade a Conch la facilidad para diseñar e implementar
aplicaciones basadas en réplicas y en descomposición del dominio. El nivel Sol es
una biblioteca C++ que facilita la construcción de modelos de simulación diseñada
para soportar los puntos de vista orientados al modelado mediante procesamiento de
eventos y mediante procesos interactuando.
GenA UIF
Sol
EcliPSe
DisplA
Graphics Tool
Conch
Ariadne
Sistema operativo nativo
Figura 2 - 1. Arquitectura de ACES.
También se aportan dos herramientas: GenA es un interfaz de usuario para generar aplicaciones y DiplA que sirve para mostrar información de una aplicación en
ejecución.
En nuestro caso interesa EcliPSe, que puede usarse sobre una aplicación secuencial con mínimos cambios y dando lugar a una ejecución formada por procesos concurrentes donde unos procesos “generadores” son coordinados por uno o varios procesos “monitor”. Un programa EcliPSe contiene los siguientes componentes:
•
Código de computación: Es el código que es ejecutado por cada generador,
siendo el responsable de la mayoría del trabajo a realizar. Usualmente requiere datos de entrada y devuelve resultados al monitor.
•
Funciones de monitor: Ejecutadas por los procesos monitor. Un monitor es
responsable de coordinar los cálculos hechos por un conjunto de generadores,
recoger datos y, finalmente, terminar las computaciones.
•
Declaraciones: Cada tipo de dato a intercambiar entre generadores y monitores debe declararse. Estas declaraciones permiten a EcliPSe encargarse del
manejo de los datos contenidos.
64
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
En el aspecto de interés para el presente trabajo cabe destacar que el método de
simulación paralelo aplicado es el de las réplicas de tamaño fijo, las réplicas terminantes o el método de las regeneraciones, proporcionando, en algunos casos, aceleraciones cercanas a la lineal con una gran cantidad de estaciones
El otro paquete interesante es AKAROA, que explota también la técnica de las
réplicas en paralelo, pero con una aproximación diferente a la anterior. También
puede utilizar estaciones heterogéneas para ejecutar simulaciones instrumentadas, de
manera que sean capaces de enviar información estadística a procesos colectores.
La comunicación entre los procesos se basa en una implementación similar a
RPC (Remote Procedure Call) basada en UDP (User Datagram Protocol) y donde se
procura que el intercambio de información sea independiente de la arquitectura. Ello
asegura una amplia portabilidad y adaptación a diferentes plataformas.
La técnica principal de análisis estadístico de la salida de este paquete es el método espectral según [Heidelberger y Welch 1981] adaptado a su ejecución paralela
[Pawlikowski et al. 1994].
Cada réplica es responsable, al comienzo de la simulación, de detectar el transitorio inicial utilizando un filtro doble basado en heurísticos [Gafarian et al. 1978] y las
pruebas propuestas en [Schruben et al. 1983]. Estos análisis se realizan a intervalos
preespecificados. Una vez superado el transitorio, se envía a intervalos fijos la información sobre la media y la varianza de las variables de salida de interés, calculándose la varianza mediante el método espectral. Cada réplica se ejecuta a la máxima
velocidad posible en su máquina, por lo que se producen diferentes cantidades de
muestras en cada una. El cálculo de la media global se realiza mediante una media
ponderada similar a la empleada en el método regenerativo para así evitar problemas
de sesgo por ratio, tomándose en consideración los resultados obtenidos en [Glynn y
Heidelberger 1992], y estimándose el intervalo de confianza mediante la distribución
t-Student.
Los resultados de cobertura ofrecidos por este paquete son muy buenos, ofreciendo además aceleraciones casi lineales con una cantidad moderada de procesadores
(resultados con hasta 8 procesadores).
2.3.3.7
Crítica a los métodos basados en réplicas paralelas
El método de las réplicas independientes de tamaño fijo en paralelo ([Heidelberger 1986, 1988], [Glynn y Heidelberger 1991]) tienen el problema de la elección del
Técnicas paralelas para acelerar simulaciones
65
tamaño de la réplica, ya que un tamaño inadecuado puede inducir una estimación
muy sesgada [Heidelberger 1988]. Además, esta aproximación tiene una gran sobrecarga cuando se aplica a simulación de régimen permanente, pues hay que eliminar
los transitorios iniciales.
Una alternativa consiste en ejecutar una réplica por computador y permitir repetidamente que el tamaño de la réplica aumente si no se cumplen las condiciones de
precisión para finalizar la simulación. Para ello recogen una cantidad fija de observaciones, se analizan, y si se cumplen las condiciones, se termina la simulación. Los
problemas de esta propuesta son:
1. El progreso de la simulación se verá retrasado por la réplica ejecutándose en
el procesador más lento, pues será la que requiera el tiempo más largo para
generar el número requerido de muestras. Ello ocurrirá también cuando los
procesadores sean idénticos debido a la compartición de recursos, la contención en la red y a una velocidad de ejecución del modelo no determinista.
2. Otro problema es la pobre eficiencia del estimador cuando el número de procesadores es pequeño. Si esto es así, entonces la normalidad del estimador
puntual se basa en que la media muestral de cada réplica esté distribuida normalmente. Dado que las observaciones a partir de las que se calculan las medias no son independientes, se necesita comprobar la aplicabilidad del Teorema Central del Límite.
Otra posibilidad es permitir que cada réplica se ejecute a la máxima velocidad
posible, evitándose una de las problemáticas de la aproximación anterior. Sin embargo, esto da lugar a un nuevo problema, pues el método supone (1) que las réplicas
son independientes y (2) idénticamente distribuidas. El tener réplicas con diferente
cantidad de observaciones hace que no se cumpla (2), pudiéndose tener diferentes
distribuciones porque la longitud es función de la variable aleatoria "número de observaciones". Al usarse estimadores de relación se introduce el problema del sesgo
por relaciones.
Los estimadores basados en ciclos regenerativos propuestos por ejemplo en [Rego y Sunderam 1991, 1992] son conceptualmente simples, pero requieren que el
usuario seleccione los puntos de regeneración, lo cual puede ser difícil en algunos
modelos y suele exigir un profundo conocimiento del sistema modelado.
Las técnicas paralelas basadas en lotes (batch-means) pueden ser bastante consumidoras de recursos, llevando a pobres aceleraciones. El principal problema radica
66
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
en la necesidad de que, n cada réplica es necesario detectar y eliminar el transitorio
inicial secuencialmente, y calcular un buen tamaño de lote, pudiéndose llegar a generar muchas más muestras de lo necesario para realizar la estimación puntual.
La aproximación espectral paralela ofrece resultados contradictorios en función
del autor consultado. En principio, la sobrecarga que introduce el método por lotes
debería ser extrapolable a este caso particular.
2.4
Conclusiones
Este capítulo pretende mostrar un resumen de las técnicas que permiten hacer una
estimación puntual de la media de un parámetro de salida de un modelo de simulación discreto orientado a eventos cuando éste se evalúa en régimen permanente.
La naturaleza de la simulación hace que dicha estimación puntual sea un problema estadístico que se puede complicar mucho en función del tipo de modelo, lo que
provoca que ésta sea una línea de trabajo abierta no resuelta aún satisfactoriamente.
Ello da lugar a distintas técnicas que intentan enfocar la solución del problema desde
distintos puntos de vista.
También se han analizado las técnicas para acelerar la obtención de resultados de
los modelos de simulación. Por una parte cabe destacar las técnicas puramente estadísticas, como la reducción de la varianza; y por otra, las técnicas basadas en la aplicación de paralelismo. La aplicación de técnicas de reducción de la varianza no
aporta una solución definitiva a la reducción de la complejidad de las simulaciones
porque, en general, es imposible conocer de antemano la reducción de varianza que
se obtendrá y puede requerir grandes esfuerzos en el desarrollo del modelo. A pesar
de todo los métodos de las variables antitéticas y de los números aleatorios comunes
suelen ser de aplicación general.
Las vías más interesantes para la aceleración consisten en la aplicación de técnicas paralelas. En este capítulo se han analizado brevemente los dos caminos disponibles.
Con respecto a la simulación distribuida (por descomposición del modelo) se
puede concluir que el modelado del sistema no se suele tener en cuenta, transformando el problema a resolver en el desarrollo del programa de simulación. Se tiene
tanto en cuenta lo relacionado con la computación, y con ello la aceleración, que se
Conclusiones
67
dejan de lado otros aspectos, como por ejemplo, la verificación de simulaciones paralelas.
Los estudios se basan normalmente en casos concretos y no existe un hilo común
entre las distintas investigaciones por lo que es imposible establecer comparaciones
entre ellos. Sería interesante disponer de una batería de pruebas que sirviesen de base
para hacer las comparaciones y comparar con otras posibilidades.
En general, no ha habido una gran aceptación de esta línea de trabajo por parte de
otras comunidades y sólo se ha podido aplicar con utilidad en casos muy concretos.
Algunas razones para ello son:
•
Las experiencias suelen hacerse sobre sistemas multiprocesadores, mientras
que la mayoría de usuarios disponen de máquinas uniprocesadoras.
•
Paralelizar una aplicación secuencial requiere un importante esfuerzo y experiencia.
•
Muchas propuestas dan lugar a nuevos lenguajes de simulación o a ampliaciones de los ya existentes. Lo ideal sería aprovechar cualquiera de los mecanismos anteriores en cualquier lenguaje de simulación disponible.
Las aceleraciones logradas son buenas si el modelo es convenientemente sintonizado, pero es extremadamente sensible a las características de la red de comunicación entre máquinas y a las fluctuaciones de carga. Como consecuencia, las simulaciones se suelen ejecutar en máquinas cuya carga es exclusivamente el modelo de
simulación en ejecución.
En definitiva, se puede concluir que esta técnica es adecuada para resolver un
problema muy concreto de simulación con unas importantes restricciones de tiempo
de respuesta o un tamaño de problema muy grande. No será adecuada como herramienta de propósito general que permita, con facilidad, acelerar cualquier tipo de
modelo, y menos aún si se desea que ello no implique un esfuerzo del modelador.
Más aún, el uso de la simulación distribuida introduce un nuevo problema en el
análisis estadístico, pues los datos de salida deberán ser ordenados de acuerdo al
tiempo de referencia del modelo simulado. Ésto puede ser difícil de conseguir cuando los datos se recogen de subprocesos ejecutándose asíncronamente en paralelo.
Además, será complejo saber saber cuándo es seguro analizar los datos para no
arriesgarse a una vuelta atrás típica de time warp.
68
Estudio de las técnicas de aceleración de simulaciones por eventos discretos
Si a pesar de todo se desean aplicar estas técnicas, de [Fujimoto 2000] se extrae
que explotar el lookahead puede llevar a código complejo y, por tanto, difícil de desarrollar y de mantener. Si el propósito es tener un entorno de simulación paralelo de
propósito general que proporcione un rendimiento robusto para un amplio abanico de
modelos y se quiere que el desarrollador no necesite estar familiarizado con los mecanismos de sincronización, entonces la aproximación optimista es la que ofrece más
esperanzas.
También de [Fujimoto 2000] se extrae la contrapartida a la afirmación anterior. Si
se quiere adaptar un modelo de simulación secuencial existente para su ejecución
paralela/distribuida, la sincronización conservativa es la que ofrece el camino más
directo. Ello es porque no se necesita añadir el mecanismo de salvaguarda del estado
ni tener en cuenta las consecuencias de la vuelta atrás sobre la E/S y sobre el tratamiento de la memoria dinámica.
Lo dicho decanta la balanza de este trabajo a utilizar la aproximación basadas en
réplicas de un mismo modelo en paralelo. La simulación basada en réplicas del modelo parece una propuesta sencilla al basarse en la ejecución de grupos de réplicas de
modelos de simulación y es, en principio, fácil de explotar en clusters de estaciones
de trabajo. Es una solución muy directa y natural que se aprovecha del principio del
paralelismo estadístico.
Como primera candidata y siguiendo los razonamientos del apartado 2.1.7, entre
las posibles elecciones del método de las réplicas se selecciona el método de las réplicas independientes de régimen permanente en paralelo, soslayando los problemas
detectados en trabajos previos.
De todas maneras, se tiene claro que el método de las réplicas independientes en
paralelo no es la solución perfecta para acelerar la obtención de resultados de simulaciones discretas por eventos, como tampoco lo es la solución de la descomposición
en procesos lógicos. En [Heidelberger 1986] se presenta un modelo matemático en el
que, siendo el objetivo obtener un estimador de la media en régimen permanente de
un parámetro de rendimiento de un sistema modelado, la elección en cuanto a la eficiencia estadística entre los dos métodos depende de:
•
El número de procesadores.
•
El factor de aceleración (speed-up).
•
La longitud de la simulación.
Conclusiones
69
•
El tamaño del transitorio inicial.
•
La variabilidad del proceso.
En dicho modelo, la eficiencia estadística se mide como el ratio entre los errores
cuadráticos medios, donde el error cuadrático medio se calcula como
mse[µˆ ] = b 2 + s 2
donde b es el sesgo ( b = µˆ − µ ) y s2 es la varianza de la muestra. Como conclusiones del modelo propuesto, el método de simulación distribuida es adecuado si se
tiene una aceleración razonable y las ejecuciones son cortas, o los transitorios son
grandes o se tienen muchos procesadores que impliquen que la aceleración → ∞ y el
método de la réplicas es adecuado en general para transitorios pequeños o ejecuciones largas.
Las condiciones que hacen inapropiado el método de las réplicas son:
1. El modelo es tal que una réplica no se puede completar en un solo procesador
en un tiempo razonable. Esto se puede deber a que el modelo es excepcionalmente grande y, por ejemplo, no cabe en la memoria de un solo procesador, o
en simulaciones de régimen permanente, para un modelo con una disipación
muy lenta del transitorio inicial.
2. La varianza de cada réplica es muy pequeña, en cuyo caso la salida es casi
determinista, y tener una gran cantidad de réplicas es simplemente un desperdicio de recursos computacionales.
Teniendo en cuenta estos problemas, se tratará de desarrollar un método paralelo
basado en réplicas independientes de régimen permanente. En primer lugar se estudiarán las características que debe tener el entorno de simulación para poder aprovechar un conjunto heterogéneo de computadores y para que sea sencillo emplear cualquier modelo de simulación por eventos discretos escrito en los lenguajes disponibles. A continuación, se propondrá y estudiará el comportamiento del analizador paralelo basado en réplicas independientes.
Los dos capítulos siguientes se dedican a describir este estudio.
3. Propuesta de un entorno paralelo para la ejecución de simulaciones
3
Propuesta de un entorno
paralelo para la ejecución
de simulaciones
El capítulo anterior explora distintas posibilidades para acelerar la obtención de
resultados de simulaciones por eventos discretos. Como conclusión se elige desarrollar un entorno basado en la ejecución de réplicas de un modelo de simulación y emplear la técnica de las réplicas independientes para analizar los datos de salida.
En este capítulo se presentan primeramente los objetivos que debe cumplir el entorno para poder aprovechar un conjunto heterogéneo de computadores de manera
que sea fácil explotarlo empleando cualquier lenguaje de simulación por eventos
discretos.
A partir de los objetivos se diseña un entorno formado por tareas concurrentes
especializadas en distintas tareas y que se describe en el apartado 3.4. Un tipo de
tareas del entorno serán precisamente las réplicas en paralelo, que serán modelos de
simulación convenientemente manipulados para poder ser gestionados por el entorno. En el apartado 3.4.3 se describe la base de la manipulación de los modelos, demostrándose en el apartado 3.4.3.1 el buen comportamiento de la técnica.
Para hacer frente a la naturaleza heterogénea de los computadores y a las variaciones de carga debidas al uso compartido de los computadores, se han desarrollado
métodos de medida de la potencia de simulación de las máquinas y del rendimiento
efectivo de las simulaciones. En los apartados 3.4.4 se resumen estas técnicas.
Para facilitar la comprensión de la adaptación de los modelos de simulación al
entorno paralelo, en el apartado 3.5 se provee de una breve guía de adaptación de
modelos escritos en los lenguajes SMPL y CSIM.
72
Propuesta de un entorno paralelo para la ejecución de simulaciones
Finalmente, el apartado 3.6 lista fragmentos de modelos adaptados para SMPL y
CSIM, comentándose los aspectos más destacables de la adaptación realizada.
Este capítulo es un extracto de [Perles 1998], [Perles et al. 1999] y [Perles et al.
1999b].
3.1
Introducción
El capítulo anterior explora las posibilidades para acelerar la obtención de resultados en simulaciones por eventos discretos.
Dos son los posibles caminos para acelerar simulaciones mediante técnicas paralelas: el primero consiste en dividir un modelo de simulación en procesos distribuidos que se ejecutan en máquinas diferentes, y el segundo consiste en ejecutar réplicas
de un modelo en computadores diferentes para generar muestras estadísticas a un
ritmo mayor. La Figura 3-1, Figura 3-2 y Figura 3-3 muestran gráficamente la idea.
+
Computador
Computador
Computador
Figura 3-1. Punto de partida: un modelo de simulación y un conjunto de computadores.
Computador
Computador
Computador
Figura 3-2. Aproximación mediante simulación distribuida.
Criterios de diseño del entorno paralelo de simulación
Computador
Computador
73
Computador
Figura 3-3. Aproximación mediante réplicas paralelas.
Cada aproximación tiene sus ventajas e inconvenientes en función del tipo de
problema a resolver. En las conclusiones del capítulo anterior se sugiere la segunda
vía, réplicas del modelo en paralelo, como la elección más adecuada.
El objetivo de este capítulo es describir el planteamiento y desarrollo de la infraestructura capaz de lograr el aprovechamiento de un conjunto de máquinas para
obtener un cluster débilmente acoplado donde ejecutar los experimentos de simulación.
Por “cluster débilmente acoplado” se entiende que los computadores que forman
el cluster están interconectados por redes de bajas prestaciones, por lo que el planteamiento de las interacciones entre procesos mediante comunicaciones será fundamental a la hora de diseñar el entorno de simulación paralela.
En [Perles 1994] se describe PSmpl , una primera aproximación al problema que
da la experiencia para plantear los objetivos de diseño de la herramienta de simulación paralela. Dicha experiencia ha permitido detectar una serie de problemas en el
planteamiento y permiten orientar mejor el trabajo de aprovechamiento de las posibilidades de los clusters de estaciones de trabajo heterogéneas en la resolución de los
costosos problemas de simulación.
Una estrategia fundamental ha sido dividir claramente los aspectos de gestión de
procesos de los aspectos de análisis estadístico de la salida. Una parte importante de
este capítulo se dedica al primer aspecto, mientras que el siguiente capítulo se dedica
exclusivamente a la estrategia de análisis estadístico.
3.2
Criterios de diseño del entorno paralelo de simulación
Partiendo de la idea de aprovechar la gran cantidad de estaciones de trabajo y PCs
de despachos y laboratorios, desocupados la mayor parte del tiempo, y aprovecharlos
para hacer simulaciones, nace la idea del entorno denominado “Cluster Simulation
74
Propuesta de un entorno paralelo para la ejecución de simulaciones
Experimenter” (CSX). CSX pretende posibilitar la realización de experimentos en
masa sin tener que preocuparse de localizar recursos computacionales para llevarlos
a cabo.
Con respecto a los modelos de simulación, los criterios de diseño del entorno
distribuido son:
•
Independencia del simulador
La técnica empleada debe ser lo suficientemente general como para que se
pueda aplicar a cualquier lenguaje de simulación por eventos discretos, ya sea
comercial o no. El objetivo es instrumentar simuladores como SMPL, CSIM,
SIM++, SIMPACK o incluso QNAP, sin tener que modificar las bibliotecas de
soporte. Obsérvese que se abarcan simuladores orientados a eventos y a procesos.
Este objetivo está reñido con el de transparencia descrito a continuación, pero
la experiencia previa con PSmpl así lo sugiere. La máxima transparencia obtenida
con SMPL aporta como ventaja la rapidez de aprovechamiento de la herramienta
desarrollada. Sin embargo, los inconvenientes se pagan cuando se pretende instrumentar un simulador comercial con el mismo propósito (por ejemplo CSIM o
QNAP).
•
Máxima transparencia
El modelo de simulación requerirá pocas modificaciones para ser adaptado al
entorno paralelo.
Con ello se pretende que la aplicación de la técnica sea directa e inmediata,
sin precisar importantes modificaciones del modelo original que dificulten la
aplicabilidad de la propuesta y precisen de un aprendizaje previo.
•
Control externo
En el modelo de simulación adaptado no se debe hacer explícito ni el tipo ni
la forma del gobierno del modelo, ni tampoco la naturaleza del análisis estadístico que se va aplicar. Con ello se pretende lograr la eliminación en el modelo de
todo tipo de gestiones que tengan que ver con el entorno paralelo, quedando el
modelo adaptado como una entidad pasiva que será gobernada externamente en la
medida de lo posible.
Criterios de diseño del entorno paralelo de simulación
•
75
Posibilidad de ejecución no monitorizada
Los modelos preparados para el entorno paralelo deberán poder seguir comportándose como su versión convencional. La idea básica es que se puedan escribir/adaptar los modelos para el entorno de simulación paralelo y puedan ser probados fueran del mismo. Una vez transcurrida la fase de depuración y validación
el modelo, éste podrá ser ejecutado en el entorno paralelo sin ninguna modificación. Con ello, se reduce el riesgo de introducir nuevos errores y se facilitan
enormemente modificaciones posteriores o ampliaciones del modelo.
•
Mínima sobrecarga del modelo de simulación
La ejecución de un modelo de simulación en el entorno paralelo no debe suponer una sobrecarga de procesamiento importante. Si la ejecución en paralelo
supone una necesidad de procesamiento extra notable, es posible que las mejoras
que aporte el entorno paralelo se diluyan debido a la sobrecarga introducida.
Con respecto a la infraestructura lógica de simulación paralela, en su diseño se
pretenden los siguientes objetivos:
•
Ocultación del subsistema de gestión paralela
En la aplicación desarrollada no deberá hacerse explícito el modelo de programación paralela empleado, procurando la máxima independencia del paradigma de programación paralela elegido. El propósito es facilitar la migración a
otros paradigmas.
•
Automatización del reparto de carga
La herramienta de simulación paralela deberá encargarse de tomar la decisión
para repartir los procesos entre las máquinas físicas. Idealmente, los procesos de
simulación tendrán capacidad de migrar dinámicamente de una máquina a otra
para equilibrar la carga y mejorar la garantía de funcionamiento.
•
Orientado a experimentos
Entendido un experimento como un conjunto de simulaciones, al entorno se le
debería dar la información de experimentos completos, con lo que tendrá criterios
más amplios para resolver óptimamente el problema completo. Un experimento
puede ser, por ejemplo, un modelo con diferentes parametrizaciones.
76
Propuesta de un entorno paralelo para la ejecución de simulaciones
•
Transferencia de información estadística limitada
Los procesos de simulación no deberán transmitir a los procesos monitores
todas las muestras de las variables estadísticas de salida del modelo. En principio,
se transmitirán sólo los estimadores puntuales de las variables de salida de interés
(la media muestral). Esta limitación se debe a que el entorno de ejecución no es
adecuado para una transmisión alta de información, debido al consumo de comunicaciones que provocaría. Como desventaja, esta estrategia limitará el tipo de
análisis estadístico a realizar.
•
Análisis estadístico flexible
Independizar los aspectos de gestión de los procesos de los de análisis estadístico. Con ello es posible desarrollar diferentes tipos de analizadores estadísticos de la salida, sin preocuparse de entorno de gestión de simulaciones subyacente.
Partiendo de estos criterios se ha diseñado el entorno paralelo que se presenta en
este capítulo.
3.3 Elección de PVM como entorno de programación
distribuida
Para el desarrollo del sistema de simulación paralelo es importante disponer de un
entorno de programación distribuida que permita simplificar el desarrollo de la aplicación. El criterio fundamental que debe cumplir el entorno para ser seleccionado es
que facilite la interacción y comunicación entre procesos repartidos en una red de
computadores heterogéneos. Se pretende que sea fácil utilizar máquinas con diferentes arquitecturas y diferentes sistemas operativos.
Cuando se empezó este trabajo [Perles 1994], la investigación en el área de los
entornos de programación distribuida sobre clusters estaba en auge. Como resultado,
una serie de paradigmas y herramientas se han implantado firmemente como estándar
de facto en distintas arquitecturas hardware/software.
Todos estos entornos se pueden clasificar en dos grupos: orientados a memoria
compartida y orientados a paso de mensaje. Algunos poseen características de ambos grupos y otros, como Linda [Mattson et al. 1991], aplican paradigmas curiosos y
potentes. Se puede concluir que todo lo realizable en un entorno, se puede hacer en
Elección de PVM como entorno de programación distribuida
77
otro. La diferencia está en la facilidad de implementación y en las herramientas que
aportan.
En [Turcotte 1993] se dispone de una amplia relación de entornos distribuidos
disponibles y se comentan sus características. Para este trabajo se consideraron entornos como Express [Kolawa 1991], P4, Linda en la implementación Glenda y
Network-Linda [Sherman 1990], MPI [MPI 1994], etc.
Finalmente, el entorno seleccionado fue PVM (Parallel Virtual Machine) [Geist
et al. 1994]. PVM es un sistema software que permite ver a una red heterogénea de
máquinas como un único recurso paralelo, y ha sido producido por la colaboración
del Oak Ridge National Laboratory, la Universidad de Tennessee, la Universidad de
Emory y la Universidad de Carnegie Mellon, con el propósito de facilitar la computación paralela heterogénea. Como ventaja, PVM es de dominio público y su código
fuente está disponible.
Bajo PVM, una colección de máquinas secuenciales, paralelas y vectoriales definida por el usuario, se ve como una gran computadora de memoria distribuida. Este
entorno aporta las funciones para arrancar tareas que se comunicarán o sincronizarán
entre ellas con total libertad. Además, maneja la conversión necesaria de tipos de
datos en la comunicación entre máquinas distintas.
La Figura 3-4 muestra el esquema de un entorno PVM. Este sistema está formado
por dos partes:
• Un demonio llamado "pvmd", instalado en todos los ordenadores que
componen la máquina virtual. Este demonio esta diseñado para que pueda
instalarlo cualquier usuario con un login válido. Así, cuando un usuario
quiere ejecutar una aplicación PVM, debe crear primero la máquina virtual
y después ejecutar su aplicación desde la línea de órdenes. Múltiples usuarios pueden configurar máquinas virtuales solapadas, y cada usuario puede
ejecutar más de una aplicación simultáneamente.
• Una biblioteca de interfaz con PVM, que contiene rutinas ejecutables por
el usuario para el paso de mensajes, lanzamiento de procesos, coordinación
de las tareas y modificación de la máquina virtual. Las aplicaciones deberán ser enlazadas con esta biblioteca para poder utilizar PVM.
La potencia de este entorno radica en la facilidad con que se explota la heterogeneidad de la máquina virtual. No ocurre lo mismo con otros entornos, que precisan
78
Propuesta de un entorno paralelo para la ejecución de simulaciones
hacerla explícita para efectuar tareas como el paso de mensajes. Esta heterogeneidad
implícita de PVM tiene su contrapartida en la dificultad añadida del mecanismo para
la creación de mensajes que hace a este entorno muy susceptible a errores de programación y excesivamente prolijo en llamadas a sus bibliotecas.
Figura 3-4. Anatomía de PVM versión 3.
PVM aporta bibliotecas para los lenguajes C y FORTRAN 77. Como muestra, se
da a continuación un ejemplo en C de un modelo maestro/esclavo con comunicación
entre los esclavos.
Elección de PVM como entorno de programación distribuida
// ----------- programa maestro ------------#include "pvm3.h"
#define SLAVENAME "slave1"
main()
{
int mytid;
/* mi TID */
int tids[32];
/* TIDs de los esclavos */
int n, nproc, numt, i, who, msgtype, nhost, narch;
float data[100], result[32];
struct pvmhostinfo *hostp[32];
/* unirse a PVM */
mytid = pvm_mytid();
/* fijar el numero de esclavos */
/* no se debe leer la entrada estandar si es hija */
if( pvm_parent() == PvmNoParent ){
puts("Cuantas tareas esclavo (1-32)?");
scanf("%d", &nproc);
}
else{
pvm_config( &nhost, &narch, hostp );
nproc = nhost;
if( nproc > 32 ) nproc = 32 ;
}
/* arrancar tareas esclavas */
numt=pvm_spawn(SLAVENAME, (char**)0, 0, "", nproc, tids);
if( numt < nproc ){
printf("Problemas lanzando esclavos. Aborto. Codigos
error:\n");
for( i=numt ; i<nproc ; i++ ) {
printf("TID %d %d\n",i,tids[i]);
}
for( i=0 ; i<numt ; i++ ){
pvm_kill( tids[i] );
}
pvm_exit();
exit();
}
/* programa del usuario */
n = 100;
/* preparar datos( data, n ); */
for( i=0 ; i<n ; i++ ){
data[i] = 1;
}
/* difundir los datos iniciales a los esclavos */
pvm_initsend(PvmDataDefault);
pvm_pkint(&nproc, 1, 1);
pvm_pkint(tids, nproc, 1);
pvm_pkint(&n, 1, 1);
pvm_pkfloat(data, n, 1);
pvm_mcast(tids, nproc, 0);
79
80
Propuesta de un entorno paralelo para la ejecución de simulaciones
/* esperar los resultados de los esclavos */
msgtype = 5;
for( i=0 ; i<nproc ; i++ ){
pvm_recv( -1, msgtype );
pvm_upkint( &who, 1, 1 );
pvm_upkfloat( &result[who], 1, 1 );
printf("He recibido %f de %d\n",result[who],who);
}
/* Programa terminado. Dejo PVM antes de salir. */
pvm_exit();
}
// ----------- programa esclavo ------------#include <stdio.h>
#include "pvm3.h"
main()
{
int mytid;
/* mi TID */
int tids[32];
/* TIDs de las tareas
int n, me, i, nproc, master, msgtype;
float data[100], result;
float work();
*/
/* Asociarse a PVM */
mytid = pvm_mytid();
/* Recibir los datos del maestro */
msgtype = 0;
pvm_recv( -1, msgtype );
pvm_upkint(&nproc, 1, 1);
pvm_upkint(tids, nproc, 1);
pvm_upkint(&n, 1, 1);
pvm_upkfloat(data, n, 1);
/* Determinar que esclavo soy (0 -- nproc-1) */
for( i=0; i<nproc ; i++ )
if( mytid == tids[i] ){ me = i; break; }
/* Hacer los calculos con los datos */
result = work( me, n, data, tids, nproc );
/* Enviar los resultados al maestro */
pvm_initsend( PvmDataDefault );
pvm_pkint( &me, 1, 1 );
pvm_pkfloat( &result, 1, 1 );
msgtype = 5;
master = pvm_parent();
pvm_send( master, msgtype );
/* Programa terminado. Dejar PVM antes de salir */
pvm_exit();
}
float work(me, n, data, tids, nproc )
/* Ejemplo simple, los esclavos intercambian los datos */
/* con el vecino de la izquierda */
Elección de PVM como entorno de programación distribuida
81
int me, n, *tids, nproc;
float *data;
{
int i, dest;
float psum = 0.0;
float sum = 0.0;
for( i=0 ; i<n ; i++ ){
sum += me * data[i];
}
/* muestra de la comunicacion nodo a nodo */
pvm_initsend( PvmDataDefault );
pvm_pkfloat( &sum, 1, 1 );
dest = me+1;
if( dest == nproc ) dest = 0;
pvm_send( tids[dest], 22 );
pvm_recv( -1, 22 );
pvm_upkfloat( &psum, 1, 1 );
return( sum+psum );
}
Un aspecto crítico del entorno distribuido de simulación es el comportamiento de
las comunicaciones entre procesos. Se ha construido un programa para hacerse una
idea de la velocidad de transferencia de mensajes, y se ha probado en un cluster formado por 5 máquinas HP7000/735 con sistema operativo HP-UX 9.01.
La aplicación está formada por dos partes: un maestro que envía mensajes con
una cantidad de datos de tipo double prefijada y espera la respuesta de un esclavo,
y un esclavo que responde con un mensaje vacío cada vez que le llega un mensaje.
Se puede configurar la aplicación para probar todas las variantes de comunicación de
PVM.
El programa toma dos tiempos: el tiempo de empaquetar y enviar (cabe destacar
que una llamada pvm_send() termina cuando el mensaje está seguro en la máquina destino), y el tiempo de empaquetar, enviar y recibir la respuesta del esclavo. Tras
realizar varias repeticiones de la comunicación, se devuelve como resultado el valor
mínimo, medio y máximo del primer tiempo, y el valor medio del segundo.
La Figura 3-5 representa el tiempo medio para transferir mensajes de diferente
longitud. Estos tiempos corresponden al de empaquetado y transferencia. Se observa
el mayor coste para la codificación XDR (codificación independiente de la arquitectura), sobretodo para grandes mensajes. El mayor rendimiento corresponde a la trans-
82
Propuesta de un entorno paralelo para la ejecución de simulaciones
ferencia PvmInplace (esta opción no emplea un buffer de empaquetado de datos
intermedio) a través de demonio.
500
demonio-xdr
demonio-raw
400
Milisegundos
demonio-inplace
directo-xdr
300
directo-raw
directo-inplace
200
100
0
0
20000
40000
60000
80000
100000
Longitud del mensaje en doubles
Figura 3-5. Tiempo de comunicación maestro-esclavo.
Los datos de la gráfica deben tomarse con cautela, pues aunque parezca que la
combinación dem-inp es la más adecuada, hay que tener en cuenta que las combinaciones dem corresponden al tiempo hasta la llegada del mensaje al demonio destino, mientras que las dir significan que el mensaje ya está en el socket TCP del esclavo destino.
La gráfica da una idea de la forma en que se deben optimizar las comunicaciones.
A pesar de ello, se ha decidido emplear la configuración menos ventajosa en cuanto a
velocidad de transferencia, pues es la que ofrece una mayor flexibilidad desde el
punto de vista de heterogeneidad del entorno de simulación, y es fácil afinar el método de comunicación a posteriori.
3.4 Propuesta de entorno de simulacion paralela basada en
réplicas
Tomando en consideración los objetivos descritos en el apartado 3.2, se ha planteado el entorno de simulación CSX (Cluster Simulation Experimenter). CSX es una
aplicación distribuida trabajando bajo PVM (Parallel Virtual Machine) y permite la
incorporación de máquinas heterogéneas UNIX y Windows a una máquina virtual de
simulación.
Propuesta de entorno de simulacion paralela basada en réplicas
83
La aplicación está formada por procesos especializados, encargados de gestionar
cada uno de los aspectos de la simulación. Esta división facilita mucho el desarrollo
de la aplicación y el reparto de las tareas entre distintas máquinas.
En los siguientes apartados se describe el diseño del entorno y las técnicas desarrolladas para conseguir la gestión eficiente de los modelos de simulación.
3.4.1 Esquema de CSX
La Figura 3-6 muestra una representación gráfica de los procesos que pueden
conformar el sistema CSX en ejecución.
El proceso central de CSX es el gestor principal (Master Monitor, MM). Se encarga de la coordinación de toda la aplicación, y es el primer proceso que se arranca
al trabajar con CSX. Lanza el proceso encargado de gestionar las máquinas físicas y
el encargado de gestionar la interacción con los usuarios. Gestiona también la base
de datos donde se depositan las definiciones de experimentos, encargándose de realizar las peticiones de inicio de simulaciones.
Dos tipos de procesos están especializados en la gestión de las máquinas físicas y
de la carga de procesos de éstas. Se trata del gestor de máquinas y carga (Machine
and Load Manager, MLM) y del monitor de carga (Load Monitor, LM).
MLM es un proceso del que se lanza una sola instancia y se encarga de gestionar
la máquina virtual, añadiendo máquinas cuando están disponibles y eliminándolas
cuando dejen de estarlo. En toda máquina que se incorpore a CSX, MLM lanzará un
proceso monitor de la carga. MLM decidirá dónde y cómo se lanzarán las simulaciones que requiera MM usando la información de potencia de las máquinas, las máquinas incorporadas y la carga.
Por su parte, LM es un proceso encargado de recoger información de carga de
cada máquina que forma parte de la máquina virtual PVM y la envía a MLM.
El entorno de simulación CSX se plantea como una herramienta que deben compartir los usuarios interesados en hacer simulaciones, pues de esta manera se evita el
que los usuarios compitan individualmente por las máquinas más potentes, siendo el
entorno el encargado de distribuir el trabajo. En este sentido hay dos tipos de procesos encargados de interaccionar con los usuarios, el servidor de interfaz de usuario
(User Interface Server, UIS) y el interfaz de usuario (User Interface, UI).
84
Propuesta de un entorno paralelo para la ejecución de simulaciones
Figura 3-6. Esquema de CSX.
Propuesta de entorno de simulacion paralela basada en réplicas
85
Del proceso UIS se lanza una sola instancia, y su propósito es gestionar los accesos y los derechos de los usuarios que se conectan a CSX para enviar y controlar sus
experimentos. Se debe procurar que los usuarios estén fuera de la máquina CSX, por
lo que parte del trabajo de UIS será proporcionar un punto de acceso exterior a CSX.
Cada usuario que accede a CSX lo hace a través de un proceso UI, que pretende
ofrecer una forma sencilla y uniforme de especificar los experimentos. Como las
necesidades de los usuarios pueden ser distintas, se provee la posibilidad de utilizar
diferentes interfaces de usuario, que se adaptan al tipo de trabajo a lanzar. Por ejemplo, una interfaz orientada a lotes permite automatizar la creación de grandes cantidades de experimentos de una forma sencilla, mientras que una interfaz visual es la
forma más directa de especificar un solo experimento.
Por último están los modelos de simulación manipulados (SIM) y los monitores
de simulación (Local Simulation Monitor, LSM).
Un proceso SIM no es más que un programa de simulación convencional adecuadamente manipulado (instrumentado) para que pueda ser gestionado por CSX. El
planteamiento de esta manipulación es de gran importancia para este trabajo, y se
describe en el apartado 3.4.3.
El lanzamiento de una simulación paralela consiste en el lanzamiento de réplicas
de un mismo procesos SIM y del lanzamiento de un proceso LSM encargado de gestionar el funcionamiento de las réplicas. LSM recoge la información estadística que
generan las réplicas y la analiza para decidir el fin de la simulación cuando se han
alcanzado las condiciones adecuadas. Se ha procurado mantener bajo el coste de las
comunicaciones entre el proceso LSM y los procesos SIM subordinados, pues de ello
dependerá el éxito del planteamiento del entorno de simulación paralelo.
En los siguientes puntos se describirán los aspectos de diseño más destacables de
los procesos que intervienen en CSX. Para el proceso LSM se dedica un capítulo
aparte, pues es el responsable de proporcionar la herramienta estadística de análisis
del modelo de simulación.
3.4.2 Planteamiento de la interacción entre procesos distribuidos
mediante mensajes
Los procesos de una aplicación PVM se comunican utilizando el paradigma de
mensajes. Estos mensajes se crean usando primitivas que empaquetan los tipos de
datos básicos de C o de Fortran en un buffer, el cual es finalmente enviado a uno o
86
Propuesta de un entorno paralelo para la ejecución de simulaciones
varios destinos. En el proceso receptor, estos mensajes deben ser desempaquetados
en el mismo orden en que fueron empaquetados empleando las primitivas que restauran los tipos de datos correspondientes.
En caso de que no se siga la misma secuencia de empaquetado/desempaquetado,
la información recuperada será incorrecta. Éste suele ser el error más habitual al escribir programas PVM, así que se ha optado por recubrir el modelo de mensajes de
PVM con tipos de mensajes más fáciles de manipular y menos propensos a errores.
Otro objetivo en el planteamiento de las comunicaciones ha sido eliminar las características intrínsecas a las comunicaciones de PVM, para facilitar una posible
adaptación de CSX a otros entornos de computación distribuida.
PVM se plantea como un entorno de computación distribuida de muy bajo nivel,
susceptible de ser recubierto de capas de mayor nivel. En el caso de CSX se han recubierto los mensajes con un nivel que evita enormemente las posibilidades de error
al codificar/decodificar los mensajes y facilita el desarrollo de la aplicación distribuida.
Los mensajes CSX son un conjunto de tuplas <identificador,dato> donde identificador es un entero que describe el tipo de dato asociado. Cuando un mensaje llega
a un proceso, CSX lo interpreta empleando el identificador para llamar a la función
asociada a dicho dato, que lo decodificará e interpretará. La Figura 3-7 muestra el
esquema de mensajes en CSX.
Figura 3-7. Esquema de los mensajes PVM usados en CSX.
Visto de otra forma, las tuplas de los mensajes son órdenes para el proceso receptor, pues la interpretación del mensaje desencadena la ejecución de las funciones
asociadas a cada identificador. Este esquema de trabajo ha evitado plantear complejas secuencias de información y protocolos en la comunicación entre los procesos
que forman CSX, y se deriva de la experiencia previa con PSmpl. Como resultado,
Propuesta de entorno de simulacion paralela basada en réplicas
87
los procesos CSX son entidades pasivas que reaccionan en función del contenido del
mensaje recibido, lográndose una gran flexibilidad en el comportamiento de cada
proceso.
3.4.3 Instrumentación de los programas de simulación
El entorno CSX no tiene futuro si no es posible lograr un mecanismo general de
extracción de información estadística de un programa de simulación clásico para que
pueda ser gestionado por CSX.
Por tanto, CSX deberá ser capaz de manejar y extraer información de los modelos
de simulación en ejecución. Dichos modelos serán programas desarrollados en los
lenguajes de simulación habituales como SMPL, QNAP, CSIM, SIM++, DEVS*,
etc., que se han instrumentado adecuadamente para ser gestionados por CSX.
En el punto 3.2 se describen las premisas que debería cumplir la instrumentación.
Estas premisas se han logrado parcialmente aplicando las siguientes estrategias:
•
Proporcionando unas bibliotecas enlazables con el programa de simulación.
•
Tomando el control del simulador inyectando eventos especiales en la cola de
eventos del simulador.
•
Sobrecargando algunas de las funciones del lenguaje de simulación
•
Añadiendo código al programa de simulación.
Se ilustra a continuación el planteamiento seguido tomando como base un programa en SMPL.
Como se ha dicho, la instrumentación incluye el enlazado con las bibliotecas de
CSX. Las bibliotecas aportan el soporte para la extracción de información estadística
de los modelos de simulación, y para la comunicación y coordinación con otros procesos de la aplicación distribuida.
Como se desea que estas bibliotecas puedan usarse para varios lenguajes de simulación, se ha optado por un diseño de tres capas que independiza cada aspecto de
la instrumentación. La Figura 3-8 muestra tal planteamiento aplicado a un modelo de
simulación SMPL, tratándose, en este caso, de bibliotecas desarrolladas en lenguaje
C.
88
Propuesta de un entorno paralelo para la ejecución de simulaciones
Figura 3-8. Estructura de bibliotecas CSX enlazadas con el programa a monitorizar.
Las capas de la biblioteca tienen el siguiente cometido:
•
El módulo principal de la biblioteca es el gestor CSX (CSX manager). Su función es recoger la información del modelo de ejecución y coordinar las capas
especificas de nexo con el simulador y con el sistema de comunicaciones.
Esto lo debe hacer de la forma más general posible, con independencia del
lenguaje de simulación empleado.
•
La capa SMPL interface adapta las funciones del CSX manager al lenguaje de
simulación específico y viceversa. Simplemente convierte las características
específicas de un programa de simulación al modelo común de representación
del estado empleado en la capa central.
•
La capa PVM interface gestiona las interacciones entre el CSX manager y el
sistema de computación distribuida, permitiendo el envío/recepción de datos
entre procesos.
El objetivoidea es que toda la gestión de la instrumentación se lleve a cabo en la
capa central. Las capas externas simplemente permiten adaptar la información de la
capa central al entorno donde se integran.
Con este planteamiento, se dispone actualmente de dos capas para simulador.
Una para SMPL [MacDougall 1987] y otra para CSIM [CSIM 1998]. Inicialmente se
desarrolló y probó la capa SMPL; posteriormente, el desarrollo de la capa CSIM fue
extremadamente sencillo, demostrando el acierto del planteamiento, y ello a pesar de
que SMPL y CSIM emplean un enfoque del modelado totalmente distinto, pues el
primero es orientado al evento y el segundo al proceso, y además el código fuente de
CSIM no está disponible. Con la misma facilidad sería sencillo cambiar la capa PVM
para poder utilizar un entorno de programación distribuida distinto.
Las bibliotecas deben ser capaces de tomar el control del modelo de simulación y,
además, sin suponer una sobrecarga. Para conseguirlo se ha decidido emplear la in-
Propuesta de entorno de simulacion paralela basada en réplicas
89
yección de un evento especial en la cola del simulador. Éste es el punto fundamental
de la estrategia de instrumentación, pues el mecanismo puede garantizar la generalidad, ya que todos los simuladores basados en eventos discretos emplean esta cola y,
en principio, les debería ser aplicable la estrategia.
La Figura 3-9 representa la cola de eventos a procesar de un simulador por eventos discretos. Los eventos están ordenados por tiempo de ocurrencia creciente, siendo
el siguiente evento a procesar el que tiene un tiempo de ocurrencia menor.
Cola de eventos
Procesamiento
de eventos
Tiempo simulado
Figura 3-9. Procesamiento de la cola de eventos en un simulador por eventos discretos.
Para que CSX tome el control del simulador, la primera acción consiste en inyectar un evento con tiempo de ocurrencia 0 en la cola del simulador (ver Figura
3-10(a)). La ejecución de dicho evento por parte del simulador hace que se ejecute el
código de control de la instrumentación (ver Figura 3-10(b)).
Cola de eventos
Procesamiento
de eventos
Tiempo simulado
Evento CSX
a)
b)
Figura 3-10. Filosofía de instrumentación de CSX: a) planificar el primer evento CSX,
b) la ejecución de un evento CSX planifica el siguiente evento CSX.
El código de instrumentación asociado al evento CSX suele realizar las siguientes
tareas:
1. Comprueba si han llegado mensajes del proceso monitor; en caso afirmativo
los interpreta.
90
Propuesta de un entorno paralelo para la ejecución de simulaciones
2. Empaqueta la información estadística recogida hasta el momento por el simulador y la envía al proceso monitor.
3. Planifica el evento CSX que permitirá una nueva toma de control del simulador.
Estos son los pasos habituales que se hacen al gestionar el evento CSX, aunque
pueden variar en función de los "mensajes orden" que lleguen del proceso monitor.
Por ejemplo, el primer evento CSX que se ejecuta en una simulación suele ser distinto al resto, pues será, en muchos casos, el encargado de configurar el comportamiento de la instrumentación. Desde el punto de vista de la implementación, el primer evento es igual que otros, pero se va a comportar de manera distinta como consecuencia de los mensajes especiales que envía el proceso monitor.
Esta técnica permite una integración total del mecanismo de instrumentación en
el simulador, con lo que no hay peligro de tomar el control en momentos críticos del
procesamiento del simulador que pudiesen llevar a inconsistencias de funcionamiento.
El defecto de la técnica es que el entorno CSX soo puede tomar el control del
modelo cuando el simulador procesa el evento especial. Sin embargo, las ventajas
son importantes: por una parte la generalidad ya reseñada, y por otra, cabe esperar
que el mecanismo implique poca sobrecarga a la ejecución del modelo.
Continuando con la instrumentación de modelos, estos deben ser modificados
adecuadamente añadiendo nuevo código y permitiendo la sobrecarga de algunas de
las funciones de simulación del lenguaje. Por ejemplo, el siguiente listado corresponde a un modelo de una cola M/M/1 implementado con SMPL y modificado para
adaptarlo a CSX. El programa deberá enlazarse con las bibliotecas de CSX y de
PVM para ser operativo.
/* mm1.c ********
M/M/1 Queue
*********/
#include <smpl.h>
#include <csx_smpl.h>
void main(int argc, char *argv[])
{
double Ta=200.0, Ts=100.0,te=2000000.0;
int customer=1,event,server;
csx_gpdouble(argc,argv,"Ta",&Ta,200.0);
Propuesta de entorno de simulacion paralela basada en réplicas
91
csx_gpdouble(argc,argv,"Ts",&Ts,100.0);
smpl(0,"Queue M/M/1");
server=facility("server",1);
csx_firstevent;
schedule(1,0.0,customer);
while(csx_loop(time()<te))
{
cause(&event,&customer);
switch(event)
{
csx_event;
case 1: /* arrival */
schedule(2,0.0,customer);
schedule(1,expntl(Ta),customer);
break;
case 2: /* server required */
if (request(server,customer,0)==0)
schedule(3,expntl(Ts),customer);
break;
case 3: /* complet */
release(server,customer);
break;
}
}
report();
}
El primer paso es incluir el fichero de cabecera csx_smpl.h, en el que están
las definiciones de las funciones especificas de CSX para SMPL y las macros que
redefinen algunas funciones de SMPL y simplifican la escritura de los programas
CSX.
Las funciones que se redefinen son smpl(), facility() y cause(). La
función smpl() se sobrecarga para que las bibliotecas de CSX puedan detectar si el
programa se lanza desde la línea de órdenes o desde el entorno paralelo, y así decidir
si se realiza la conexión con el monitor o se trabaja en modo convencional. La función facility() se sobrecarga para que las bibliotecas CSX tomen nota de los
índices estadísticos que posee el modelo, y que se deben enviar en cada muestreo. A
la función cause() se le añade el incremento de la variable global CSX_EVCNT,
que lleva la contabilidad del total de eventos procesados.
La función csx_gpdouble() permite obtener los parámetros de entrada del
modelo a partir de la línea de comandos. El propósito de esta función es tener una
forma sencilla de que el monitor pueda especificar cuáles son los parámetros con los
92
Propuesta de un entorno paralelo para la ejecución de simulaciones
que debe funcionar el modelo. Por ejemplo, en el caso de la cola M/M/1, para especificar un tiempo de servicio de 80 y un tiempo entre llegadas de 90 se podría escribir
en el indicador de una máquina UNIX:
$ mm1 Ts=80 Ta=90
La macro csx_firstevent equivale a una llamada a la función de planificación de eventos de SMPL schedule() que planifica un evento reservado para
CSX con tiempo de simulación 0,0, y que permite tomar el control del simulador.
La macro csx_event corresponde al caso del evento reservado por CSX para la
construcción switch-case de procesamiento de eventos de SMPL. Este evento
permite tomar el control del simulador. Su tarea habitual consiste en preparar la
muestra de variables de salida para el monitor, enviarla y planificar el evento que
provocará el siguiente muestreo. Éste es el único punto donde se interpretan los mensajes que llegan desde el monitor; por tanto, las órdenes de CSX solo se atienden en
esos instantes.
Con todas estas estrategias aquí descritas, se consigue la toma de control del modelo de simulación por parte de CSX.
Las muestras de información estadística se extraen en los instantes del tiempo de
simulación que fije el usuario o por el método de análisis seleccionado, no pudiéndose extraer información fuera de esos instantes. La ventaja de este método es que es
fácil de implementar, la sobrecarga introducida es pequeña y se puede aplicar a casi
todos los lenguajes de simulación. La desventaja es que obliga a que el control externo del programa de simulación solo pueda hacerse en unos instantes de tiempo muy
definidos.
3.4.3.1
Resultados de las pruebas de sobrecarga de los modelos
instrumentados
Idealmente, la monitorización de los programas de simulación debería provocar
una sobrecarga mínima en el tiempo de ejecución de los modelos. La sobrecarga introducida debe ser proporcional a las veces que se muestree el modelo y a las condiciones de las comunicaciones simulación-monitor. Cuantas menos muestras se extraigan, menor debe ser la sobrecarga.
Utilizando el modelo de cola M/M/1 antes mostrado se han realizado una serie de
pruebas para estimar el efecto de la manipulación del modelo en la sobrecarga introducida en el tiempo de ejecución. La simplicidad del modelo elegido hace que cual-
Propuesta de entorno de simulacion paralela basada en réplicas
93
quier variación introducida se aprecie notablemente en el tiempo de respuesta. La
Tabla 3-1 muestra los resultados de la prueba realizada.
Tiempo de
ejecución
(segundos)
Sobrecarga
comparada
con SMPL
estándar
Original SMPL
208,803
0%
SMPL manipulado y enlazado con CSX.
Ejecutado como un programa normal
220,419
6%
SMPL manipulado y enlazado con CSX.
Monitorizado solicitando 1 muestra.
218,553
5%
0,05
SMPL manipulado y enlazado con CSX.
Monitorizado solicitando 10 muestras.
219,486
5%
0,46
SMPL manipulado y enlazado con CSX.
Monitorizado solicitando 100 muestras.
227,932
9%
4,39
SMPL manipulado y enlazado con CSX.
Monitorizado solicitando 1.000 muestras.
286,464
37%
34,91
SMPL manipulado y enlazado con CSX.
Monitorizado solicitando 10.000 muestras.
1127,419
440%
8,87
Descripción
Muestras
por
segundo
Tabla 3-1. Tiempos de respuesta de un programa SMPL monitorizado con CSX.
El modelo original se ha ejecutado en una máquina bajo Windows, ofreciendo un
tiempo medio de respuesta de 208,8 segundos que se toma como referencia.
El programa se ha adaptado a CSX como se muestra en el apartado anterior.
Cuando se lanza directamente desde el indicador del sistema, en modo no monitorizado, su funcionamiento es equivalente a un programa SMPL normal. En este caso el
tiempo de respuesta aumenta ligeramente, produciéndose una sobrecarga del 6%
aproximadamente respecto al modelo SMPL sin manipular.
El resto de las filas de la tabla muestran el tiempo de ejecución del modelo que se
tiene cuando el programa es monitorizado por CSX. En este caso, tanto el programa
monitor como el proceso SMPL se ejecutan en la misma máquina, siendo las comunicaciones PVM locales. El tiempo de respuesta resultante será debido al programa
monitorizado, más el monitor y más las comunicaciones locales.
Cuando el monitor solo requiere una muestra al final del tiempo de simulación, la
sobrecarga es la mínima posible, pues solo habrá dos envíos de información al mo-
94
Propuesta de un entorno paralelo para la ejecución de simulaciones
nitor: uno al principio, para establecer la forma de trabajo de modelo y saber cuáles
son sus variables de entrada y de salida, y una al final, que contiene los valores de las
variables de salida del modelo. En este caso, la sobrecarga es cercana al 5%, casi
equivalente al programa CSX-SMPL que se lanza como un programa SMPL normal.
La pequeña reducción del tiempo se debe a que, en el caso de los programas monitorizados, la condición de fin especificada por el usuario en el bucle de simulación no
es evaluada, pues es anulada por la macro csx_loop().
Según se van aumentando las muestras requeridas, el tiempo de respuesta aumenta y las comunicaciones juegan un papel muy importante en estos resultados. En
el caso del experimento, unas 5 muestras por segundo es un tope para tener una sobrecarga razonable. Un sobremuestreo aumenta notablemente la sobrecarga, llegándose a un punto donde el rendimiento cae en picado y se satura el sistema de comunicaciones.
La Figura 3-11 refleja la sobrecarga en porcentaje producida por el aumento de
las muestras requeridas.
300%
250%
Sobrecarga de SMPL en CSX (cola M/M/1 , Windows)
200%
150%
100%
50%
0%
SMPL
SMPL-CSX no
monitorizado
1 muestra
10 muestras
100 muestras
1.000 muestras
10.000
muestras
Figura 3-11. Sobrecarga del modelo M/M/1 instrumentado para CSX.
Como resultado de estas pruebas, y sobre la base del esquema de instrumentación
de los modelos de simulación, se puede extrapolar que un programa monitorizado se
Propuesta de entorno de simulacion paralela basada en réplicas
95
ejecuta prácticamente igual de rápido que su versión estándar. Recuérdese que el
modelo M/M/1 es tan sencillo que cualquier adición de código afecta adversamente a
su rendimiento; en modelos más complejos la sobrecarga sería mucho menor.
Las comunicaciones van a ser el único factor que afecte al rendimiento. Para reducir su penalización se debe mantener una tasa de muestreo baja; así, el efecto de
las comunicaciones no se apreciará en el tiempo de respuesta. En cualquier caso, no
tiene sentido mantener una frecuencia de actualización alta, pues el modelo no habrá
evolucionado apreciablemente entre extracciones consecutivas.
3.4.4 Reparto de la carga
El hecho de emplear un conjunto heterogéneo de computadores y de que su potencia se comparte con otros procesos hace imprescindible disponer de alguna forma
de repartir la carga que suponen los procesos SIM (simulaciones instrumentadas) en
la máquina virtual de simulación.
Dos van a ser los factores que repercuten en el tiempo de respuesta de las simulaciones, por una parte la velocidad de la máquina sobre la que se ejecuta el modelo y,
por otra, según la literatura, el canal aleatorio que se emplee [Lin 1994].
Será fundamental implementar mecanismos que permitan una gestión adecuada y
dinámica de las velocidades de ejecución del modelo, sobretodo si se usan métodos
de análisis como el de las réplicas independientes. En este método es necesario tener
medidas de todos los modelos para el cálculo del intervalo de confianza, y el retraso
de una réplica provoca el retraso global de toda la simulación.
En el caso de que se llegue a la conclusión de que la carga de réplicas se debe recolocar, se pueden aplicar técnicas que permitan migrar un proceso en ejecución de
una máquina a otra. Para este propósito se pueden usar técnicas de punto de comprobación (checkpointing) propuestas en entornos como MIST/MPVM [Casas et al.
1995], CoCheck [Pruyne et al. 1998] un derivado de Carmi bajo CONDOR y otros
[Song 1997], [Dikken el al. 1994]. También se puede aprovechar el software desarrollado para los entornos tipo Beowulf de segunda generación [Otero y Ferri 2002].
Pero la aplicación del reparto de carga precisa técnicas que permitan resolver aspectos como:
•
Clasificar las máquinas físicas por su potencial de simulación.
•
Medir la carga de las máquinas.
96
Propuesta de un entorno paralelo para la ejecución de simulaciones
•
Medir la velocidad efectiva de una simulación, apreciando el efecto de las variaciones de carga en la velocidad de simulación.
•
Considerar el efecto de los canales aleatorios empleados en las réplicas.
A continuación se describen las técnicas desarrolladas para estos cometidos.
3.4.4.1
Medida del potencial de simulación de una máquina
Para el cálculo inicial del reparto de los procesos de simulación se deben tener en
cuenta dos factores: por una parte la potencia de simulación de una máquina, y por
otra, la carga de procesos que actualmente soporta.
Las medidas de carga se realizan mediante los monitores LSM que CSX lanza en
cada máquina. Estos monitores son sencillos y se usan modificaciones de monitores
orientados a arquitecturas heterogéneas como MTool [Sostaric et al 1998].
La información de carga no es suficiente. Debido a la heterogeneidad de arquitecturas es difícil saber qué velocidad de simulación se conseguirá en una determinada máquina a partir de los datos de carga. Por tanto, es necesario buscar un índice
que permita clasificar las máquinas por su rendimiento ejecutando simulaciones. Para
lograrlo se ha empleado un modelo de simulación especial para obtener un índice de
prestaciones. En este caso, en todas las máquinas se ejecuta un modelo SMPL que
calcula los eventos por milisegundo que puede tratar la máquina cuando se emplea el
100% de la CPU sin interferencia de otras tareas. Esta información es guardada en la
tabla de configuración del cluster y se usará para estimar las velocidades de simulación que se lograrán a partir de los datos de carga de las máquinas.
Emplear un modelo de simulación para el cálculo de la velocidad permite considerar aspectos como: el rendimiento de la CPU para las estructuras típicas de un programa de simulación, las optimizaciones que haga el compilador/intérprete del lenguaje al ejecutar el modelo en una arquitectura particular, y el efecto de las bibliotecas del lenguaje de simulación. En este caso, el modelo SMPL no es más que un modelo de una cola M/M/1 adecuadamente preparado para este propósito.
Como ejemplo, la Tabla 3-2 muestra algunos índices de prestaciones de simulación obtenidos con el modelo en computadores tipo PC con distintos procesadores.
El programa para el cálculo de velocidad se ha compilado con GNU gcc y todas las
opciones de optimización deshabilitadas. Para ejecutarlo se ha usado el sistema operativo Linux.
Propuesta de entorno de simulacion paralela basada en réplicas
Máquina
feli
terra
zape
mapia
joanas
Procesador
Intel Pentium 75 Mhz
Intel Pentium 166 Mhz
AMD K6/2 210 Mhz
AMD Athlon 740 Mhz
Intel Pentium IV 2,4 Ghz
97
Índice
168
364
384
1.340
3.482
Tabla 3-2. Índice de prestaciones de simulación obtenidos en distintas plataformas.
A partir de las medidas de carga actual de las máquinas y del índice almacenado
en una base de datos se puede calcular un reparto de las réplicas.
Él índice de prestaciones obtenido con este método se debe considerar como una
aproximación a la potencia real de procesamiento de un computador determinado,
pues los resultados de rendimiento de un modelo particular dependen de muchos
factores. Por ejemplo, el modelo empleado para obtener estos índices ofrece resultados muy diferentes (y no proporcionales a los mostrados en la tabla) si se activan las
opciones de optimización del compilador.
3.4.4.2
Medida de la velocidad de simulación de un modelo
Puede ocurrir que la carga en las máquinas cambie drásticamente o que la estimación de la potencia no haya sido acertada. Ello sugiere que proveer un esquema de
replanificación de la colocación de los procesos sea muy atractivo, pero para poder
pensar en repartos dinámicos de carga es necesario conocer el rendimiento individual
de cada uno de los modelos en ejecución.
Ello se ha logrado empleando técnicas similares a las usadas en [Wilson et al.
1996] para la simulación distribuida con reparto dinámico de carga. En el caso de
CSX, en cada una de las réplicas del modelo en ejecución se contabilizan todos los
eventos tratados por el programa de simulación.
Cada vez que se envía una muestra de las variables de salida, también se envían
la cantidad de eventos tratados hasta el momento y la cantidad media de eventos por
milisegundo que se han tratado entre esa muestra y la anterior.
Con dicha información y el tiempo simulado hasta el momento se puede estimar
cuál será el tiempo de respuesta para alcanzar un determinado tiempo de simulación
o para generar una determinada cantidad de observaciones. Con esta información es
fácil decidir si puede ser conveniente mover la carga de réplicas a otras máquinas.
Como ejemplo la Figura 3-12 muestra la información de carga enviada a CSX por
dos réplicas ejecutándose en una máquina bajo Linux. La máquina estaba dedicada
98
Propuesta de un entorno paralelo para la ejecución de simulaciones
exclusivamente a la ejecución de las réplicas. En dicha gráfica se aprecia que las dos
réplicas ejecutan una cantidad similar de eventos por unidad de tiempo, por lo que,
asintóticamente hablando, están consumiendo tiempo simulado a la misma velocidad.
Además, como las dos réplicas son instancias del mismo programa, los requisitos de
recursos son idénticos por lo hay un reparto equitativo de estos entre ambos.
Eventos por milisegundo
300
250
200
150
100
50
Réplica 1
Réplica 2
0
Tiem po (60 segundos)
Figura 3-12. Velocidad de simulación para dos réplicas ejecutándose en una máquina.
La Figura 3-13 muestra una ejecución idéntica a la anterior, pero la máquina está
siendo empleada por un usuario interactivo. Se aprecia claramente el efecto de las
variaciones de carga en la velocidad efectiva de simulación. Las dos réplicas se ven
afectadas prácticamente de la misma forma.
Eventos por milisegundo
300
250
200
150
100
50
Réplica 1
Réplica 2
0
Tiem po (60 segundos)
Figura 3-13. Velocidad de simulación para dos réplicas ejecutándose en una máquina y
la máquina siendo empleada por un usuario interactivo.
Propuesta de entorno de simulacion paralela basada en réplicas
99
Si en lugar de ejecutar 2 réplicas en la máquina se ejecutan 4, se produce el resultado de la Figura 3-14 en cuanto a velocidad de simulación. En este caso, el procesador se ha repartido también equitativamente entre las 4 tareas y se aprecia que la
velocidad de simulación de una réplica del caso anterior es, justamente, el doble de
una réplica en este caso.
Eventos por milisegundo
300
250
200
150
100
Réplica 1
Réplica 2
50
Réplica 3
Réplica 4
0
Tiem po (60 segundos)
Figura 3-14. Velocidad de simulación para cuatro réplicas ejecutándose
en una máquina.
La técnica de medida de velocidad de simulación basada en eventos muestra ser
muy efectiva. Como el recurso más necesario para las simulaciones es el procesador
y todas las réplicas se comportan de igual forma, es muy sencillo implementar políticas de gestión de la ejecución de las réplicas.
Eventos por milisegundo
300
250
200
150
100
50
Réplica
0
Tiem po (60 segundos)
Figura 3-15. Perdida del rendimiento de simulación al activarse
un salvapantallas en Windows.
100
Propuesta de un entorno paralelo para la ejecución de simulaciones
En cualquier caso, si se emplean las máquinas de los despachos y de los laboratorios para realizar simulaciones paralelas, será necesario configurarlas adecuadamente
para lograr un aprovechamiento óptimo. Como ejemplo, la Figura 3-15 muestra una
gráfica de la información de carga enviada por un modelo ejecutándose en una máquina Windows. La caída de rendimiento se debe a la activación de un salvapantallas, que desperdicia una gran cantidad de recursos en un trabajo poco útil.
3.4.4.3
Consideraciones sobre el efecto de los canales aleatorios
Como se ha indicado antes, la velocidad de ejecución de un modelo puede depender de la velocidad de la máquina y del canal aleatorio empleado. En [Bhavasar e
Isaac 1987] se establece que los tiempos de ejecución de las réplicas son variables
aleatorias que se distribuyen exponencialmente con media normalizada a 1.
Se ha hecho un experimento para comprobar el efecto del canal aleatorio. Para
ello, se ha ejecutado el modelo de la cola M/M/1 realizado con SMPL durante un
tiempo simulado largo, y se han tomado medidas del tiempo de ejecución. En la
Tabla 3-3 se muestran los resultados. El tiempo de respuesta indicado corresponde a
la media de 10 experimentos con cada canal, para así disminuir los efectos no deterministas introducidos por cada ejecución particular en la máquina. En este caso, se
observa que no hay diferencias relevantes entre los tiempos de respuesta de cada canal.
Canal
aleatorio
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Tiempo
Eventos
Tiempo de
simulado contabilizados ejecución (ms)
30000005,1
5256643
13270,9
30000002,7
5256322
13270,4
30000009,4
5255290
13267,4
30000003,9
5256592
13270,6
30000028,6
5256386
13271,6
30000019,2
5258512
13282,7
30000012,3
5257950
13276,0
30000019,8
5258161
13297,5
30000016,2
5258126
13273,1
30000015,9
5258105
13274,4
30000002,0
5257426
13273,1
30000003,3
5257491
13275,7
30000003,4
5256334
13267,8
30000058,1
5255859
13267,9
30000000,6
5256752
13271,5
Tabla 3-3 Tiempo de respuesta de un modelo M/M/1 ejecutado
con cada uno de los canales aleatorios de SMPL
Propuesta de entorno de simulacion paralela basada en réplicas
101
Con modelos mucho más complejos se han obtenido resultados similares, aunque
las diferencias de velocidad pueden ser mayores. La Figura 3-16 muestra la evolución del tiempo de ejecución de varias réplicas de un modelo en función de la variable independiente “tiempo simulado” en un modelo muy complejo y costoso de evaluar Se aprecia una creciente diferencia de velocidad entre réplicas que se debe al
efecto que han tenido los números aleatorios empleados en la configuración particular de la réplica.
1800
1583 segundos
Tiempo de ejecución (segundos)
1600
1400
1200
1000
1355 segundos
800
600
400
200
97
100
94
91
88
85
82
79
76
73
70
67
64
61
58
55
52
49
46
43
40
37
34
31
28
25
22
19
16
13
7
10
4
1
0
Tiempo simulado
Figura 3-16. Tiempo de ejecució de un modelo en función del tiempo simulado.
A pesar de todo, aunque el efecto no parezca importante, el mecanismo de medida de la velocidad de simulación basado en eventos tratados está preparado para medir el efecto y, por tanto, para subsanarlo aplicando repartos dinámicos de carga.
3.4.5 La interfaz de usuario
En el apartado 3.3 se da una descripción global del entorno CSX; y allí se describen dos tipos de procesos orientados al acceso del usuario a CSX, UIS y UI.
El servidor de interfaz de usuario UIS es el encargado de gestionar los accesos y
los derechos de los usuarios proporcionando un punto de acceso exterior a CSX.
El interfaz de usuario UI es la aplicación con la que el usuario accede a CSX.
Cada usuario que accede a CSX lo hace a través de un proceso UI, que pretende
ofrecer una forma sencilla y uniforme de especificar los experimentos.
102
Propuesta de un entorno paralelo para la ejecución de simulaciones
Como aspecto fundamental de diseño de la interfaz de usuario de CSX se ha decidido que ésta sea fácilmente sustituible. Así, es posible tener varios tipos de UI. Por
ejemplo: orientada a línea de comandos, orientada a procesamiento por lotes, visual,
etc.
El interfaz de usuario ideal para CSX es aquel que se puede usar desde cualquier
entorno de trabajo y se adapte al gusto de cada usuario. Actualmente, la concepción
de entornos de alta y sencilla disponibilidad ha cambiado notablemente, imponiéndose la idea de que si se desea acceder a un entorno con el mínimo esfuerzo, sin tediosas instalaciones y configuraciones, la mejor opción es hacerlo a través de un navegador web, preferiblemente preparado para ejecutar aplicaciones Java. Aunque éste
puede ser un posible objetivo futuro, en la actualidad se han desarrollado dos interfaces prototipo. La primera es una aplicación visual para Windows y la segunda es una
interfaz orientada a lotes para la especificación de series de experimentos en entornos
UNIX. Se ha elegido aquí describir brevemente la interfaz visual para ilustrar las
posibilidades del entorno CSX.
3.4.5.1
Prototipo de interfaz visual para Windows
La Figura 3-17 muestra el aspecto de la interfaz. Ésta se ha desarrollado con
Borland C++ Builder para Windows. En esta aplicación se ha aplicado la filosofía
basada en capas usada en la instrumentación de los modelos de simulación. Así, un
módulo escrito en ANSI C es común a las otras implementaciones de la interfaz, y
una parte C++ corresponde a las características específicas de esta implementación.
Figura 3-17. Ssim3 en ejecución.
Propuesta de entorno de simulacion paralela basada en réplicas
103
Para ilustrar el funcionamiento de CSX se usará el modelo SMPL de la cola
M/M/1 y se seguirá una sesión típica con el entorno. El primer paso es especificar el
nombre del ejecutable que contiene el modelo, en este caso mm1 (ver Figura 3-18).
Figura 3-18. Especificando el nombre del ejecutable con el modelo.
Como los modelos están instrumentados, se aprovecha esta característica para
lanzar y sacrificar una instancia del modelo con el fin de extraer de él toda la información posible. Esta información permitirá especificar, de una forma sencilla, los
parámetros de entrada del modelo y las condiciones de fin de la simulación. Pulsando
en el botón “Auto fill” se emplea esta característica y se rellenan gran parte de los
datos del modelo (ver Figura 3-19).
En este ejemplo particular, el lanzamiento del modelo permite saber que se trata
de un programa SMPL y cuál es el nombre del modelo. En la pestaña “Input vars” se
han rellenado automáticamente los parámetros de funcionamiento del modelo, en
este caso, el tiempo de servicio Ts en la cola y el tiempo entre llegadas Ta, ambos de
tipo double (ver Figura 3-20). Y en la pestaña “Output vars” están las variables de
salida del modelo, en este caso son los índices recogidos por la estación de servicio
server (ver Figura 3-21). También se recolecta la información interna sobre el
rendimiento del modelo que genera la biblioteca CSX, información que servirá para
poder plantear el reparto dinámico de carga.
104
Propuesta de un entorno paralelo para la ejecución de simulaciones
Figura 3-19. Resultados de la activación del botón “Auto-fill” (1).
Figura 3-20. Resultados de la activación del botón “Auto-fill” (2).
Con la información recogida ya es posible lanzar simulaciones. En la pestaña
“Run Characteristics” se especifican las características de la ejecución del experimento. Por ejemplo, se pueden extraer 50 muestras de la ejecución del modelo mm1
con un tiempo de simulación entre muestras de 2.000 unidades de tiempo y usando el
canal aleatorio por defecto.
Propuesta de entorno de simulacion paralela basada en réplicas
105
Figura 3-21. Resultados de la activación del botón “Auto-fill” (3).
Figura 3-22. Ejemplo de prueba de monitorización.
La información de “Output Vars” es guardada en un archivo con formato CSV
(datos delimitados por comas) con lo que es muy sencillo aprovechar la información
resultante en muchas aplicaciones (ver Figura 3-23). También podría copiarse fácilmente a una hoja de cálculo Microsoft Excel, aprovechando las características de
“copiar y pegar” de la aplicación.
106
Propuesta de un entorno paralelo para la ejecución de simulaciones
Figura 3-23. “Output Vars” tras ejecutar la prueba.
La aplicación desarrollada permite visualizar fácilmente una gráfica de la fila seleccionada en función del tiempo de simulación. El propósito es poder “echar una
ojeada” previa a los datos obtenidos. Por ejemplo, la Figura 3-24 muestra la evolución del índice de utilización en la estación de servicio server (f_server_U)
activando una casilla de dicha fila y pulsando el botón “Display Graphic”.
Figura 3-24. Gráfica de la evolución del índice en la estación de servicio “server”.
Con la opción de mostrar gráficas se puede ver también las variables especiales
que recogen la información de rendimiento. Por ejemplo, mientras se redacta este
Propuesta de entorno de simulacion paralela basada en réplicas
107
documento se ha lanzado una nueva ejecución de mm1 con 50 muestras y un tiempo
entre muestras de 30.000.000 u.t., para así poder mostrar el efecto de las fluctuaciones de carga. Al mismo tiempo se están ejecutando un capturador de gráficos y un
monitor del sistema. La Figura 3-25 muestra la variable interna ev_mili_i (eventos por milisegundos instantánea) que recoge la cantidad de eventos procesados entre
cada envío. En este caso se aprecia la fuerte influencia en la velocidad de simulación
que tienen el resto de las tareas.
Figura 3-25. Rendimiento de la simulación medido en eventos por milisegundo.
La Figura 3-26 muestra la evolución del tiempo de respuesta medido en milisegundos que recoge la variable interna time_end. Este tiempo de ejecución y las
previsiones de carga permiten predecir aproximadamente tiempos de ejecución para
unos tiempos de simulación dados, que pueden ser usados para replanificar la carga.
En el caso de un entorno con carga constante cabe esperar una línea aproximadamente recta. Sin embargo, en la figura se aprecian cambios de pendiente que se deben a las fluctuaciones de carga.
El propósito de la pestaña “In Vars” es especificar una serie de simulaciones que
formen un experimento. En general, un modelo de simulación se emplea para evaluar
cierto índice en función de un conjunto valores de parámetros de entrada (nº de procesadores, paquetes en una red, terminales, etc).
108
Propuesta de un entorno paralelo para la ejecución de simulaciones
Figura 3-26 Tiempo de ejecución en función del tiempo de simulación.
Por ejemplo, para el modelo mm1 podemos especificar fácilmente un experimento
para obtener la utilización de la estación para un tiempo de servicio Ts de 100, 110,
... 190. La Figura 3-27 muestra “In Vars” rellenándose. Como en Ta no se ha indicado ningún valor, la simulación usará el valor por defecto.
Figura 3-27. Especificando un experimento.
Aunque no sea estadísticamente una buena estrategia, en este caso se ejecutará
cada simulación durante un tiempo de simulación largo para intentar conseguir el
valor de régimen permanente.
La Figura 3-28 muestra los datos de la simulación. Se ha indicado que se usen los
valores de “In Vars” y solo se solicita una muestra al final del periodo de simulación.
Propuesta de entorno de simulacion paralela basada en réplicas
109
Figura 3-28. Experimento ejecutándose.
En “Output Vars” están los resultados de las 10 simulaciones. Si interesase una
gráfica de la utilización en función del tiempo de servicio no se podría hacer uso de
las limitadas capacidades gráficas de esta interfaz. Es mejor utilizar una aplicación
más adecuada. Por ejemplo, se pueden copiar las filas de interés a Microsoft Excel (o
abrir el fichero CSV generado en Excel o en GNU Plot) y preparar el gráfico que
interese. Por ejemplo, la Figura 3-29 muestra una ventana de Excel con los datos
copiados en ella y en la Figura 3-30 una gráfica de los resultados realizada con dicha
hoja de cálculo.
Figura 3-29. Copiar y pegar de la interfaz de CSX a EXCEL.
110
Propuesta de un entorno paralelo para la ejecución de simulaciones
1
0,9
f_server_U
Utilización
0,8
0,7
0,6
0,5
0,4
100
110
120
130
140
150
160
170
180
190
Ts (tiempo de servicio), Ta=200
Figura 3-30. Gráfica obtenida con los valores recuperados de la interfaz CSX.
3.5 Introducción a la instrumentación de modelos SMPL y
CSIM
Este apartado pretende dar una idea de cómo se realiza la instrumentación de modelos para CSX, no pretendiendo ser la guía de referencia completa.
En la actualidad se dispone de dos capas de instrumentación. La instrumentación
para estos dos lenguajes consta de una serie de funciones comunes a ambos y de funciones específicas para el lenguaje de simulación concreto. Se describen a continuación las funciones comunes.
3.5.1 Funciones comunes de instrumentación
Las siguientes funciones de instrumentación son comunes a los dos lenguajes de
simulación instrumentados. Son:
int csx_gpdouble( int argc, char *argv[], char *pname,
double *value, double default)
Extrae el valor asignado al texto pname de los parámetros de llamada al
programa, los interpreta como un dato de tipo double y los asigna a la
Introducción a la instrumentación de modelos SMPL y CSIM
111
variable apuntada por value. En caso de no estar definido el parámetro,
asigna el valor default y devuelve un valor entero <0.
Ejemplo:
Supóngase que se ejecuta el modelo mm1 con los siguientes parámetros
mm1 Ts=15.3 Ta=2.7
entonces, para extraer el valor asociado a Ts se puede hacer
double t_servicio;
csx_gpdouble(argc, argv, "Ts",&t_servicio, 0.0);
int csx_gpint( int argc, char *argv[], char *pname,
int *value, int default)
Igual que gpdouble(), pero para datos de tipo int.
int csx_obs_new(char *name);
Crea un nuevo recolector de observaciones al que CSX accederá para recoger estadísticas. En name se especificará la etiqueta con la que se le
identificará en CSX.
Devuelve un entero >0 que se deberá usar como identificador al almacenar
las observaciones.
int csx_obs_add(int obsid, double value);
Permite añadir una nueva muestra al recolector de observaciones identificado por obsid.
Ejemplo:
int obs_trespuesta;
obs_trespuesta = csx_obs_new("Tpo_Respuesta");
…
csx_obs_add(obs_trespuesta, clock()-time_start);
112
Propuesta de un entorno paralelo para la ejecución de simulaciones
Estas dos funciones se emplean cuando las facilidades de recolección del
lenguaje de simulación específico no son suficientes o cuando se desea que
CSX pueda recoger estadísticas cada N observaciones recolectadas.
En una simulación paralela, CSX podrá especificar el número de observaciones a recoger cada vez que se desee un envío de información. En la actualidad, la información enviada será el promedio de las muestras recogidas.
void csx_uservar(char *name, double (*func)(int));
Define una variable estadística de salida del modelo, de la que CSX obtendrá el valor ejecutando la función func proporcionada por el usuario. Esta
forma de trabajo evita que el programa de simulación deba actualizar continuamente un valor para que esté siempre disponible para CSX. CSX llamará a la función pasándole el valor 1 cuando desee obtener la medida y el
valor 0 cuando se requiera una reinicialización de las estadísticas. En CSX
se identificará la variable por el parámetro name.
Ejemplo:
El siguiente fragmento muestra el posible aspecto de una función para calcular una estadística propuesta por el usuario
static double n = 0.0,s = 0.0;
double mrt(int i)
{
if (i) {
/* reset call */
s = n = 0.0;
return(0.0);
}
if (n > 0.0)
return(s/n);
else
return(0.0);
}
Para informar a CSX de la función se puede hacer
csx_uservar("Mean_resp_time",mrt);
Introducción a la instrumentación de modelos SMPL y CSIM
113
csx_loop(X)
Macro que devuele el valor lógico de X si el programa está ejecutádose en
modo no monitorizado y el valor lógico “verdadero” si el programa está
bajo el control de CSX. Se emplea para evitar que un programa de simulación en modo monitorizado termine cuando se alcanza la condición de finalización en modo no monitorizado (por ejemplo, un tiempo simulado especificado por el usuario).
3.5.2 Instrumentación específica para SMPL
Para realizar la instrumentación de modelos SMPL es necesario incluir el fichero
de cabecera csx_smpl.h inmediatamente después de la inclusión del fichero de
cabecera smpl.h.
La instrumentación sobrecarga las funciones del lenguaje de simulación
smpl(), facility() y cause(), con el propósito descrito en el apartado 3.4.3.
Además, será necesario emplear las siguientes macros:
csx_event;
Macro que debe introducirse en la estructura switch del bucle de procesamiento de eventos. Corresponde a un case con identificador de evento
reservado para CSX y que permite conseguir el control de la simulación en
los intervalos deseados.
Su uso tendrá siempre la siguiente forma,
cause(&event,&customer);
switch(event)
{
csx_event;
case … //resto de procesamiento de eventos
}
csx_firstevent;
Macro que planifica un evento con tiempo 0.0 empleando el identificador
reservado para CSX. El propósito es que el primer evento que se procese
permita a CSX tomar el control y conseguir analizar los detalles de la si-
114
Propuesta de un entorno paralelo para la ejecución de simulaciones
mulación a realizar. Este primer evento se aprovecha también para planificar el siguiente evento CSX.
Como ejemplo de modelo SMPL se puede recurrir al apartado 3.4.3, en el que se
describe el planteamiento de la instrumentación.
3.5.3 Instrumentación específica para CSIM
Para la instrumentación de la versión C de CSIM basta con incluir el fichero de
cabecera csx_csim.h inmediatamente después de incluir el fichero de cabecera
csim.h.
Igual que en el caso anterior, el fichero de cabecera sobrecarga algunas de las
funciones de CSIM.
En general, no será necesario realizar ninguna modificación más para disponer de
un modelo listo para funcionar en CSX, y que también funcionará de la manera convencional. El único requisito es que se proporcione explícitamente la función
main()al modelo, y desde ella se llame a la función de simulación de CSIM
sim().
3.5.4 Ejemplo de modelo CSIM
A continuación se lista una implementación de un modelo de cola M/M/1 adaptado a CSX. En este caso la adaptación es incluso más sencilla que en el caso de
SMPL.
/* mm1 example for CSIM */
#include <csim.h>
#include <csx_csim.h>
FACILITY f;
double Ta, Ts;
main (int argc, char *argv[])
{
Ejemplos de modelos instrumentados
115
csx_gpdouble(argc,argv,"Ta",&Ta,1.0);
csx_gpdouble(argc,argv,"Ts",&Ts,0.5);
sim();
}
sim()
{
create("sim");
f=facility("center");
while (csx_loop(simtime()<5000.0)) {
hold(exponential(Ta));
customer();
}
report();
terminate();
}
customer()
{
create("customer");
use(f,exponential(Ts));
terminate();
}
3.6
Ejemplos de modelos instrumentados
3.6.1 Modelo SMPL de una red Ethernet
El modelo de red Ethernet aquí adaptado corresponde al modelo SMPL propuesto
en [McDougall 1987]. Este modelo tiene bastantes parámetros de entrada que deben
ser recogidos con las funciones de CSX adecuadas. Las variables de salida del modelo son recogidas creando funciones de usuario que calculen los índices de prestaciones requeridos y que serán llamadas por CSX para muestrarlos.
Debido a la longitud del código original sólo se transcriben las partes del software que se han modificado. A continuación se lista el fragmento de interés, resaltando las adiciones y/o modificaciones.
/* Model SMPL ether.c */
#include
#include
#include
#include
<stdio.h>
<math.h>
<smpl.h>
<csx_smpl.h>
116
Propuesta de un entorno paralelo para la ejecución de simulaciones
...
static
static
static
static
double
double
double
double
Tp = 0.0225;
Tif = 0.0096;
Tslot = 0.0512;
Tjam=0.0032;
/*
/*
/*
/*
propagation delay (ms.)
interframe delay (ms.)
slot time (ms.)
jam time (ms.)
*/
*/
*/
*/
/* user function to calculate S output variable */
static double Ssum=0.0;
double S(int i)
{
static double rsttime = 0.0;
double t;
if (i) {
/* reset call */
Ssum = 0.0;
rsttime = time();
return(0.0);
}
t = time()-rsttime;
if (t > 0.0)
return(Ssum/t);
else
return(0.0);
}
/* user function to calculate D output variable */
static double Dsum=0.0;
static long Dcount=0L;
double D(int i)
{
if (i) {
Dsum=0.0;
Dcount=0;
return(0.0);
}
if (Dcount > 0)
return((Dsum/Dcount)/(Tp/a));
else
return(0.0);
}
/**********************************************/
void main(int argc, char *argv[])
{
int event,stn,nb; double hw=0.0,Td=0.0;
Tf=Tp/a; Ti=Tf*((double)N/G-1.0);
/* load input values fron command line */
double dval;
csx_gpdouble(argc,argv,"Tp",&Tp,0.0225); // propag. delay (ms.)
csx_gpdouble(argc,argv,"Tif",&Tif,0.0096); // interframe delay
csx_gpdouble(argc,argv,"Tslot",&Tslot,0.0512); // slot time
csx_gpdouble(argc,argv,"Tjam",&Tjam,0.0032); // jam time (ms.)
csx_gpdouble(argc,argv,"N",&dval,200); // no. of stations
N=dval;
/* propagation/transfer time ratio
*/
Ejemplos de modelos instrumentados
117
csx_gpdouble(argc,argv,"a",&a,0.05);
/* offered load: G=N*Tf/(Ti+Tf) */
csx_gpdouble(argc,argv,"G",&G,0.50);
smpl(0,"Ethernet Local Area Network");
csx_uservar("S(throughput)",S);
csx_uservar("D(norm delay)",D);
for (stn=1; stn<=Na; stn++) desc[stn].lnk=stn+1;
desc[Na].lnk=0;
init_bm(2000,2000);
csx_firstevent;
schedule(1,Tp,0);
while (csx_loop(!end))
{/* run until 10% accuracy achieved */
cause(&event,&stn);
switch (event)
{
csx_event;
case 1: TransmitFrame(); break;
case 2: Defer(stn);
break;
case 3: StartTransmit(stn);
break;
case 4: EndTransmit(stn);
break;
case 5: InitBackoff(stn);
break;
case 6: Deassert();
break;
}
}
civals(&Td,&hw,&nb);
printf("S = %.3f\n",tfsum/time());
printf("D = %.3f\n",Td/Tf);
}
...
Como puede observarse, la instrumentación sigue siempre la misma pauta: añadir
el fichero de cabecera, las modificaciones al procesamiento de eventos y la capacidad
de interpretar los parámetros escritos en la línea de comandos.
3.6.2 Plan factorial 23 equilibrado aplicado a un modelo SMPL de
servidor central
En este caso se pretende mostrar cómo aplicar la interfaz de CSX para monitorizar un modelo SMPL de un servidor central y aplicarle un análisis estadístico tipo
plan factorial 2k. La Figura 3-31 muestra el sistema de colas del modelo de interés.
118
Propuesta de un entorno paralelo para la ejecución de simulaciones
Mem.
p_disk1
t_disk1
p_disk2
n_mem
t_cpu
t_disk2
n_terms
t_terms
Figura 3-31. Red de colas del modelo implementado.
El siguiente listado corresponde al programa SMPL que representa el modelo, y
que ha sido convenientemente preparado para ser monitorizado por CSX.
/* central server */
#include <smpl.h>
#include <csx_smpl.h>
#include <stdio.h>
#define real double
#define MAXTERMS 200
static double t_terms, t_disk1, t_disk2,
p_disk1, p_disk2, t_cpu;
static int n_terms, n_mem;
static struct token {
real ts;
} task[MAXTERMS+1];
static int cpu,queuemem,terms,monitor;
static int disk[3];
static double n = 0.0,s = 0.0;
double mrt(int i)
{
if (i) {
/* reset call */
s = n = 0.0;
return(0.0);
}
if (n > 0.0)
return(s/n);
else
return(0.0);
}
static int turns = 200;
Ejemplos de modelos instrumentados
void main(int argc, char *argv[])
{
int i,event;
real r;
n = s = 0.0;
csx_gpint(argc,argv,"n_terms",&n_terms,12);
csx_gpdouble(argc,argv,"t_terms",&t_terms,30.0);
csx_gpdouble(argc,argv,"t_disk1",&t_disk1,0.03);
csx_gpdouble(argc,argv,"t_disk2",&t_disk2,0.05);
csx_gpdouble(argc,argv,"p_disk1",&p_disk1,0.9);
csx_gpdouble(argc,argv,"p_disk2",&p_disk2,0.0);
csx_gpdouble(argc,argv,"t_cpu",&t_cpu,0.5);
csx_gpint(argc,argv,"n_mem",&n_mem,8);
smpl(0,"Central server.");
csx_uservar("Mean_resp_time",mrt);
cpu = facility ("CPU",1);
disk[1] = facility ("disk1",1);
disk[2] = facility ("disk2",1);
queuemem = facility ("Mem_resource",n_mem);
terms = facility ("Terminals",n_terms);
monitor = facility ("Monitor",n_terms);
csx_firstevent;
for (i=1;i<=n_terms;i++) schedule(1,0.0,i);
while (csx_loop(turns)) {
cause (&event,&i);
switch (event)
{
csx_event;
case 1: /* arrival to terminal */
schedule (2,0.0,i);
break;
case 2: /* terminal service */
if (request(terms,i,0) == 0 )
schedule (3,expntl(t_terms),i);
break;
case 3: /* release term, go to queuemem */
release (terms,i);
request(monitor,-i,0);
task[i].ts = time();
schedule (4,0.0,i);
break;
case 4: /* arrival queuemem */
if (request(queuemem,i,0) == 0)
schedule (5,0.0,i);
break;
case 5: /* release queuemem, go to cpu */
schedule (6,0.0,i);
break;
119
120
Propuesta de un entorno paralelo para la ejecución de simulaciones
case 6: /* cpu service */
if (request(cpu,i,0) == 0)
schedule (8,expntl(t_cpu),i);
break;
case 8: /* release cpu, where go? */
release (cpu,i);
r = ranf();
if (r <= p_disk1) schedule (10,0.0,i);
else if (r <= (p_disk1+p_disk2)) schedule (20,0.0,i);
else schedule (29,0.0,i);
break;
case 10: /* disk1 service */
if (request(disk[1],i,0) == 0)
schedule (11,expntl(t_disk1),i);
break;
case 11: /* release disk1, go to cpu */
release (disk[1],i);
schedule (6,0.0,i);
break;
case 20: /* disk2 service */
if (request(disk[2],i,0) == 0)
schedule (21,expntl(t_disk2),i);
break;
case 21: /* release disk2, go to cpu */
release (disk[2],i);
schedule (6,0.0,i);
break;
case 29: /* free mem., new cpu client */
release (queuemem,i);
s += time()-task[i].ts;
n = n + 1.0;
release (monitor,-i);
turns-- ;
//printf ("Tr %.2f ",s/n);
schedule (1,0.0,i);
break;
}
}
report();
/* same of B index of monitor facility */
printf (" Mean response time = %.2f\n",s/n);
}
El índice que interesa estudiar es el tiempo medio de respuesta de los trabajos
proporcionados en los terminales. Se parte de los siguientes datos fijos:
Variable
n_term
t_term
p_disk1
p_disk2
Valor
20
10
0’9
0
Descripción
número de terminales
tiempo de reflexión
probabilidad de usar el disco 1
probabilidad de usar el disco 2
Ejemplos de modelos instrumentados
121
Se desean evaluar dos elecciones para la memoria de entrada, la CPU y el disco 1
que son:
• Memoria entrada: para 2 ó 10 trabajos.
• CPU: rendimiento de 0,1 ó 0,2 segundos por trabajo.
• Disco 1: tiempo de servicio de 0,05 ó 0,1 segundos.
Un análisis adecuado para este tipo de problemas es un plan 23 equilibrado que
con 8 experimentos es capaz de evaluar todas las posibilidades. Las variables a usar
en este experimento son cualitativas.
La Figura 3-32 muestra una hoja de cálculo de Microsoft Excel usada para preparar los datos de entrada al experimento. El factor A corresponde a las unidades de
memoria, el factor B a la CPU y el factor C al disco.
Figura 3-32. Preparando el plan 23 en Excel.
Ahora es necesario pasar estos datos a la interfaz de CSX. Para ello se usa primeramente la opción de rellenado automático de CSX (Figura 3-33).
122
Propuesta de un entorno paralelo para la ejecución de simulaciones
Figura 3-33. Parámetros de entrada al modelo usando opción “Auto Fill”.
Los datos del experimento se pueden pasar a CSX desde Excel usando “copiar y
pegar”, aplicando previamente la traspuesta a los datos de Excel, pues allí están en
columnas y en CSX en filas. El resto de los campos se fijan con los parámetros deseados (ver Figura 3-34).
Figura 3-34. Parámetros de entrada al modelo.
El siguiente paso consiste en realizar las simulaciones. En este caso se harán ejecuciones largas para tener un resultado de salida con mínimas garantías de ser estable. Nótese que éste no es el procedimiento correcto y que los resultados no tienen
validez estadística. Unos resultados más correctos se obtendrían empleando el anali-
Ejemplos de modelos instrumentados
123
zador estadístico desarrollado en el siguiente capítulo. La Figura 3-35 muestra la
interfaz de CSX ejecutando los experimentos.
Figura 3-35. Experimento en ejecución.
Finalmente, con CSX se consiguen los datos de la Tabla 3-4.
n_terms
20
20
20
20
20
20
20
20
t_terms
10
10
10
10
10
10
10
10
t_disk1
0,05
0,05
0,05
0,05
0,1
0,1
0,1
0,1
0,9
0,9
0,9
0,9
0,9
0,9
0,9
0,9
t_disk2
p_disk1
p_disk2
t_cpu
n_mem
0
0
0
0
0
0
0
0
0,1
0,1
0,2
0,2
0,1
0,1
0,2
0,2
2
10
2
10
2
10
2
10
100000
100000
100000
100000
100000
100000
100000
100000
event_count
4795497
5807581
2637220
2852770
3823489
5739481
2404152
2952084
ev_mili_m
403,2201 352,0812 399,2158 338,3266 399,4451
ev_mili_i
403,2200 352,0812
sim_time
time_start
time_end
Mean_resp_time
355,056 395,9407 340,1018
399,215 338,3264 399,4450 355,0559 395,9405 340,1017
110
110
110
110
110
110
11893
16495
6606
8432
9572
16165
12,78382 10,11871 31,32411 29,71388 18,47125 11,36811
110
110
6072
8680
35,2256 29,99521
f_CPU_U
0,876774 0,994667 0,960229 0,999996 0,701565 0,936988 0,876788 0,999809
f_CPU_B
0,099971 0,099998
f_CPU_Lq
0,604116 6,979303 0,783718 8,681610 0,369833 4,497974 0,604210 8,154842
F_disk1_U
0,394750 0,447630 0,216272 0,224924 0,630080 0,843498 0,395781
F_disk1_B
F_disk1_Lq
0,05001 0,049997
0,19968 0,199839 0,100065 0,100055 0,199524 0,199851
0,05000 0,049973 0,099876
0,122511 0,356666 0,039768
0,45003
0,10008 0,100125 0,099938
0,06520 0,298359 2,818800 0,123209 0,367662
F_disk2_U
0
0
0
0
0
0
0
F_disk2_B
0
0
0
0
0
0
0
0
F_disk2_Lq
0
0
0
0
0
0
0
0
F_Mem_resource_U
F_Mem_resource_B
1,998030 8,777650 1,999975 9,970117
2,27685 8,832056 4,136283
0
1,99983 9,096397 1,999732 9,970524
19,8181 2,846856 9,706758 4,528994 19,95382
124
Propuesta de un entorno paralelo para la ejecución de simulaciones
F_Mem_resource_Lq
F_Terminals_U
F_Terminals_B
9,221356 1,278814
13,1473 4,979646 10,97642 1,556926 13,55678 5,018475
8,77975 9,942010 4,852210
5,0481
7,02319 9,344528 4,442091 5,008574
10,00348 10,00242 10,03269 10,03174 9,996429 9,970687 10,05657 10,02075
F_Terminals_Lq
0
0
0
0
0
0
0
0
F_Monitor_U
11,21831 10,05638 15,14583 14,94846 12,97550 10,65328 15,55354 14,98801
F_Monitor_B
12,78382 10,11871 31,32411
F_Monitor_Lq
0
0
0
29,7138 18,47125 11,36811
0
0
35,2256 29,99521
0
0
0
Tabla 3-4. Datos generados con CSX al ejecutar el modelo del servidor central.
El índice que interesa analizar se ha obtenido por dos vías: como tiempo medio
de permanencia en la estación de servicio monitor y mediante la función
Mean_resp_time creada al efecto (obsérvese que los resultados coinciden). Estos
datos se copian y pegan transpuestos a la hoja de cálculo previa para proceder al
análisis de los datos. La Tabla 3-5 muestra el resultado.
A
+
+
+
+
B
+
+
+
+
C
+
+
+
+
A
B
C
2
0,1
0,05
+
10
0,2
0,1
A
2
10
2
10
2
10
2
10
B
0,1
0,1
0,2
0,2
0,1
0,1
0,2
0,2
C
0,05
0,05
0,05
0,05
0,1
0,1
0,1
0,1
MRT
12,78
10,12
31,32
29,71
18,47
11,37
35,23
30,00
22,38
Ef. A
Ef. B
Ef. C
Ef. AxB
Ef. AxC
Ef. BxC
-2,08
9,19
1,39
0,37
-1,01
-0,34
0,10
Ef. AxBxC
Tabla 3-5. Análisis de los resultados en la hoja de cálculo.
Un vistazo a los datos permite ver que el factor CPU (Ef. B) es el más destacado,
seguido del número de memorias para los trabajos. Sería necesario un análisis de la
varianza (ANOVA) para ver realmente cuáles de los resultados son significativos
estadísticamente. Obsérvese que parece haber una interacción entre la cantidad de
memoria de entrada y el tiempo de acceso al disco duro.
Ejemplos de modelos instrumentados
125
3.6.3 Modelo CSIM de una cola M/M/3//k
A continuación se lista una implementación en CSIM de un modelo de colas
M/M/3//k. La adaptación de modelos CSIM es igual o más sencilla que la de modelos SMPL. Para ilustrar otras posibilidades, se ha decidido emplear las funciones
csx_obs_new() y csx_obs_add() para la recogida de muestras. Esta funciones permiten que CSX pueda especificar el número de muestras del parámetro de
interés que se deben recoger para realizar cada envío.
// mm35
#include <csim.h>
#include <csx_csim.h>
void csx_createuservariables(void);
// ----------------- parametres del model -----------------------int NTERMS;
double Z=0.5;
double Tcpu=1.0/8.0;
#define TSIM
50000.0
FACILITY cpu;
TABLE respt_closed;
int obrespt_closed, obcpu_cnt;
void informe(void);
void closed_job(int i);
int closed_job_cnt = 0;
int terminal_cnt = 0;
double terminal_tsim = 0.0;
// ------ int main(int argc, char *argv[]) ----------------------int main(int argc, char *argv[])
{
long sid;
int i;
csx_gpint(argc,argv,"nterms",&NTERMS,5);
set_model_name("MM35");
obrespt_closed = csx_obs_new("obrespt_closed");
obcpu_cnt = csx_obs_new("obcpu_cnt");
sim();
}
126
Propuesta de un entorno paralelo para la ejecución de simulaciones
// ------------------- sim() -----------------------------------void sim (void) {
int i;
create("sim");
cpu = facility_ms("CPU",3);
respt_closed = table("respt_closed");
// closed jobs
for (i=0;i<NTERMS;i++)
closed_job(i);
hold(0.0);
// impedir la terminación en modo monitorizado
if (CSX_M != CSXMODE_OFF) {
EVENT dummy;
csx_proc();
hold(0.0);
dummy = event("dummy");
wait(dummy); //no ocurrirá nunca
}
else {
hold(TSIM);
informe();
conclude_csim();
}
}
// ----------------------- informe() -----------------------------void informe (void) {
int i;
printf("est, serv, util, qlen, resp, tput\n");
printf("CPU, %lf, %lf, %lf, %lf, %lf\n", serv(cpu), util(cpu),
qlen(cpu), resp(cpu), tput(cpu));
printf("Tiempo respuesta trabajos cerrados. %lf\n",
table_mean(respt_closed));
printf("Productividad terminales........... %lf\n",
terminal_cnt/(clock-terminal_tsim)) ;
printf("Trabajos terminales................ %d\n",
terminal_cnt);
}
// -------------- void closed_job(int i) -------------------------void closed_job(int i) {
double dprob;
TIME timestamp;
create("closed_job");
while(1) { // siempre
hold(exponential(Z));
terminal_cnt++;
timestamp = clock;
CPU_CLOSE:
//terminal
Ejemplos de modelos instrumentados
127
use(cpu, exponential(Tcpu)); // CPU
csx_obs_add(obcpu_cnt,1.0);
closed_job_cnt++;
record(clock - timestamp, respt_closed);
csx_obs_add(obrespt_closed,clock - timestamp);
} //while(1)
}
3.6.4 Modelo CSIM de un servidor central mixto
El siguiente listado corresponde a la implementación en CSIM de un modelo servidor central mixto (con clientes abiertos y cerrados). En este caso se ha optado por
instrumentar el modelo de manera que se recojan estadísticas mediante funciones
definidas por el usuario y funciones csx_obs*(). Se pretende también ilustrar la
forma de recoger muchos índices de prestaciones del modelo sin tener que realizar un
gran esfuerzo de codificación de funciones de usuario.
// mixed central server
#include <csim.h>
#include "csx_csim.h"
void csx_createuservariables(void);
// ----------------- parametres del model ------------------------#define NDISK
3L
double Tdisk=0.01;
double Tdisk1=0.02;
double Tdisk2=0.05;
int NTERMS;
double Z=6.0;
double lambda;
double Tcpu=0.0375;
#define TSIM
50000.0
FACILITY cpu;
FACILITY disk[NDISK];
TABLE respt_open, respt_closed;
//observadores
int obrespt_open, obrespt_closed, obterm_cnt;
void
void
void
void
open_job(void);
open_job_generator(void);
informe(void);
closed_job(int i);
128
Propuesta de un entorno paralelo para la ejecución de simulaciones
int closed_job_cnt = 0;
int open_job_cnt = 0;
int terminal_cnt = 0;
double terminal_tsim = 0.0;
// ----------- int main(int argc, char *argv[]) ------------------int main(int argc, char *argv[])
{
long sid;
int i;
csx_gpint(argc,argv,"nterms",&NTERMS,48);
csx_gpdouble(argc,argv,"lambda",&lambda,0.0001);
set_model_name("Mixed central server");
// observadores
obrespt_open = csx_obs_new("obrespt_open");
obrespt_closed = csx_obs_new("obrespt_closed");
obterm_cnt = csx_obs_new("obterm_cnt");
sim();
}
// ---------------------- sim() ---------------------------------void sim (void) {
int i;
create("sim");
cpu = facility("CPU");
facility_set(disk,"DISK",NDISK);
respt_open = table("respt_open");
respt_closed = table("respt_closed");
// closed jobs
for (i=0;i<NTERMS;i++)
closed_job(i);
hold(0.0);
// open jobs
if (lambda > 0.0)
open_job_generator();
/* #@ */
csx_createuservariables();
//detectar si se trabaja en modo monitorizado
if (CSX_M != CSXMODE_OFF) {
EVENT dummy;
csx_proc();
hold(0.0);
dummy = event("dummy");
wait(dummy); //no ocurrirá nunca
}
Ejemplos de modelos instrumentados
129
else {
hold(TSIM);
informe();
conclude_csim();
}
}
}
// ------------------ informe() ----------------------------------void informe (void) {
int i;
printf("est, serv, util, qlen, resp, tput\n");
printf("CPU, %lf, %lf, %lf, %lf, %lf\n", serv(cpu), util(cpu),
qlen(cpu), resp(cpu), tput(cpu));
i=0; printf("DISK_1, %lf, %lf, %lf, %lf, %lf\n", serv(disk[i])
,util(disk[i]), qlen(disk[i]), resp(disk[i]), tput(disk[i]));
i=1; printf("DISK_2, %lf, %lf, %lf, %lf, %lf\n", serv(disk[i])
,util(disk[i]), qlen(disk[i]), resp(disk[i]), tput(disk[i]));
printf("Temps resposta treballs oberts %lf\n",
table_mean(respt_open));
printf("Temps resposta treballs tancats %lf\n",
table_mean(respt_closed));
printf("Throughput terminals %lf\n",
terminal_cnt/(clock-terminal_tsim)) ;
printf("Treballs terminals %d\n",terminal_cnt);
}
// ---------------- void open_job_generator(void) ----------------void open_job_generator(void) {
create("open_job_generator");
while (1) {
open_job(); //new job
hold(expntl(1.0/lambda));
}
//interarrival
}
// -------- void open_job(void) ----------------------------------void open_job(void) {
double dprob;
TIME timestamp;
create("open_job");
timestamp = clock;
CPU_OPEN:
use(cpu, exponential(Tcpu)); //CPU use
dprob = uniform01();
if (dprob <= (25.0/320))
{ use(disk[0], exponential(Tdisk1)); goto CPU_OPEN;}
else if (dprob <= ((25.0+6.0)/320))
{ use(disk[1], exponential(Tdisk2)); goto CPU_OPEN;}
else
{ open_job_cnt++;
record(clock - timestamp, respt_open);
csx_obs_add(obrespt_open,clock - timestamp);
130
Propuesta de un entorno paralelo para la ejecución de simulaciones
}; // OUT
}
// ---------- void closed_job(int i) ----------------------------void closed_job(int i) {
double dprob;
TIME timestamp;
create("closed_job");
while(1) { // looping forever
hold(exponential(Z));
//terminal
terminal_cnt++;
csx_obs_add(obterm_cnt,1.0);
timestamp = clock;
CPU_CLOSE:
use(cpu, exponential(Tcpu)); // CPU use
dprob = uniform01();
if (dprob <= (25.0/320))
{
use(disk[0], exponential(Tdisk1));
goto CPU_CLOSE;}
else if (dprob <= ((25.0+6.0)/320))
{
use(disk[1], exponential(Tdisk2));
goto CPU_CLOSE;}
else
{ closed_job_cnt++;
record(clock - timestamp, respt_closed);
csx_obs_add(obrespt_closed,clock - timestamp);
}; //TERM
} //while(1)
}
// -------------- user variables -------------------#define CSXCSIMFUNC(A,B) double A (int x) \
{static int i = 1; \
if (i==1) \
{ \
i=0;\
return(0.0); \
} \
else \
return(B); \
}
CSXCSIMFUNC(cpu_serv,serv(cpu))
CSXCSIMFUNC(cpu_util,util(cpu))
CSXCSIMFUNC(cpu_qlen,qlen(cpu))
CSXCSIMFUNC(cpu_resp,resp(cpu))
CSXCSIMFUNC(cpu_tput,tput(cpu))
double term_tput (int x)
{static int i = 1;
Ejemplos de modelos instrumentados
if (x==1) { //reset
terminal_cnt = 0;
terminal_tsim = clock;
return(0.0);
}
if (i==1)
{
i=0;
return(0.0);
}
else
return(terminal_cnt/(clock-terminal_tsim));
}
double term_cnt (int x)
{static int i = 1;
if (x==1) { //reset
terminal_cnt = 0;
return(0.0);
}
if (i==1)
{
i=0;
return(0.0);
}
else
return(terminal_cnt);
}
CSXCSIMFUNC(disk1_serv,serv(disk[0]))
CSXCSIMFUNC(disk1_util,util(disk[0]))
CSXCSIMFUNC(disk1_qlen,qlen(disk[0]))
CSXCSIMFUNC(disk1_resp,resp(disk[0]))
CSXCSIMFUNC(disk1_tput,tput(disk[0]))
CSXCSIMFUNC(disk2_serv,serv(disk[1]))
CSXCSIMFUNC(disk2_util,util(disk[1]))
CSXCSIMFUNC(disk2_qlen,qlen(disk[1]))
CSXCSIMFUNC(disk2_resp,resp(disk[1]))
CSXCSIMFUNC(disk2_tput,tput(disk[1]))
CSXCSIMFUNC(open_cnt,open_job_cnt)
CSXCSIMFUNC(closed_cnt,closed_job_cnt)
CSXCSIMFUNC(frespt_open,table_mean(respt_open))
CSXCSIMFUNC(frespt_closed,table_mean(respt_closed))
void csx_createuservariables(void) {
csx_uservar("cpu_serv",cpu_serv);
csx_uservar("cpu_util",cpu_util);
csx_uservar("cpu_qlen",cpu_qlen);
csx_uservar("cpu_resp",cpu_resp);
131
132
Propuesta de un entorno paralelo para la ejecución de simulaciones
csx_uservar("cpu_tput",cpu_tput);
csx_uservar("term_tput",term_tput);
csx_uservar("term_cnt",term_cnt);
csx_uservar("disk1_serv",disk1_serv);
csx_uservar("disk1_util",disk1_util);
csx_uservar("disk1_qlen",disk1_qlen);
csx_uservar("disk1_resp",disk1_resp);
csx_uservar("disk1_tput",disk1_tput);
csx_uservar("disk2_serv",disk2_serv);
csx_uservar("disk2_util",disk2_util);
csx_uservar("disk2_qlen",disk2_qlen);
csx_uservar("disk2_resp",disk2_resp);
csx_uservar("disk2_tput",disk2_tput);
csx_uservar("open_cnt",open_cnt);
csx_uservar("closed_cnt",closed_cnt);
csx_uservar("rnd_cnt",rnd_cntb);
csx_uservar("respt_open",frespt_open);
csx_uservar("respt_closed",frespt_closed);
}
3.7
Conclusiones
Con el objetivo principal de obtener un entorno paralelo donde ejecutar simulaciones por eventos discretos, este capítulo propone las características básicas deseables de dicho entorno.
El entorno paralelo propuesto aquí pretende ser capaz de gestionar eficientemente
los experimentos de simulación que múltiples usuarios soliciten, encargándose de
repartir el trabajo entre los recursos de computación disponibles.
Con estas premisas se describe también en este capítulo el desarrollo de las técnicas para obtener el entorno.
Una premisa fundamental es la aplicabilidad a cualquier lenguaje de simulación
por eventos. Con la técnica de inyección de eventos en la cola del simulador, se tiene
un mecanismo de instrumentación que permite, al entorno paralelo, tomar el control
de un modelo de simulación de forma transparente.
Se ha comprobado que la instrumentación del modelo y su ejecución en el entorno paralelo no supone una sobrecarga apreciable en la ejecución de éste, con lo que
se demuestra lo adecuado de la técnica propuesta.
Conclusiones
133
La adaptación de un modelo al entorno paralelo requiere muy pocas modificaciones, con lo que se garantiza una rápida aplicabilidad.
Como la “máquina paralela de simulación” está compuesta por computadores de
distintas prestaciones, se han desarrollado y probado las técnicas que permiten, por
una parte, clasificar a las máquinas por su potencia de simulación, y por otra, medir
la velocidad efectiva de simulación de un modelo en ejecución. Estas dos medidas
pueden permitir la aplicación de técnicas de migración de carga en un futuro.
En este capítulo no se ha hablado del análisis estadístico a realizar con los datos
de salida de las réplicas, pues se ha seguido la estrategia de separar ambas partes para
garantizar, en la medida de lo posible, su independencia.
4. Desarrollo de un analizador paralelo basado en réplicas independientes
4
Desarrollo de un analizador
paralelo basado en réplicas
independientes
En este capítulo se describe el planteamiento, desarrollo y refinamiento de un
módulo de análisis de la salida basado en el método de las réplicas independientes en
régimen permanente, aplicado a la herramienta CSX.
Para la implementación del método de las réplicas se elige ejecutar una cantidad
fija de ellas y permitir que evolucionen hasta que se alcancen las condiciones deseadas. Esta aproximación es la más adecuada desde el punto de vista estadístico, pero
presenta problemas en su implementación. Se ha diseñado un algoritmo de gestión de
las réplicas que permite resolver la limitación y permite obtener un gran rendimiento
a la propuesta. El algoritmo se describe en el apartado 4.2.
Para terminar una simulación por eventos discretos se pueden emplear distintos
criterios de parada. En este sentido se proponen nuevos criterios de parada que son
descritos en el apartado 4.3. La propuesta de algoritmo de gestión de réplicas es
evaluada junto a los criterios de parada, consiguiéndose una buena aceleración de las
simulaciones y unos criterios de parada más robustos, estadísticamente hablando, que
los clásicos.
En los experimentos del apartado antes reseñado se pone de manifiesto la problemática del método de las réplicas para conseguir importantes aceleraciones en el
caso de modelos con transitorios iniciales apreciables. En el apartado 4.4 se propone
un algoritmo para reducir el efecto del transitorio. Los experimentos realizados con
la propuesta demuestran una mejora de la calidad estadística (cobertura) de los datos
de salida de la simulación sin incrementar el coste de la simulación, y permitiendo
mayores posibilidades de aceleración.
136
Desarrollo de un analizador paralelo basado en réplicas independientes
Para completar la flexibilidad de la herramienta de análisis estadístico, en el
apartado 4.5 se propone un algoritmo para la automatización de los tiempos entre
extracciones en aquellos modelos cuyas variables de salida deban analizarse empleando como referencia el tiempo simulado.
Este capítulo es un extracto de [Perles 1998], [Perles et al. 2002b] y [Perles et al.
2003].
4.1 Criterio de selección del método y propuesta básica de
funcionamiento
El planteamiento de la herramienta CSX hace viable la aplicación de aquellos
métodos de análisis estadístico de la salida descritos en el capítulo 2 que no precisan
de procesamiento estadístico previo en los esclavos.
La justificación de la elección del método de las réplicas frente a las propuestas
que se adaptan con naturalidad a la secuencialidad de un monoprocesador es, precisamente, el hecho de que en este caso no se tiene dicha restricción. Ello permite
aprovechar la gran ventaja estadística de la independencia real entre réplicas exclusiva de este método y que fuerza a otros métodos a estimar o intentar reducir las correlaciones muestrales.
El método de las réplicas es el preferido de muchos autores por este hecho [Law
y Kelton 2000] y por otras ventajas adicionales cuando se pretenden comparar distintas configuraciones de sistemas. Sin embargo, la realidad muestra que es más fácil
implementar un método estadístico con control automático de parada basado en una
técnica de análisis secuencial (por ejemplo, lotes) que hacerlo con el método de las
réplicas, pues en el segundo caso se debe fijar a priori el tamaño de cada réplica, con
lo que se está a expensas de que el efecto del transitorio inicial sesgue los resultados.
Si se usa el método de las réplicas en paralelo y este paralelismo se basa en lanzar
réplicas de tamaño fijo hasta que se alcance un criterio de parada se pueden producir
efectos indeseados de sesgo que obligan a importantes cautelas como se demuestra
en [Heidelberger y Welch 1983, Heidelberger 1988].
En [Glynn 1995] se muestra que es asintóticamente mejor ejecutar un conjunto
reducido de réplicas durante mucho tiempo que ejecutar muchas cortas. Ello se debe
principalmente al talón de Aquiles del método de las réplicas, que es el efecto del
transitorio inicial.
Propuesta de algoritmos para gestionar la ejecución de las réplicas independientes
137
El entorno donde resulta natural explotar la herramienta CSX consiste en los laboratorios docentes de un departamento universitario, los cuales se pueden emplear
para propósitos de investigación fuera del horario de prácticas. En el caso del DISCA, dichos laboratorios están constituidos por entre 20 y 30 ordenadores personales
con idénticas características, por lo que parece muy viable utilizar el método de las
réplicas independientes. Pero se elige la opción de lanzar una cantidad fija de réplicas y dejar que evolucionen hasta que se cumpla un determinado criterio de parada.
Con ello se evita el problema del sesgo que implica tener que decidir el tamaño de la
réplica (en términos de tiempo de simulación, de consumo de CPU, etc.).
La propuesta básica del método es lanzar un número fijo de modelos de simulación idénticos en diferentes máquinas. La única diferencia entre los modelos es que
emplearán un canal de números aleatorios diferente y, por tanto, serán estadísticamente independientes entre sí. Los modelos deberán enviar a intervalos fijos (medidos en las unidades que interese) las medias estadísticas recolectadas de los índices
de prestaciones elegidos.
El proceso monitor recoge las muestras y las analiza para comprobar si se ha
cumplido un determinado criterio de parada. Si el criterio se cumple, se envía orden
de que las réplicas terminen; en caso contrario, la orden es que continúen hasta el
siguiente punto de sincronización y se repita el proceso.
En principio, el beneficio teórico de esta aproximación es la disminución del
efecto del transitorio inicial según aumenta el tamaño de la réplica. Técnicas de disminución del efecto del transitorio podrían mejorar aún más esta aproximación, reduciéndose el tiempo de simulación necesario o aumentando la cobertura de las medidas.
4.2 Propuesta de algoritmos para gestionar la ejecución de
las réplicas independientes
El primer prototipo de gestor de la ejecución de las réplicas se propuso en [Perles
1994]. Como ya se ha indicado, la manera de gestionar la ejecución de las réplicas
consiste en que estas envíen la información estadística recogida a intervalos fijos
(checkpoints). En el primer prototipo, cada vez que la réplica ha enviado su información, esperará a que el proceso monitor le indique si debe seguir calculando o no. El
monitor dará la orden de continuar cuando haya recibido la información de cada una
de las réplicas y no se hayan alcanzado las condiciones de finalización de la simula-
138
Desarrollo de un analizador paralelo basado en réplicas independientes
ción. La Figura 4-1 muestra un esquema del comportamiento real cuando se emplea
esta estrategia.
Monitor
Réplica 1
Réplica 2
Réplica 3
Desocupado
1 rocesando
P
1
tiempo
Figura 4-1. Escenario típico de una monitorización de 3 réplicas sincronizándose en
cada punto de comunicación de estadísticas.
Este planteamiento hace que el tiempo de ejecución de la simulación sea el sumatorio de los máximos tiempos de ejecución de las réplicas entre dos puntos consecutivos de comprobación (checkpoint). Expresado matemáticamente, para k réplicas
y un total de c puntos de comprobación se tiene,
t ≈ ∑ (máx(t R1, j , t R 2, j ,..., t Rk , j ) + t mon + t com1 + t com 2 ) =
c
j =1
c
= c(t mon + t com1 + t com 2 ) + ∑ máx(t R1, j , t R 2, j ,..., t Rk , j )
(4.1)
j =1
donde tRi,j representa el tiempo de reloj necesario para procesar (simular) el jésimo checkpoint en la réplica i, tmon representa el tiempo para que el monitor procese la información estadística recibida, tcom1 representa el tiempo necesario para la
transmisión de la información estadística de la réplica más lenta al monitor, y tcom2
representa el tiempo necesario para la transmisión de las respuestas del monitor a las
réplicas. Por simplicidad se han supuesto constantes tmon, tcom1 y tcom2 respectivamente.
La expresión muestra claramente que a mayor cantidad de puntos de comprobación se tendrán un aprovechamiento peor de los recursos computacionales. En la expresión destacan, por una parte, los costes fijos de monitorización y de comunicación
y, por otra, la suma de los costes de la peor réplica en cada punto de comprobación.
Teniendo en cuenta que el tiempo de ejecución de cada fragmento de simulación
no es exactamente el mismo y que los efectos de la variación de carga de máquinas
particulares afectarán muy negativamente a la globalidad de la simulación, cabe esperar que los efectos sean considerables, obligando a tomar otras alternativas.
Propuesta de algoritmos para gestionar la ejecución de las réplicas independientes
139
En [Yau 1999] ya se indica que la necesidad de sincronización de las réplicas hace que esta técnica no sea adecuada para su aplicación en entornos paralelos. Esta
importante limitación debe se ha de soslayar para hacer viable el método de análisis
propuesto.
Una posibilidad consiste en que las réplicas se comuniquen asíncronamente con
el monitor, sin espera en una sincronización. Con ello se consigue una disminución
del tiempo de respuesta y un mejor aprovechamiento de los recursos. Un beneficio
adicional directo será una disminución del efecto de las fluctuaciones transitorias de
la carga en un computador compartido, siendo la carga media del computador un
índice apropiado para el reparto de réplicas. La Figura 4-2 ilustra el nuevo escenario
empleando la estrategia propuesta.
Monitor
Réplica 1
Réplica 2
Réplica 3
Desocupado
1 rocesando
P
1
tiempo
Figura 4-2. Escenario asíncrono de una monitorización de 3 réplicas.
Ahora, el tiempo de ejecución de la simulación se puede estimar aproximadamente como,
c
c

 c
t ≈ máx ∑ t R1, j ,∑ t R 2, j ,...,∑ t Rk , j 
(4.2)
j =1
j =1

 j =1
El primer beneficio es la práctica desaparición de los costes, en tiempo de ejecución, que implican el monitor y las comunicaciones. Se consigue que el tiempo de
ejecución de la simulación sea, precisamente, el tiempo de ejecución de la réplica
más lenta, midiéndose este tiempo de igual manera que se haría en un entorno secuencial, pero con todas las ventajas de un entorno paralelo. Como importante ventaja adicional, las pequeñas fluctuaciones de carga, que afectaban muy negativamente a la aproximación anterior, son absorbidas por esta estrategia.
Un defecto de la segunda aproximación es la posibilidad de desperdicio de tiempo de computación debido a que parte de las réplicas pueden haber simulado más allá
del punto de comprobación que cumple la condición de fin de la simulación. Esta
situación parece inevitable si se quieren obtener las ventajas descritas.
140
Desarrollo de un analizador paralelo basado en réplicas independientes
Aunque no parece necesario en este caso, es posible cuantificar estadísticamente
el efecto de las expresiones (4.1) y (4.2) aplicando los resultados de [Bhavasar and
Isaac 1987], donde se establece que los tiempos de ejecución de las réplicas son variables aleatorias que se distribuyen exponencialmente con media normalizada a 1.
Este algoritmo de gestión de las réplicas se ha implementado en CSX, y ha cumplido los resultados teóricos expuestos. Por tanto, la estrategia resuelve los problemas
comentados en la literatura y puede ser un buen candidato para un gestor paralelo
basado en réplicas independientes.
La aproximación propuesta es satisfactoria en un escenario donde cada réplica se
ejecuta en una máquina distinta. Ése puede no ser el escenario en muchas ocasiones,
pudiendo ocurrir que se desee ejecutar más de una réplica en una máquina (por
ejemplo, si se dispone de pocas máquinas, o una máquina es más potente que las
otras). La Figura 4-3 ilustra esta situación; en el caso b) se ha decidido introducir 2
réplicas en cada estación.
R1
R2
R3
R1
R2
R3
R4
R5
R6
R4
R5
R6
a)
b)
Figura 4-3. Ejemplos del reparto de 6 réplicas. a) Una en cada estación,
b) Dos en cada estación.
En los casos en que se decida planificar más de una réplica en cada estación, se
estará repartiendo el tiempo de procesador entre cada réplica, por lo que todas competirán continuamente por dicho recurso. Parece intuitivo que la aproximación inicial
(con síncronización en el monitor) puede no ser tan mala en este caso, pues cuando
una réplica “llega” a su punto de comprobación y se detiene, cede el recurso de computación al resto de las réplicas, autocompensándose el sistema de simulación.
La Figura 4-4 muestra un escenario límite de una simulación real donde un monitor y 5 réplicas se ejecutan en la misma máquina con el esquema síncrono. La imagen se ha obtenido con el monitor XPVM que complementa al paquete PVM. Cuando la réplica más rápida en cada punto de comprobación (checkpoint) termina, el
Propuesta de algoritmos para gestionar la ejecución de las réplicas independientes
141
resto tienen más posibilidades de terminar antes. A pesar de todo, se sigue apreciando el efecto negativo de la sincronización con el monitor.
Monitor
Procesando
Desocupado
Figura 4-4. Traza de una simulación real síncrona de un monitor
y 5 réplicas ejecutándose en una máquina.
La Figura 4-5 muestra el mismo escenario pero trabajando en modo asíncrono. Se
aprecia un “alargamiento” en el tiempo de ejecución de cada punto de comprobación.
En dicha imagen también se puede apreciar que el tiempo de ejecución de un checkpoint no es constante e independiente de puntos de comprobación anteriores.
Figura 4-5. Traza de una simulación real asíncrona de un monitor y 5 réplicas ejecutándose en una máquina.
En este tipo de escenarios sería ideal combinar las ventajas de las dos aproximaciones. Para ello se ha mejorado el algoritmo incluyendo un esquema híbrido de sincronización local para las réplicas que se ejecutan en una misma máquina.
El sistema de sincronización local se basa en que todas las réplicas colocadas en
una máquina conozcan el número de puntos de comprobación que han generado el
resto de réplicas en la misma máquina. Una réplica podrá continuar simulando si no
ha sobrepasado en una cantidad fija el número de puntos (checkpoints) que han producido el resto de las réplica locales.
142
Desarrollo de un analizador paralelo basado en réplicas independientes
El mecanismo se plantea de la siguiente forma: dadas l réplicas locales y cki el
número de puntos de comprobación generados por una réplica, la réplica i podrá
continuar simulando si se cumple que,
mín(ck1, ck2, … ckl) + TH > cki
(4.3)
donde TH es un valor entero mayor o igual a 1.
Con esta expresión se consigue limitar la "distancia", medida en puntos de comprobación, entre las réplicas más rápidas y las más lentas, y proporcionar recursos
computacionales a las más lentas cuando se rezaguen.
La Figura 4-6 muestra un ejemplo de escenario donde la distancia máxima entre
la réplica más rápida y la más lenta es TH=1. En el gráfico, los puntos indican el
instante en que una réplica indica a sus vecinas que ha completado su punto de comprobación. Debajo de cada punto se representa el número de checkpoints finalizados
hasta el momento.
R1
R2
R3
(ckR1, ckR2, ckR3)
(0,0,0)
(1,1,0)
(1,2,1)
(2,2,2)
(1,0,0) (1,1,1)
(1,2,2)
Figura 4-6. Ejemplo de sincronización local con TH=1.
En la Figura 4-7 se muestra un escenario con distancia TH=2.
R1
R2
R3
(1,1,0) (2,2,0)
(0,0,0)
(ckR1, ckR2, ckR3)
(1,0,0)
(2,1,0)
(2,2,1)
(3,3,2)
(2,3,1)
(2,3,2)
Figura 4-7. Ejemplo de sincronización local con TH=2.
Para poder evaluar la expresión (4.2) se requiere que todas las réplicas conozcan
el estado de simulación del resto. La opción finalmente desarrollada consiste en que
cada réplica conozca cuáles son sus vecinas locales y les remita un mensaje asíncrono cada vez que finaliza un punto de comprobación.
Propuesta de algoritmos para gestionar la ejecución de las réplicas independientes
143
Tal como se ha realizado la implementación de CSX, la cola de mensajes sólo se
consulta al final de cada punto de comprobación. En ese momento es cuando la réplica sabe cómo está el resto y toma la decisión de continuar o no (bloqueándose o no a
la espera de un mensaje).
Esta implementación no produce ninguna sobrecarga apreciable a las réplicas y se
aprovecha del esquema de diseño de CSX. Como ventaja adicional, todas las comunicaciones son locales. Los únicos aspectos negativos vienen en la complicación de
relaciones entre réplicas en el caso de aplicar técnicas de tolerancia a fallos.
El sistema de sincronización local diseñado es especialmente útil cuando se pretende comparar un sistema con dos configuraciones A y B. El método de las réplicas
permite un análisis pareado donde se estudia directamente la diferencia entre las medias X A − X B de las dos configuraciones en lugar de simular por separado y comparar después los resultados. Al trabajar así se aumenta la potencia del experimento y
se puede recurrir, además, al uso de técnicas de reducción de la varianza como números aleatorios comunes.
Si suponemos el escenario asíncrono inicialmente descrito, el problema aparente
de realizar un experimento paralelo con dos modelos es la probable diferencia de
velocidades de simulación, siendo el modelo más costoso de ejecutar el que rezague
el experimento, permitiendo que el modelo más rápido esté realizando trabajo en
balde yendo más allá de lo necesario.
Para enfocar el problema, una posibilidad consiste en conseguir que todas las réplicas se ejecuten al mismo ritmo, y que, de alguna manera, se asignen los recursos
computacionales de forma que se puedan compensar las velocidades, proporcionando
más recursos al que más los necesita.
R1A
R2A
R3A
R4A
R5A
R6A
R1B
R2B
R3B
R4B
R5B
R6B
Figura 4-8. Análisis pareado con una réplica de cada modelo en cada máquina.
Para hacerlo, se puede aprovechar el mecanismo de sincronización local entre los
experimentos pareados, y colocar dos réplicas en cada máquina, una del modelo A y
otra del modelo B. La réplica más rápida cederá procesador a la más lenta para compensar las diferencias de velocidad. El mecanismo funcionará de forma transparente
utilizando los algoritmos descritos y sin necesidad de intervención del usuario. La
144
Desarrollo de un analizador paralelo basado en réplicas independientes
Figura 4-8 ilustra la aproximación. Este mecanismo es apropiado siempre y cuando
los dos modelos quepan en la máquina.
4.3
Criterios de parada. Propuestas y su análisis
Partiendo de que CSX está empleando el analizador estadístico basado en el método de las réplicas independientes, supóngase que se lanzan k réplicas de un programa de simulación, cada una de las cuales emplea un canal aleatorio distinto.
Sea ahora X j la media de las observaciones de una variable de salida de la jésima réplica, que es remitida al monitor de CSX en cada punto de comprobación.
Según la teoría del método de las réplicas independientes, Estas observaciones se
pueden considerar como realizaciones de variables aleatorias independientes y distribuidas normalmente. El monitor calcula un estimador de la verdadera media
µ = E( X ) como,
k
X=
∑X
j
j =1
k
Para obtener un intervalo de confianza con un porcentaje del (1-α)100% asintóticamente válido para la media global X , el monitor aplica la siguiente ecuación,
X ± t1−α / 2,k −1
S k2
k
donde S k2 es la varianza de las medias muestrales y t es la distribución t de Student.
Cada vez que se alcanza un punto de comprobación en las réplicas, el monitor
reevalúa las anteriores expresiones y, en función de los resultados obtenidos y de
otros criterios deberá decidir si se debe poner fin a la simulación. A ello se le denomina "criterio de parada".
A continuación se describirán los criterios de parada clásicos y nuevas propuestas. Dichos criterios se han evaluado desde el punto de vista del rendimiento en la
ejecución de la simulación y cobertura de la verdadera media. En esta sección se describirá también la metodología de evaluación y los resultados que se obtienen con
ella.
Criterios de parada. Propuestas y su análisis
145
4.3.1 Criterio 1: Comprobación de la precisión relativa del intervalo de
confianza
El criterio de parada más ampliamente extendido para todos los métodos de análisis de la salida secuenciales es la comprobación del error relativo de la mitad del intervalo de confianza a un determinado nivel de confianza. Para el método de las réplicas dicho error se calcula como,
ε=
t1−α / 2 ,k −1
Sk2
k
X
El criterio se aplica comprobando si el error relativo calculado con la expresión
anterior está por debajo de un umbral ε max , dándose entonces por finalizada la simulación. Es decir,
si ε < ε max entonces parar
Valores habituales de εmax son 0,05 ó 0,1 que corresponden a un error relativo del
5% y del 10% respectivamente. Estos errores se suelen calcular a niveles de confianza del 95% o del 99%.
En general, elegir errores relativos pequeños es mejor que elegirlos grandes desde
el punto de vista de la cobertura de las medias, ya que suele obligar a los métodos de
análisis de la salida a simular más, con lo que disminuyen problemas de falta de
normalidad y de correlación.
4.3.2 Criterio 2: Comprobación del error relativo y su decrecimiento
La aleatoriedad de la salida de las simulaciones y los efectos de correlación pueden dar lugar a terminaciones prematuras de las simulaciones por culpa de una casual
convergencia de factores adversos que se dan en momentos concretos de la simulación.
Para evitar estos efectos, se suele forzar a una simulación que cumple la condición de finalización a que simule algo más para estar más seguro de que se sigue
cumpliendo dicha condición y no se trata de un efecto espúreo. Por ejemplo, el paquete comercial QNAP utiliza esta estrategia de simular más allá del cumplimiento
del error relativo para comprobar que se sigue cumpliendo la condición de fin.
146
Desarrollo de un analizador paralelo basado en réplicas independientes
Aquí se propone aplicar la misma idea al método de las réplicas, concretándose
en que la simulación terminará cuando se alcance el error relativo deseado y éste
decrezca en las siguientes muestras. Esta comprobación se hará dos puntos de comprobación más adelante, es decir,
si
εmax > εi >εi+1 >εi+2 entonces parar
La aplicación de esta técnica se basa en que las medias que se obtienen al empezar la simulación suelen ser mucho más variables que cuando va avanzando la simulación, donde la sucesión de observaciones hace que la media acumulada vaya siendo
más suave conforme se incrementa el tiempo de simulación.
Los resultados que se describen más adelante muestran que esta estrategia aumenta considerablemente la cobertura de la media de algunos modelos, pero no es
adecuado para otros.
4.3.3 Criterio 3: Comprobación del error relativo y la pendiente de la
media
En esta prueba se comprueba el error relativo y, además, si la pendiente s de la
media global de las muestras entre dos puntos de comprobación consecutivos es cercana a 0, es decir, prácticamente horizontal. Con ello se trata de evitar terminaciones
espúreas debidas a fuertes correlaciones negativas (ver Figura 4-9).
Figura 4-9. Pendientes de la media que pretende calcular el criterio 3.
El cálculo se realiza aplicando la expresión,
 X i − X i −1 

 tsim i − tsim i −1

<s
Xi
Criterios de parada. Propuestas y su análisis
147
donde tsimi es el tiempo simulado en el i-ésimo punto de comprobación. O la expresión,
 X i − X i −1 

 obsi − obsi −1

<s
Xi
donde obsi es el número de muestras recogidas en el i-ésimo punto de comprobación.
La elección entre una u otra expresión depende del tipo de variable de salida a
analizar, que influirá en tipo de punto de comprobación a aplicar (basado en tiempo
simulado o número de observaciones).
En las expresiones se intenta normalizar el análisis dividiendo entre la media de
forma que sea aplicable tanto a medias pequeñas como grandes.
En este caso, el propósito es disminuir las posibilidades de que el sesgo inicial
haga terminar prematuramente las simulaciones. Si un modelo parte de unas condiciones iniciales poco razonables, y los valores de salida están muy correlados, puede
ocurrir que la media "evolucione" lentamente hacia el valor de convergencia. En este
caso, la distancia de las medias entre réplicas será pequeña, provocando que el error
relativo sea pequeño, pero no debido a la cercanía a la media verdadera. Cuando la
pendiente de la media global sea prácticamente horizontal es más probable que esté
cerca de la media verdadera.
El criterio de parada a aplicar se ha definido como,
si
εmax >εi,εi+1,εi+2
∧
smax=0.0001>si,si+1,si+2
entonces parar
esto es, el error relativo es menor que εmax y la pendiente es menor que Smax en
las siguientes dos muestras. El valor de smax se ha elegido intentando que sea lo suficientemente pequeño y, simplemente, es una primera elección para su evaluación
empírica posterior.
4.3.4 Criterio 4: Combinación de los criterios 2 y 3
Los criterios 2 y 3 se han pensado para resolver problemas distintos, por lo que
puede ocurrir que el criterio 2 sea adecuado a unos modelos y el criterio 3 a otros. En
este trabajo el propósito es dejar el trabajo de modelado al modelador y el análisis
148
Desarrollo de un analizador paralelo basado en réplicas independientes
estadístico de la salida a la herramienta, con los suficientes mecanismos para que el
modelador no tenga que enfrentarse a muchos aspectos estadísticos que la mayoría
no dominan.
En esa línea de generalidad de aplicación a cualquier modelo de simulación, es
interesante que el criterio de terminación sea aplicable a cualquier tipo de respuesta
de salida de los modelos, por lo que se ha decidido combinar el criterio 2 y el criterio
3.
Se propone como criterio 4 que,
si
εmax > εi >εi+1 >εi+2
∧
smax=0.0001>si+1,si+2
entonces parar
es decir, que se cumplan simultáneamente criterios muy similares al 2 y 3. El
propósito es que los problemas de un criterio con algunos modelos sea resuelto por el
otro criterio y viceversa.
El criterio aquí propuesto no es exactamente la combinación del criterio 2 y 3,
esto se ha hecho deliberadamente para poder apreciar como influye la diferencia introducida en el comportamiento del criterio.
4.3.5 Evaluación de los criterios
4.3.5.1
Metodología
En este apartado se expone la metodología seguida para la evaluación de la técni-
ca de las réplicas paralelas propuesta. Los aspectos que interesan son el rendimiento
de la ejecución de la simulación y la cobertura de la verdadera media.
Desde el punto de vista del rendimiento, interesa conocer el número medio de observaciones o el tiempo simulado medio (promedio de las repeticiones del experimento con distintos números aleatorios) necesario para alcanzar el criterio de parada
en función del número de réplicas empleado. Con ello se desea apreciar el efecto del
número de réplicas en el tiempo de ejecución del modelo.
En cuanto a la cobertura de la verdadera media p̂ , ésta se estima empleando la
relación,
pˆ =
x
n
Criterios de parada. Propuestas y su análisis
149
donde n es el número de repeticiones estadísticamente independientes de un experimento y x es el número de experimentos que producen un intervalo de confianza
de la media muestral de salida que incluye a la verdadera media µ.
Dado que el análisis de cobertura implica conocer la media verdadera µ, es necesario emplear modelos con solución analítica.
Se ha elegido un conjunto de modelos con solución analítica para este propósito
que se describirán en el siguiente apartado, y para los que se ha escrito y validado un
modelo equivalente de simulación por eventos discretos en el lenguaje CSIM [CSIM
1998] y se ha instrumentado para que pueda ser utilizado por CSX.
Debido a que no se conoce la naturaleza y bondad del generador aleatorio de
CSIM, pues no está documentado y no se dispone de su código fuente, se ha decidido
sustituir su generador por el generador mrg32k5a [L'Ecuyer 1999] con periodo 2319
descrito en el capítulo 2. Por la misma razón se ha decidido sustituir la generación de
variables aleatorias. Con ello se pretende asegurar la máxima calidad en la generación de las variables aleatorias de entrada para disminuir el riesgo de sesgos. La
Figura 4-10 muestra el esquema del procedimiento seguido.
Generador
números
aleatorios
MRG32K5A
Modelo
de simulación
Variables
de salida
Figura 4-10. Un generador aleatorio externo maneja las simulaciones.
Para el cálculo de rendimiento medio y de cobertura se ha repetido cada experimento 1.000 veces usando secuencias aleatorias independientes generadas a partir de
la corriente principal del generador mrg32k5a y separadas 108 números aleatorios
entre sí con el objeto de garantizar que no se solapen las corrientes de números aleatorios. Este número de repeticiones del experimento es suficientemente grande para
apreciar la diferencia de coberturas entre las distintas propuestas.
Para las condiciones estadísticas de fin de la simulación se ha seleccionado un
error relativo del 5% al 95% de nivel de confianza, por ser éste un valor ampliamente
utilizado. Para el criterio de parada 3 se ha elegido smax=0,0001. Los experimentos se
han ejecutado para el conjunto de número de réplicas paralelas R={3, 5, 7, 8, 10, 15,
20, 30}.
150
Desarrollo de un analizador paralelo basado en réplicas independientes
Los resultados experimentales que se obtienen con los modelos que se describen
en el siguiente apartado se mostrarán resumidos en forma de gráficas organizadas
como en la Figura 4-11. Dichas gráficas representan la cobertura y el coste de la simulación.
El pie de dichas gráficas describe la referencia al modelo utilizado, incluyendo la
configuración de los parámetros de entrada y, si es necesario, la variable de salida a
analizar. También contiene el punto temporal de extracción de muestras estadísticas
en cada réplica paralela (parámetro "check") y el punto temporal donde se descartan
las observaciones recogidas previamente con el propósito de eliminar un transitorio
(parámetro "reset").
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
40k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 120k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
Figura 4-11 Cobertura y rendimiento. Modelo (nombre del modelo y configuración).
Check=(punto de comprobación), reset=(punto de reinicio de estadísticas).
La gráfica de la izquierda representa la cobertura obtenida en función del número
de réplicas y el criterio usado (criterio 1=p1, criterio 2=p2, …). Para la obtención de
cada punto de la gráfica de cobertura se ha repetido 1.000 veces cada experimento.
Recuérdese que la cobertura teórica es del 95%, y por tanto, aquellos puntos que estén por debajo del punto de abcisa 0,95 corresponden a coberturas nominales por
debajo de la teórica, y al contrario para los que estén por encima.
La gráfica central representa, el coste medio de la simulación promediado a partir
de las 1.000 repeticiones del experimento. Dicho coste se puede medir en número
medio de observaciones o en tiempo medio simulado (dependiendo del tipo de variable de salida a analizar) que debe generar cada réplica para que el algoritmo termine.
Este valor es asintóticamente proporcional a otros tipos de métrica, como por ejemplo, el tiempo de CPU o el tiempo de ejecución del modelo, pero con la ventaja de
ser independientes del sistema de apoyo a la simulación (computador, sistema operativo, lenguaje de simulación, etc.). Un decrecimiento en esta curva según aumenta el
0
30
Criterios de parada. Propuestas y su análisis
151
número de réplicas indica que el paralelismo está logrando reducir el tiempo de ejecución del modelo.
La gráfica de la derecha representa la cantidad total de muestras o el tiempo simulado total que se ha necesitado para terminar la simulación. Es la suma de las
muestras o del tiempo generado por cada réplica. Por ejemplo, si con 10 réplicas se
han generado 200 muestras en cada réplica, el número total de observaciones será
2.000. Esta gráfica contiene la misma información que la gráfica central, pero es más
fácil apreciar en ella la influencia del número de réplicas en la cantidad total de
muestras o de tiempo total a generar. Un mínimo en una curva indica el número de
réplicas que alcanza el criterio de parada con menos muestras. De igual forma, un
crecimiento de la curva indica que se requerirán más muestras según aumenta el número de réplicas, y una horizontal indica un comportamiento lineal en la mejora de
rendimiento.
4.3.5.2
Modelos con solución analítica
Para el análisis de rendimiento se han seleccionado cuatro modelos de colas con
solución analítica exacta. Dos de los modelos son abiertos y dos son cerrados. Aunque todos estos modelos son sencillos de evaluar recurriendo a las expresiones matemáticas disponibles en la literatura, se ha recurrido a desarrollar una representación
equivalente en QNAP, pues permite recurrir al análisis analítico o por simulación sin
cambiar de herramienta.
El primer modelo abierto es una cola M/M/1. La Figura 4-12 representa un diagrama de colas equivalente.
entrada
salida
Figura 4-12. Modelo de una cola M/M/1.
La variable de salida empleada para el análisis ha sido el tiempo de respuesta de
los clientes. Para la obtención de los valores analíticos se ha recurrido al siguiente
modelo QNAP.
/DECLARE/
QUEUE FONT, ESTACION;
REAL lambda;
REAL mu;
/STATION/
152
Desarrollo de un analizador paralelo basado en réplicas independientes
NAME
TYPE
SERVICE
TRANSIT
=
=
=
=
/STATION/
NAME
=
TYPE
=
SERVICE =
TRANSIT =
FONT;
SOURCE;
EXP(1.0/lambda);
ESTACION;
ESTACION;
SERVER, SINGLE;
EXP(1.0/mu);
OUT;
/CONTROL/
OPTION=NRESULT;
/EXEC/
BEGIN
mu := 1.0;
FOR lambda:=0.1 STEP 0.1 UNTIL 1.0 DO
BEGIN
SOLVE;
PRINT(lambda/mu,MRESPONSE(ESTACION));
END;
END;
/END/
La Tabla 4-1 resume los valores analíticos del tiempo de respuesta obtenidos con
el modelo QNAP para distintos valores de carga normalizada.
Carga normalizada (ρ
ρ)
0,1
0,2
0,3
0,4
0,5
0,6
0,7
0,8
0,9
Tiempo de respuesta
1,111
1,250
1,429
1,667
2,000
2,500
3,333
5,000
10,00
Tabla 4-1. Tiempos de respuesta para los clientes de la cola M/M/1
El segundo modelo empleado es un modelo de servidor central abierto [Lazowska
et al. 1984]. En la Figura 4-13 se representa la red de colas equivalente.
En este caso se han considerado como variables de salida el tiempo de respuesta
del sistema para los clientes. El tiempo de respuesta corresponde en este modelo al
tiempo medio que tarda un cliente en ser procesado, es decir, el tiempo transcurrido
desde que entra al sistema hasta que sale de él.
Criterios de parada. Propuestas y su análisis
discos
CPU
λ
entrada
153
tdisk=0,02
pdisk=25/32
tdisk=0,05
tcpu=0,0375
pdisk=6/32
salida
Figura 4-13. Modelo de colas de un servidor central abierto.
Igual que antes, se ha empleado el siguiente programa QNAP para la evaluación
analítica.
/DECLARE/
INTEGER ND=2;
QUEUE REAL Tdisc;
QUEUE FONT,CPU,DISC(ND);
REAL Tcpu;
REAL lambda;
REAL R;
/STATION/
NAME = FONT;
TYPE = SOURCE;
SERVICE
= EXP(1.0/lambda);
TRANSIT
= CPU;
/STATION/
NAME = CPU;
TYPE = SERVER, SINGLE;
SERVICE
= EXP(Tcpu);
TRANSIT
= DISC(1),25,DISC(2),6,OUT,1;
/STATION/
NAME = DISC;
TYPE = SERVER, SINGLE;
SERVICE
= EXP(Tdisc);
TRANSIT
= CPU;
/CONTROL/
OPTION=NRESULT;
/EXEC/
BEGIN
Tcpu:=0.0375;
DISC(1).Tdisc:=0.02;
DISC(2).Tdisc:=0.05;
FOR lambda:=0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.75,0.8 DO
BEGIN
SOLVE;
154
Desarrollo de un analizador paralelo basado en réplicas independientes
R :=
(MCUSTNB(DISC(1))+MCUSTNB(DISC(2))+MCUSTNB(CPU))/lambda;
PRINT(lambda,R);
END;
END;
La Tabla 4-2 contiene el tiempo medio de respuesta obtenido analíticamente para
distintos valores de carga de entrada.
Carga (ρ
ρ)
0,10
0,20
0,30
0,40
0,50
0,60
0,70
0,75
0,80
Tiempo de respuesta
2,199
2,454
2,793
3,274
4,020
5,366
8,649
13,19
31,23
Tabla 4-2. Tiempomedio de respuesta para los clientes del
modelo servidor central abierto.
El primer modelo cerrado empleado es una cola M/M/3//K. La Figura 4-14
muestra una representación de dicho sistema.
K
Z=0,5
t=1/8
Figura 4-14. Modelo de M/M/3//K.
En este caso se han considerado como variables de salida la productividad del
sistema y el tiempo de respuesta de los clientes. Al igual que antes, se ha desarrollado un modelo equivalente QNAP para obtener los resultados analíticos.
/CONTROL/
OPTION=SOURCE;
OPTION=NRESULT;
/DECLARE/
QUEUE TERMS,ESTACION;
REAL Z,K;
/STATION/
Criterios de parada. Propuestas y su análisis
155
NAME
=TERMS;
TYPE
=SERVER,INFINITE;
INIT
=K;
SERVICE=EXP(Z);
TRANSIT=CPU;
/STATION/
NAME
=ESTACION;
TYPE
=SERVER,MULTIPLE(3);
SCHED =FIFO;
SERVICE=EXP(1.0/8.0);
TRANSIT=TERMS;
/CONTROL/
MARGINAL = ESTACION;
/EXEC/
BEGIN
Z:=0.5;
FOR K:=5 STEP 5 UNTIL 25 DO
BEGIN
SOLVE;
PRINT(K,MTHRUPUT(CPU),MRESPONSE(CPU));
END;
END;
/END/
La Tabla 4-3 contiene los resultados analíticos obtenidos con el modelo QNAP
para diferentes poblaciones de clientes.
Clientes (K)
5
10
15
20
25
Productividad (trab./u.t.)
7,984
15,48
21,10
23,56
23,98
Tiempo de respuesta (u.t.)
0,1262
0,1459
0,2108
0,3489
0,5427
Tabla 4-3. Productividad del sistema y tiempo de respuesta de la cola M/M/3//K
para diferentes poblaciones de clientes
El segundo modelo cerrado empleado es un servidor central cerrado [Lazowska et
al. 1984]. La Figura 4-15 representa el modelo de colas equivalente. Los parámetros
de la CPU y los discos son los mismos que los empleados en el modelo servidor
central abierto.
El modelo se ha empleado para evaluar el tiempo medio de respuesta del sistema
experimentado por los clientes, es decir, de las peticiones hechas desde los terminales, y de la productividad del sistema.
156
Desarrollo de un analizador paralelo basado en réplicas independientes
TERMS
DISCOS
tdisk=0,02
pdisk=25/32
CPU
tdisk=0,05
tcpu=0,0375
pdisk=6/32
Z=6
Figura 4-15. Modelo servidor central cerrado.
Para su evaluación analítica se ha empleado el siguiente modelo QNAP.
/DECLARE/
INTEGER ND=2;
QUEUE REAL Tdisc;
QUEUE TERMS,CPU,DISC(ND);
REAL Tcpu;
REAL Z;
REAL R;
INTEGER N;
/STATION/
NAME = TERMS;
TYPE = SERVER,INFINITE;
INIT = N;
SERVICE
= EXP(Z);
TRANSIT
= CPU;
/STATION/
NAME = CPU;
TYPE = SERVER, SINGLE;
SERVICE
= EXP(Tcpu);
TRANSIT
= DISC(1),25,DISC(2),6,TERMS,1;
/STATION/
NAME = DISC;
TYPE = SERVER, SINGLE;
SERVICE
= EXP(Tdisc);
TRANSIT
= CPU;
/CONTROL/
OPTION=NRESULT;
/EXEC/
BEGIN
Tcpu:=0.0375;
DISC(1).Tdisc:=0.02;
DISC(2).Tdisc:=0.05;
Z:=6.0;
FOR N:=1 STEP 1 UNTIL 16 DO
BEGIN
Criterios de parada. Propuestas y su análisis
157
SOLVE;
R := (MCUSTNB(DISC(1))+MCUSTNB(DISC(2)) +
MCUSTNB(CPU))/MTHRUPUT(TERMS);
PRINT(N,MTHRUPUT(TERMS),R);
END;
END;
La Tabla 4-4 contiene los resultados analíticos obtenidos con el modelo QNAP
para diferente número de terminales.
Terminales (N)
1
2
3
4
5
6
7
8
9
10
11
12
16
100
Productividad
0,1250
0,2432
0,3534
0,4538
0,5432
0,6199
0,6832
0,7328
0,7695
0,7950
0,8115
0,8216
0,8327
0,8333
Tiempo de respuesta
2,000
2,223
2,490
2,814
3,205
3,678
4,246
4,917
5,696
6,579
7,555
8,606
13,21
114,0
Tabla 4-4. Productividad y tiempo de respuesta del modelo servidor central cerrado
para diferentes cantidades de terminales.
4.3.5.3
Resultados de cobertura y rendimiento en el modelo M/M/1
Este apartado muestra los resultados que se han obtenido al evaluar el modelo
M/M/1 con la metodología descrita y con los cuatro criterios de parada propuestos.
La variable de salida del modelo a estimar es el tiempo medio de respuesta de los
clientes, y, para la gestión de las réplicas, se ha decidido que el análisis se realice
cada 100 muestras recogidas por cada réplica. Esto implica que cada réplica enviará
la media muestral al monitor CSX cuando haya recogido 100 muestras. Este valor es,
en la práctica real, un valor pequeño y arriesgado, pero en este experimento interesa
saber los efectos que tiene este riesgo en los criterios. Además, se ha decidido no
eliminar el transitorio inicial en la primera serie de experimentos.
La Figura 4-16, Figura 4-17, Figura 4-18 y Figura 4-19 muestran los resultados
de cobertura y rendimiento para cargas normalizadas del modelo 0,1, 0,4, 0,7 y 0,9
respectivamente. Cabe destacar que las escalas temporales de las gráficas de rendi-
158
Desarrollo de un analizador paralelo basado en réplicas independientes
miento no son iguales para cada configuración del modelo. Esto se ha hecho así porque el cambio de parámetros del modelo da lugar a necesidades de simulación muy
distintas. Si se usase siempre la misma escala, sería difícil apreciar las diferencias en
el comportamiento de cada criterio, ya que se vería una línea horizontal para todos
los modelos con poca carga y sólo se apreciarían diferencias en el modelo con carga
alta.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
4k
Total de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 15k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-16 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,1.
Check= 100 muestras, reset=no.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
10k
Total de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 35k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-17 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,4.
Check= 100 muestras, reset=no.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
40k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 120k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-18 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,7.
Check= 100 muestras, reset=no.
0
30
Criterios de parada. Propuestas y su análisis
159
Observaciones
por réplica
Observations per replication
Cobertura
Coverage
300k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 900k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
Figura 4-19 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,9.
Check= 100 muestras, reset=no.
En las gráficas de la Figura 4-16 se observa que con una carga normalizada 0,1,
todos los criterios de parada ofrecen buenos resultados de cobertura, a excepción del
método clásico (criterio 1) para un número muy bajo de réplicas. El método clásico
ofrece siempre un rendimiento temporal superior, pero a costa de una disminución de
cobertura. Todos los criterios mejoran el tiempo de simulación con un aumento del
número de réplicas paralelas; sin embargo, los criterios 2, 3 y 4 consumen más recursos debido a que el test de finalización obliga a una innecesaria generación de eventos que desperdicia recursos, pues la media ya está correctamente cubierta con los
datos previos.
Un aumento de la carga del sistema (Figura 4-17, Figura 4-18, Figura 4-19) implica una disminución de la cobertura, sobre todo en el criterio clásico 1. El criterio 2
es el que mejor se comporta en este caso. A pesar de todo, ninguno de los criterios
supera el efecto de una carga muy alta ρ=0,9 en el modelo.
En cuanto al rendimiento, los nuevos criterios mejoran conforme aumenta la carga del modelo, comportándose casi linealmente y compensando ampliamente las
pérdidas de rendimiento cuando el modelo está poco cargado. La Figura 4-20 ilustra
el coste de simulación de modelo para los distintos niveles de carga. Es evidente que
el modelo en carga alta consume recursos computacionales que están muy por encima del modelo a baja carga.
Uno de los aspectos más delicados del método estadístico de las réplicas independientes es el efecto del transitorio inicial. En teoría, la eliminación de parte de las
muestras iniciales deben disminuir el sesgo de las medias que suelen producir las
primeras observaciones. En el caso particular de la cola M/M/1 se ha decidido eliminar 100 y 400 observaciones iniciales en los modelos más cargados (ρ={0,7, 0,9}).
0
30
160
Desarrollo de un analizador paralelo basado en réplicas independientes
número total de observaciones
número total de observaciones
700000
p1
600000
p2
500000
p3
400000
p4
300000
200000
100000
0
0,1
0,4
0,7
700000
p1
600000
p2
500000
p3
400000
p4
300000
200000
100000
0
0,1
0,9
0,4
0,7
0,9
carga modelo
carga modelo
10 réplicas
30 réplicas
Figura 4-20 Número total de observaciones para distintos niveles de carga
del modelo M/M/1.
La Figura 4-21 y Figura 4-22 muestran los resultados para carga ρ=0,7 y eliminando 100 y 400 observaciones respectivamente. Se aprecia una ligera mejora de
cobertura, sobre todo en el criterio clásico 1 y un pequeño incremento en el tiempo
de simulación que, lógicamente, es más perjudicial según se aumenta el número de
réplicas, pues se han desechado más observaciones en total.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
40k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 120k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-21 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,7.
Check= 100 muestras, reset=100 muestras.
Observaciones
por réplica
Observations per replication
Cobertura
Coverage
40k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 120k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
Replications
de réplicas
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
0
30
0
3
5
78
10
15
NúmeroReplications
de réplicas
Figura 4-22 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,7.
Check= 100 muestras, reset=400 muestras.
20
0
30
Criterios de parada. Propuestas y su análisis
161
La Figura 4-23 y la Figura 4-24 muestran los resultados para ρ=0,9, observándose
que, en este caso crítico, la eliminación de muestras no aporta nada y no afecta prácticamente al tiempo de simulación, pues la cantidad de muestras eliminadas en relación con la cantidad total de muestras es muy pequeña.
Observaciones
réplica
Observations per por
replication
Cobertura
Coverage
300k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 900k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-23 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,9.
Check= 100 muestras, reset=100 muestras.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
300k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 900k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-24 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,9.
Check= 100 muestras, reset=400 muestras.
Como recurso para intentar mejorar el comportamiento en el caso de carga ρ=0,9
se puede optar por aumentar el número de muestras entre puntos de comprobación.
La Figura 4-25 muestran el efecto de aumentar a 1.000 el punto de comprobación y
no eliminando transitorio, y en la Figura 4-26, el efecto de eliminar 4.000 muestras.
En estos dos casos se aprecia de nuevo la mejora que aportan los nuevos criterios y el
hecho de que eliminar 4.000 muestras no aporta una mejora sustancial de cobertura,
pero tampoco perjudica demasiado al rendimiento en este caso, aunque sí empeora a
los casos con menor carga.
0
30
162
Desarrollo de un analizador paralelo basado en réplicas independientes
Cobertura
Coverage
Observaciones
réplica
Observations per por
replication
300k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 900k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-25 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,9.
Check= 1000 muestras, reset= no.
Observaciones
réplica
Observations per por
replication
Cobertura
Coverage
300k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 900k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-26 Cobertura y rendimiento. Modelo M/M/1, carga ρ=0,9.
Check= 1000 muestras, reset=4000 muestras.
4.3.5.4
Resultados de cobertura y rendimiento en el modelo del
servidor central abierto
Este apartado muestra los resultados que se han obtenido al evaluar el modelo del
servidor central abierto con la metodología descrita y con los cuatro criterios de parada propuestos.
La variable salida del modelo a estimar es el tiempo medio de respuesta del sistema experimentado por los clientes. Al igual que para el modelo M/M/1, para la
gestión de las réplicas se ha decidido que el análisis se realice cada 100 muestras
recogidas por cada réplica. En la primera serie de experimentos no se han eliminado
muestras iniciales.
En la Figura 4-27, Figura 4-28, Figura 4-29 y Figura 4-30 se muestran los resultados de cobertura y rendimiento para cargas de entrada al modelo λ={0,10, 0,30,
0,60, 0,75}.
0
30
Criterios de parada. Propuestas y su análisis
163
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
5k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 50k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-27 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,10.
Check= 100 muestras, reset = no.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
10k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 50k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-28 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,30.
Checkpoint= 100 muestras, reset = no.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
55k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
NúmeroReplications
de réplicas
20
Figura 4-29 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,60.
Check = 100 muestras, reset = no.
Los resultados mostrados reflejan un comportamiento muy similar al del modelo
M/M/1. Los criterios de parada propuestos se comportan mejor que el criterio clásico, destacando la diferencia con un número bajo de réplicas; pero fallan también
cuando el modelo está próximo a la saturación. En este modelo particular, la saturación se produce al alcanzarse una carga crítica en uno de los discos.
0
30
164
Desarrollo de un analizador paralelo basado en réplicas independientes
Cobertura
Coverage
Observaciones
réplica
Observations per por
replication
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-30 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,75.
Check= 100 muestras, reset = no.
La Figura 4-31 y la Figura 4-32 muestran el efecto de eliminar 200 muestras iniciales en el modelo con carga 0,60 y carga 0,75. Como en el caso de la cola M/M/1,
se obtiene una ligera mejoría de la cobertura, y el rendimiento no se ve prácticamente
afectado.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
55k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-31 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,60.
Check = 100 muestras, reset=200.
Observaciones
réplica
Observations per por
replication
Cobertura
Coverage
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-32 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,75.
Check = 100 muestras, reset = 200.
El aumento del espacio entre puntos de comprobación mejora notablemente el
comportamiento de la cobertura. La Figura 4-33 y Figura 4-34 muestran los resultados para carga 0,60 y 0,75, espacio entre puntos de comprobación igual a 1.000 y sin
0
30
Criterios de parada. Propuestas y su análisis
165
eliminación de transitorio. Como en el caso anterior, el modelo más cargado es el
que más se beneficia, pues se consigue la cobertura teórica y el rendimiento no se ve
excesivamente afectado. En el caso de carga 0,60, el rendimiento disminuye, pues el
algoritmo es obligado a recolectar más muestras de lo necesario. Este efecto es más
patente cuantas más réplicas hay. Por ejemplo, para 30 réplicas, cada nueva incorporación supone 30 x1.000 = 30.000 muestras. En cualquier caso, de nuevo destaca
mayor cobertura de los nuevos criterios frente al clásico.
Observaciones
por réplica
Observations per replication
Cobertura
Coverage
55k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-33 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,60.
Check = 1000 muestras, reset = no.
Observaciones
por réplica
Observations per replication
Cobertura
Coverage
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-34 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,75.
Check= 1000 muestras, reset = no.
La Figura 4-35, y la Figura 4-36 muestran el efecto de eliminar 2000 muestras en
los dos casos anteriores. La cobertura no mejora significativamente y el rendimiento
para la carga 0,60 es afectado para un número alto de réplicas. Lógicamente, a más
réplicas, más muestras desechadas. Por ejemplo, se han desechado
30 x 2.000 = 60.000 muestras en el caso de 30 réplicas, aunque con la "ventaja" tem-
poral de que se han desperdiciado en paralelo. En el caso de carga 0,75, quien más se
ha beneficiado de ésta eliminación ha sido el método clásico.
0
30
166
Desarrollo de un analizador paralelo basado en réplicas independientes
Observaciones
réplica
Observations per por
replication
Cobertura
Coverage
55k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-35 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,60.
Check= 1000 muestras, reset=2000.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-36 Cobertura y rendimiento. Modelo servidor central abierto, carga λ=0,75.
Check= 1000 muestras, reset=2000.
4.3.5.5
Resultados de cobertura y rendimiento en el modelo
M/M/3//K
Este apartado muestra los resultados que se han obtenido al evaluar el modelo
M/M/3//k. La naturaleza de este modelo es distinta a la de los anteriores, pues se trata
de un modelo cerrado, con lo que cabe esperar un tipo de respuesta distinto.
En este caso se analiza el modelo para las variables de salida tiempo medio de
respuesta de los clientes y productividad del sistema. Estas elecciones afectan notablemente al modo en que se extrae la información de las réplicas en paralelo. En el
primer caso, la extracción se realiza cada n observaciones recogidas, mientras que en
el segundo caso se realiza cada t unidades de tiempo simulado. Con ello se evitan los
problemas de sesgo por ratio descritos en capítulos previos.
En primer lugar se muestran los resultados para el tiempo medio de respuesta de
los clientes donde, como en los apartados anteriores, el análisis se realiza cada 100
observaciones recogidas en cada réplica.
0
30
Criterios de parada. Propuestas y su análisis
167
En la Figura 4-37, Figura 4-38 y Figura 4-39 se muestran los resultados obtenidos
para k={5, 15, 25} clientes, y sin eliminación de muestras iniciales. Los primeros
resultados obtenidos muestran un comportamiento muy distinto a los modelos abiertos descritos en los apartados anteriores. Por una parte, es ahora el criterio 3 el que
muestra el mejor comportamiento en cuanto a cobertura, y por otra, el aumento del
número de réplicas lleva a una caída en la cobertura para los criterios 1 y 2.
El mantenimiento de la cobertura del criterio 3 fuerza a una disminución del rendimiento en comparación con los otros criterios. Ello obliga a preguntarse si este
sobrecoste es excesivo en comparación con los beneficios obtenidos.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
10k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 100k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-37 Cobertura y rendimiento. Modelo M/M/3//k, k=5, "tiempo de respuesta de
los clientes". Check = 100 muestras, reset = no.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
NúmeroReplications
de réplicas
20
Figura 4-38 Cobertura y rendimiento. Modelo M/M/3//k, k=15, variable "tiempo de
respuesta de los clientes". Check = 100 muestras, reset = no.
El hecho de que el aumento de réplicas lleve a una caída de la cobertura hace
sospechar que el talón de Aquiles del método de las réplicas se está manifestando, es
decir, el sesgo producido por las muestras iniciales contamina la media muestral y no
la hace representativa del régimen estacionario. Esta sospecha es clara cuando se
sabe cómo se ha implementado el modelo: en este caso concreto los clientes se crean
como k clientes encolados en una estación con ∞ servidores, por lo que hay un estado
inicial del sistema no natural al régimen permanente del modelo.
0
30
168
Desarrollo de un analizador paralelo basado en réplicas independientes
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-39 Cobertura y rendimiento. Modelo M/M/3//k, k=25, variable "tiempo de
respuesta de los clientes". Check = 100 muestras, reset = no.
La Figura 4-40 y Figura 4-41 muestran el efecto del borrado de 200 observaciones en los casos k = {15, 25}. Como resultado, la cobertura mejora notablemente
para los criterios 1 y 2, y el rendimiento no se ve prácticamente afectado. Se aprecia
especialmente la mejora de cobertura al emplearse un número alto de réplicas. Este
efecto se debe a que se han eliminado muestras iniciales muy sesgadas, que se aprecian más cuando aumenta el número de réplicas, pues al ser más cortas, su efecto es
más patente.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-40 Cobertura y rendimiento. Modelo M/M/3//k, k=15, variable "tiempo de
respuesta de los clientes". Check = 100 muestras, reset = 200 muestras.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Replications
Número
de réplicas
30
0
3
5
78
10
15
20
Replications
Número
de réplicas
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-41 Cobertura y rendimiento. Modelo M/M/3//k, k=25, Variable "tiempo de
respuesta de los clientes". Check= 100 muestras, reset = 200 muestras.
0
30
Criterios de parada. Propuestas y su análisis
169
A continuación se muestran los resultados para la productividad del sistema. La
extracción de la información estadística de las réplicas se ha hecho para ts=1 (tiempo
simulado). Este valor es pequeño, pero, como en los casos anteriores, interesa observar el comportamiento en condiciones desfavorables. La Figura 4-42, Figura 4-43 y
Figura 4-44 resumen los resultados para k ={5, 15, 25} clientes.
La interpretación de los resultados se complica debido a que se fija el mismo
tiempo de extracción para las tres configuraciones del modelo. Al contrario de lo que
ocurre para las simulaciones cuyo control se basa en el número de observaciones
recogidas, en este caso el tiempo simulado necesario es menor según aumenta la carga, lo cual es lógico, pues al incrementar la carga se generan más eventos de interés
por unidad de tiempo. Sin embargo, la cobertura no responde proporcionalmente al
cambio de carga porque la influencia del control por tiempo simulado está enmascarando el efecto sobre la cobertura e impidiendo que los resultados sean intuitivos.
Fijar el tiempo de extracción para todas las configuraciones del modelo no parece la
política más adecuada y sería más interesante implementar un mecanismo que se
pueda adaptar a los diferentes niveles de carga.
Cobertura
Coverage
Observaciones
réplica
Simulated
time per por
replication
1k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 10k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-42 Cobertura y rendimiento. Modelo M/M/3//k, k=5,
variable "productividad". Check = 1, reset=no.
Observaciones
réplica
Simulated
time per por
replication
Cobertura
Coverage
1k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 10k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-43 Cobertura y rendimiento. Modelo M/M/3//k, k=15,
variable "productividad ". Check = 1, reset=no.
0
30
170
Desarrollo de un analizador paralelo basado en réplicas independientes
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
500
Total de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1
5k
0
30
0
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-44 Cobertura y rendimiento. Modelo M/M/3//k, k=25,
variable "productividad ". Check = 1, reset = no.
Con independencia del problema detectado, los resultados son parecidos a los
obtenidos con la variable tiempo de respuesta. La cobertura cae con el aumento de
réplicas, y el criterio 3 ofrece mejor cobertura a costa de un peor rendimiento.
Los resultados obtenidos muestran un comportamiento superior del criterio 3 en
cuanto a cobertura, pero reflejan una penalización en rendimiento. La Figura 4-45
muestra el efecto de modificar el parámetro s de este criterio. Para los tres valores
elegidos de s, s={0,01, 0,001, 0,0001} la cobertura es buena, siendo la diferencia
fundamental el coste temporal de la simulación. En este caso particular, una de las
elecciones para s llega a ofrecer una mayor cobertura con un rendimiento similar.
Cobertura
Coverage
Observaciones
réplica
Simulated
time perpor
replication
500
p1
p2
p3(s=0.0001)
p4
p3(s=0.01)
p3(s=0.001)
1
Total de time
observaciones
Simulated
accumulated
1
5k
0
30
0
p1
p2
p3(s=0.0001)
p4
p3(s=0.01)
p3(s=0.001)
1
0.95
0.9
0.85
p1
p2
p3(s=0.0001)
p4
p3(s=0.01)
p3(s=0.001)
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
3
5
78
10
15
20
Número
de réplicas
Replications
Figura 4-45 Ampliación de la Figura 4-44 con el efecto del parámetro s
del criterio 3 en la cobertura.
La Figura 4-46 y la Figura 4-47 muestran el efecto de aumentar el tiempo de extracción a ts=10 para los casos k ={15, 25} respectivamente. En este caso, con un
rendimiento temporal ligeramente mejor se solventan todos los problemas de cobertura. El mayor tiempo entre muestras permite superar el transitorio inicial a los criterios con peor comportamiento, con lo que proveen una solución adecuada en cuanto
a rendimiento, pero no segura en su aplicación a otros modelos en los que no se conozca la longitud del transitorio. En cualquier caso, parece imprescindible un tiempo
0
30
Criterios de parada. Propuestas y su análisis
171
entre extracciones grande para evitar los problemas de falta de cobertura mostrados.
Al elegir un tiempo mayor, se tiende a acortar las diferencias entre los algoritmos con
mejor rendimiento temporal y los que ofrecen un peor comportamiento en el caso de
modelos saturados.
Cobertura
Coverage
Observaciones
réplica
Simulated
time per por
replication
1k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 10k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-46 Cobertura y rendimiento. Modelo M/M/3//k, k=15,
variable "productividad ". Check = 10, reset = no.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
500
Total de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1
5k
0
30
0
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
3
5
78
10
15
20
Número
de réplicas
Replications
Figura 4-47 Cobertura y rendimiento. Modelo M/M/3//k, k=25,
variable "productividad ". Check = 10, reset = no.
4.3.5.6
Resultados de cobertura y rendimiento en el modelo del
servidor central cerrado
Este apartado muestra los resultados que se han obtenido al evaluar el modelo
servidor central cerrado. Como en el caso anterior, se trata de un modelo cerrado, y
donde la cantidad de clientes (terminales) se fija en cada configuración del modelo.
En este caso se analiza el modelo para las variables de salida tiempo medio de
respuesta de los clientes y productividad del sistema. En el primer caso, la extracción
se realiza cada n observaciones recogidas, mientras que en el segundo caso se realiza
cada t unidades de tiempo simulado.
0
30
172
Desarrollo de un analizador paralelo basado en réplicas independientes
En primer lugar se muestran los resultados para la variable tiempo medio de respuesta de los clientes, donde el análisis se realiza cada 100 observaciones recogidas
en cada réplica y sin eliminación de muestras iniciales.
La Figura 4-48, Figura 4-49, Figura 4-50, Figura 4-51, y Figura 4-52 muestran
los resultados de cobertura y rendimiento obtenidos para N={1, 4, 8, 12, 100} terminales, respectivamente.
Se aprecia una disminución de la cobertura según aumenta la carga (N), apreciándose una clara caída de cobertura cuando aumenta el número de réplicas, lo que pone
de manifiesto el efecto negativo del transitorio inicial. Para N=100 la cobertura cae
drásticamente para todas las pruebas. La combinación de los criterios 2 y 3 en 4 ofrece el mejor resultado para dicho caso, pero no consigue tampoco mantener una cobertura adecuada. El efecto se debe a la tremenda diferencia entre el estado inicial del
modelo y el régimen permanente, y a la lentitud de convergencia hacia el valor esperado.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
10k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-48 Cobertura y rendimiento. Modelo servidor central cerrado, N=1, variable
"tiempo de respuesta de los clientes". Check = 100 muestras, reset = no.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
10k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-49 Cobertura y rendimiento. Modelo servidor central cerrado, N=4, variable
"tiempo de respuesta de los clientes". Check = 100 muestras, reset = no.
0
30
Criterios de parada. Propuestas y su análisis
173
Observaciones
por réplica
Observations per replication
Cobertura
Coverage
10k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-50 Cobertura y rendimiento. Modelo servidor central cerrado, N=8, variable
"tiempo de respuesta de los clientes". Check = 100 muestras, reset = no.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-51 Cobertura y rendimiento. Modelo servidor central cerrado, N=12, variable
"tiempo de respuesta de los clientes". Check = 100 muestras, reset = no.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
20k
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
Replications
de réplicas
30
0
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
3
5
78
10
15
20
Número
Replications
de réplicas
1 200k
0
30
0
p1
p2
p3
p4
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-52 Cobertura y rendimiento. Modelo servidor central cerrado, N=100, variable "tiempo de respuesta de los clientes". Check = 100 muestras, reset = no.
La Figura 4-53 y Figura 4-54 muestran el efecto de la eliminación de 200 observaciones de cada réplica para los casos N=12 y N=100. Cabe destacar una sustancial
mejora de la cobertura y una disminución del tiempo necesario para realizar la simulación con el aumento del número de réplicas. Esta pequeña eliminación ha repercutido en una mejora del tiempo total de simulación, compensando el desperdicio inicial.
1
0
30
174
Desarrollo de un analizador paralelo basado en réplicas independientes
A pesar de la mejora, los criterios 1 y 2 siguen fallando para N=100, mientras qu
el y el 4 manifiestan sus virtudes en este caso.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-53 Cobertura y rendimiento. Modelo servidor central cerrado, N=12, variable
"tiempo de respuesta de los clientes". Check = 100 muestras, reset = 200 muestras.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-54 Cobertura y rendimiento. Modelo servidor central cerrado, N=100, variable "tiempo de respuesta de los clientes". Check = 100 muestras, reset = 200 muestras.
En la Figura 4-55 y la Figura 4-56 se muestra el efecto de aumentar hasta 1.000 el
número de observaciones recogidas antes de enviar la información estadística al monitor para los casos N ={12, 100}. La cobertura aumenta con respecto a los ejemplos
anteriores, pero a costa de un notable incremento del coste temporal.
En el caso de un número elevado de réplicas, dicho coste temporal se debe a que
el criterio de terminación fuerza a continuar la simulación más allá de lo necesario.
En cualquier caso, el criterio 1 sigue sin aportar un comportamiento adecuado para
N=100.
0
30
Criterios de parada. Propuestas y su análisis
Cobertura
Coverage
175
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-55 Cobertura y rendimiento. Modelo servidor central cerrado, N=12, variable
"tiempo de respuesta de los clientes". Check = 1000 muestras, reset = no.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Replications
Número
de réplicas
30
0
3
5
78
0
30
10
15
20
Replications
Número
de réplicas
0
3
5
78
0
30
10
15
20
Replications
Número
de réplicas
Figura 4-56 Cobertura y rendimiento. Modelo servidor central cerrado, N=100, variable "tiempo de respuesta de los clientes". Check = 1000 muestras, reset = no.
En la Figura 4-57 y Figura 4-58 se muestra el efecto de eliminar 2.000 observaciones de cada de una de las réplicas para los dos casos anteriores. Nótese que el criterio 1 consigue una buena cobertura para N=100, pues la eliminación del transitorio
le permite ofrecer dicho resultado. En cualquier caso el rendimiento se ve afectado
por el desperdicio de muestras.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-57 Cobertura y rendimiento modelo servidor central cerrado, N=12, variable
"tiempo de respuesta de los clientes". Check = 1000 muestras, reset = 2000 muestras.
0
30
176
Desarrollo de un analizador paralelo basado en réplicas independientes
Observaciones
por réplica
Observations per replication
Cobertura
Coverage
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
10
15
NúmeroReplications
de réplicas
0
30
20
Figura 4-58 Cobertura y rendimiento. Modelo servidor central cerrado, N=100, variable "tiempo de respuesta de los clientes". Check = 1000 muestras, reset = 2000.
A continuación se muestran los resultados para la variable de salida productividad del sistema. La extracción de la información estadística de las réplicas se ha hecho para ts=50. Como en los casos anteriores, este valor está por debajo de lo razonable para así intentar observar el comportamiento en condiciones desfavorables.
La Figura 4-59, Figura 4-60, Figura 4-61, Figura 4-62 y Figura 4-63 muestran los
resultados para N={1, 4, 8, 12, 100}. Dichos resultados son similares a los obtenidos
con la variable tiempo de respuesta donde la contaminación con el transitorio reduce
notablemente la cobertura para los modelos más cargados y para un número alto de
réplicas. De nuevo, los criterios de parada basados en s proporcionan la mejor cobertura.
Cobertura
Coverage
Observaciones
réplica
Simulated
time perpor
replication
10k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 50k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
0
30
0
3
5
78
10
15
NúmeroReplications
de réplicas
20
Figura 4-59 Cobertura y rendimiento. Modelo servidor central cerrado, N=1, variable
"productividad ". Check = 50 tiempo simulado, reset = no.
La Figura 4-64y la Figura 4-65 muestran el efecto de aumentar el espacio entre
puntos de comprobación a 500 para los casos N ={12, 100}. A pesar del aumento de
cobertura, ninguno de los criterios consigue la cobertura para N=100, y produciéndose un efecto inesperado en 3 y 4, pues 3 produce una cobertura muy superior a la de
4. Este resultado se debe a la combinación de factores como tiempo de muestreo,
0
30
Criterios de parada. Propuestas y su análisis
177
características del modelo, etc., y que muestran el efecto de un transitorio poco representativo del régimen permanente.
Cobertura
Coverage
Observaciones
réplica
Simulated
time perpor
replication
10k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 50k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-60 Cobertura y rendimiento. Modelo servidor central cerrado, N=4, variable
"productividad ". Check = 50 tiempo simulado, reset = no.
Observaciones
réplica
Simulated
time per por
replication
Cobertura
Coverage
10k
Total de time
observaciones
Simulated
accumulated
p1
p2
p3
p4
1
1 50k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-61 Cobertura y rendimiento. Modelo servidor central cerrado, N=8, variable
"productividad ". Check = 50 tiempo simulado, reset = no.
Observaciones
réplica
Simulated
time perpor
replication
Cobertura
Coverage
10k
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
Total
de observaciones
Simulated
time accumulated
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
1 100k
0
30
0
p1
p2
p3
p4
3
5
78
10
15
NúmeroReplications
de réplicas
20
Figura 4-62 Cobertura y rendimiento. Modelo servidor central cerrado, N=12, variable
"productividad ". Check = 50 muestras, reset = no.
1
0
30
178
Desarrollo de un analizador paralelo basado en réplicas independientes
Cobertura
Coverage
Observaciones
réplica
Simulated
time per por
replication
10k
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Replications
Número
de réplicas
30
0
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
3
5
78
1 100k
0
30
10
15
20
Replications
Número
de réplicas
0
p1
p2
p3
p4
3
5
78
1
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-63 Cobertura y rendimiento. Modelo servidor central cerrado, N=100, variable "productividad ". Check = 50 tiempo simulado, reset = no.
Cobertura
Coverage
Observaciones
réplica
Simulated
time per por
replication
10k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 100k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-64 Cobertura y rendimiento. Modelo servidor central cerrado, N=12, variable
"productividad ". Check = 500 tiempo simulado, reset = no.
Cobertura
Coverage
Observaciones
réplica
Simulated
time perpor
replication
10k
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
Total
de observaciones
Simulated
time accumulated
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
1 100k
0
30
0
p1
p2
p3
p4
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-65 Cobertura y rendimiento. Modelo servidor central cerrado, N=100, variable "productividad ". Check = 500 tiempo simulado, reset = no.
4.4 Técnica para la reducción del efecto del transitorio
inicial
Los resultados obtenidos con los criterios de terminación aplicados muestran el
negativo efecto del transitorio inicial. En función de la política seguida en su gestión
se pueden producir dos posibles resultados negativos.
1
0
30
Técnica para la reducción del efecto del transitorio inicial
179
Primero, si se toma la precaución de eliminar una cantidad apreciable de observaciones iniciales para garantizar la eliminación del sesgo en la estimación puntual, se
estarán limitando las posibilidades de explotación en paralelo, pues a mayor proporción de muestras desperdiciadas, menores serán las posibilidades de aceleración.
Segundo, si se obvia el efecto del transitorio y, por tanto, no se elimina, los criterios de terminación pueden acabar prematuramente y el resultado no cubrir la media.
Las características de la información estadística que envían las réplicas al monitor
hacen difícil aplicar técnicas que detecten automáticamente el fin del transitorio y lo
eliminen, pues dichas variables provienen de una media acumulada calculada con la
ponderación de las observaciones del total de la simulación. Ello dificulta enormemente la detección del fin del transitorio. Además, los métodos para la detección de
transitorio suelen ser más adecuadas para las técnicas secuenciales de análisis estadístico de la salida (lotes, espectral, etc.) donde un desperdicio inicial mayor de lo
necesario no afecta demasiado al coste temporal final del algoritmo.
De todas formas, los resultados obtenidos en los apartados anteriores sugieren
que la eliminación de una pequeña porción de las réplicas no afecta apreciablemente
al rendimiento toda vez que la mejora la cobertura. Dicho resultado concuerda con
los resultados teóricos descritos en [Glynn 1995].
La eliminación de una pequeña proporción de las muestras iniciales puede ser insuficiente en los casos con transitorios que tardan en disiparse, como ha ocurrido en
el caso del modelo de servidor central cerrado. En consecuencia, resulta de interés
intentar aplicar alguna estrategia que permitia disminuir el efecto del transitorio sin
limitar las posibilidades de paralelismo.
Como ya se ha dicho, el transitorio inicial es el talón de Aquiles del método de
las réplicas, y la literatura sugiere que una de las formas de reducir su efecto es
arrancar el modelo en un estado similar al del régimen permanente. En esta línea, en
[Kelton 1985] se prueba el efecto de iniciar un modelo de cola Erlang-exponencial en
estados cercanos al final, concluyéndose que, para dicho modelo, es mejor iniciar el
modelo por encima del régimen permanente que por debajo. Otras aproximaciones
inicializan el modelo en un estado aleatorio, lo que evita el uso del mismo estado
para todas las réplicas. También hay aproximaciones que parten de ejecuciones previas o de modelos analíticos simplificados para obtener un punto de partida más cercano al régimen permanente.
180
Desarrollo de un analizador paralelo basado en réplicas independientes
El esfuerzo de aplicar las aproximaciones anteriores puede no ser rentable. Si se
usa la aproximación de realizar ejecuciones previas, la rentabilidad de ésta aproximación se puede perder en cuanto a tiempo de ejecución que hay que añadir a la solución del experimento, requiriendo, además, una posterior preparación del modelo
con las condiciones iniciales obtenidas. Si se emplea la aproximación basada en un
modelo analítico, la problemática será el coste del desarrollo de dicho modelo y lo
representativo que pueda ser del modelo de simulación; incluso puede ser tremendamente complejo o imposible conseguir un modelo cercano al de simulación. Como
consecuencia, estas aproximaciones se suelen limitar actualmente al terreno de la
investigación teórica en el área de simulación.
Los beneficios que, según la literatura, puede aportar una inicialización adecuada
en la técnica de análisis, hacen considerar la posibilidad de un esfuerzo en este sentido. Para plantear la estrategia se ha decidido seguir el camino inverso, es decir, conociendo las limitaciones descritas antes, preguntarse cómo aplicar la aproximación
al producto final de un experimento de simulación.
La Figura 4-66 muestra un ejemplo habitual de posible resultado de un estudio en
que se emplea la simulación. Un modelo se ejecuta con diferentes parámetros de entrada w para estimar el valor X wi de alguna variable de salida del modelo y, por
ejemplo, poder trazar una curva o una superficie de comportamiento.
Variable de salida (media)
Wk
W k-1
W4
W3
W2
W1
Carga
Figura 4-66 Ejemplo de resultado obtenido con un experimento de simulación.
Ordenando cada instancia del modelo (punto en la gráfica) de forma que la distancia entre cada par de tuplas de parámetros de entrada sea lo más pequeña posible,
seguramente estaremos ante modelos cuyo régimen permanente esté cercano o, al
Técnica para la reducción del efecto del transitorio inicial
181
menos, más cercanos entre sí que la distancia entre cada uno de los regímenes permanentes y el estado del modelo con condiciones iniciales no representativas del
régimen permanente. Si suponemos que se cumple dicha condición, la inicialización
de un modelo con el régimen permanente del anterior puede reducir significativamente el efecto del transitorio inicial, pues se parte de mejores condiciones iniciales.
Para implementar esta idea se propone la siguiente aproximación. El primer modelo se ejecuta de la forma habitual. Cuando el monitor de réplicas decide que se han
alcanzado las condiciones iniciales, las réplicas se reconfiguran adecuadamente para
empezar a ejecutar el siguiente punto partiendo del estado actual del modelo anterior.
La Figura 4-67 muestra un ejemplo real del efecto buscado. Cada nueva simulación parte del estado en que quedó el modelo anterior tras la simulación. Al partir de
un modelo no vacío y en equilibrio parece lógico esperar que la transición hasta el
nuevo régimen permanente sea menos sesgada y más rápida.
14000
Tiempo respuesta E/S (ciclo
s)
12000
Reinicio estadísticos
y cambio de configuración
10000
8000
6000
4000
2000
carga={8.5, 13.5,16, 23.5}
127
120
113
106
99
92
85
78
71
64
57
50
43
36
29
22
15
8
1
0
Tiempo simulado (ciclos/5,000)
Figura 4-67 Ejemplo de efecto buscado en la estrategia propuesta para reducir el efecto
del transitorio inicial.
El primer problema que se presenta para llevar a término esta idea es su implementación. El siguiente apartado describe cómo se ha llevado a cabo.
4.4.1 Implementación
Para la implementación de esta idea en CSX es necesario resolver dos problemas:
por una parte que cada réplica tenga capacidad para ser reconfigurada, y por otra, que
el monitor CSX coordine la reconfiguración de las réplicas.
182
Desarrollo de un analizador paralelo basado en réplicas independientes
Para la reconfiguración de cada réplica se ha decidido que el modelo sea consciente de dicha reconfiguración al implementarse. Ello va a permitir un mecanismo
de reconfiguración más flexible y más sencillo de realizar.
Para conseguir la máxima flexibilidad, el modelo debe proporcionar una función
cuya ejecución se encargue de la reconfiguración, y a la que las bibliotecas de CSX
llamarán cuando se desee realizar dicha reconfiguración. A continuación se describe
la implementación y cómo se ha aplicado al modelo M/M/1.
La siguiente función CSX permite informar al gestor de la réplica de la función
proporcionada por el modelo que se deberá encargar de la reconfiguración, y a la que
llamará CSX cuando desee la reconfiguración.
void csx_setchangeconffunc(void (*func)(char *));
La función de usuario proporcionada deberá aceptar una cadena de caracteres de
la que se extraerán los parámetros de reconfiguración. Por ejemplo, el siguiente
fragmento contiene la función de usuario que reconfigura el modelo M/M/1 desarrollado en CSIM.
//CSX llama a esta función cuando se require una reconfiguración
void change_conf(char *params) {
char buf[100];
char *myargv[50];
int myargc;
csx_stringtoargv(params,myargv,&myargc);
csx_gpdouble(myargc,myargv,"lambda",&lambda,0.1);
csx_gpdouble(myargc,myargv,"mu",&mu,1.0);
}
La reconfiguración de este modelo consiste en variar el ritmo de llegada de
clientes y el tiempo de servicio de la cola. Así, la función de reconfiguración simplemente cambia los valores de las variables lambda y mu que son empleadas para
generar las distribuciones de probabilidad, con lo que los clientes llegan al modelo y
son servidos a un ritmo diferente.
Para que CSX pueda llamar a esta función, se ha informado de la función de
usuario ejecutando,
csx_setchangeconffunc(change_conf);
La otra mitad del mecanismo la coordina el monitor de CSX. Para que éste realice la reconfiguración, se envía un mensaje con los nuevos parámetros de entrada del
Técnica para la reducción del efecto del transitorio inicial
183
modelo. Siguiendo con la filosofía de CSX, dicho mensaje será procesado en el siguiente punto de comprobación de cada réplica, momento en el que el modelo será
reconfigurado y empezará a trabajar como si de un modelo con parámetros de entrada diferentes se tratara.
mensajes con
datos estadísticos
monitor (LSM)
s
s
s
réplica
mensaje de
reconfiguración
a)
monitor (LSM)
s
s+1
s+1
réplica
b)
Figura 4-68 Reconfiguración de una simulación. a) El monitor LSM envía los datos de
reconfiguración mediante un mensaje. b) La réplica reconfigurada remite nuevos mensajes de datos con el indicador de secuencia s incrementado.
Con el propósito de evitar sincronizaciones de las réplicas, el monitor CSX puede
enviar información de reconfiguración a las réplicas en cualquier momento, aunque
haya mensajes con información estadística pendientes de procesar en la cola de recepción de mensajes del monitor. La Figura 4-68 representa el envío de un mensaje
de reconfiguración a una réplica por parte de un monitor LSM. Cuando la réplica
recibe la orden de reconfiguración y cambia su comportamiento, un identificador de
secuencia enviado en los mensajes de datos es incrementando, permitiendo al monitor detectar cuándo empieza a llegar el producto de la reconfiguración, con lo que
puede descartar los mensajes que pertenezcan a restos de simulación del experimento
previo.
La limitación de este sencillo mecanismo parece estar en la dificultad de implementar la reconfiguración del modelo. A pesar de las primeras dudas, la experiencia
ha mostrado que resulta sencillo, sobre todo si se tiene en mente este mecanismo a la
hora de desarrollar el modelo. Como ejemplo, a continuación se muestra la función
de reconfiguración del modelo del servidor central cerrado.
184
Desarrollo de un analizador paralelo basado en réplicas independientes
void change_conf(char *params) {
char buf[100];
char *myargv[50];
int myargc;
int i;
csx_stringtoargv(params,myargv,&myargc);
csx_gpint(myargc,myargv,"nterms",&new_NTERMS,0);
if (new_NTERMS > NTERMS) {
for (i=NTERMS;i<new_NTERMS;i++)
closed_job(i);
NTERMS = new_NTERMS;
} else {
//se autoeliminan a partir diferencia new_NTERMS y NTERMS
}
}
La variable NTERMS contiene el número previo de terminales que contenía el
modelo y en new_NTERMS se especifica la nueva cantidad. En el caso de que se
deseen más terminales que en el caso previo, se genera la diferencia entre NTERMS y
new_NTERMS como nuevos trabajos cerrados. En el caso de que se deseen menos,
dichos trabajos van siendo eliminados del modelo. El siguiente fragmento muestra la
función de simulación de los clientes donde se aprecia la progresiva eliminación de
los clientes (en subrayado).
void closed_job(int i) {
double dprob;
TIME timestamp;
create("closed_job");
while(1) { // bucle infinito
hold(exponential(Z));
//terminal
if (new_NTERMS < NTERMS) goto SAL_CLOSE;
terminal_cnt++;
csx_obs_add(obterm_cnt,1.0);
timestamp = clock;
CPU_CLOSE:
use(cpu, exponential(Tcpu)); // CPU use
if (new_NTERMS < NTERMS) goto SAL_CLOSE;
dprob = uniform01();
if (dprob <= (25.0/320))
{
use(disk[0], exponential(Tdisk1));
if (new_NTERMS < NTERMS) goto SAL_CLOSE;
goto CPU_CLOSE;}
else if (dprob <= ((25.0+6.0)/320))
{
use(disk[1], exponential(Tdisk2));
if (new_NTERMS < NTERMS) goto SAL_CLOSE;
Técnica para la reducción del efecto del transitorio inicial
185
goto CPU_CLOSE;}
else
{ closed_job_cnt++;
record(clock - timestamp, respt_closed);
csx_obs_add(obrespt_closed,clock - timestamp);
}; //TERM
} //while(1)
// salida por decremento de terminales
SAL_CLOSE:
NTERMS--;
}
La forma en que se implemente la reconfiguración influirá en lo rápido que se
diluya el efecto del estado previo. En el ejemplo anterior, la eliminación de terminales es mucho mejor que el incremento, pero a costa de una mayor complejidad.
4.4.2 Resultados de cobertura y rendimiento
A continuación se muestran algunos de los resultados obtenidos al evaluar los
modelos analíticos empleando esta técnica. Sólo se muestran los efectos obtenidos
cuando los modelos están muy cargados, pues tiene mayor interés.
La Figura 4-69 muestra el resultado de aplicar la técnica sobre el modelo M/M/1.
En este caso se ha configurado la extracción para que se relice cada 100 extracciones
y no se eliminen muestras iniciales. La configuración de los encadenamientos de
simulaciones ha consistido en empezar la simulación con carga normalizada ρ=0,1, y
continuar realizando simulaciones para ρ={0,4, 0,7, 0,9}, siendo el caso de mayor
carga el mostrado. Si se compara con su equivalente sin precalentamiento de la
Figura 4-19 no se aprecia una mejora notable, simplemente un pequeño aumento de
cobertura.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
300k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 900k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
Replications
de réplicas
30
0
3
5
78
10
15
20
Número
Replications
de réplicas
0
30
0
3
5
78
10
15
20
Número
Replications
de réplicas
Figura 4-69. Cobertura y rendimiento con precalentamiento. Modelo M/M/1, carga
ρ=0,10 → 0,40 → 0,70 → 0,90. Check= 100 muestras, reset=no.
0
30
186
Desarrollo de un analizador paralelo basado en réplicas independientes
La Figura 4-70 y la Figura 4-71 muestran el equivalente con precalentamiento de
la Figura 4-30 para el modelo del servidor central abierto, empleando extracción cada
100 observaciones. En este caso se han probado dos configuraciones de precalentamiento, la primera, cuando la carga del modelo pasa de λ=0,60 a 0,75, y la segunda,
cuando pasa de λ=0,10 a 0,75. Para el primer caso se aprecia una mejoría en la cobertura mayor que en el modelo M/M/1 y en el segundo caso esta mejoría no es tan
apreciable. Como parece lógico, cuando la configuración previa del modelo está
“cercana” a la siguiente, esta técnica produce mejores resultados.
Cobertura
Coverage
Observaciones
por réplica
Observations per replication
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-70 Cobertura y rendimiento con precalentamiento. Modelo servidor central
abierto, carga λ=0,60 → 0,75. Check= 100 muestras, reset = no.
Observaciones
réplica
Observations per por
replication
Cobertura
Coverage
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-71 Cobertura y rendimiento con precalentamiento. Modelo servidor central
abierto, carga λ= 0,10 → 0,75. Check= 100 muestras, reset = no.
La Figura 4-72 muestra el efecto de aumentar el número de muestras recogido
entre envíos a 1.000 para el caso λ=0,60 a 0,75. Su equivalente es la Figura 4-34. No
cabe destacar una mejora significativa al aplicar la técnica de precalentamiento, pero
sí se aprecia que desaparece el efecto de caída de cobertura con el aumento de réplicas paralelas.
0
30
Técnica para la reducción del efecto del transitorio inicial
187
Observaciones
réplica
Observations per por
replication
Cobertura
Coverage
170k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 700k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-72 Cobertura y rendimiento con precalentamiento. Modelo servidor central
abierto, carga λ=0,60 → 0,75. Check= 1000 muestras, reset = no.
La Figura 4-73 muestra resultados para el modelo del servidor central cerrado
cuando N pasa de 8 a 12. Comparándolo con su equivalente de la Figura 4-51 se
aprecia una notable mejoría de la cobertura, sobre todo al aumentar el número de
réplicas, y todo ello sin afectar al rendimiento. La aplicación de la técnica a este caso
está permitiendo el aprovechamiento adecuado del paralelismo, dado que se puede
usar un mayor número de réplicas sin que el problema del transitorio inicial limite el
paralelismo.
Cobertura
Coverage
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
0
30
0
3
5
78
10
15
20
Número
de réplicas
Replications
Figura 4-73 Cobertura y rendimiento con precalentamiento.
Modelo servidor central cerrado, N=8 → 12, variable "tiempo de respuesta del
sistema". Check = 100 muestras, reset = no.
La Figura 4-74 muestra resultados para el modelo del servidor central cerrado
cuando N pasa de 12 a 100. Su equivalente es la Figura 4-51. A pesar de que la cobertura mejora, no se consigue alcanzar el límite teórico. Se aprecia también un comportamiento superior de los criterios 3 y 4, destacando, además, una mejora de rendimiento con un número alto de réplicas.
En este caso es interesante destacar el salto que supone pasar de 12 a 100 terminales, el cual puede suponer una fuerte contaminación inicial de las observaciones.
Como el modelador ha tenido que implementar el mecanismo de reconfiguración del
0
30
188
Desarrollo de un analizador paralelo basado en réplicas independientes
modelo, debe ser consciente de que la forma de esta implementación influye en la
reducción del efecto del transitorio. Nótese que en la implementación realizada se
consigue disipar con mayor rapidez la configuración del modelo si se disminuye el
número de terminales que si se aumenta.
Observaciones
por réplica
Observations
per replication
Cobertura
Coverage
20k
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
1 200k
0
30
0
p1
p2
p3
p4
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-74 Cobertura y rendimiento con precalentamiento.
Modelo servidor central cerrado, N=12 → 100, variable "tiempo de respuesta del
sistema". Check = 100 muestras, reset = no.
Se han realizado experimentos con precalentamiento donde se ha ido disminuyendo la carga del modelo en lugar de aumentarla. Los resultados suelen ser mejores,
(ver estudios teóricos en [Kelton 1985]) pero se ha omitido deliberadamente comentarlos porque los casos problemáticos son los que emplean cargas altas, por lo que es
lógico empezar con cargas bajas e ir aumentándolas progresivamente.
La eliminación de observaciones iniciales en la técnica del precalentamiento puede solventar algunos problemas que esta técnica no consigue resolver completamente. La Figura 4-75 muestra el efecto de eliminar 200 observaciones de cada réplica,
como se hace en su equivalente de la Figura 4-54. Se consigue una mejora notable de
cobertura y un rendimiento ligeramente mayor. Este resultado muestra que la técnica
de precalentamiento y la de eliminación clásica de muestras iniciales se complementan sin problemas.
Con la variable productividad del sistema del modelo del servidor central cerrado
se obtienen resultados similares. La Figura 4-76 y la Figura 4-77 muestran los resultados para N=8 a 12 y para N=12 a 100, respectivamente. Sus equivalentes son la
Figura 4-63 y la Figura 4-64. Se aprecia un notable incremento de cobertura y una
mejora del rendimiento, sobre todo en el último caso donde un número alto de réplicas no penaliza la aceleración del experimento.
1
0
30
Técnica para la reducción del efecto del transitorio inicial
Cobertura
Coverage
189
Observaciones
por réplica
Observations
per replication
20k
Total
de observaciones
Observations
accumulated
p1
p2
p3
p4
1
1 200k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
Figura 4-75 Cobertura y rendimiento con precalentamiento.
Modelo servidor central cerrado, N=12→
→100, variable "tiempo de respuesta del
sistema". Check = 100 muestras, reset = 200 muestras.
Cobertura
Coverage
Observaciones
réplica
Simulated
time per por
replication
10k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 100k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Número
de réplicas
Replications
30
0
3
5
78
0
30
10
15
20
Número
de réplicas
Replications
0
3
5
78
0
30
10
15
20
NúmeroReplications
de réplicas
Figura 4-76 Cobertura y rendimiento con precalentamiento.
Modelo servidor central cerrado, N=8 → 12, variable "productividad sistema".
Check = 50 muestras, reset = no.
Cobertura
Coverage
Observaciones
réplica
Simulated
time per por
replication
10k
Total de observaciones
Simulated
time accumulated
p1
p2
p3
p4
1
1 100k
p1
p2
p3
p4
1
0.95
0.9
0.85
p1
p2
p3
p4
3
5
78
10
15
20
Replications
Número
de réplicas
30
0
3
5
78
10
15
20
Replications
Número
de réplicas
0
30
0
3
5
78
10
15
20
NúmeroReplications
de réplicas
Figura 4-77 Cobertura y rendimiento con precalentamiento.
Modelo servidor central cerrado, N=12 → 100, variable "productividad sistema".
Check = 50 tiempo simulado, reset = no.
Cuando se emplea la técnica con los modelos a baja carga los resultados son similares a la técnica clásica. Este resultado es importante, pues indica que, en general,
la técnica no va a empeorar ni el rendimiento ni la cobertura y puede emplearse a
discreción, aportando siempre beneficios en los casos peores.
0
30
190
Desarrollo de un analizador paralelo basado en réplicas independientes
4.5 Técnica para el ajuste automático del punto de
comprobación basado en tiempo simulado
La gestión de los puntos de comprobación (checkpoint) de las réplicas se puede
hacer de dos formas: basándose en el número de observaciones recogidas de la variable de interés o en el tiempo de simulación transcurrido. La elección dependerá de la
naturaleza de la variable a analizar, y con el propósito de evitar sesgos por ratio.
En el caso de que se emplee el número de muestras como punto de comprobación, el usuario no tendrá problema en especificar un valor (idealmente grande) con
el cual es consciente de la cantidad de información estadística que se introduce en
cada análisis.
En cambio, si se usa el tiempo para realizar el control, será muy difícil estar seguro de si, para el cálculo de la variable, se han recogido muchas o pocas muestras.
Más aún, fijar dicho tiempo para todos los experimentos no es una buena política,
pues suele cambiar drásticamente la cantidad de eventos contabilizados según la carga del modelo.
Para resolver este problema se propone una técnica de ajuste automático del
punto de comprobación en el caso de usar tiempo simulado. Para ello, junto a la variable observada se recoge la cuenta de eventos que se ha empleado para el cálculo
de la misma (por ejemplo, para el cálculo de la productividad de un modelo de colas,
se recoge la cuenta de clientes servidos, que es la que se emplea, dividida por el
tiempo, para el cálculo de dicha productividad).
Las réplicas se lanzan para ser comprobadas transcurrido un tiempo simulado especificado por el usuario tuser. Suponiendo k réplicas, cada una de ellas informará de
que se han contabilizado ci eventos para el cálculo de la variable de interés. Las replica se gestionan en modo síncrono, por lo que quedan bloqueadas a la espera de
ódenes.
Con los ci eventos remitidos es posible calcular el tiempo adecuado para los
puntos de comprobación. Para ello, el usuario habrá especificado previamente el número de eventos mínimos N con los que se debe calcular la variable de salida. El
tiempo de comprobación se calcula aplicando la expresión,
t chk =
t user
xN
min(c1 , c 2 ,..., c k )
Conclusiones
191
Las réplicas son informadas entonces del nuevo punto de comprobación y continúan la simulación.
Puede ocurrir que se hayan recogido muy pocas muestras para calcular adecuadamente el tiempo de extracción. Dicho extremo se comprueba aplicando la expresión, min(c1,c2,…,ck)<50. Caso de cumplirse, se procede a utilizar el nuevo tiempo de
usuario tuser=tchk y se repite de nuevo el proceso.
El problema insalvable de este algoritmo es que el modelador debe elegir tuser,
pues es difícil que la herramienta de simulación averigüe automáticamente, y sin
equivocarse, los órdenes de magnitud involucrados en el modelo. Este valor debe ser
del orden de la magnitud de las variables temporales de interés del modelo, pero a la
vez suficientemente pequeño para no forzar una simulación más allá de lo necesario.
En cualquier caso, el algoritmo ajustará automáticamente el valor por mucho que el
modelador se haya equivocado en su estimación.
Como resultado de la aplicación de este algoritmo se estará proporcionando robustez a la estimación de la variable de salida de interés sin tener que preocuparse de
tener que ajustar el tiempo de comprobación para cada conjunto de configuraciones
de entrada al modelo.
4.6
Conclusiones
En este capítulo se han resumido los resultados obtenidos en el desarrollo de un
analizador paralelo basado en el método de las réplicas independientes.
Hay dos opciones posibles para gestionar réplicas independientes en paralelo.
Una de ellas propone ir lanzando réplicas de tamaño fijo en paralelo y recolectar resultados hasta que se alcance la precisión deseada. Esta aproximación es sencilla
pero puede dar lugar a importantes problemas de sesgo [Glynn y Heidelberger 1992,
Glynn y Heidelberger 1992b]. La otra opción consiste en mantener una cantidad fija
de réplicas en paralelo y permitir que evolucionen hasta que se alcancen las condiciones deseadas. Esta opción es más deseable que la anterior como justifican algunos
resultados [Glynn 1995]. La problemática es fácil de ilustrar: imagínese el caso de
lanzar decenas de réplicas de tamaño fijo en paralelo y ser éstas demasiado cortas
para superar el transitorio. Ello podría dar lugar a una estimación puntual muy precisa, pero que, probablemente, no cubriese la verdadera media.
192
Desarrollo de un analizador paralelo basado en réplicas independientes
A pesar de la aparente idoneidad de la segunda aproximación, no se dispone de
implementaciones paralelas eficientes. Ello es debido a la necesidad de sincronización entre todas las réplicas y el proceso colector en los puntos donde se hace el cálculo estadístico y se decide si la simulación debe continuar o no. Esta barrera de sincronización limita enormemente las posibilidades del método, que se agrava debido a
entornos de ejecución donde hay variaciones de carga y a la naturaleza aleatoria del
tiempo de ejecución de una porción de simulación.
En este capítulo se ha propuesto un algoritmo asíncrono de comunicación réplicas-monitor que elimina esta barrera. Con ello se consigue que los modelos de simulación ejecutados en paralelo corran tan rápido como lo harían sus equivalentes
secuenciales, no suponiendo la infraestructura de CSX una sobrecarga.
El algoritmo de gestión inicialmente propuesto se ha mejorado para los casos en
que más de una réplica se ejecuta en una misma máquina. El mecanismo compensa
automáticamente las diferencias de velocidad entre las réplicas, proporcionando más
recurso computacional (procesador) a quien más lo necesita en cada momento de la
simulación. Este mecanismo también se puede aprovechar para realizar un análisis
estadístico con datos pareados, consiguiendo ejecutar dos modelos distintos simultáneamente de manera que el algoritmo compense automáticamente las naturales diferencias de velocidad entre cada modelo.
Los algoritmos de gestión han permitido superar las restricciones que supone la
ejecución en paralelo de un conjunto fijo de réplicas independientes. Se ha pasado
entonces a probar el comportamiento del gestor desde los puntos de vista de rendimiento en paralelo y de la cobertura. Para ello se ha elegido una batería de modelos
de simulación, y se han ejecutado empleando el criterio de terminación clásico basado en el error relativo. Dicho criterio ha resultado poco satisfactorio en cuanto a cobertura de la media real, sobre todo en los casos con un número bajo o un número
elevado de réplicas.
Para resolver los problemas del criterio clásico de terminación se han propuesto
dos nuevos criterios: uno basado en la reducción del error relativo, y otro basado en
la pendiente normalizada de la media global de las réplicas. Los dos han mostrado
ser superiores al criterio clásico, aunque a costa de un rendimiento lógicamente menor.
Los criterios propuestos están pensados para resolver dos tipos de problemas distintos que suelen darse al simular con varios métodos de análisis de la salida. El cri-
Conclusiones
193
terio 2 intenta superar las finalizaciones de simulación espúreas debidas a una disminución puntual del error relativo (Figura 4-78 a)), y ha mostrado comportarse bien
con los dos modelos abiertos. El criterio 3 pretende evitar la terminación prematura
en modelos que evolucionan lentamente hacia el valor de régimen permanente debido, principalmente, al sesgo inicial (ver Figura 4-78 b) y c)). Este segundo criterio se
ha comportado adecuadamente con los dos modelos cerrados.
a)
b)
c)
Figura 4-78 Distintas evoluciones típicas de la media de la variable de salida
de un modelo de simulación.
Como los dos criterios resuelven problemas distintos se ha decidido combinar
ambos con la idea de disponer así de un criterio que pueda hacer frente a diferentes
tipos de problemáticas sin necesidad de que el modelador deba distinguirlos. El criterio combinado propuesto se comporta bien incluso para valores bajos y altos de réplicas.
En caso de emplear un tiempo entre extracciones demasiado pequeño, ninguno de
los criterios es capaz de enfrentarse a modelos muy saturados. Para resolver este problema es necesario recurrir al borrado de muestras iniciales y a incrementar el tiempo
entre extracciones.
El borrado de muestras iniciales puede resolver el problema del sesgo pero a
costa de limitar el paralelismo. Por el contrario, el sesgo inicial limita la cobertura
para un número alto de réplicas. Estos dos efectos limitan las posibilidades de paralelismo. La técnica de precalentamiento de modelos propuesta en este trabajo permite
romper ese límite, logrando aumentar la cobertura y mejorar el rendimiento en los
modelos que presentan transitorio inicial. Además, el mecanismo no suele reducir el
rendimiento ni la cobertura en ningún caso, por lo que puede explotarse sistemáticamente sin temor a empeorar los resultados. El mecanismo es sencillo de implementar
y sólo requiere que el usuario proporcione una función que permita la reconfiguración de un modelo en ejecución.
194
Desarrollo de un analizador paralelo basado en réplicas independientes
Esta última técnica permite incrementar las posibilidades de aceleración del modelo al lograr que un número más alto de réplicas (probablemente más cortas) no
sesguen el resultado. Combinándolo con el método clásico del borrado inicial puede
resolver muchos problemas de cobertura.
Como recomendación de uso del analizador se propone:
•
Utilizar un mínimo de 10 réplicas paralelas para realizar el experimento. Si no
se dispone de suficientes máquinas se puede recurrir a ejecutar varias réplicas
en la misma máquina. Por ejemplo, si se dispone de 5 máquinas, depositar 2
réplicas por máquina es una buena opción. Si, por ejemplo, se dispone de 3
máquinas, se puede optar por colocar 3 réplicas en cada máquina, teniendo un
total de 9 réplicas paralelas. Incluso ejecutar 10 réplicas en paralelo en una
sola máquina proporciona buenos resultados y es una alternativa viable a los
métodos secuenciales clásicos. La limitación viene dada por el tamaño del
ejecutable en la memoria del computador, pudiéndose dar el caso de que todas las réplicas no quepan simultáneamente en la memoria principal del computador lo que causará un exceso de paginado a disco duro que limitará
enormemente la potencia de computación.
•
Emplear un espacio entre puntos de extracción relativamente grande. Por
ejemplo, 500 observaciones. Aunque esto pueda limitar el rendimiento, es
mejor que arriesgarse a un problema de cobertura.
•
En caso de usar control espacio entre puntos de extracción basado en tiempo
simulado, emplear el algoritmo de ajuste automático del tiempo de extracción
fijando el número de observaciones según lo dicho en el punto anterior.
•
Utilizar el criterio de terminación combinado propuesto con s = 0,001.
•
Utilizar siempre que sea posible la técnica de precalentamiento del modelo.
En caso de modelos con transitorio inicial, su efecto será menor y, posiblemente, también reduzca el tiempo para alcanzar el régimen permanente. Su
implantación es sencilla y los beneficios pueden ser notables
•
Borrar siempre una pequeña porción de las muestras iniciales. Por ejemplo,
eliminar hasta el primer punto de comprobación mejorará la cobertura de los
modelos sesgados y no disminuirá demasiado el rendimiento. En el caso de
modelos con transitorio rápido, apenas aportará beneficio, pero tampoco
afectará excesivamente al rendimiento.
Conclusiones
195
Con el analizador propuesto en este capítulo se consigue una herramienta de análisis estadístico robusta y adecuada para acelerar simulaciones por eventos discretos.
Además, el método de las réplicas independientes es el método preferido por muchos
analistas debido a sus propiedades, las cuales se pierden al recurrir a otros métodos
impuestos por los entornos secuenciales.
La posible mejora del analizador se puede afrontar en dos aspectos. El primero es
encontrar otros criterios de terminación que permitan asegurar la recolección de suficientes observaciones para garantizar el cumplimiento de las restricciones del método de las réplicas independientes (normalidad, etc.). El segundo es la aplicación de
técnicas para la detección y eliminación automática del transitorio inicial, como por
ejemplo, las basadas en el método gráfico de Welch [Welch 1983] o [Vassilacopoulos 1989]. No son aplicables técnicas de eliminación automática habituales, como las
basadas en series temporales estandarizadas [Schruben 1983], [Goldsman et al. 1994]
o el método espectral [Heidelberger y Welch 1981b], pues la naturaleza de la información recogida por el monitor no lo permite y su aplicación a discreción puede desechar muchos valores válidos, efecto no tan negativo en los métodos secuenciales de
análisis.
5. Experimentos aplicando CSX a un modelo de red de almacenamiento
5
Experimentos aplicando
CSX a un modelo de red
de almacenamiento
Este capítulo resume las experiencias aplicando CSX a un modelo de simulación
de gran complejidad de una red de almacenamiento de altas prestaciones (SAN,
Storage Area Network) [Farley 2.000]. EL modelo se ha desarrollado en el lenguaje
de simulación CSIM y se describe en el apartado 5.1.
En estas experiencias se prueban distintas estrategias de configuración del entorno paralelo para el lanzamiento del experimento, donde el experimento es un conjunto de configuraciones del modelo. Dichas estrategias se describen en el apartado
5.2.
El propósito es tomar tiempos de ejecución de la simulación para compararlos
con el tiempo de simulación original que se obtiene aplicando el método por lotes
(batch-means) incorporado en el paquete CSIM.
En este capítulo se propone, además, una técnica para ajustar automáticamente la
cantidad de réplicas a fin de reducir el tiempo de ejecución necesario para simular el
sistema. Ello se aplica cuando se pretende resolver un experimento formado por un
modelo de simulación en el que se varía un parámetro de entrada.
Los resultados que se ofrecen en el apartado 5.3 muestran que la herramienta
construida como resultado de este trabajo es capaz de ofrecer también buenos resultados cuando lo que se pretende es resolver rápidamente un experimento (conjunto
de simulaciones); siendo superior a estrategias de lanzamiento simultáneo de simulaciones secuenciales en un conjunto de computadores.
198
Experimentos aplicando CSX a un modelo de red de almacenamiento
Este capítulo resume resultados publicados en [Perles et al. 2000], [Perles et al.
2000b] y [Perles et al. 2002].
5.1
El modelo de simulación SAN
Las redes de almacenamiento (SAN) son una plataforma emergente de comunicación de datos que interconecta servidores y dispositivos de almacenamiento para
crear un sistema de almacenamiento al que los usuarios pueden acceder directamente. Esta aproximación en red proporciona muchos beneficios, como por ejemplo,
flexibilidad topológica, tolerancia a fallos, alta disponibilidad, computación en grupo, gestión remota, etc.
Para evaluar el rendimiento de estos sistemas se ha desarrollado un simulador
muy flexible y sencillo de usar [Molero et al. 2.000]. El simulador se ha escrito empleando las bibliotecas CSIM. Por tanto, el modelo interpreta el comportamiento del
sistema mediante un conjunto de procesos que interactúan entre ellos empleando las
estructuras y mecanismos internos de CSIM. La versión actual es un programa de
unas 18.000 líneas en código estándar ANSI C que se ejecuta tanto en plataformas
Unix como Windows gracias a su portabilidad.
Como este simulador modela con precisión una SAN centrándose en su diseño
interno, el programa resultante es complejo y necesita de gran cantidad de recursos
computacionales para su evaluación, tanto de memoria de principal como de procesador.
Originalmente, el simulador emplea el método de análisis estadístico por lotes
(batch-means) implementado internamente en CSIM para el análisis de las variables
de salida. La obtención de resultados precisos provoca largos tiempos de ejecución.
La Figura 5-1 muestra un resultado típico obtenido usando el modelo de simulación, donde cada punto representado corresponde a un proceso de simulación sim()
de CSIM con un valor distinto para la carga de trabajo de entrada. Esta carga se calcula como el tráfico total inyectado en la red de interconexión, y se mide en bytes por
ciclo de reloj. Como se puede observar en la gráfica, el sistema estará en un estado
operacional mientras el tráfico distribuido sea igual al tráfico inyectado (zona lineal).
En este estudio particular con el entorno de simulación paralelo CSX se ha considerado una SAN con la topología floors [Ovicki y Karlin 1.992] mostrado en la
Figura 5-2. En esta topología, que es usada en edificios, la mayoría de las conexiones
El modelo de simulación SAN
199
se dan entre los conmutadores y los dispositivos de cada una de las plantas. La estructura en cada planta, mostrada en la Figura 5-2(b), consiste en una estrella con
conmutadores centrales y conmutadores finales. Esta estructura se replica tantas veces como plantas se incluyan en la SAN. Los conmutadores centrales están específicamente dedicados a la conexión de conmutadores entre las distintas plantas. Los
servidores y dispositivos de almacenamiento están conectados a la SAN mediante los
conmutadores finales. Esta estructura tiene bastantes conexiones para proporcionar
cierto grado de tolerancia a fallos.
900
I/O mean response time (cicles)
800
700
sim()
600
sim()
500
sim()
400
300
200
0.5
1
1.5
2
2.5
3
3.5
4
4.5
Delivered traffic (bytes/cycle)
Figura 5-1. Resultado típico del simulador SAN: “tiempo medio de respuesta de E/S”
comparado con “tráfico distribuido”.
S
D
Planta n
D
D
D
D
Conmutador final
Conmutador central
Planta 3
Conmutador final
Planta 2
S
D
D
D
D
D
Planta 1
a) Conexión entre conmutadores
de diferentes plantas
b) Conexión entre los
conmutadores de una planta
Figura 5-2. Configuración SAN considerada en el estudio.
200
Experimentos aplicando CSX a un modelo de red de almacenamiento
En este caso particular, la estructura está compuesta por una topología de 5 plantas, donde cada planta tiene dos conmutadores centrales. Cada conmutador central
está conectado a todos los conmutadores centrales de las plantas adyacentes. Cuatro
conmutadores finales proveen conectividad a cada planta. Cada conmutador final
está conectado a un servidor y a 5 discos. Por tanto, 20 servidores y 100 discos componen la red de almacenamiento.
5.2
Estrategias de simulación
Se asume que el modelo de simulación se ha de resolver para w valores diferentes
de la carga de entrada, y que la simulación se ejecuta en un cluster compuesto por n
computadores, donde w ≤ n. En esta sección se proponen diferentes estrategias para
acortar el tiempo de ejecución del experimento, midiendo este tiempo como el tiempo real que transcurre desde que se inicia el experimento hasta que se obtiene el resultado de la última simulación.
Se describen a continuación las diferentes estrategias de planificación de las simulaciones que se han comparado en este estudio. El método A corresponde a la
técnica secuencial de análisis por lotes de la versión original. Los métodos B, C y D
corresponden a diversas políticas de ejecución en paralelo.
5.2.1 Método A: ejecución secuencial
Este método corresponde a la aproximación clásica secuencial. El modelo de simulación es ejecutado en una estación para cada valor de carga de entrada empleando la técnica de análisis por lotes para la obtención del intervalo de confianza de la
variable de salida.
Zona transitoria.
Arranque del
modelo en vacío.
Una estación
Punto de carga 1
Punto de carga 2
En paralelo
Zona de régimen permanente. Una estación
Punto de carga w
Figura 5-3. Método A: simulaciones independientes para cada punto de carga.
Estrategias de simulación
201
Estas simulaciones independientes pueden ejecutarse simultáneamente, cada una
en una máquina diferente del cluster, como se representa en la Figura 5-3.
Si se arrancan todas las simulaciones al mismo tiempo, entonces la cantidad de
tiempo T que el experimento necesitará para estar terminado será el coste de la ejecución más larga, esto es,
w
T = max{ti }
i =1
donde w es el número de puntos de carga de entrada y ti es el tiempo necesario
para simular el punto de carga i.
5.2.2 Método B: ejecución paralela
En este caso, cada configuración de entrada es realizada mediante la ejecución de
tantas réplicas paralelas como computadores haya en el cluster. Como es habitual en
el método de las réplicas independientes, todas las réplicas parten de un estado del
modelo anormal, poco representativo del régimen permanente, hasta que, transcurrido un transitorio inicial, el modelo está en equilibrio y genera observaciones propias
del régimen permanente.
La ejecución del modelo de simulación para cada punto de carga se hace secuencialmente, tal y como se muestra en la Figura 5-4.
n estaciones
Zona transitoria
global (n réplicas)
Punto de carga 1
Punto de carga 2
Zona estable
global
n estaciones
Simulaciones con
transitorio debido
a arranque en
vacío del modelo.
Punto de carga w
Figura 5-4. Método B: réplicas independientes en paralelo para cada punto de carga.
202
Experimentos aplicando CSX a un modelo de red de almacenamiento
El tiempo total de ejecución T que el experimento necesitará para ser calculado se
puede calcular como la suma de los tiempos de ejecución necesarios para realizar
cada uno de los puntos, esto es,
w
T = ∑ ti
i =1
donde w es el número de puntos de carga, y ti es el tiempo necesario para ejecutar
el punto i.
5.2.3 Método C: ejecución paralela ajustando el número de réplicas
independientes
En este caso la simulación del primer punto es empleada para ajustar el número
adecuado de réplicas independientes que debería utilizarse para el resto de los puntos
de simulación. Este proceso de ajuste tiene en cuenta la relación entre computadores
disponibles, su potencia de cálculo, y el particular comportamiento del modelo de
simulación con el propósito de estimar cuál es la cantidad idónea de réplicas que
permite terminar más rápidamente el experimento.
n estaciones
Zona transitoria
global
1ª fase
(sintonización)
Punto de carga 1
n1 estaciones
Punto de carga 2
Zona estable
global
n2 estaciones
Simulaciones
arrancadas con el
modelo vacío
2ª fase
(en paralelo)
Punto de carga 3
Figura 5-5. Método C: el primer punto de carga simulado se emplea para sintonizar el
resto del proceso.
Estrategias de simulación
203
La Figura 5-5 muestra gráficamente la aplicación de este proceso. Como se puede
ver, el primer punto de carga es simulado empleando todas las estaciones del cluster,
cada una de ellas ejecutando una réplica. Una vez que el primer punto ha sido simulado, la información recogida puede ser empleada para sintonizar la ejecución del
resto de las simulaciones.
En este caso, el segundo punto de carga es ejecutado en n1 estaciones y el tercero
en n2 estaciones, con n=n1+n2. Se asume que los dos conjuntos de estaciones se
mantienen inalterado a lo largo del resto de las simulaciones.
El tiempo total de repuesta T del experimento de simulación se puede calcular
sumando al tiempo de la primera simulación el tiempo más largo del subconjunto de
ejecuciones de puntos de carga. Por ejemplo, si el conjunto se divide en dos subconjuntos iguales de puntos se tendrá,
 w2 +1

w


T = t1 + max ∑ t i , ∑ t j 
 i=2 j = w +2 
2


donde w es el número de puntos de carga, y ti es el tiempo necesario para ejecutar
el punto i.
5.2.4 Método D: ejecución paralela ajustando el número de réplicas y
reduciendo el efecto del transitorio inicial
El objetivo de este método es reducir del efecto el estado inicial no representativo
en el que se suelen arrancar las simulaciones. Como se ha descrito en el capítulo previo, este método arranca el modelo en un estado cercano al régimen permanente
aprovechando el estado que deja la simulación previa.
Para hacerlo, se puede aplicar una pequeña variación al caso previo. Una vez que
la simulación del primer punto ha terminado, el resto de las simulaciones pueden
empezar a partir del estado dejado por la simulación previa. Como en el método C, la
ejecución del primer punto sirve para ajustar el número de réplicas que deben usarse
en el resto de los puntos.
La Figura 5-6 muestra gráficamente la aplicación de este método. El primer punto
de carga es simulado empleando todas las estaciones del cluster: cada estación ejecuta una réplica independiente. Una vez que el primer punto ha sido simulado, el
resultado obtenido se puede usar para ajustar el resto de la simulación. Por ejemplo,
204
Experimentos aplicando CSX a un modelo de red de almacenamiento
en este caso el segundo punto es ejecutado en n1 estaciones y el tercero en n2, con n =
n1 + n2. Sin embargo, a diferencia del caso anterior, todas las réplicas del segundo y
siguientes puntos empiezan en un estado distinto al vacío.
n1 estaciones
n workstations
Resto de los “puntos
de carga”
Zona transitoria
global
El estado inicial de estos puntos viene determinado
por el estado final de la simulación previa
Punto de carga 1
Simulaciones con
transitorio arrancadas con
el modelo vacío
Simulaciones con
transitorio debido al
estado previo no vacío
n2 estaciones
Figura 5-6. Método D: primera simulación sintoniza y el resto se simulan reconfigurando las réplicas en ejecución.
El tiempo total de respuesta T del experimento de simulación se puede calcular
igual que en el caso anterior.
5.3
Resultados experimentales
Esta sección compara la cantidad de tiempo T necesaria para realizar el experimento cuando se usa cada uno de los métodos descritos previamente. Para ejecutar
los experimentos se ha utilizado un cluster compuesto por 10 PC (n=10) AMD K62/350 Mhz con 128 MB de RAM y ejecutando Linux SuSE 6.1.
La variable de salida del modelo considerada ha sido el tiempo medio de respuesta de las operaciones de E/S. Este tiempo incluye la latencia de la red, el tiempo
de acceso a disco y los tiempos de esperan en colas. Se han considerado 7 niveles
diferentes para el parámetro de carga de entrada del modelo (w = 7). Estos niveles de
carga han sido 8,5, 11, 13,5, 16, 18,5, 21 y 23,6, todos medidos en bytes/ciclo, donde
un ciclo de reloj equivale a 6,5 nanosegundos [Molero et al. 2.000].
El código original del simulador SAN ha sido modificado y enlazado con la biblioteca CSX para que pueda ser monitorizado en el entorno paralelo. Para el criterio
Resultados experimentales
205
de fin de simulación se ha empleado un error relativo del 5% a un nivel de confianza
del 95%.
5.3.1 Método A: ejecución secuencial
Este experimento se ha realizado empleando el método de análisis por lotes implementado en CSIM. Debido a que la implementación particular del método en
CSIM no está accesible y no está adecuadamente documentada, se le ha considerado
como una especie de caja negra que ofrece dos salidas: un intervalo de confianza y
un indicador lógico de si se ha producido la convergencia.
La Tabla 5-1 resume los resultados obtenidos para cada punto de carga. Se muestran la media, el intervalo de confianza, y el tiempo de ejecución para cada caso.
Como se puede apreciar, el tiempo de ejecución se incrementa al aumentar el nivel
de carga. Este hecho se debe al incremento de variabilidad como ocurría en los modelos estudiados teóricamente en el capítulo previo, pero también al hecho de que
CSIM incrementa el número de lotes a recoger cuando no se ha alcanzado la convergencia en la fase previa. Para el valor más alto de carga, el método no ha convergido
a pesar de haber invertido 10 horas de simulación.
Carga
Media
H
8,5
11
13,5
16
18,5
21
23,5
4281,9
4875,8
5528,2
6552,1
7649,2
9255,0
11583,4
61,1
106,2
117,6
154,5
180,7
177,6
no disponible
Tiempo de ejecución
(minutos)
50
52
51
104
199
109
600
Tabla 5-1. Media, intervalo de confianza y tiempo de ejecución para el análisis de la
variable de salida en el método A.
De los datos de la Tabla 5-1, el tiempo de ejecución para obtener los resultados
del experimento utilizando el cluster de computadores es,
w
T = max{t i } = max{50,52,51,104,199,109,600} = 600 minutos
i =1
5.3.2 Método B: ejecución paralela
Para llevar a cabo este experimento se han lanzado 10 réplicas independientes en
el cluster, una en cada computador. La información estadística relacionada con la
206
Experimentos aplicando CSX a un modelo de red de almacenamiento
evolución de la variable objetivo es enviada periódicamente a CSX para que calcule
la media global y el intervalo de confianza.
Se ha analizado el efecto del arranque inicial antes de llevar a cabo el experimento definitivo. La Figura 5-7 muestra el efecto en la evolución de la media y del
error relativo para 10 réplicas cuando se aplica una eliminación de muestras iniciales
en el punto que parece apropiado. Como se puede observar, el reinicio de estadísticos
hace que la media alcance más rápidamente el valor de régimen permanente, y la
evolución del error relativo es similar en ambos casos.
7000
Tiempo de respuesta E/S (ciclos)
6000
5000
4000
R e in ic io d e e s ta d ís tic o s
3000
S in r e in ic io
2000
1000
c arg a = 1 6
0
1
8
15
22
29
36
43
50
57
64
71
78
85
92
99
T i e m p o s i m u l a d o ( c i c l o s /5 .0 0 0 )
Error (%)
15%
10%
5%
0%
1
9
17
25
33
41
49
57
65
73
81
89
97
Figura 5-7. Evolución de la media y el error relativo al aplicar un reinicio de estadísticos. 10 réplicas y carga 16.
Carga
Media
H
8,5
11
13,5
16
18,5
21
23,5
4253,6
4840,0
5508,6
6348,1
7484,7
9081,0
11328,5
92,9
105,2
96,9
72,0
95,5
162,8
289,8
Tiempo de ejecución
(minutos)
3,1
4,0
5,9
9,5
14,7
27,9
45,7
Tabla 5-2. Media, intervalo de confianza y tiempo de ejecución para el análisis de la
variable de salida en el método B.
Resultados experimentales
207
A pesar de que la eliminación de muestras mejora la calidad de la salida, se ha
decidido no aplicarlo para facilitar la comparación de tiempos de ejecución. La Tabla
5-2 resume los resultados obtenidos para cada nivel de carga y 10 réplicas. De los
datos de la tabla se tiene que el tiempo para obtener los resultados del experimento
es,
w
T = ∑ t i = 3.1 + 4.0 + 5.9 + 9.5 + 14.7 + 27.9 + 45.7 = 110 minutos
i =1
5.3.3 Método C: ejecución paralela ajustando el número de réplicas
independientes
En este caso se emplean los 10 computadores para ejecutar una réplica en cada
uno de ellos con el primer punto de carga. A la simulación se la dejará ejecutarse lo
suficiente para descubrir cuál es el número adecuado de réplicas en función del comportamiento del modelo y la potencia de procesamiento de las máquinas.
La idea básica es sencilla: por medio de la ejecución de 10 réplicas durante un
tiempo suficientemente largo, se puede calcular cuánto tiempo sería invertido para
alcanzar la convergencia con 9, 8, 7 ... réplicas. Este tiempo es buen indicador del
comportamiento del modelo cuando se simulen el resto de los puntos de carga, siempre y cuando estos estén cercanos entre sí.
Tiempo de ejecución (minutos)
La Figura 5-8 muestra el tiempo de terminación para diferentes cantidades de réplicas cuando se emplea un nivel de carga de 8,5. Para seleccionar el número ideal de
réplicas las opciones más factibles son 3, 5 ó 10 réplicas. La elección de 3 réplicas
puede ser una elección poco segura desde el punto de vista de cobertura de la media,
mientras que 10 réplicas consumirán una gran cantidad de recursos computacionales
sin proporcionar una mejora importante comparado con 5 réplicas.
20
17,5
15
10
5
5,6
3,9
0
1
2
3
4
5
3,1
3,3
0
6
7
8
9
10
Número de réplicas
Figura 5-8. Tiempo de ejecución para diferentes cantidades de réplicas y carga 8,5.
208
Experimentos aplicando CSX a un modelo de red de almacenamiento
Teniendo en cuenta que el cluster de computadores empleado en el experimento
consta de 10 máquinas, parece que la elección más apropiada consiste en elegir 5
réplicas.
Con esta elección, se han ejecutado los puntos de carga 11, 13,5 y 16 en un grupo
de 5 máquinas, y los puntos de carga 18,5, 21 y 23,5 en el resto. La Tabla 5-3 resume
los resultados obtenidos para cada nivel de carga.
Carga
Media
H
8,5
11
13,5
16
18,5
21
23,5
4289,4
4792,1
5569,3
6432,6
7527,3
9109,7
11251,2
106,5
113,3
124,3
79,1
100,9
265,4
247,6
Tiempo de ejecución
(minutos)
6,0
5,1
7,8
13,1
21,6
32,5
48,8
Tabla 5-3. Media, intervalo de confianza y tiempo de ejecución para el análisis de la
variable de salida en el método C.
De los datos de la tabla, el tiempo de ejecución del experimento es,
 w2 +1

w


T = t1 + max ∑ t i , ∑ t j  = 6.0 + max{5.1 + 7.8 + 13.1, 21.6 + 32.5 + 48.8} = 108 minutos
 i =2 j = w + 2 
2


El análisis de la expresión anterior nos muestra que la ejecución del experimento
se ha penalizado debido a que uno de los grupos de 5 máquinas ha realizado los experimentos más costosos. Por tanto, sería deseable un mecanismo dinámico capaz de
repartir las simulaciones. Por ejemplo, si se planifica el siguiente punto de carga en
el grupo de estaciones que termina primero un punto, se obtiene el siguiente tiempo
de ejecución,
T = 6.0 + max{5.1 + 13.1 + 32.5, 7.8 + 21.6 + 48.8} = 84.2 minutos
Se llamará C2 a este método para diferenciarlo del primero, al que se llamará C1.
Por otra parte, si se planifica alternativamente el último y el primer punto de carga en
el grupo de estaciones que termina un determinado punto entonces se tiene un tiempo
de ejecución (C3),
T = 6.0 + max{5.1 + 7.8 + 13.1 + 21.6 + 32.5, 48.8} = 86.1 minutos
Resultados experimentales
209
Es posible realizar un mejor reparto del trabajo, por ejemplo, ejecutando los niveles de carga 11, 13.5 y 23.5 en un grupo de máquinas, y los niveles 16, 18.5 y 21
en el otro grupo. En este caso el tiempo de ejecución es,
T = 6.0 + max{5.1 + 7.8 + 48.8, 13.1 + 21.6 + 32.5} = 73 minutos
Sin embargo, este valor ideal no se puede obtener dinámicamente a priori, pues
no se conoce antemano el tiempo que necesitan los experimentos para simularse.
5.3.4 Método D: ejecución paralela ajustando el número de réplicas y
reduciendo el efecto del transitorio inicial
En este método, el primer punto simulado se usa, de la misma manera que en el
caso anterior, para sintonizar el número de réplicas. En este caso, basándonos en los
resultados precedentes, el experimento se ejecutará de la siguiente forma: los niveles
de carga 11, 18,5 y 21 en un grupo de máquinas y los niveles 13,5, 16 y 23,5 en otro
grupo. Esta elección pretende comprobar también el efecto de elegir puntos de carga
“cercanos” y “distantes” con respecto al valor previo.
La Figura 5-9 y Figura 5-10 muestran la evolución de la media y el error relativo
para los niveles de carga 8,5, 11, 18,5 y 21, y los niveles 8,5, 13,5, 16 y 23,5 respectivamente.
Tiempo de respuesta E/S (ciclos)
12000
Reinicio estadísticos
y cambio de carga
10000
8000
6000
4000
2000
carga={8.5, 11, 18, 5, 21}
115
121
116
121
97
96
109
91
91
103
85
86
79
73
67
61
55
49
43
37
31
25
19
13
7
1
0
111
106
101
81
76
71
66
61
56
51
46
41
36
31
26
21
16
6
11
15,0%
10,0%
5,0%
0,0%
1
Error (%)
Tiempo simulado (ciclos/5.000)
Figura 5-9. Evolución de la media y del error relativo para los niveles de carga 8,5, 11,
18,5 y 21.
210
Experimentos aplicando CSX a un modelo de red de almacenamiento
Tiempo de respuesta E/S (ciclos)
14000
12000
Reinicio estadísticos y
cambio de punto de carga
10000
8000
6000
4000
2000
carga={8,5, 13,5,16, 23,5}
127
120
113
106
99
92
85
78
71
64
57
50
43
36
29
22
15
8
1
0
131
126
121
116
111
106
101
96
91
86
81
76
71
66
61
56
51
46
41
36
31
26
21
16
11
6
15,0%
10,0%
5,0%
0,0%
1
Error (%)
Tiempo simulado (ciclos/5.000)
Figura 5-10. Evolución de la media y del error relativo para los niveles de carga 8,5,
13,5, 16 y 23,5.
La Tabla 5-4 resume los resultados obtenidos para todos los niveles de carga considerados.
Carga
Media
H
8,5
11
13,5
16
18,5
21
23,5
4289,4
4694,7
5367,4
6378,3
7494,7
9003,9
11729,4
106,5
112,8
156,5
79,2
105,1
231,1
282,3
Tiempo de ejecución
(minutos)
6,0
5,1
7,8
4,2
12,1
30,2
44,6
Tabla 5-4. Media, intervalo de confianza y tiempo de ejecución para el análisis de la
variable de salida en el método D.
De los datos de la tabla se tiene que el tiempo de ejecución del experimento completo es,
T = 6.0 + max{5.1 + 12.1 + 30.2, 7.8 + 4.2 + 44.6} = 62.6 minutos
Si el reparto de puntos de carga empleado aquí se hubiese empleado en el método
C, el tiempo de ejecución del experimento hubiese sido de 75,7 minutos, con lo que
la mejora es apreciable.
Conclusiones
5.4
211
Conclusiones
Es imposible justificar la validez estadística de los resultados obtenidos por los
distintos métodos, pues no es posible disponer de resultados analíticos del modelo
que permitan contrastar los resultados. De todas formas, los intervalos de confianza
solapan para los distintos métodos, lo cual es un punto a favor de considerar los resultados como válidos.
Tiempo de ejecución
(minutos)
La conclusión de este experimento solo puede tener el marco de los tiempos de
ejecución como único punto a analizar. La Figura 5-11 muestra los tiempos de respuesta para los distintos métodos. Se comprueba que la ejecución paralela mejora
notablemente los tiempos de terminación del experimento.
200
600
150
110
108
100
84,2
86,1
C2
C3
62,6
50
0
A
B
C1
D
Método de simulación
Figura 5-11. Tiempos de respuesta de los experimentos para distintos métodos.
Los métodos C2 y C3 son dos aproximaciones dinámicas al método C inicial que
proporcionan un mejor uso de los recursos computacionales. Por tanto, se puede perder el beneficio de la fase de sintonización si no se provee un mecanismo de planificación dinámica de las simulaciones. Los mejores resultados se obtendrán con el
mecanismo dinámico y, en general, un mayor número de niveles beneficiará los
tiempos de simulación del experimento.
Finalmente, el método D proporciona un rendimiento ligeramente superior a la
versión dinámica del método C. Este resultado se mejorará también al incrementar el
número de puntos y al aplicar técnicas de planificación dinámicas.
El método de sintonización de réplicas debe considerase con extremada cautela.
A la vista de los resultados del capítulo previo se desprenden dos problemáticas:. por
una parte, la variación de los parámetros de entrada del modelo modifica el comportamiento temporal de las réplicas, con lo que la elección adecuada del número de
212
Experimentos aplicando CSX a un modelo de red de almacenamiento
réplicas no es obvia, y por otra, la sintonización puede provocar una elección del
número de réplicas pequeña (5 en este experimento), lo que puede dar lugar a problemas de cobertura, problemas que se pueden corregir, en parte, gracias al método
de reducción del efecto del transitorio. Estos problemas sugieren que es necesario
investigar mejor las posibilidades del método de sintonización para analizar si su
aplicación práctica es viable
A parte de las conclusiones que ya se han justificado mucho mejor en el capítulo
previo, cabe aquí indicar que la aproximación paralela puede competir con la aproximación secuencial en dos frentes: la reducción del tiempo de ejecución de una simulación individual, o la reducción del tiempo de ejecución de un experimento completo (conjunto de simulaciones), resultado no tan obvio si se tiene en cuenta la posibilidad evidente de lanzar simultáneamente distintas simulaciones secuenciales en
distintas máquinas.
6. Conclusiones
6
Conclusiones
Este capítulo ofrece una síntesis general del trabajo realizado y de posibles líneas
de trabajo. Al final de los capítulos previos se comentan las conclusiones particulares
de cada uno de los aspectos del trabajo realizado.
6.1
Conclusiones generales y contribuciones
En esta tesis se han propuesto técnicas que permiten acelerar la ejecución de modelos de simulación por eventos discretos. Las propuestas han sido implementadas y
validadas empíricamente, pues el objetivo final es emplear dichas técnicas en los
modelos de simulación que se desarrollan en el grupo de investigación.
El trabajo pretende reducir el tiempo de obtención de resultados de estimadores
puntuales de régimen permanente en modelos de simulación por eventos discretos. El
estudio de las posible vías que se resume en el capítulo 2 concluye que la opción más
viable parece ser la aplicación de la técnica de réplicas en paralelo. Sin embargo, en
la literatura no hay ninguna propuesta adecuada al problema.
A partir de los criterios ideales que debe cumplir el entorno de simulación paralelo para adaptarse a la problemática particular, se han diseño y desarrollado las técnicas necesarias para hacer posible que un conjunto heterogéneo de ordenadores
forme parte de un sistema de simulación paralelo en el que sea posible lanzar modelos de simulación, especificados en cualquier lenguaje de simulación, de manera que
sean gestionados por el entorno. Se han propuesto las técnicas que permiten una fácil
adaptación de los modelos, con lo que se facilita enormemente la aplicación del entorno paralelo por parte de los modeladores. El modelo secuencial adaptado al entor-
214
Conclusiones
no paralelo no sufre prácticamente sobrecarga, por lo que se sigue ejecutando a la
misma velocidad que su versión original secuencial.
La naturaleza heterogénea del entorno de simulación ha obligado a desarrollar las
técnicas para estimar la potencia de simulación de los computadores que forman
parte del cluster y de evaluar el rendimiento de las simulaciones en ejecución. Con
estas técnicas el entorno conoce el “rendimiento” de una simulación en ejecución,
pudiéndose aplicar fácilmente estrategias de redistribución dinámica de la carga que
supone la ejecución de los modelos.
Uno de los criterios de diseño fundamental ha sido separar los aspectos de gestión
de los procesos que componen el entorno paralelo, de los aspectos de análisis estadísticos de los datos generados por las réplicas. En este sentido, se ha diseñado un
analizador de datos basado en el método de las réplicas independientes. Una de las
razones para la elección de este método, en detrimento de otros, se justifica en que la
ejecución paralela permite romper las barreras que no lo hacen adecuado en un entorno secuencial, y que han fomentando el empleo de otras técnicas como lotes
(batch-means). Además de ésta, hay otras razones importantes para elegir este método [Law y Kelton 2.000].
La aplicación paralela de la técnica de réplicas independientes tiene dos posibles
vertientes: la aproximación basada en la ejecución de réplicas de tamaño fijo y la
basada en la ejecución de una cantidad de réplicas fija a la que se les permite crecer.
En el capítulo 2 se justifica la mejor calidad estadística de la segunda aproximación.
Sin embargo, ésta no es la elección implementada en la literatura debido a los problemas originados por la diferente velocidad de generación de cada réplica. En este
sentido, el primer paso ha sido diseñar las técnicas que permiten romper esta barrera,
consiguiéndose un mecanismo capaz de permitir la ejecución de las réplicas a la máxima velocidad posible sin que se interfieran ente ellas. Ello se ha logrado con una
gestión asíncrona de las réplicas paralelas. También se han desarrollado mejoras al
mecanismo asíncrono en el caso particular de ejecutar más de una réplica en un computador mediante la aplicación de sincronizaciones locales. La mayor ventaja de este
mecanismo se logra cuando se pretende comparar dos modelos, pues es posible lanzarlos simultáneamente y compensar automáticamente las lógicas diferencias de velocidad de cada modelo.
El comportamiento del analizador por réplicas se ha evaluado desde el punto de
vista de rendimiento (tiempo de ejecución) y de cobertura de la media empleando
cuatro modelos con solución analítica. Las características evaluadas han sido: el
Conclusiones generales y contribuciones
215
tiempo entre extracciones de información estadística, la eliminación de muestras iniciales de las réplicas, el número de réplicas paralelas y los criterios de parada. Como
primer criterio de parada se ha utilizado el empleado en el método de las réplicas
independientes en su implementación secuencial. Los pobres resultados de cobertura
han obligado a plantear nuevos criterios de parada, que han mostrado ser superiores
al criterio clásico en distintos escenarios. Una combinación de los criterios propuestos permite un comportamiento superior para distintos tipos de respuesta del modelo
de salida. Este criterio combinado se basa en la comprobación de la disminución del
error relativo según evoluciona la simulación (para incrementar la probabilidad de
que no se trata de un cumplimiento espúreo de las condiciones de fin) y en la detección de la estabilización de la media mediante la comprobación de la pendiente entre
dos muestras sucesivas..
Un factor primordial que puede limitar la aceleración de la simulación es el sesgo
de las observaciones iniciales del método de las réplicas independientes, pues un
incremento del número de réplicas aumenta la cantidad de muestras contaminadas
que forman parte de la media, provocando una disminución de la cobertura. En este
sentido se ha propuesto y desarrollado una técnica de precalentamiento basada en
aprovechar el régimen permanente de una simulación previa para realizar la siguiente
simulación, con lo que se espera que la transición al nuevo régimen permanente sea
más rápida y menos sesgada. Como suele ser habitual ejecutar un modelo con distintos parámetros de entrada, esto se puede aprovechar para conseguir la propuesta
anterior. En este sentido, se han desarrollado las técnicas que permiten al entorno
paralelo reconfigurar un modelo en ejecución para que simule una configuración
diferente de parámetros de entrada.
Como demuestran los resultados del capítulo 4, la aplicación de la técnica de precalentamiento, una discreta eliminación de muestras iniciales, un tamaño de extracción suficientemente grande y el criterio de parada combinado propuesto, proporcionan un analizador paralelo bastante robusto desde el punto de vista estadístico y con
una alta escalabilidad paralela.
En el capítulo 5 se evalúan estrategias de reparto de réplicas en experimentos con
varios puntos de carga (configuraciones de entrada) aplicados a un complejo modelo
de SAN. Los resultados muestran que la aproximación paralela puede ser mejor que
la secuencial incluso si se pretende simular varios puntos y se toma la estrategia de
simular secuencialmente cada punto en una máquina diferente al mismo tiempo.
216
Conclusiones
En definitiva, las técnicas propuestas y su implementación práctica posibilitan el
aprovechamiento de computadores heterogéneos para la realización masiva de experimentos de simulación en paralelo, permitiendo una notable reducción del tiempo de
respuesta de los experimentos. Ajustándose a uno de los criterios de diseño propuestos, la aplicación de las técnicas es sencilla y extensible, en principio, a cualquier
lenguaje de simulación por eventos discretos, con lo que el modelador puede aprovechar fácilmente las nuevas ventajas y olvidarse del problema del análisis estadístico
de salida.
6.2
Publicaciones
Se detallan a continuación las publicaciones en las que se han difundido las principales aportaciones de esta tesis.
•
Perles, A., Martí, A., Serrano, J.J. Clustered simulation experimenter: A tool
for concurrent simulation execution on loosely coupled workstations. Proceedings 13th European Simulation Multiconference. Society for Computer Simulation International. pp: 207-214. 1999
•
Perles, A., Martí, A., Serrano, J.J. Reparto de experimentos de simulacion en
redes hetereógeneas de estaciones de trabajo. Actas del Simposio Español de
Informática Distribuida. pp: 213-219. 1999
•
Perles, A., Molero, X., Martí, A., Santonja, V., Serrano, J.J., Improving the
simulation of Storage Area Networks (SAN) using concurrent execution.
Proceedings 12th European Simulation Symposium. Society for Computer
Simulation International. pp: 149-153. 2000
•
Perles, A., Molero, X., Martí, A., Santonja, V., Serrano, J.J. Simulación concurrente de redes de almacenamiento de altas prestaciones (SAN, Storage
Area Networks). Actas del Simposio Español de Informática Distribuida
(SEID’2000). pp: 483-493. 2000
•
Perles, A., Molero, X., Martí, A., Santonja, V., Serrano, J.J., Improving the
execution of groups of simulations on a cluster o workstations and its application to Storage Area Networks. Proceedings of the 34th Annual Simulation
Symposium. IEEE Computer Society. pp: 227-234. 2002
Líneas de investigación abiertas
217
•
Perles, A., Molero, X., Martí, A., Serrano, J.J. Analysis of coverage and performance of the variable sized replications simulation method in parallel.
Proceedings of the16th European Simulation Multiconference. pp: 219-223.
2002
•
Perles, A., Molero, X., Martí, A., Serrano, J.J. Analysis of new proposals for
parallel replication based discrete-event simulation. Proceedings 2003 Industrial Simulation Conference. EUROSIS. pp: 103-110. 2003
6.3
Líneas de investigación abiertas
Dos son las líneas principales que se pueden seguir en un futuro:
•
Mejorar los aspectos relacionados con el análisis estadístico de los datos de
salida de las réplicas.
•
Optimizar algunos aspectos relacionados con la gestión de los procesos en el
cluster.
El análisis estadístico de los datos de salida debe ser la primera línea de trabajo a
seguir, pues es la que garantiza, en última instancia, la calidad de los estimadores de
las variables de salida.
En este sentido, cabe resaltar un punto débil del mecanismo de instrumentación
de las réplicas paralelas. Los modelos transfieren al monitor la media ponderada de
las observaciones recogidas hasta el momento. Esta forma de trabajar tiene la ventaja
de la poca cantidad de información a transferir entre procesos, pero presenta la contrapartida de que se pierde la riqueza que supone transferir todas las observaciones al
monitor, permitiendo realizar un análisis estadístico mucho más potente. Como resultado de la aproximación realizada, el proceso monitor recibe una media actualizada que es cada vez más suave según se incorporan datos y que imposibilita separar el
efecto de distintas tandas de observaciones. Una consecuencia importante en el método de las réplicas independientes es la imposibilidad de detectar automáticamente
qué muestras iniciales están sesgadas y eliminarlas para disminuir su efecto en la
estimación de la media.
La primera propuesta a investigar pasa por estudiar la posibilidad de que el mecanismo de instrumentación recoja información en forma de lotes, los cuales se calculan promediando una secuencia ordenada de observaciones. Así, por ejemplo, una
218
Conclusiones
réplica paralela puede dividir la secuencia de N observaciones en L lotes de tamaño
M, y remitir al monitor la media de cada lote, con lo que la cantidad de información a
transmitir se puede mantener arbitrariamente baja. Además, se cumple que la media
de las observaciones generadas por la réplica es igual a la media de los promedios de
los lotes, por lo que se siguen pudiendo aplicar directamente las propuestas hechas en
este trabajo. Si el monitor almacena la información de cada lote, es posible realizar
análisis estadísticos más potentes; por ejemplo, es posible la aplicación de heurísticos
para intentar la detección y eliminación automática del transitorio inicial. Parece
plausible que, aplicando ideas propuestas en [Fishman 2.001], [Vassilacopoulos
1.989], [Welch 1.983] y [Gafarian et al. 1.978], se pueda aumentar cualitativamente
la potencia del método de análisis basado en réplicas independientes, optimizándose
la eliminación del transitorio inicial.
La idea de implementar un sistema de lotes facilita la construcción de otros analizadores estadísticos. Por ejemplo, sería inmediato desarrollar un analizador por lotes
(batch-means) con la ventaja de que los lotes entre réplicas son independientes y, por
tanto, de mayor calidad que en la versión secuencial.
Por otro lado, cuando se emplean máquinas con distinta potencia lo habitual es
que unas réplicas sean más rápidas que otras, generando más observaciones. Una
segunda línea de trabajo intentaría mejorar el método de análisis estadístico para lograr estimadores de la esperanza y el intervalo de confianza en estos casos. Aunque
no se ha comentado en la presente tesis, se ha intentado lograr un método robusto
para estimar el intervalo de confianza en estos casos aplicando la estadística empleada en el método de las regeneraciones. El problema radica en que la estimación del
intervalo necesita una cantidad grande de ciclos regenerativos para suponer la normalidad, lo cual no es cierto en nuestro caso, pues el número de réplicas independientes suele ser relativamente bajo. A pesar de este problema, en [Mota et al. 1.998]
se aplica esta misma idea reforzándola con mecanismos adicionales, aunque el razonamiento no se ha demostrado teóricamente.
Una vez mejorados los mecanismos de análisis estadístico se puede trabajar la línea de la gestión de los procesos concurrentes. En este sentido, CSX está construido
mediante PVM, entorno de computación distribuida que, junto a MPI, se emplea en
interesantes arquitecturas Beowulf de 1ª generación (multicomputadores construidos
con ordenadores PC). Las herramientas paralelas para entornos Beowulf de 2º generación [Otero y Ferri 2002] están evolucionando rápidamente, sobre todo bajo el sistema operativo Linux, con lo que se dispone de plataformas ideales para dar un salto
Líneas de investigación abiertas
219
hacia adelante en la gestión de los procesos. El diseño de la herramienta ya se ha
hecho pensando en esta posibilidad, facilitando esta migración.
Los aspectos de gestión del entorno paralelo de simulación se deben centrar en
facilitar la gestión dinámica de los procesos (se han realizado experiencias con el
lenguaje Java, agentes inteligentes y Corba), garantizando la seguridad y confidencialidad de los datos contenidos en los computadores que los usuarios ceden a CSX
para la ejecución de simulaciones de terceras personas, y la aplicación de técnicas de
garantía de funcionamiento con el fin de asegurar la disponibilidad del entorno a pesar de las posibles pérdidas inesperadas de algunas máquinas.
1. Bibliografía
1
Bibliografía
1.1 Bibliografía
[Adam 1983] Adam, N. R. Achieving a confidence interval for parameters estimated
by simulation. Management Science. vol. 29. no. 7. pp: 856-866. July 1983
[Alexopoulos y Kim 2002] Alexopoulos, Ch., Kim, S-H. Output analysis for simulations. Proceedings of the 2002 Winter Simulation Conference. pp: 85-96.
2002
[Ayani 1989] Ayani, R. A parallel simulation scheme based on the distance between
objects. Proceedings of the SCS Multiconference on Distributed Simulation.
21, 2 pp: 113-118. March 1989
[Azadivar 1999] Azadivar, F. Simulation optimization methodologies. Proceedings
of the 1999 Winter Simulation Conference. pp: 93-100. 1999
[Bain y Scott 1988] Bain, W. L., Scott, D. S. An algorithm for time synchronization
in distributed discrete event simulation. Proceedings of the SCS Multiconference on Distributed Simulation. 19, 3. pp: 30-33. July 1988
[Bauer y Wilson 1989] Bauer, K. W. Jr., Wilson, J. R. Control-variate selection criteria, SMS 89-13. School of Industrial Engineering. Purdue University, West
Lafayette. 1989
[Bagrodia y Lio 1995] Bagrodia, R. L., Lio, W. –T. Maisie user manual, release 2.2.
UCLA Parallel Computing Lab. 1995
[Bagrodia 1996] Bagrodia, R. L. Perils and pitfalls of parallel discrete-event simulation. Proceedings 1996 Winter Simulation Conference. pp: 136-143. 1996
[Bhavsar e Isaac 1987] Bhavsar, V. C., Isaac, J. R. Design and analysis of parallel
Monte-Carlo algorithms. SIAM Journal on Scientific and Statistical Computing. 8. 73-95. 1987
[Biles et al. 1985] Biles, W. E., Daniels, D. M., O’Donell, T. J. Statistical considerations in simulation on a network of microcomputers. Proceedings 1985
Winter Simulation Conference. pp: 388-392. 1985
[Bryan 1977] Bryan, R. E. Simulation of packet communications architecture computer systems. MIT-LCS-TR-188- Massachusetts Institute of Technology.
1977
222
Bibliografía
[Bühlman y Künsch 1999] Bühlmann, P., Künsch, H. R. Block length selection in the
bootstrap for time series. Computational Statistics and Data Analysis 31,
pp: 295-310. 1999
[Carothers et al. 1999] Carothers, C. D., Perumalla, K. S., Fujimoto, R. M. Efficient
optimistic parallel simulations using reverse computation. ACM Transactions on Modelling and Computer Simulation. vol. 9 n.2 pp: 224-253. July
1999
[Casas et al. 1995] Casas, J., Clark, D., Konuru, R., Otto, S., Prouty, R., Walk Pole,
J. MPVM: A migration transparent version of PVM, Technical Report 95002, Oregon Graduate Institute of Science and Technology, Department of
Computer Science and Engineering, February 1995
[Comfort y Gopal 1988] Comfort, J. C., Gopal, R. R. Environment partitioned distributed simulation with transputers. Proceedings of the SCS Multiconference on Distributed Simulation. pp: 103-108. July 1988
[Cota y Sargent 1988] Cota, B., Sargent, R. A discrete event simulator with shared
memory. Proceedings of the SCS Multiconference on Distributed Simulation. July 1988
[Crane e Iglehart 1974a] Crane, M. A., Iglehart, D. L. Simulating estable stochastic
systems, I: General multiserver queues. Journal of the ACM. vol. 21. pp:
103-113. 1974
[Crane e Iglehart 1974b] Crane, M. A., Iglehart, D. L. Simulating estable stochastic
systems, II: Markov chains. Journal of the Association Computer Machines.
vol. 21. pp: 114-123. 1974
[Crane e Iglehart 1975] Crane, M. A., Iglehart, D. L. Simulating estable stochastic
systems, III: Regenerative processes and discrete event simulations. Operations Research. vol. 23. pp: 33-45. 1975
[CSIM 1998] User's guide: CSIM18 Simulation Engine (C version). Mesquite Software, Inc. 1998
[Chandy y Misra 1979] Chandy, K. M., Misra, J. Distributed simulation: a case study
in the design and verification of distributed programs. IEEE Transsaccions
on Software Engineering. SE-5, 5 pp: 440-452. September 1979
[Chandy y Misra 1981] Chandy, K. M., Misra, J. Asynchronous distributed simulation via a sequence of parallel computations. Communications of the ACM.
24,11 pp: 198-205. November 1981
[Chen y Sargent 1986] Chen, B., Sargent, G. Using standarized time series to estimate confidence intervals for the difference between two stationary stochastic processes. Operations Research. vol. 35 n. 3 pp:428-436. 1986
[Chen y Sargent 1990] Chen, B., Sargent, G. Asymptotic variance estimation for
stationary processes. Management Science, Vol. 36, No. 2 pp: 200-211.
1990
[Chen y Kelton 2000] Chen, E. J., Kelton, W. D. Mean estimation based on phimixing sequences. IEEE-SCS Proceedings of the 33rd Annual Simulation
Symposium. pp:237-244. 2000
Bibliografía
223
[Dado et. al. 1992] Dado, B., Menhart, P., Safarik, J. Distributed simulation: A
simulation system for discrete event systems. International Conference on
Decentralized and Distributed Systems. pp: 263-273. 1992
[Damerdji 1991] Damerdji, H. Strong consistency and others properties of the spectral variance estimator. Management Science. n. 37 pp: 1424-1440. 1991
[Damerdji y Henderson 1997] Damerdji, H., Henderson, S. G. Computational efficiency evaluation in output analysis. Proceedings of the 1997 Winter Simulation Conference. 1997
[Das et al. 1994] Das, S., Fujimoto, R. M., Panesar, K., Allison, D., Hybinette, M.
GTW: A Time Warp system for shared memory multiprocessors. Proceedings of the 1994 Winter Simulaciont Conference. pp: 1332-1339. 1994
[Deslandres y Pierreval 1991] Deslandres, V., Pierreval, H. An expert system prototype assisting the statistical validation of simulation models. Simulation.
vol. 56 n. 2 pp: 79-89. February 1991
[Dikken et al 1994] Dikken, L., Linden, F., Vesseur, J., Sloot, P. Dynamic PVM.
Dynamic load balancing on parallel systems,. High-Performance Computing
and Networking, proceedings, vol. 797 pp. 273-277. 1994
[Dickens y Reynolds 1990] Dickens, P. M., Reynolds Jr, P. F. SRADS with local
rollback. Proceedings of the SCS Multiconference on Distributed Simulation. 22,1 pp: 161-164. January 1990
[Edward et al. 1995] Mascarenhas, E., Knop, F., Rego, V. ParaSol: A multithreaded
system for parallel simulaton based on mobile threads. Proceedings of the
1995 Winter Simulation Conference. pp:690-697. 1995
[Falsafi y Wood 1997] Falsafi, B., Wood, D. A. Modelling cost/performance of a
parallel computer simulation. ACM Transactions on Modelling and Computer Simulation. vol. 7 n. 1 pp: 104-130. January 1997
[Farley 2000] Farley, M. Building storage area networks. McGraw-Hill, 2000
[Fishman 1971] Fishman, G. S. Estimating sample size in computer simulation experiments. Management Science. vol. 18 pp: 21-38. 1971
[Fishman 1973] Fishman, G. S. Statistical analysis for queueing simulations. Management Science. vol. 20 pp: 363-369. 1973
[Fishman 1973b] Fishman, G. S. Concepts and methods in discrete event digital
simulation. John Wiley. Ney York. 1973
[Fishman 1974] Fishman, G. S. Estimation in multiserver queueing simulations. Operations Research. vol. 22 pp:72-78. 1974
[Fishman 1977] Fishman, G. S. Achieving specific accuracy in simulation output
analysis. Communications of the ACM. vol. 20 n. 5 pp: 310-315. May 1977.
[Fishman 1978] Fishman, G. S. Grouping observations in digital simulation. Management Science. vol. 24. pp: 510-521. 1978
[Fishman y Yarberry 1994] Fishman, G. S., Yarberry, L. S. An implementation of
the batch means method. Technical report UNC/OR/TR-93/1. Department of
Operations Research. University of North Carolina al Chapel Hill. 1994
224
Bibliografía
[Fishman 2001] Fishman, G. S. Discrete-event simulation. Ed. Springer-Verlag. New
York. 2001
[Fox et al. 1991] Fox, B. L., Goldsman, D., Swain, J. J. Spaced batch means. Operations Research. vol. 10. pp: 255-263. 1991
[Fujimoto 1989] Fujimoto, R. M. Performance measurements of distributed simulation strategies. Transactions of the SCS. 6, 2, pp:89-132. April 1989
[Fujimoto 1990] Fujimoto, R. M. Parallel discrete event simulation. Communications
of the ACM. vol. 33. n. 10, pp:30-53. October 1990
[Fujimoto 1993] Fujimoto, R. M. Parallel discrete event simulation: Will the field
survive? ORSA Journal of Computing. 5,3 pp: 213-230. 1993
[Fujimoto 2000] Fujimoto, R. M. Parallel and distributed simulation systems. John
Wiley. 2000
[Gafarian et al. 1978] Gafarian, A. V., Anker, C. J. Jr., Morisaku, F. Evaluation of
commonly used rules for detecting “steady-state” in computer simulation.
Naval Research Logistics Quaterly. vol. 25 pp: 511-529. 1978
[Gafni 1988] Gafni, A. Roll-back mechanisms for optimistic distributed simulation.
Proceedings of the SCS Muticonference on Distributed Simulation. 19,3 pp:
61-67. July 1968
[Gallagher et al. 1996] Gallagher, M. A., Bauer, K. W. Jr., Maybeck, P. S. Initial
data truncation for univariate output of discrete-event simulations using the
kalman filter. Management Science. vol. 42 pp: 559-575. 1996
[Geist et al. 1994] Geist, A., Beguelin, A., Dongarra, J., Jiang, W., Manchek, R.,
Sunderam, V. PVM3 user's guide and reference manual, Technical Report
ORNL/TM-12187, Oak Ridge National Laboratory, May 1994
[Ghosh et al. 1994] Ghosh, K., Panesar, K., Fujimoto, R. M., Schwan, K. PORTS: A
parallel, optimistic, real-time simulator. Proceedings of the 8th Workshop on
Parallel and Distributed Simulation. pp: 24-31. 1994
[Glynn 1987] Glynn, P.W. Limit theorems for the method of replication. Communications Statist. Stochastic Models. vol. 3 pp: 343-355. 1987
[Glynn y Heidelberger 1991] Glynn, P. W., Heidelberger, P. Analysis of parallel
replicated simulations under a completion time constraint. ACM Transactions on Modelling and Computer Simulation. vol. 1 n. 1 pp: 3-23. January
1991
[Glynn y Heidelberger 1992] Glynn, P. W., Heidelberger, P. Analysis of initial transient eletion for parallel steady-steate simulations. SIAM Journal Sci. Stat.
Comput. vol. 13 n. 4 pp: 904-922. July 1992
[Glynn y Heidelberger 1992b] Glynn, P. W., Heidelberger, P. Experiments with initial transient deletion for parallel replicated steady-state simulations. Management Science. 38. pp: 400-418. 1992
[Glynn y Whitt 1992] Glynn, P. W., Whitt, W. The asymptotic efficiency of simulation estimators. Operations Research. vol. 40 n. 3 pp: 505-520. May-June
1992
[Glynn e Iglehart 1993] Glynn, P. W. Iglehart, D. L. Conditions for the applicability
of regenerative method. Management Science. vol. 39 pp: 1108-1111. 1993
Bibliografía
225
[Glynn 1995] Glynn, P. W. Some new results on the initial transient problem. Proceedings of the 1995 Winter Simulation Conference. pp:165-170. 1995
[Goldsman et al. 1990] Goldsman, D., Meketon, M., Schruben, L. Properties of standardized time series wighted area variance estimators. Management Science.
vol. 36 n. 5 pp: 602-612. 1990
[Goldsman y Schruben 1990] Goldsman, D., Schruben, L. New confidence interval
estimators using standardized time series. Management Science. vol. 36 n. 3
pp: 393-397. 1990
[Goldsman y Kang 1991] Goldsman, D., Kang, K. Cramer-von Mises variance estimators for simulations. Proceedings of the 1991 Winter Simulation Conference. pp: 916-920. 1991
[Goldsman et al. 1994] Goldsman, D., Schruben, L., Swain J. J. Tests for transient
means in simulated time series. Naval Research Logistics. vol. 41, pp: 171187. 1994
[Goldsman y Tokol 2000] Goldsman, D., Tokol, G. Output analysis procedures for
computer simulations. Proceedings of the 2000 Winter Simulation Conference. pp: 39-45. 2000
[GTU 1994] CPSim 1.0. User’s guide and reference manual. Arlington. June 1994.
[Hammersley y Morton 1956] Hammersley, J. M. y Morton, K. W. A new Monte
Carlo technique: antithetic variables. Proc. Camb. Phil. Soc. vol 52, pp:
449-475. 1956
[Heidelberger y Welch 1981] Heidelberger, P., Welch, P. D. Adaptative spectral
methods for simulation output analysis. IBM J. res. development. vol. 25
pp: 860-876. 1981
[Heidelberger y Welch 1981b] Heidelberger, P., Welch, P. D. A spectral method for
confidence interval generation and run length control in simulations. Communications of the ACM. vol. 24 pp:233-245. 1981
[Heidelberger y Welch 1983] Heidelberger, P., Welch, P. D. Simulation run length
control in the presence of an initial transient. Operations Research. vol. 31
pp: 1109-1144. 1983
[Heidelberger 1983] Heidelberger, P. Statistical analysis of parallel simulations. Proceedings of the 1986 Winter Simulation Conference. pp: 290-295. 1983
[Heidelberger 1988] Heidelberger, P. Discrete event simulations and parallel processing: Statistical properties. SIAM J. Sci. Stat. Comput. 9 pp: 1114-1132.
1988
[Howard et al. 1992] Howard, R. B., Gallagher, M. A., Bauer Jr., K. W., Maybeck, P.
S. Confidence intervals for univariate discrete-event simulation output using
the Kalman filter. Proceedings of the 1992 Winter Simulation Conference.
pp:586-593. 1992
[Iglehart y Lewis 1979] Iglehart, D. L., Lewis, P. A. Regenerative simulation with
internals controls. Journal of the ACM. vol 26 n. 2 pp: 271-282. April 1979
[Jain 1991] Jain, R. The art of computer systems performance analysis. techniques
for experimental design, measurement, simulation and modeling. John
Wiley & Sons, Inc. 1991
226
Bibliografía
[Jefferson 1985] Jefferson, D. R. Virtual time. ACM Transactions on Programming
Languages and Systems. 7,3 pp: 404-425. July 1985
[Katsaros y Lazos 2000] Katsaros, P., Lazos, L. Regenerative queuing network distributed simulation. Proceedings of the European Simulation Multiconference. pp: 108-113. 2000
[Kelton y Law 1983] Kelton W. D., Law, A. M. A new approach for dealing with the
startup problem in discrete event simulation. Naval Research Logistics
Quaterly. vol. 30, pp: 641-658. 1983
[Kelton y Law 1985] Kelton, W. D., Law, A. M. The transient behaviour of the
M/M/s queue with implications for steady-state simulation. Operations Reseach. 33 pp: 378-396. 1985
[Kelton 1985] Kelton, W. D. Transient exponential-Erlang queues and steady-state
simulation. Communications of the ACM. vol. 28 n. 7 pp: 741-749. July
1985
[Kelton 1986] Kelton W. D. Replication splitting and variance for simulating discrete-parameter stochastic processes. Operations Research Letters. vol. 4.
pp: 275-279. 1986
[Kelton 1989] Kelton, W. D. Random initialization methods in simulation. IEEE
Transactions. vol. 21 pp: 355-367. 1989
[Knop et al. 1994] Knop, F., Rego, V., Sunderam, V., Ferrari, A. Failure resilient
computation in the EcliPSe system. Proceedings of the International Conference on Parallel Processing. 1994
[Knop et al. 1994b] Knop, F. Mascarenhas, E., Rego, V., Sunderam, V. S. An introduction to fault tolerant parallel simulation with EcliPSe. Proceedings of the
1994 Winter Simulation Conference. pp: 700-707. 1994
[Knop et al. 1995] Knop, F., Mascarenhas, E., Rego, V. Concurrent and fail-safe
replicated simulations on heterogeneous networks: An introduction to
EcliPSe. Simulation Practice and Theory. 3 pp: 121-146. 1995
[Knop et al. 1996] Knop, F., Mascarenhas, E., Rego, V. A parallel GPSS based on
ParaSol simulation system. Proceedings of the 1996 Winter Simulation
Conference. pp: 801-808. 1996
[Knuth 1997] Knuth D. E. The Art of Computer Programming, Volume 2: Seminumerical Algorithms. Third ed. Reading Mass.: Addison-Wesley. 1997
[Kolawa 1991] Kolawa, A. The Express programming environment. Workshop on
Heterogeneous Network-Based Concurrent Computing. Tallahassee, October 1991
[Krishnamurthi et al 1985] Krishnamurthi, M., Chandrasekaran, U., Sheppard, S.
Two approaches to the implementationof a distributed simulation system.
Proceedings of the 1985 Winter Simulation Conference. pp: 435-443. 1985
[Lazowska et al. 1984] Lazowska, E. D., Zahorjan, J., Graham, G. S., Sevcik, K. C.
Quantitative System Performance. Computer System Analysis Using
Queueing Networks Models. Prentice-Hall. 1984.
Bibliografía
227
[Law 1977] Law, A. M. Confidence Intervals in Discrete Event Simulation: a Comparison of Replication and Batch means. Naval Research Logistics Quaterly. vol. 24, pp: 667-678, 1977
[Law 1983] Law, A. M. Statistical analysis of simulation output data. Operations
Research. vol. 31, num. 6, pp: 983-1029, 1983
[Law y Carson 1979] Law, A. M., Carson, J. S. A sequential procedure for determining the length of steady-state simulation. Operations Research. vol. 27.
pp: 1011-1025. 1979
[Law y Kelton 1984] Law, A. M., Kelton, W. D. Confidence intervals for steadystate simulations: I. A survey of fixed sample size procedures. Operations
Research. vol. 32 n. 6 pp:1221-1239. December 1984
[Law y Kelton 2000] Law A. M., Kelton W. D. Simulation Modeling and Analysis.
Ed. McGraw-Hill. 2000
[Lawrence y Lewis 1981] Lawrence, A. J., Lewis, P. A. W. A new autorregressive
timeseries model in exponential random variables (NEAR(1)). Adv. Appl.
Probab. 13, 826-845. 1981
[L'Ecuyer 1990] L'Ecuyer, P. Random numbers for simulation. Communications of
the ACM. vol. 33 n. 10. pp: 85-97 October 1990
[L'Ecuyer y Hellekalek 1998] L'Ecuyer, P. and Hellekalek, P. Random number generators: Selection criteria and testing. Random and Quasi-Random Point
Sets. Lecture Notes in Statistics. vol. 138, pp; 223-265. New York, Springer.
1998
[L'Ecuyer 1999] L'Ecuyer, P. Some recomendable uniform random number generators. Proceedings of the 13th European Simulation Multiconference. vol. 2
pp: 185-190. May 1999.
[Lee et al. 1998] Lee, J., McNickle, D., Pawlikowski, K. A survey of confidence interval formulae for coverage analysis. Technical report TR-COSC 04/98.
Department of Computer Science. University of Canterbury. Christchurch.
New Zealand. 1998
[Lee 1999] Sequential regenerative simulation. Technical report TR-COSC 02/99.
Department of Computer Science. University of Canterbury. Christchurch.
New Zealand. May 1999
[Lencse 1998] Lencse, G. Efficient parallel simulation with the statistical synchronization method. Western Multiconference. Communications and Distributed
Systems (CNDS’98). 1998
[Lin 1994] Lin, Y-B. Parallel independent replicated simulation on a network of
workstations. Proceedings of the 8th Workshop on Parallel and Distributed
Simulation (PADS'94). vol. 24 n. 1. pp: 73-80. July 1994
[Lin y Fishwick 1996] Lin, Y-B., Fishwick, P. A. Asynchronous parallel discrete
event simulation. IEEE Transactions on Systems, Man and Cybernetics. vol.
26 n. 4. pp: 397-412. 1996
[Liu y Tropper 1990] Liu, L. Z., Tropper, C. Local deadlock detection in distributed
simulation. Proceedings of the SCS Multiconference on Distributed Simulation. 22,1 pp:64-69. January 1990
228
Bibliografía
[Lomow et al. 1988] Lomow, G., Cleary, J., Unger, B., West, D. A performance
study of time warp. Proceedings of the SCS Muticonference on Distributed
Simulation. 19,3 pp: 50-55. July 1988
[Loucks y Preiss 1990] Loucks, W.M., Preiss, B. R. The role of knowledge in distributed simulation. Proceedings of the SCS Multiconference on Distributed
Simulation. 22,1 pp: 9-16. January 1990
[Low et al. 1999] Low, Y-H., Lim, Ch., Cai, W., Huang, S-Y., Hsu, W-J., Jain, S.,
Turner, S. Survey of languages and runtime libraries for parallel discreteevent simulation. Simulation. 72, 3 pp: 170-189. 1999
[Lubachevsky 1989] Lubachevsky, B. D. Efficient distributed event-driven simulations of multiple-loop networks. Communications of the ACM. vol 32. n.1
pp: 111-123. 1989
[Lubachevsky 1989b] Lubachevsky, B. D. Scalability of the bounded lag distributed
discrete-event simulation. Proceedings of the SCS Multiconference on Distributed Simulation. 21, 2 pp: 100-107. March 1989
[Lubachevsky et al. 1989] Lubachevsky, B. D., Shwartz, A., Weiss, A. Roll-back
sometimes work ... if filtered. Proceedings of 1989 Winter Simulation Conference. pp: 630-639. Decembre 1989
[MacDougall 1987] MacDougall, M. H. Simulating Computer Systems. The MIT
Press, Cambridge, Massachusetts. 1987
[Madisetti et al. 1988] Madisetti, V., Walrand, J., Messerschmitt, D. Wolf: a rollback algorithm for optimistic distributed simulation systems. Proceedings of
1988 Winter Simulation Conference. pp: 296-305. December 1988
[Mascarenhas et al. 1995] Mascarenhas, E., Knop, F., Rego, V. ParaSol: A multithreaded system for parallel simulation based on mobile threads. Proceedings of the 1995 Winter Simulation Conference. pp: 690-697. 1995
[Mattson et al. 1992] Mattson, T., Bjornson, B., Kaminsky, D. The C-Linda Language for Networks of Workstations. Proceedings of the Workshop on
Cluster Computing. 1992
[McGeoch 1992] McGeoch, C. Analyzing algorithms by simulation: Variance reduction techniques and simulation speedups. ACM Computing Surveys. vol.
24 n. 2 June 1992
[McNickle et al. 1996] McNickle, D. C., Pawlikowski, K., Ewing, G. Experimental
evaluation of confidence interval procedures in sequential steady-state
simulation. Proceedings of the 1996 Winter Simulation Conference. pp:
382-389. 1996
[Meketon y Schmeiser 1984] Meketon, M., Schmeiser, B. Overlapping batch means:
something for nothing. Proceedings of the Winter Simulation Conference.
pp: 227-230. 1984
[Merrifield et al. 1990] Merrifield, B. C., Richardson, S. B., Roberts, J. B. G. Quantitative studies of discrete event simulation modelling of road traffic. Proceedings of the SCS Multiconference on Distributed Simulation. 22,1 pp:
188-193. January 1990
Bibliografía
229
[Miller 1999] Miller, N. Improved batching for confidence construction in steadystate simulation. Ph.D. Thesis. North Carolina State University. 1999
[Misra 1986] Misra, J. Distributed discrete-event simulation. ACM Computer Surveys. 18,1 pp: 39-65. March 1986
[Molero et al. 2000] Molero, X., Silla, F., Santonja, V., Duato, J. Modeling and
simulation of storage area networks. Proceedings of the 8th International
Symposium on Modelling Analysis and Simulation of Computer and Telecommunications Systems. IEEE Society Press. August 2000.
[Mota et al. 1998] Mota, E., Wolisz, A., Pawlikowski, K. Experinece with
AKAROA: Speeding up stochastic simulation using parallel replications.
Proceedings of the High-Performance Computing. pp: 296-301. 1998
[Mota et al 2000] Mota, E., Fitzek, F., Wolisz, A. Towards credible and efficient
network simulation experiments. Proceedings of High-Performance Computing. pp: 116-121. 2000
[Mota et al 2000b] Mota, E., Wolisz, A., Pawlikowski, K. Comparing overlaping
batch means and standardized time series under multiple replications in parallel. Proceedings of the 12th European Simulation Multiconference. pp: 4348 2000
[Mota et al 2000c] Mota, E., Wolisz, A., Pawlikowski, K. A perspective of batching
methods in a simulation environment of multiple replications in parallel.
Proceedings of the 2000 Winter Simulation Conference. pp: 761-766. 2000
[MPI 1994] MPI: A Message-Passing Interface Standard. University of Tennessee,
Knoxville, May 1994
[Murray y Kelton 1988] Murray, J., Kelton, W. D. Initializing for bias reduction:
some analytical considerations. Proceedings of the 1988 Winter Simulation
Conference. pp: 546-548. 1988
[Nakayama 1994] Nakayama, M. K. Two-stage stopping procedures based on standardized time series. Management Science 40, pp: 1189-1206. 1994
[Nakayama 1996] Nakayama, M. K. Multiple comparisons with the best using common random numbers for stead-state simulations. Proceedings Second St.
Petersburg Workshop on Mathematical Methods in Stochastic Simulation
and Experimental Design. pp: 230-235. 1996
[Nicol y Reynolds 1984] Nicol, D. M., Reynolds, P. F. Jr., Problem oriented protocol
design. Proceedings of 1984 Winter Simulation Conference. pp: 471-474.
December 1984
[Nicol 1989] Nicol, D. M. The cost of conservative synchronization in parallel discrete-event simulations. Tech. rep.90-20 ICASE. June 1989
[Nicol 1991] Nicol, D. M. Performance bounds on parallel self-initiating discreteevent simulations. ACM Transactions on Modelling and Computer Simulation. vol. 1 n. 1 pp: 24-50. 1991
[Nicol y Fujimoto 1994] Nicol, D., Fujimoto, R. Parallel simulation today. Annals of
Operations Research. 53 pp: 249-286 1994
[Nicol 1995] Nicol, D. M. Noncommital barrier syncronization. Parallel computing.
21 pp: 529-549. 1995
230
Bibliografía
[Nicol y Heidelberger 1996] Nicol, D., Heidelberger, P. Parallel execution for serial
simulators. ACM Transactions on Modelling and Computer Simulation. vol.
6 n. 3 pp: 210-242. 1996
[Ockerman y Goldsman 1997] Ockerman, D. H., Goldsman, D. The impact of transients on simulation variance estimators. Proceedings of the 1997 Winter
Simulation Conference. pp: 234-239. 1997
[Otero y Ferri 2002] Otero, G., Ferri, R. The Beowulf evolution. Linux Journal. pp:
108-113. August 2002
[Owicki y Karlin 1992] Owicki, S. S., Karlin, A. R. Factors in the performance of the
AN1 computer network. Digital SRC research report 88. June 1992
[Pawlikowski 1990] Pawlikowski, K. Steady-state simulation of queueing processes:
A survey of problems and solutions. ACM computing surveys. vol. 22 n. 2
pp: 123-170. 1990
[Pawlikowski et al. 1994] Pawlikowski, K., Yau, V., McNickle, D. Distributed stochastic discrete-event simulation in parallel time streams. Proceedings of
the 1994 Winter Simulation Conference. pp: 723-730. 1994
[Perles 1994] Perles, A., Serrano, J. Evaluación y análisis de PVM 3. Aprovechamiento para la simulación discreta por el método de réplicas. Proyecto
fin de carrera. Diciembre 1994
[Perles 1997] Perles, A. Simulación paralela y distribuida. Métodos de análisis
estadístico de la salida. Trabajo de doctorado de dos créditos. Departamento
DISCA. Universidad Politécnica de Valencia. 1997
[Perles 1998] Perles, A. Simulación paralela y distribuida. El entorno CSX: aprovechamiento de clusters de máquinas heterogéneas para acelerar simulaciones discretas. Trabajo de doctorado de seis créditos. Departamento DISCA.
Universidad Politécnica de Valencia. 1998
[Perles et. al. 1999] Perles, A., Martí, A., Serrano, J.J. Clustered simulation experimenter: A tool for concurrent simulation execution on loosely coupled
workstations. Proceedings 13th European Simulation Multiconference. Society for Computer Simulation International. pp: 207-214. 1999
[Perles et. al. 1999] Perles, A., Martí, A., Serrano, J.J. Reparto de experimentos de
simulacion en redes hetereógeneas de estaciones de trabajo. Actas del Simposio Español de Informática Distribuida. pp: 213-219. 1999
[Perles et. al. 2000] Perles, A., Molero, X., Martí, A., Santonja, V., Serrano, J.J., Improving the simulation of Storage Area Networks (SAN) using concurrent
execution. Proceedings 12th European Simulation Symposium. Society for
Computer Simulation International. pp: 149-153. 2000
[Perles et. al. 2000b] Perles, A., Molero, X., Martí, A., Santonja, V., Serrano, J.J.
Simulación concurrente de redes de almacenamiento de altas prestaciones
(SAN, Storage Area Networks). Actas del Simposio Español de Informática
Distribuida (SEID’2000). pp: 483-493. 2000
[Perles et. al. 2002] Perles, A., Molero, X., Martí, A., Santonja, V., Serrano, J.J., Improving the execution of groups of simulations on a cluster o workstations
Bibliografía
231
and its application to storage area networks. Proceedings of the 34th Annual
Simulation Symposium. IEEE Computer Society. pp: 227-234. 2002
[Perles et al. 2002b] Perles, A., Molero, X., Martí, A., Serrano, J.J. Analysis of coverage and performance of the variable sized replications simulation method
in parallel. Proceedings of the16th European Simulation Multiconference.
pp: 219-223. 2002
[Perles et. al. 2003] Perles, A., Molero, X., Martí, A., Serrano, J.J. Analysis of new
proposals for parallel replication based discrete-event simulation. Proceedings 2003 Industrial Simulation Conference. EUROSIS. pp: 103-110. 2003
[Pollatscheck 1995] Pollatscheck, M.A. Programming Discrete Simulations. R&D
Books, 1995
[Preiss 1989] Preiss, B. R. The Yaddes distributed discrete event simulation specification language and execution environments. SCS Distributed simulation.
vol. 21 1989
[Pruyne et al. 1998] Pruyne, J., Livny, M. Managing Checkpoints for Parallel Programs, Dpt. of Computer Sciences. University of Wisconsin-Madison. 1998
[QNAP 1994] QNAP2 User’s Guide. Simulog, Jan 1994
[Raatikainen 1992] Raatikainen, K. Run length control using parallel spectral methods. Proceedings of the 1992 Winter Simulation Conference. pp: 594-602
December 1992.
[Raatikainen 1994] Raatikainen, K. E. Experimental evaluation of a parallel spectral
method for run length control in steady-state simulation. Report C-1994-4.
University of Helsinki. November 1994
[Reese 1985] Reese, R.M. A software development environment for distributed
simulation. Proceedings SCS Distributed Simulation Conference. pp: 37-40.
1985
[Rego y Sunderam 1992] Rego, V. J., Sunderam, V. S. Experiments in concurrent
stochastic simulation: The EcliPSe paradigm. Journal of Parallel and Distributed Computing. 14-1. pp: 66-84. 1992
[Reynolds 1988] Reynolds, P. A spectrum of options for parallel simulation. Proceedings of the 1988 Winter Simulation Conference. pp: 325-332. December
1988
[Rich y Michelsen 1991] An assessment of ModSim/TWOS parallel simulation environment. Proceedings of the 1991 Winter Simulation Conference. pp: 509518. 1991
[Righter y Walrand 1989] Righter, R., Walrand, J. C. Distributed simulation of discrete event systems. Proceedings of the IEEE 77,1 pp: 99-113. January 1989
[Rios et al. 1997] Ríos D., Ríos S., Martín J. Simulación. Métodos y aplicaciones.
Ed. Ra-Ma. 1997
[Sauer 1979] Sauer, S. H. Confidence intervals for queueing simulations of computer
systems. ACM Performance Evaluation Review. vol. 8 pp: 46-55. 1979
[Schmeiser 1982] Schmeiser, B. Batch size effects in the analysis of simulation output. Operations Research. vol. 30, pp: 569-590. 1982
232
Bibliografía
[Schruben 1982] Schruben, L. W. Detecting initialization bias in simulation output.
Operations Research. vol. 30 pp: 569-590. 1982
[Schruben 1983] Schruben, L. Confidence interval estimation using standardized
time series. Operations Research. vol. 31 pp: 1090-1108. 1983
[Schruben et al. 1983] Scruben, L. W., Singh, H., Tierney, L. Optimal tests for initialization bias in simulation output. Operations Research. vol. 31 pp: 11671178. 1983
[Shanker et al. 2000] Shanker, M. S., Padman, R., M. S., Kelton, W. D. Efficient
distributed simulation through dynamic load balancing. IEEE Transactions.
33 (Operations Engineering), special simulation issue. 2000.
[Sheppard et al 1988] Sheppard, S. V., Davis, C. K., Chandra, U. Parallel simulation
environments for multiprocessor architectures. Proceedings of the SCS
Multiconference on Distributed Simulation. pp: 109-114. July 1988
[Sherman 1990] Sherman, A.H. C-Linda Reference Manual. Scientific Computing
Associates,Inc. 1990
[Snell y Schruben 1985] Snell, M., Schruben, L. Weighting simulation data to reduce
initialization effects. IEEE Transactions. vol. 17, pp:254-363. 1985
[Sokol et al. 1988] Sokol, L. M., Briscoe, D. P., Wieland, A. P. MTW: a strategie for
scheduling discrete simulation events for concurrent execution. Proceedings
of the SCS Multiconference on Distributed Simulation. 19, 3 pp: 34-42. July
1988
[Sokol y Stucky 1990] Sokol, L. M., Stucky, B. K. MTW: experimental results for a
constrained optimistic scheduling paradigm. Proceedings of the SCS Multiconference on Distributed Simulation. 22, 1 pp: 169-173. 1990
[Song 1997] Song, J., Choo, H. K. Aplication-level load migration and its implementation on top of PVM. Concurrency - Practice and Experience. 9(1): pp:
1-19. 1997
[Sostaric et al. 1998] Sostaric, A., Gabor, M., Gygi, A. MTool: Performance Monitoring for Multiplatform Systems. Linux Journal. June 1998
[Steinman 1992] Steinman, J. S. SPEEDES: A unified approach to parallel simulation. Proceedings of the 1992 Workshop on Parallel and Distributed Simulation. pp: 75-83. 1992
[Su y Seitz 1989] Su, W. K., Seitz, C. L., Variants of the Chandy-Misra-Brayant distributed discrete-event simulation algorithm.
http://resolver.caltech.edu/CaltechCSTR:1988.cs-tr-88-22 1989
[Teo et al. 1996] Teo, Y. M., Tay, S. C., Kong, S. T. SPaDES: An environment for
structured parallel simulation. Technical report TR20/96. Department of Information Systems and Control and Computer Science. National University
of Singapore. 1996
[Tokol et al. 1997] Tokol, G., Goldsman, D., Ockerman, D. H., Swain, J. J. Standardized time series Lp-norm variance estimators for simulations. Management Science. 44, pp: 234-245. 1997
[Trotter y Tukey 1956] Trotter, H. Y., Tukey, J. Conditional Monte Carlo for normal
samples. Symposium on Monte Carlo Methods. Wiley. pp: 64-79. 1956
Bibliografía
233
[Tuffin 1997] Tuffin, B. Variance reduction applied to product-form multiclass
queuing networks. ACM Transactions on Modelling and Computer Simulation. vol. 7 n. 4 pp: 478-500. October 1997
[Turcotte 1993] Turcotte, L. A Survey of Software Environments for Exploiting Networked Computing Resources, Draft Report, Engineering Research Center
for Computational Field Simulations. Mississippi State, January 1993
[Vassilacopoulos 1989] Vassilacopoulos, G. Testing for initialization bias in simulation output. Simulation. vol. 52 pp: 151-153. 1989
[Wagner y Lazowska 1989] Wagner, D. B., Lazowska, E. D. Parallel simulation of
queueing networks: Limitations and potentials. Proceedings of the 1989
ACM SIGMETRICS and PERFORMANCE’89. 17,1 pp: 146-155. May 1989
[Welch 1983] Welch, P. D. The Statistical Analysis of Simulation Results. Computer
Performance Handbook. Academic Press. New York. pp: 268-328. 1983
[West 1988] West, D. Optimizing time warp: lazy roll-back and lazy reevaluation.
MS thesis University of Calgary. January 1988
[Wilson et al 1996] Wilson, L., Nicol, D. Experiments in Automated Load Balancing, Proceedings 10 Workshop on Parallel and Distributed Simulation
(PADS’96). May 1996
[Wonnacott y Bruce 1995] Wonnacott, P., Bruce, D. A prototype implementation of
APOSTLE, and its performance. Proceedings of the 1995 Summer Simulation Conference. 1995
[Yau 1999] Yau, V. Automating parallel simulation using parallel time streams.
ACM Transactions on Modeling and Computer Simulation. vol. 9. n. 2. pp:
171-201. April 1999
[Yau y Pawlikowski 2000] Yau, V., Pawlikowski, K. A parallel simulation methodology for speed-up and obtaining performance estimates with specific accuracy: Experiences of its application in studies of metropolitan area networks.
Simulation 75:4 pp: 221-224. October 2000
[Yuan y Nelson 1994] Yuan, M., Nelson, B. L. Autorregresive-output-analysis
method revisited. Annals of Operations Research. vol. 53. pp: 391-418.
1994
[Zarei 2000] Zarei, B. A taxonomic review of parallel discrete event simulation. Proceedings of the 12th European Simulation Symposium. pp: 61-76. September 2000