PUNTO 4

Planteamiento del problema

Un sistema de colas con cuatro canales en serie funciona con las caractersticas
siguientes:
Llegadas de Poisson, = 0.04
Tasas de servicio 1= 0.05, 2 = 0.06, 3 = 0.05 y 4= 0.07 todas con
distribucin exponencial
Longitud de las colas NQ1 = 100, NQ2= 10, NQ3 = 20 y NQ4 = 30
Solo el 60% entran en la instalacin 2. Las otras van con igual probabilidad a
las instalaciones 3 4

Analice este sistema durante un periodo de 30 das de tiempo simulado, Qu

ocurrira si slo el 20% de las unidades entraran al canal 2 y las otras fueran con
las mismas probabilidades a los canales 3 y 4?

Cdigo fuente:
Cabe anotar que tanto en el carpeta del proyecto como en el proyecto como tal
en c, se incluye la librera simlib.h con su correspondiente fuente (simlib.c) y sus
definiciones (simlibdefs.h) y como nica modificacin a la definicin INFINITY la
cual generaba conflicto con el compilador MinGW (por defecto del IDE, DEV c++)
al tratar de sobrescribir una definicin nativa.
#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
servicio. */

1 /* serie de numeros aleatorios para tiempo de

#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 distinta
#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
//listas
#define
#define
#define
#define

SERVER_ONE 1
SERVER_TWO 2
SERVER_THREE 3
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], completed[MAX_NUM_SERVERS +1]; //el i sirve de
iterador
float lambda_interarrival, length_simulation, prob_distrib_prox_task[4],
mean_service[MAX_NUM_SERVERS +1];
FILE *infile, *outfile;
/* Declaracion funciones no-simlib. */
void
void
void
void

arrive(int new);
depart(int channel);
report(FILE *file);
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 %f %f", &num_stations, &lambda_interarrival,
&length_simulation);
//lee las medias de servicio
for (i = 1; i <= num_stations; ++i)
fscanf(infile, "%f", &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, "%f", &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",lambda_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.3f
", mean_service[i]);
fprintf(outfile, "\nEl tamao 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.1f 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) ,EVENT_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_DEPARTURE); /*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_DEPARTURE);/*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] prob_distrib_prox_task[j-1]);

fprintf(file, "\n\n\n servidor

utilizacion
trabajos");
fprintf(file,
"\n (canal)
promedio
atendidos");
for (j = 1; j <= num_stations; ++j){
fprintf(file, "\n\n%4d%17.3f
maxQ[j], sampst(0.0, -j), completed[j]);

cola mas

Demora promedio

larga

en cola

%4d %17.3f

%4d", j, filest(j),

}
}

Listas, Entidades y atributos

Se tiene 3 tipos de entidad: servidores, filas, y productos/personas.
#define SERVER_ONE 1
#define QUEUE_ONE 5
#define SERVER_TWO 2
#define QUEUE_TWO 6
#define SERVER_THREE 3
#define QUEUE_THREE 7
#define SERVER_FOUR 4
#define QUEUE_FOUR 8
//lista de eventos
25

Servers
Recurso del sistema que corresponde a las listas 1 a 4, no tienen atributos
especficos asociados, es de inters si tamao el cual si es 1 corresponde a
ocupacin, si es 0 denota su ocio.
Queues
Fila usual ubicada en las listas 5 a 8, su atributo de inters es el tiempo de llegada
de una transaccin issue
Issues
Entidad ficticia que atraviesa el sistema.

Eventos y Procesos
//eventos
#define EVENT_ARRIVAL
1 /* llegadas. */
#define EVENT_DEPARTURE
2 /* terminacion de servicio */
#define EVENT_END_SIMULATION 3 /* Fin de la simulacion*/
Cabe anotar que la distribucin poisson es una distribucin que modela la
ocurrencia de cierta cantidad de eventos discretos en un intervalo dado, es por
ende que se utilizan algoritmos que barren a manera de clculo infinitesimal los
intervalos, esto se usa ms que todo en procesos estocsticos, para procesos
determinsticos la distribucin que modela el tiempo entre dos ocurrencias de
eventos tipo poisson sigue una distribucin gamma con parmetros 1 y lambda lo
cual es lo mismo que una exponencial de parmetro lambda. (Blanco, 2004)

Los procesos son descritos a continuacin mediante diagramas de flujos para ver
el cdigo remtase a cdigo fuente paginas atrs.

Contadores Estadsticos y medidas de desempeo

Se utilizan contadores nativos de simlib tipo sampst uno para cada par cola y
servidor, adicional a estos se lleva en los arreglos: maxQ[MAX_NUM_SERVERS+1]
y completed[MAX_NUM_SERVERS +1] respectivamente la cola mxima por
servidor y el nmero de servicios por servidor.
Como medida de desempeo en la funcin report se imprime: la utilizacin
promedio, la demora promedio en cola, la cola ms larga y los trabajos
entendidos para el servidor j en un ciclo for que recorre todos los servidores,
respectivamente estas medidas corresponden a : filest(j) sampst(0.0, -j), ,
maxQ[j], completed[j]).

Resultados
Con parmetros 1
MODELO DE CANALES EN SERIE usando simlib
La media de llegadas corresponde a poisson de lambda: 0.04000
El numero de servidores(canales): 4
Media de servicio por canal:
0.070
El tamao de cola por servidor es:
030
Se va a simular por:
servidor
2
3
4
servidor
(canal)

0.050

0.060

0.050

100

010

020

720.0 horas

probabilidad de pasar despues del tarea 1

0.600
0.200
0.200
utilizacion
promedio

cola mas
larga

Demora promedio
trabajos
en cola
atendidos

1.000

3503

69.630

0.736

21

0.171

8639

0.798

28

0.208

11559

1.000

4231

105.266

14494

10262

Con parmetros 2
MODELO DE CANALES EN SERIE usando simlib
La media de llegadas corresponde a poisson de lambda: 0.04000
El numero de servidores(canales): 4
Media de servicio por canal:
0.070
El tamao de cola por servidor es:
030

0.050

0.060

0.050

100

010

020

Se va a simular por:

servidor
2
3
4

720.0 horas

probabilidad de pasar despues del tarea 1

0.200
0.400
0.400

servidor
(canal)

utilizacion
promedio

cola mas
larga

1.000

3503

0.237

0.594

22

1.000

4233

Demora promedio
trabajos
en cola
atendidos
69.630
0.016
0.075
105.396

14494
2842
8641
10262

Anylogic
Main:
Al correr el programa el tiempo de simulacin avanza lo suficientemente lento
como para dar tiempo de elegir la poltica que regula las salidas del servidor 1, ya
sea segn el numeral general del problema (A), o el cambio de condiciones en la
escalera de probabilidad(B), despus de elegir se puede acelerar el tiempo.

El sink overflow, se utiliza solo cuando la simulacin ha llegado a un tiempo muy

avanzado en el cual, los cuellos de botella son muy evidentes y las colas se
saturan generando un error por tratar de asignar una entidad a un recurso
inexistente asi, estas entidades salen del sistema y son contabilizadas en genral.
Modelo corriendo

Bibliografa
Blanco, L. (2004). Probabilidad. UNILIBROS.