Documentos de Académico
Documentos de Profesional
Documentos de Cultura
a)
b)
c)
d)
e)
1
2
3
4
5
6
7
8
9
10
#include
#include
#include
#include
#define
#define
#define
#define
<iostream>
<stdio.h>
<cstdlib>
"lcgrand.h"
Q_LIMIT 100
BUSY
1
IDLE
0
DMG
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
void initialize(void);
void timing(void);
void arrive_A(void);
void arrive_B(void);
void depart_A(void);
void depart_B(void);
void depart_C(void);
void dmg_A(void);
void dmg_B(void);
void report();
void update_time_avg_stats();
float uniform(float a, float b);
int main(int argc, char *argv[]) {
num_events = 9;
initialize();
do{
timing();
update_time_avg_stats();
printf("event %d time %f ", next_event_type, sim_time);
system("Pause");
switch (next_event_type){
case 1:
arrive_A();
break;
case 2:
arrive_B();
62
break;
63
case 3:
64
depart_A();
65
break;
66
case 4:
67
depart_B();
68
break;
69
case 5:
70
depart_C();
71
break;
72
case 6:
73
dmg_A();
74
break;
75
case 7:
76
dmg_B();
77
break;
78
case 8:
79
report();
80
/*Inicializo el reloj de simulacin en cero
81
muchas veces, entonces jams llego a las
82
40 horas
83
/*guardar = sim_time;
84
initialize();
85
time_next_event[8] = 1.0e+29;
86
sim_time=guardar;*/
87
break;
88
case 9:
89
report();
90
break;
91
}
92
}while (next_event_type != 8);
93
94
return 0;
95 }
96
97 void timing(void) /* Timing function. */
98 {
99
int
i;
100
float min_time_next_event = 1.0e+29;
101
102
next_event_type = 0;
103
104
/* Determine the event type of the next event to occur. */
105
106
for (i = 1; i <= num_events; ++i)
107
if (time_next_event[i] < min_time_next_event) {
108
min_time_next_event = time_next_event[i];
109
next_event_type
= i;
110
}
111
112
113
/* Check to see whether the event list is empty. */
114
115
if (next_event_type == 0) {
116
117
/* The event list is empty, so stop the simulation */
118
119
printf("\nEvent list empty at time %f", sim_time);
120
exit(1);
121
}
122
123
/* The event list is not empty, so advance the simulation clock. */
124
125
sim_time = min_time_next_event;
126 }
127
128 void initialize(void) /* Initialization function. */
129 {
130
/* Initialize the simulation clock. */
131
132
sim_time = 0.0;
133
134
/* Initialize the state variables. */
135
136
server_A_status
= IDLE;
137
server_B_status
= IDLE;
138
server_C_status
= IDLE;
139
num_in_q_A
= 0;
140
num_in_q_NB
= 0;
141
num_in_q_PB
= 0;
142
num_in_q_NC
= 0;
143
num_in_q_PC
= 0;
144
time_last_event
= 0.0;
145
total_of_delays_A = 0.0;
146
total_of_delays_NB = 0.0;
147
total_of_delays_PB = 0.0;
148
total_of_delays_NC = 0.0;
149
total_of_delays_PC = 0.0;
150
time_last_event = 0.0;
151
152
/* Initialize the statistical counters. */
153
154
num_pc_delayed = 0;
155
/*area_num_in_q
= 0.0;
156
area_server_status = 0.0;*/
157
158
/* Initialize event list. Since no customers are present, the departure
159
(service completion) event is eliminated from consideration. */
160
161
time_next_event[1] = sim_time + uniform(90, 110);
162
time_next_event[2] = sim_time + uniform(4, 16);
163
time_next_event[3] = 1.0e+30;
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
time_next_event[4]
time_next_event[5]
time_next_event[6]
time_next_event[7]
time_next_event[8]
time_next_event[9]
=
=
=
=
=
=
1.0e+30;
1.0e+30;
sim_time + uniform(50, 750);
sim_time + uniform(50, 350);
480.0;
2400.0;
area_num_in_q_A
area_num_in_q_NB
area_num_in_q_PB
area_num_in_q_NC
area_num_in_q_PC
=
=
=
=
=
0.0;
0.0;
0.0;
0.0;
0.0;
area_server_A_status = 0.0;
area_server_B_status = 0.0;
area_server_C_status = 0.0;
}
void arrive_A(void)
{
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
depart_A(void){
if (server_A_status != DMG){
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
if (server_C_status == BUSY){
++num_in_q_PC;
if(num_in_q_PC > Q_LIMIT){
/* The queue has overflowed, so stop the
simulation. */
printf("\nOverflow of the array time_arrival PC at");
printf(" time %f", sim_time);
exit(2);
}
time_arrival_PC[num_in_q_PC] = sim_time;
}else{
server_C_status = BUSY;
time_next_event[5] = sim_time + uniform(2, 14);
}
}
int i;
float delay;
if (server_A_status == DMG){
/*Esta es la terminacin del dao, se asume que la pieza que
estaba
trabajando ya est en cola en B, o ya est siendo procesada
por B.
Ahora se procede a seguir con el procedimiento normal*/
server_A_status = IDLE;
time_next_event[3] = 1.0e+30;
time_next_event[6] = sim_time + uniform(50, 750);
}if (num_in_q_A == 0){
server_A_status = IDLE;
time_next_event[3] = 1.0e+30;
}else{
--num_in_q_A;
delay
= sim_time - time_arrival_A[1];
total_of_delays_A += delay;
time_next_event[3] = sim_time + uniform(75, 105);
/* Move each customer in queue (if any) up one place. */
for (i = 1; i <= num_in_q_A; ++i)
time_arrival_A[i] = time_arrival_A[i + 1];
}
}
void
depart_B(void){
if (server_B_status != DMG){
317
if (server_C_status == BUSY){
318
319
++num_in_q_NC;
320
if(num_in_q_NC > Q_LIMIT){
321
/* The queue has overflowed, so stop the
322 simulation. */
323
324
printf("\nOverflow of the array time_arrival PC at");
325
printf(" time %f", sim_time);
326
exit(2);
327
}
328
329
time_arrival_NC[num_in_q_NC] = sim_time;
330
}else{
331
332
server_C_status = BUSY;
333
time_next_event[5] = sim_time + uniform(2, 14);
334
}
335
}
336
int i;
337
float delay;
338
if (server_B_status == DMG){
339
/*Esta es la terminacin del dao, se asume que la pieza que
340
estaba
341
trabajando ya est en cola en B, o ya est siendo procesada
342
343 por B.
Ahora se procede a seguir con el procedimiento normal*/
344
server_B_status = IDLE;
345
time_next_event[4] = 1.0e+30;
346
time_next_event[7] = sim_time + uniform(50, 350);
347
}if (num_in_q_PB > 0){
348
--num_in_q_PB;
349
delay = sim_time - time_arrival_PB[1];
350
total_of_delays_PB += delay;
351
time_next_event[4] = sim_time + uniform(80, 120);
352
353
354
for (i = 1; i <= num_in_q_PB; ++i)
355
time_arrival_PB[i] = time_arrival_PB[i + 1];
356
}else if (num_in_q_NB == 0){
357
server_B_status = IDLE;
358
time_next_event[4] = 1.0e+30;
359
}else{
360
--num_in_q_NB;
361
delay = sim_time - time_arrival_NB[1];
362
total_of_delays_NB += delay;
363
time_next_event[4] = sim_time + uniform(3, 13);
364
365
for (i = 1; i <= num_in_q_NB; ++i)
366
time_arrival_NB[i] = time_arrival_NB[i + 1];
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
}
}
void
depart_C(void){
int i;
float delay;
++num_pc_delayed;
if (num_in_q_PC > 0){
--num_in_q_PC;
delay = sim_time - time_arrival_PC[1];
total_of_delays_PC += delay;
time_next_event[5] = sim_time + uniform(2, 14);
for (i = 1; i <= num_in_q_PC; ++i)
time_arrival_PC[i] = time_arrival_PC[i + 1];
}else if (num_in_q_NC == 0){
server_C_status = IDLE;
time_next_event[5] = 1.0e+30;
}else{
--num_in_q_NC;
delay = sim_time - time_arrival_NC[1];
total_of_delays_NC += delay;
time_next_event[5] = sim_time + uniform(2, 14);
for (i = 1; i <= num_in_q_NC; ++i)
time_arrival_NC[i] = time_arrival_NC[i + 1];
}
}
void
dmg_A(void){
server_A_status = DMG;
time_next_event[6] = sim_time + uniform(50, 750);
if (server_B_status == BUSY || server_B_status == DMG){
++num_in_q_PB;
if(num_in_q_PB > Q_LIMIT){
/* The queue has overflowed, so stop the simulation.
*/
printf("\nOverflow of the array time_arrival PB at");
printf(" time %f", sim_time);
exit(2);
}
time_arrival_PB[num_in_q_PB] = sim_time;
}else{
server_B_status = BUSY;
time_next_event[4] = sim_time + uniform(80, 120);
}
/*En esta parte le avisa al sistema que la interrupcion ha
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
terminado*/
time_next_event[3] = sim_time + uniform(1, 29);
}
void
dmg_B(void){
server_B_status = DMG;
time_next_event[7] = sim_time + uniform(50, 350);
/*En esta parte le avisa al sistema que la interrupcion ha
terminado*/
time_next_event[4] = sim_time + uniform(2, 18);
}
void update_time_avg_stats(void)
average
{
float time_since_last_event;
/* Compute time since last event, and update last-event-time marker. */
time_since_last_event = sim_time - time_last_event;
time_last_event
= sim_time;
/* Update area under number-in-queue function. */
area_num_in_q_A
area_num_in_q_NB
area_num_in_q_PB
area_num_in_q_NC
area_num_in_q_PC
+= num_in_q_A *
+= num_in_q_NB
+= num_in_q_PB
+= num_in_q_NC
+= num_in_q_PC
time_since_last_event;
* time_since_last_event;
* time_since_last_event;
* time_since_last_event;
* time_since_last_event;
}
void report(void) /* Report generator function. */
{
/* Compute and write estimates of desired measures of performance. */
/*printf("\n\nAverage delay in queue%11.3f minutes\n\n",
total_of_delays / num_custs_delayed);*/
printf("Average number in queue A%10.3f\n\n",
area_num_in_q_A / sim_time);
printf("Average number in queue NB%10.3f\n\n",
area_num_in_q_NB / sim_time);
printf("Average number in queue PB%10.3f\n\n",
area_num_in_q_PB / sim_time);
printf("Average number in queue NC%10.3f\n\n",
area_num_in_q_NC / sim_time);
printf("Average number in queue PC%10.3f\n\n",
area_num_in_q_PC / sim_time);
printf("Server A utilization%15.3f\n\n",
area_server_A_status / sim_time);
printf("Server B utilization%15.3f\n\n",
area_server_B_status / sim_time);
printf("Server C utilization%15.3f\n\n",
area_server_C_status / sim_time);
printf("Time simulation ended%12.3f minutes", sim_time);
470
471
472
473
474
475 }
476
477 float uniform(float a, float b) /* Uniform variate generation function. */
{
/* Return a U(a,b) random variate. */
return a + lcgrand(1) * (b - a);
}
Hay que tener como una consideracin adicional, que el tiempo de simulacin es
de 8 horas, pues los dueos estn interesados en el comportamiento de los
servidores en este tiempo.
Adicionalmente, en momentos en que el servidor A se encuentra Daado, o tiene
una falla, las piezas que lleguen, sern enviadas a la cola de espera del servidor, a
menos que el servidor B est disponible, por lo cual prioriza la pieza, y la empieza
a trabajar.
f)
g)
h)
i)
j)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
Contadores estadsticos
i. Tiempo recorrido actual.
ii.
Tiempo promedio total recorridos
Medidas de desempeo
i. Tiempo esperado
ii.
Tiempo real utilizado
#include <iostream>
#include lcgrand.h
int recorridos;
char sim_time, tipo;
float tiempoPromedioViajes, tiempoTotalViajesP, time_next_event,
prob_distrib_camA[3]={0.0,0.5,1.0}/*1 = camino 1; 2 = camino 2*/,
prob_distrib_camB[3]={0.0,0.8,1}/*1 = camino 3; 2 = camino 4*/,
prob_distrib_camC[3]={0.0,0.6,1}/*1 = camino 5; 2 = camino 6*/;
/* run this program using the console pauser or add your own getch,
system(pause) or input loop */
using namespace std;
void
void
void
int
float
initialize(void);
llegadaestacion(char T);
report(void);
random_integer(float prob_distrib []);
uniform(float a, float b);
initialize();
printf(Inicio de la XamaXacin \n);
while (recorridos <= 500){
llegadaestacion(tipo);
}
printf(Tiempo promedio total viajes %f, tiempoTotalViajesP/500);
return 0;
}
void initialize(void)
{
//sim_time = 0.0;
recorridos = 0;
43
time_next_event = 0.0;
44
tipo = A;
45
tiempoPromedioViajes = 0.0;
46
tiempoTotalViajesP = 0.0;
47
48 }
49
50 void llegadaestacion(char T){
51
int cam=0;
52
switch (T) {
53
case A:
54
tiempoPromedioViajes = 0.0;
55
printf(Recorrido %d Camino A , recorridos);
56
cam = random_integer(prob_distrib_camA);
57
if (cam == 1){
58
tiempoPromedioViajes += uniform(18, 22);
59
tipo = B;
60
}else{
61
tiempoPromedioViajes += uniform(14, 16);
62
tipo = C;
63
}
64
printf(%c , tipo);
65
break;
66
case B:
67
cam = random_integer(prob_distrib_camB);
68
if (cam == 1){
69
tiempoPromedioViajes += uniform(5, 6);
70
tipo = D;
71
}else{
72
tiempoPromedioViajes += uniform(6, 8);
73
tipo = E;
74
}
75
printf(%c , tipo);
76
break;
77
case C:
78
cam = random_integer(prob_distrib_camB);
79
if (cam == 1){
80
tiempoPromedioViajes += uniform(5, 7);
81
tipo = E;
82
}else{
83
tiempoPromedioViajes += uniform(8, 12);
84
tipo = F;
85
}
86
printf(%c , tipo);
87
break;
88
case D:
89
tiempoPromedioViajes += uniform(4, 6);
90
tipo = G;
91
printf(%c , tipo);
92
break;
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
case E:
tiempoPromedioViajes += uniform(5, 6);
tipo = G;
printf(%c , tipo);
break;
case F:
tiempoPromedioViajes += uniform(6, 9);
tipo = G;
printf(%c , tipo);
break;
case G:
tipo = A;
recorridos ++;
tiempoTotalViajesP += tiempoPromedioViajes;
printf(Tiempo = %f \n, tiempoPromedioViajes);
break;
}
}
int random_integer(float prob_distrib[])
{
int
i;
float u;
/* Generate a U(0,1) random variate. */
u = lcgrand(1);
/* Return a random integer in accordance with the (cumulative)
distribution
function prob_distrib. */
for (i = 1; u >= prob_distrib[i]; ++i)
;
return i;
}
float uniform(float a, float b) /* Uniform variate generation function. */
{
/* Return a U(a,b) random variate. */
return a + lcgrand(1) * (b a);
}