Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
FACULTAD DE INGIERIÍA
SEDE BOGOTÁ
Mohseni, Hamed
Desarrollo de la simulación:
A. Estado del Sistema (variables)
B. Entidades y sus atributos
C. Eventos, Actividades y procesos
D. Contadores y/o acumuladores
E. Medidas de desempeño
Análisis
● Avión
● Número de pasajeros
● Disponibilidad del avión
● Capacidad de pasajeros
● Precio de ruta
● Tiempo de vuelo
D. Contadores estadísticos:
● Tiempo de estadía de un pasajero
● Número de aviones disponibles
● Número de aviones en el sistema
E. Medidas de desempeño:
● Tiempo promedio de espera de un cliente para tomar un avión
● Tiempo promedio en reposo de aviones disponibles (pasajeros abordando)
● Porcentaje promedio de número de pasajeros en cada avión
1.10
Enunciado
Después del embalaje, un transportador de banda transfiere al inventario los productos acabados en
lotes de 1000 unidades. Los cartones de embalaje se colocan en la banda del transportador
automáticamente, a una distancia de 2.10 m. de centro a centro. Los cartones se descargan a mano y
se retiran de la banda dentro de una distancia de 2.10 m. O sea que el trabajador no puede alcanzar
un cartón que este a más de 1.05 m de él. Cualquier cartón no descargado por el empleado cae
automáticamente de la banda y se debe recuperar en un momento posterior. El tiempo necesario
para descargar un cartón está distribuido normalmente con una media de 15 segundo y una
desviación estándar de 3 segundos.
La distancia del punto de carga al de descarga, medida a lo largo del transportador, es de 30 m. El
transportador puede funcionar a cualquier velocidad que se desee. Sea X el número de cartones
retirados por hora y sea y el número de cartones que deja de descargar el empleado por hora.
a) Mediante la simulación y una técnica apropiada de investigación, determínese la
velocidad del transportador que maximice x – y.
b) Resuélvase el problema anterior, cuando la distancia entre cartones sucesivos tenga una
distribución exponencial con una media de 2.40 m.
Desarrollo de la simulación
A. Estado del Sistema (variables):
Reloj
Tiempo de inicio
Tiempo final
Velocidad de banda transportadora
Cartones descargados
Cartones sin descargar
E. Medidas de desempeño:
Promedio de descarga
Total de cartones descargados
Total de cartones no descargados
Diagrama de flujo
Simulación:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//Constantes
const int lote = 1000; // Cantidad de cartones
const float aumenDist = 0.7;//Coeficiente de avance para poder avanzar
//variables
int loteActual, tiempoAcu, CajaDisponible, Disponibilidad, x, y;
float velocidad, velMaxX = 0, velMaxY = 0; //(x) Cajas descargadas, (y) Cajas sin descargar
float tiempoAum, tiempoAct,tiempoTrabjador; // El reloj aumenta de a segundos
float cartones[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
//Functions
//Iniciar
void inicio(){
tiempoAct = 0;
CajaDisponible = 0;
Disponibilidad = 1;
loteActual = 1000;
velocidad = 0.0001;
tiempoTrabjador = 0.001;
x = 0;
y = 0;
}
//Ajustar posicion
void ajustPosicion(int aux, float sum){
if(aux <= 14){
for(int i = 0; i < 14; i++){
if(i == 13){
cartones[i] = sum;
}else if(cartones[i+1] != 0){
cartones[i] = cartones[i+1];
cartones[i] += sum;
}
}
}else if(aux >= 987){
for(int i = 0; i < 14; i++){
if(i == 13 || cartones[i+1] == 0){
cartones[i] = 0;
}else if(cartones[i+1] == 0){
break;
}else{
cartones[i] = cartones[i+1]+sum;
}
}
}else{
for(int i = 0; i < 14; i++){
if(i == 13){
cartones[i] = sum;
}else{
cartones[i] = cartones[i+1] + sum;
}
}
}
}
//Sumar por el paso de tiempo
void sumPar(float sum){
for(int i = 0; i < 14; i++){
if(cartones[i] != 0){
cartones[i] += sum;
}
}
}
//Generador de Tiempo de trabajador aleatorio
int generarTiempoTrabajador(){
return rand() % (12-18+1)+12;
}
//Mayor entre dos flotantes
float may(float a, float b){
if(a >= b){
return a;
}else{
return b;
}
}
//Generar velocidad
void descargaDifVel(){
//Inicializar variables
inicio();
//Proceso de maximizar 'x' y 'y', variando la velocidad
for(int i = 1; velocidad <= 100; i++){
//Inicializacion tiempos de banda transportadora y el trabajador
float tiemBand = 0, tiemTrab = 0;
int auxCon = 0, aux = 1, change = 0;
int xAux = 0, yAux = 0;
//Cambio de velociddad
velocidad += 0.01;
//Hallar tiempo que transcurre para que la banda avance 0.7m
float tiempoBandaTrans = (aumenDist/velocidad), tiempoActual = 0;
//Desplazamiento cada cierto tiempo
float despla = (velocidad * tiempoBandaTrans), acum = 0;
//Situacion inicial
Disponibilidad = 1;
CajaDisponible = 0;
//Variable para ver el desface que tiene el trabajador para poder volver a estar disponible
float tiempoNuevo = 0;
for(int j = 0; aux <= 1000; j++){
auxCon = 0;
acum += despla;
//Analisis en el momento que los cartenoes llegan a area de descarga
if(aux > 14){
CajaDisponible = 1;
//Trabajador se encuentra disponible
if(Disponibilidad == 1){
//Descargue por parte del trabajador
int rr = generarTiempoTrabajador();
float a = (float) rr;
//Analisar en que momento el trabajador vuelve a estar diponible
if(a > tiempoBandaTrans){
for(int w = 0; a > tiempoBandaTrans; w++){
a -= tiempoBandaTrans;
tiempoNuevo += tiempoBandaTrans;
}
//Verficar
if(change == 1){
xAux++;
}
Disponibilidad = 0;
}else{
if(change == 1){
xAux++;
}
Disponibilidad = 1;
}
}else if(Disponibilidad == 0){ //Trabajador no disponibe
tiempoNuevo -= tiempoBandaTrans;
if(tiempoNuevo == 0){
if(change == 1){
yAux++;
}
Disponibilidad = 1;
}else{
if(change == 1){
yAux++;
}
Disponibilidad = 0;
}
}
CajaDisponible = 0;
change = 0;
}
//Verficar que la caja ya avanzo 2.1m
int ver = (int)((acum - 2.100000)*10);
//Actualización del arreglo de lugares de la banda
if(j == 0){
cartones[13] += acum;
}else if(ver == 0){ //Verificar cuando salir la otra caja
ajustPosicion(aux,despla);
aux++;
if(aux > 14){
change = 1;
}
acum = 0;
}else{
sumPar(despla);
}
//Actualiza tiempo
tiempoActual += tiempoBandaTrans;
}
//'x' y 'y' maximizandose
x = may(x, xAux);
if(x == xAux){
velMaxX = velocidad;
};
y = may(y, yAux);
if(yAux == y){
velMaxY = velocidad;
};
//Actualización del tiempo de la simulación
tiempoAct += tiempoActual;
//Reincio de los lugares de la banda de transporte
for(int w = 0; w < 14; w++){
cartones[w] = 0;
}
}
printf("Maximo numero de x = %i, Velocidad De maximo x = %f \n", x, velMaxX);
printf("Maximo numero de y = %i, Velocidad De maximo y = %f \n", y, velMaxY);
}
int main(){
descargaDifVel();
printf("\nTiempo que dura la simulacion de 10000 velocidades para\n\t fue: %.2f segundos",
tiempoAct);
}
Análisis
En la simulación anterior, se tuvo que proceder a la realización de iteraciones, que dependían de la
cantidad de cartones que había en un lote.
Con el fin de poder analizar y maximizar tanto las variables ‘x’ y ‘y’ dependiendo de la velocidad
de la banda, tenía que realizar bucles iterando el valor de la velocidad con saber en qué momento y
con qué velocidad x toma su máximo valor o y toma su máximo valor.
Lo mismo se realizó pera el segundo punto, pero se tendría que hallar valores aleatorios de una
distribución exponencial, teniendo en cuenta que la media que planteo el docente correspondía a
2.4, con ese valor entregado se podía hallar λ (lambda), y poder usar la fórmula:
−1
x= ln ( 1−u ) ; u=U (0,1)
λ
1.11
Enunciado
Personas llegan a un paradero de bus a la tasa de uno cada 20 ± 15 segundos. Ellos esperan por el
bus a menos que la cola tenga 10 personas, en cuyo caso se alejan. El bus llega cada 5 ± 1 minuto.
Las personas abordan el bus uno a la vez, tomando 5 segundos cada uno. El bus espera por lo
menos 20 segundos, de lo contrario sale tan pronto como las personas terminen de subir. Simular 10
autobuses llenos de personas. (Utilice flujos de números aleatorios para representar personas y
buses y de prioridad a las personas).
Desarrollo de la simulación
E. Medidas de desempeño:
Promedio de espera en la cola
Total de personas que llegaron
Total de personas que abordaron
Promedio de abordaje
Promedio de pasajeros en el bus
Diagrama de flujo
Simulación
#include <stdio.h>
#include <stdlib.h>
#include "lcgrand.h"
#define FOR(n) for(int i=0;i<n;i++)
#define FOREX(i,n,in) for(i;i<n;i+=in)
#define Q_LIMIT 10
#define T_BUSES 10
#define ABORDAJE 5
#define ESPERA_BUS 20
#define ON 1
#define OFF 0
int tipo_siguiente_evento, fila, bus_estado, llegada_persona, abordaje_perso
na,buses,eventos, persona_no_abordar, personas_espera, eventos;
float clock, ultimo_evento, area_personas_cola, tiempo_abordaje, tiempo_espe
ra_total, tiempo_espera_bus,
tiempo_sig_evento[5], tiempo_llegada_pasajeros[Q_LIMIT], llegada_buses
[T_BUSES], pro_llegada_p, pro_llegada_b;
void iniciar(void);
void tiempo(void);
void actualizar_var_pro(void);
void llegada_p(void);
void llegada_b(void);
void abordar(void);
void salida_b(void);
void reportar(void);
int main()
{
iniciar();
while (buses<T_BUSES){
tiempo();
actualizar_var_pro();
switch (tipo_siguiente_evento) {
case 1:
llegada_p();
break;
case 2:
llegada_b();
break;
case 3:
abordar();
break;
case 4:
salida_b();
break;
}
}
reportar();
}
void iniciar(void){
clock = 0.0;
bus_estado = OFF;
fila = 0;
llegada_persona=0;
abordaje_persona=0;
buses=0;
area_personas_cola=0.0;
eventos=4;
persona_no_abordar=0;
personas_espera=0;
ultimo_evento=0.0;
tiempo_abordaje=0.0;
tiempo_espera_total=0.0;
tiempo_espera_bus=0.0;
pro_llegada_p=rand () % 31 + 5;
pro_llegada_b=rand () % 121 + 240;
tiempo_sig_evento[1]= clock + lcgrand(pro_llegada_p);
tiempo_sig_evento[2]= clock + lcgrand(pro_llegada_b);
tiempo_sig_evento[3]= 1.0e+30;
tiempo_sig_evento[4]=1.0e+30;
}
void tiempo(void)
{
float min_time_next_event = 1.0e+29;
tipo_siguiente_evento = 0;
FOR(eventos){
if (tiempo_sig_evento[i+1] < min_time_next_event) {
min_time_next_event = tiempo_sig_evento[i+1];
tipo_siguiente_evento = i+1;
}
}
clock = min_time_next_event;
}
void llegada_p(void)
{
float delay;
tiempo_sig_evento[1]= clock + lcgrand(pro_llegada_p);
++llegada_persona;
if(fila == 0 && bus_estado== ON){
delay=0.0;
tiempo_espera_total+=delay;
++personas_espera;
tiempo_sig_evento[2]=1.0e+30;
tiempo_sig_evento[3]=clock +ABORDAJE;
}else if (fila < Q_LIMIT)
{
++fila;
tiempo_llegada_pasajeros[fila] = clock;
tiempo_sig_evento[2]=clock + lcgrand(pro_llegada_b);
}else if (Q_LIMIT > fila){
++persona_no_abordar;
}
}
void llegada_b(void){
tiempo_sig_evento[2] = clock+lcgrand(pro_llegada_b);
bus_estado=ON;
if(fila > 0){
tiempo_sig_evento[3] = clock + ABORDAJE;
}else{
tiempo_sig_evento[4] = clock + ESPERA_BUS;
tiempo_espera_bus=clock + ESPERA_BUS;
}
}
void abordar(void)
{
tiempo_sig_evento[3] = clock + ABORDAJE;
tiempo_abordaje += ABORDAJE;
tiempo_espera_total += tiempo_llegada_pasajeros[1];
--fila;
++abordaje_persona;
for(int i = 0; i < Q_LIMIT-1; i++){
tiempo_llegada_pasajeros[i] = tiempo_llegada_pasajeros[i+1];
}
if(fila > 0){
tiempo_sig_evento[4] = clock + ABORDAJE;
}
else {
tiempo_sig_evento[3] = clock+lcgrand(pro_llegada_b);
}
}
void salida_b(void)
{
bus_estado = OFF;
tiempo_sig_evento[2] =clock + ABORDAJE ;
++buses;
void reportar(void){
printf( "\n\nDemora Promedio de personas: %11.3f \n\n",
tiempo_espera_total /personas_espera);
printf( "\n\nDemora Promedio de buses: %11.3f \n\n",
tiempo_espera_bus / buses);
printf( "Numero promedio de personas en cola: %10.3f\n\n",
area_personas_cola / clock);
printf( "Personas que no abordaron: %d\n\n",
persona_no_abordar);
printf( "Numero de personas atendidas: %d",
personas_espera);
}
void actualizar_var_pro(void){
float desde_ultimo_evento = clock - ultimo_evento;
ultimo_evento = clock;
area_personas_cola += fila * desde_ultimo_evento;
}
Análisis
La estación de buses no suele tener cola ya que el flujo de personas no supera el flujo
de buses en la estación.
Asimismo, la demora promedio de un usuario es 0 al igual que la cantidad de personas
que no alcanzan a abordar un bus.
1.12
Enunciado
Un sistema de colas con cuatro canales en serie funciona con las características siguientes:
• Llegadas de Poisson, ʎ = 0.04
• Tasas de servicio µ1= 0.05, µ2 = 0.06, µ3 = 0.05 y µ4= 0.07 todas con distribución
exponencial
• Longitud de las colas NQ1 = 100, NQ2= 10, NQ3 = 20 y NQ4 = 30
• Solo el 60% entran en la instalación 2. Las otras van con igual probabilidad a las
instalaciones 3 o 4
Analice este sistema durante un periodo de 30 días de tiempo simulado, Qué ocurriría si
sólo el 20% de las unidades entraran al canal 2 y las otras fueran con las mismas
probabilidades a los canales 3 y 4?
Desarrollo de la simulación
E. Medidas de desempeño:
La utilización promedio
Demora promedio en la cola
La cola más larga
Los trabajos hechos por los servidores
Promedio de pasajeros en el bus
Diagrama de flujo
Simulación
Cabe aclarar las que toca poner las tres librerías de simlib como, simlib.h, simlib.c, simlibdefs.h
#include "simlib.h"
//eventos
#define EVENT_ARRIVAL 1 /* llegadas. */
#define EVENT_DEPARTURE 2 /* terminacion de servicio */
#define EVENT_END_SIMULATION 3 /* Fin de la simulacion*/
//semillas
#define STREAM_SERVICE_1 1 /* serie de numeros aleatorios para tiempo de servicio. *
/
#define STREAM_SERVICE_2 2 /* serie de numeros aleatorios para tiempo de servicio. *
/
#define STREAM_SERVICE_3 3 /* serie de numeros aleatorios para tiempo de servicio. *
/
#define STREAM_SERVICE_4 4 /* serie de numeros aleatorios para tiempo de servicio. *
/
//esto asi para garantizar mayor independencia pues cada servicio tiene una media distint
a
#define STREAM_INTERARRIVAL 5 /* serie de numeros aleatorios interllegadas. */
#define STREAM_NEXT 6 /* serie de numeros aleatorios para la siguiente tarea. */
#define MAX_NUM_SERVERS 4
//listas
#define SERVER_ONE 1
#define SERVER_TWO 2
#define SERVER_THREE 3
#define SERVER_FOUR 4
#define QUEUE_ONE 5
#define QUEUE_TWO 6
#define QUEUE_THREE 7
#define QUEUE_FOUR 8
//lista de eventos 25
/* Declaracion de variables goblales no-simlib. */
int num_stations, i, queues[MAX_NUM_SERVERS+1], maxQ[MAX_NUM_SERVERS+1], com
pleted[MAX_NUM_SERVERS +1]; //el i sirve de iterador
double lambda_interarrival, prob_distrib_prox_task[4], mean_service[MAX_NUM_SERVER
S +1];
double length_simulation;
FILE *infile, *outfile;
/* Declaracion funciones no-simlib. */
void arrive(int new);
void depart(int channel);
void report(FILE *file);
void intit_model();
main(){
//abrir archivos
FILE *infile , *outfile;
infile = freopen("model_in.txt","r",stdin);
outfile =freopen("model_out.txt","w",stdout);
//leer parametros
if(infile == NULL||outfile ==NULL){
printf("no se pudo abrir archivos");
exit(0);
}
//lee el numero de estaciones
fscanf(infile, "%d %lf %lf ", &num_stations, &lambda_interarrival,&length_simulation);
//lee las medias de servicio
for (i = 1; i <= num_stations; ++i)
fscanf(infile, "%lf", &mean_service[i] );
//lee las colas
for (i = 1; i <= num_stations; ++i)
fscanf(infile, "%d", &queues[i] );
//lee la escalera que define la salida del modulo 1
prob_distrib_prox_task[0]=0;
for (i = 1; i <= num_stations -1; ++i)
fscanf(infile, "%lf", &prob_distrib_prox_task[i] );
/*Reportar parametros de simulacion*/
fprintf(outfile, " MODELO DE CANALES EN SERIE usando simlib\n\n");
fprintf(outfile, "La media de llegadas corresponde a poisson de lambda: %1.5f\n",lam
bda_interarrival);
fprintf(outfile,"El numero de servidores(canales): %d\n",num_stations);
fprintf(outfile, "\nMedia de servicio por canal: ");
for (i = 1; i <= num_stations; ++i)
fprintf(outfile, "%8.3lf ", mean_service[i]);
fprintf(outfile, "\nEl tama�o de cola por servidor es: ");
for (i = 1; i <= num_stations; ++i)
fprintf(outfile, "%8.3d ", queues[i]);
fprintf(outfile, "\n\nSe va a simular por: %20.1lf horas\n\n\n", length_simulation);
//inicializar
init_model();
do{//mientras no se de el evento tipo 3
//mover el tiempo
timing();
//evento 1,2 3
switch(next_event_type){
case EVENT_ARRIVAL:
//--llamar funcion de llegada
arrive(transfer[3]);
break;
case EVENT_DEPARTURE:
//---llamar f de salida
depart(transfer[3]);
break;
case EVENT_END_SIMULATION:
//---llamar reporte
report(outfile);
break;
}
}while(next_event_type < EVENT_END_SIMULATION);
fclose(infile);
fclose(outfile);
}
init_model(){
init_simlib(); //prepara listas, reloj = 0, estadisiticos = 0
maxatr = 4; /* Kelton recomienda minimo usar 4. */
//programar evento fin de la simulacion.
event_schedule(length_simulation,EVENT_END_SIMULATION);
//programa una llegada
transfer[3] = SERVER_ONE;
event_schedule(sim_time + expon(lambda_interarrival,STREAM_INTERARRIVAL) ,EVENT
_ARRIVAL);
// inicializar variables no simlib
for(i=1;i<=MAX_NUM_SERVERS+1; i++)
maxQ[i]=0;
completed[i] = 0;
}
void arrive(int server){
if(server ==1){
//programa una proxima llegada al sistema(servidor uno)
//ojo son llegadas exponenciales porque el tiempo (continuo) entre eventos poisson(
discreto) se modela estadisiticamente con una gamma (1,lambda)
transfer[3]= SERVER_ONE;
event_schedule(sim_time + expon(lambda_interarrival,STREAM_INTERARRIVAL) ,EVE
NT_ARRIVAL);
}
// esta el servidor libre?
if(list_size[server]==0){
//completo demora
sampst(0.0,server);
//asigna al servidor
list_file(FIRST,server);
//programa el fin del servicio
transfer[3]= server;
event_schedule(sim_time + expon(mean_service[server], server), EVENT_DEPARTU
RE); /*cada servidor tiene su stream homologo*/
return;//termina la rutina
}
//no quedo en servicio asi que se une a la fila.
transfer[1]=sim_time;
list_file(LAST,MAX_NUM_SERVERS + server);
if(maxQ[server] < list_size[MAX_NUM_SERVERS + server]){
maxQ[server]++;
}
}
void depart(int channel){
//se identificia la salida del canal channel
//Esta la cola libre para este canal?
if(list_size[MAX_NUM_SERVERS + channel] == 0){
//SI!, maerque libre
list_remove(FIRST,channel);
}else{
//no! pase el siguiente
list_remove(FIRST,MAX_NUM_SERVERS + channel);
//completo demora En trasnfer 1 esta la llegada a esta lista
sampst(sim_time-transfer[1],channel);
//programa fin de servicio
transfer[3]=channel;
event_schedule(sim_time + expon(mean_service[channel], channel), EVENT_DEPART
URE);/*cada servidor tiene su stream homologo*/
}
completed[channel]++;
//el que se va donde viene?
switch(channel){
case SERVER_ONE: //channel 1, pasa a canal 2, 3 o 4 segun probabilidad
arrive(random_integer(prob_distrib_prox_task, STREAM_NEXT) + 1);
break;
case SERVER_TWO://channel 2, pasa a canal 3
arrive(SERVER_THREE);
break;
case SERVER_THREE://channel 3, pasa a canal 4
arrive(SERVER_FOUR);
break;
case SERVER_FOUR://chanel 4 termin�!
break;
}
}
void report(FILE *file){
int j;
//probabilidades para la segunda tarea "tipo de trabajo"
fprintf(file, "\n servidor probabilidad de pasar despues del tarea 1");
for(j=1;j<=3;j++)
fprintf(file, "\n %4d %17.3f", j+1,prob_distrib_prox_task[j] );
fprintf(file, "\n\n\n servidor utilizacion cola mas Demora promedio trabajo
s");
fprintf(file, "\n (canal) promedio larga en cola atendidos");
for (j = 1; j <= num_stations; ++j){
fprintf(file, "\n\n%4d%17.3f %4d %17.3f %4d", j, filest(j), maxQ[j], sam
pst(0.0, -j), completed[j]);
}
}
Resultados y Análisis
Aquí podemos ver, después de simular las dos características que nos plantea el problema siempre
la cola 1 tiene los mismos datos dado que la probabilidad que nos plantea el problema no cambia.
En lo más resaltable es que la cola 4 es donde siempre atienden la mayor cantidad de trabajos y la
suele ser la cola más larga precisamente por esto y la distribución Poisson que nos proponen desde
el principio del problema. El tiempo que también nos propone el problema también influye porque
nos da a entender mejor cómo funciona el sistema con datos más grandes.
1.13
Enunciado
Considere una facilidad de servicio con s servidores en paralelo (s>= 1) Suponga que los tiempos
entre llegadas de los clientes son variables aleatorias exponenciales con media E(A) y que los
tiempos de servicio de los clientes (independiente del servidor) son variables aleatorias
idénticamente distribuidas e independientes con media E(S). Si un cliente llega y encuentra uno o
más servicios libres, el cliente inicia servicio inmediatamente. De lo contrario, el cliente se une al
final de una cola FIFO (COLA M/M/s). Escriba un programa general para simular el sistema con el
cual evaluar demora promedio en la cola, número promedio de clientes en la cola y la utilización
promedio de los servidores con condición de terminación de completar n demoras. Corra el modelo
con los parámetros s = 5, E(A)=1, E(S)=4, y n = 1000
Desarrollo de la simulación
A. Estado del Sistema (variables)
Reloj
Tiempo entre llegada de clientes
Tiempo de espera en la cola
Tiempo de servicio en los servidores
Llegada de un cliente
Salida del Cliente
Actividades:
Clientes en espera
Procesos:
Diagrama de flujo
Simulación
#include <stdio.h>
#include <stdbool.h>
#include <math.h>
#define MODLUS 2147483647
#define MULT1 24112
#define MULT2 26143
#define Q_LIMIT 10000
#define BUSY 1
#define IDLE 0
static long zrng[] =
{ 1,
1973272912, 281629770, 20006270,1280689831,2096730329,1933576050,
913566091, 246780520,1363774876, 604901985,1511192140,1259851944,
824064364, 150493284, 242708531, 75253171,1964472944,1202299975,
233217322,1911216000, 726370533, 403498145, 993232223,1103205531,
762430696,1922803170,1385516923, 76271663, 413682397, 726466604,
336157058,1432650381,1120463904, 595778810, 877722890,1046574445,
68911991,2088367019, 748545416, 622401386,2122378830, 640690903,
1774806513,2132545692,2079249579, 78130110, 852776735,1187867272,
1351423507,1645973084,1997049139, 922510944,2045512870, 898585771,
243649545,1004818771, 773686062, 403188473, 372279877,1901633463,
498067494,2087759558, 493157915, 597104727,1530940798,1814496276,
536444882,1663153658, 855503735, 67784357,1432404475, 619691088,
119025595, 880802310, 176192644,1116780070, 277854671,1366580350,
1142483975,2026948561,1053920743, 786262391,1792203830,1494667770,
1923011392,1433700034,1244184613,1147297105, 539712780,1545929719,
190641742,1645390429, 264907697, 620389253,1502074852, 927711160,
364849192,2049576050, 638580085, 547070247 };
int next_event_type, num_custs_delayed, num_delays_required,
num_events, num_in_q, num_servidores,servidores[];
float area_num_in_q, area_server_status, mean_interarrival,
mean_service, time, time_arrival[Q_LIMIT+1], time_last_event,
time_next_event[3], total_of_delays;
FILE *infile, *outfile;
void initialize(void);
void timing(void);
void arrive(void);
void depart(void);
void report(void);
void update_time_avg_stats(void);
float expon(float mean);
float lcgrand(int stream);
void lcgrandst (long zset, int stream);
long lcgrandgt (int stream);
main(){
infile = fopen("reporte.in", "r");
outfile = fopen("reporte.out", "w");
num_events=2;
fscanf(infile, "%d %f %f %d",&num_servidores, &mean_interarrival, &mean_serv
ice,
&num_delays_required);
fprintf(outfile, "Sistema de cola multi-servidor\n\n");
fprintf(outfile, "Numero de servidores%14d\n\n",
num_servidores);
fprintf(outfile, "Tiempo medio de llegadas%11.3f minutes\n\n",
mean_interarrival);
fprintf(outfile, "Tiempo medio de servicios%16.3f minutes\n\n",
mean_service);
fprintf(outfile, "Numero de clientes%14d\n\n",
num_delays_required);
initialize();
while (num_custs_delayed < num_delays_required){
timing();
update_time_avg_stats();
switch(next_event_type){
case 1:
arrive();
break;
case 2:
depart();
break;
}
}
report();
fclose(infile);
fclose(outfile);
return 0;
}
void initialize(void){
int i;
time=0.0;
num_in_q=0;
time_last_event=0.0;
num_custs_delayed=0;
total_of_delays=0.0;
area_num_in_q=0.0;
area_server_status=0.0;
time_next_event[1] = time + expon(mean_interarrival);
time_next_event[2] = 1.0e+30;
for(i=1;i<=num_servidores;i++){
servidores[num_servidores]= IDLE;
}
void timing(void){
int i;
float min_time_next_event = 1.0e+29;
next_event_type=0;
for (i=1;i <= num_events; ++i) {
if (time_next_event[i] < min_time_next_event) {
min_time_next_event = time_next_event[i];
next_event_type = i;
}
}
if(next_event_type == 0){
fprintf(outfile, "\nEvent list empty at time %f", time);
exit(1);
}
time = min_time_next_event;
}
void arrive(void){
int i;
int aux=0;
float delay;
time_next_event[1] = time + expon(mean_interarrival);
for(i=1;i<= num_servidores;i++){
if(servidores[num_servidores] == BUSY){
aux=aux+1;
if(aux==num_servidores){
++num_in_q;
}
}
}
time_arrival[num_in_q] = time;
if(num_in_q > Q_LIMIT){
fprintf(outfile, "\nOverflow of the array time_arrival at");
fprintf(outfile, " time %f", time);
exit(2);
}
if(aux<num_servidores){
delay =0.0;
total_of_delays += delay;
++num_custs_delayed;
for(i=1;i<=num_servidores;i++){
if(servidores[num_servidores]== IDLE){
servidores[num_servidores]=BUSY;
i=num_servidores+1;
}
}
time_next_event[2] = time + expon(mean_service);
}
}
void depart(void){
int i;
float delay;
if (num_in_q == 0){
for(i=1;i<=num_servidores;i++){
servidores[num_servidores] = IDLE;
}
time_next_event[2]=1.0+29;
}else{
--num_in_q;
delay = time - time_arrival[1];
total_of_delays += delay;
++num_custs_delayed;
servidores[num_servidores]=IDLE;
time_next_event[2] = time + expon(mean_service);
for(i=1;i<= num_in_q; ++i){
time_arrival[i]= time_arrival[i+1];
}
}
}
void report(void){
float aux, aux1,aux2;
aux=area_server_status / time;
aux1=area_num_in_q / time;
aux2=total_of_delays / num_custs_delayed;
fprintf(outfile, "\n\nPromedio retraso en cola: %11.3f\n\n",
aux2/num_servidores);
fprintf(outfile, "Numero promedio en cola: %10.3f\n\n",
aux1/num_servidores);
fprintf(outfile, "Utilizacion de los servidores: %15.3f\n\n",
aux/num_servidores);
fprintf(outfile, "Tiempo de simulacion: %12.3f", time);
}
void update_time_avg_stats(void){
float time_since_last_event;
int i;
time_since_last_event = time - time_last_event;
time_last_event = time;
area_num_in_q += num_in_q * time_since_last_event;
for(i=1;i<=num_servidores;i++){
area_server_status += servidores[num_servidores]* time_since_last_e
vent;
}
}
float expon(float mean){
return -mean*log(lcgrand(1));
}
float lcgrand(int stream){
long zi, lowprd, hi31;
zi = zrng[stream];
lowprd = (zi & 65535) * MULT1;
hi31 = (zi >> 16) * MULT1 + (lowprd >> 16);
zi = ((lowprd & 65535) - MODLUS) +
((hi31 & 32767) << 16) + (hi31 >> 15);
if (zi < 0) zi += MODLUS;
lowprd = (zi & 65535) * MULT2;
hi31 = (zi >> 16) * MULT2 + (lowprd >> 16);
zi = ((lowprd & 65535) - MODLUS) +
((hi31 & 32767) << 16) + (hi31 >> 15);
if (zi < 0) zi += MODLUS;
zrng[stream] = zi;
return (zi >> 7 | 1) / 16777216.0;
}
void lcgrandst (long zset, int stream){
zrng[stream] = zset;
}
long lcgrandgt (int stream){
return zrng[stream];
}
Entrada:
Salida:
Análisis
Se tiene que el uso de la bomba de gasolina es casi del 100%, en este caso se tendría que
utilizar otra bomba para evitar que esta se use tanto generando un desgaste apresurado o se
cree una cola que podría ser exageradamente larga
La demora promedio de los carros particulares es muy superior a la de los carros policiacos,
psicológicamente esto podría causar muchas renuncias por parte de los carros particulares y
así reducir las ventas de la estación de gasolina al ver la prioridad que tienen los del otro
tipo.
El promedio de carros en la cola es muy grande y la espera promedio de los vehículos
particulares es mucha, el uso de un solo recurso genera esto. La espera podría bajar
considerablemente si se tiene en cuenta la creación de otra bomba.