---------------------------------------------------------------------------
Simulador de relojes logicos - David Corrales A11072 / Pablo Rosales A13207

Curso de Sistemas Distribuidos - Francisco Torres Rojas
Maestría en Ciencias de la Computación - Universidad de Costa Rica
---------------------------------------------------------------------------

* Acerca de *
El simulador de relojes lógicos se divide en dos programas: 
 - generador: encargado de generar historias distribuidas.
 - relojes: responsable de estampar historias y comparar relojes lógicos.


* Consideraciones *
Las entradas de datos no se verifican (aunque sí se despliega el rango válido de datos). Esto para evitar complejidad innecesaria en el desarrollo de este trabajo.

Se utiliza el término -cadena- a través del código, para referirse a un sitio o nodo adonde ocurren eventos.

Todas las cadenas se inician con un proceso regular por defecto. Esto modela mejor la realidad (ningún programa podría tener un receive o send, sin antes haber realizado su proceso de inicialización), y además facilita el proceso de la creación de historias.

Debido al gran tamaño que ocupa el producto cartesiano en memoria, se recomienda no exceder los 5000 eventos (25 millones de pares por producto). En una máquina con 1gb de memoria, 6000+ eventos causan excesiva paginación.


* Requisitos *
Linux (probado en: Ubuntu 7.04, Fedora Core 6, CentOS 5, OpenSuSe 10.2)
g++
libstdc++


* Compilación *
Una vez descomprimido el archivo se crean dos directorios principales: generador y relojes.

Para compilar ambos programas, entre al directorio generador/Release y ejecute el comando 'make'. El ejecutable resultante tendrá el nombre 'generador'.
Realice el mismo proceso para el directorio relojes/Release.


* Uso *
Una vez compilados los ejecutables, el siguiente paso es crear una historia distribuida aleatoria.

Ejecute el programa 'generador' e ingrese la siguiente información:
 - Número de cadenas: número de sitios en la historia. Entero > 0
 - Media de los sends: media exponencial de los sends. Doble >= 0
 - Media de los eventos: media uniforme de los eventos por cadena. Doble >= cadenas
 - Modo de simulación: Cliente/Servidor o Peer to Peer: Entero 1 ó 0
 - Proporción de servidores (sólo C/S): proporción de servidores en la historia. Entero >= 0
 - Nombre del archivo: nombre del archivo de salida. Relativo al path actual.

La salida es un archivo de texto plano con la información necesaria para reconstruir la historia distribuida generada.
Durante la generación se despliega la creación de los eventos y el tamaño de las cadenas.

Con la historia lista, es momento de evaluar los relojes logicos por medio de 'relojes'.
Al ejecutarlo, requiere la siguiente información:
 - K: campos del vector para KLA. Entero > 1
 - R: campos del vector para REV. Entero > 0
 - Nombre del archivo: path absoluto al archivo que contiene la historia distribuida generada con 'generador'.

Siendo el producto cartesiano la operación más costosa en tiempo/espacio, 'relojes' despliega un indicar de progreso durante su cálculo.

Una vez listo, se muestran los resultados finales. Para cada reloj lógico se despliega:
 - Tiempo: tiempo de estampación, cálculo de producto cartesiano y comparación.
 - Errores: cantidad de eventos concurrentes no detectados.
 - ro: proporción de errores con respecto a todos los pares de eventos.
 - ro': proporción de errores con respecto a todos los pares de eventos concurrentes.

También se detallan los siguientes datos generales:
 - Tiempo total: suma de los tiempos para cada reloj.
 - Cadenas de eventos: cantidad de cadenas en la historia.
 - Cantidad de eventos: total de eventos en la historia.
 - Media de eventos: media de eventos por cadena.
 - Media de sends: media de los sends.
 - Modo: Cliente/Servidor ó Peer to Peer.
 - Total de servidores (sólo C/S): cantidad de servidores.
 - Pares de eventos: cantidad de elementos en el producto cartesiano.
 - Pares concurrentes: pares de eventos concurrentes (||).
 - Pares causales: pares de eventos causalmente relacionados (-> ó <-).
 - Pares iguales: pares de eventos iguales (=).