Hello friends, I have the following program ..

Code:
#include <stdio.h> 
#include <math.h> 
#include <stdlib.h> 
 
#define SERVIDORES 5 
#define NUMERO_COLAS 1 
#define MAX_EN_COLA 15 
 
typedef struct{ 
    int elem[MAX_EN_COLA]; 
    int cuenta; 
    int frente; 
    int ultimo; 
}cola_t; 
 
void ColaInicializar(cola_t *colap){ 
    colap->cuenta=colap->frente=colap->ultimo=0; 
} 
 
int ColaVacia(cola_t *colap){ 
    return colap->cuenta==0; 
} 
 
int ColaCuenta(cola_t *colap){ 
    return colap->cuenta; 
} 
 
int ColaMeter(cola_t *colap,int dato){ 
    if(colap->cuenta==MAX_EN_COLA) 
        return 0; 
    colap->cuenta++; 
    colap->elem[colap->ultimo]=dato; 
    colap->ultimo=(colap->ultimo+1)%MAX_EN_COLA; 
    return 1; 
} 
 
int ColaSacar(cola_t *colap,int *dato){ 
    if(colap->cuenta==0) 
        return 0; 
    colap->cuenta--; 
    *dato=colap->elem[colap->frente]; 
    colap->frente=(colap->frente+1)%MAX_EN_COLA; 
    return 1; 
} 
 
// Estructuras para colas y servidores 
 
cola_t colas[NUMERO_COLAS]; 
 
struct { 
    int minimo; 
    int maximo; 
    int acumulado; 
    int cantidad; 
    int max_longitud; 
} estadisticas_colas[NUMERO_COLAS]; 
 
struct { 
    int media_atencion; 
    int ocupado; 
    int ocupado_hasta; 
    int cola_que_atiende; 
    int numeros_atendidos; 
    int tiempo_acumulado; 
} servidores[SERVIDORES]; 
 
int t_simulacion = 32400, t_cierre = 28800; // Tiempos simulacion 
 
// Inicia colas 
 
void inicia_colas(void){ 
    int i; 
 
    for(i=0;i<NUMERO_COLAS;i++){ 
        ColaInicializar(&colas[i]); 
        estadisticas_colas[i].minimo = 28800; 
        estadisticas_colas[i].maximo = 0; 
        estadisticas_colas[i].acumulado = 0; 
        estadisticas_colas[i].cantidad = 0; 
        estadisticas_colas[i].max_longitud = 0; 
    } 
} 
 
// Inicia los servidores 
 
void inicia_servidores(void){ 
    int i; 
 
    for(i=0;i<SERVIDORES;i++){ 
        servidores[i].cola_que_atiende = i; 
        servidores[i].ocupado = 1; 
        servidores[i].ocupado_hasta =  150-i*10;    // tiempo inicio de atencion 
        servidores[i].media_atencion = 300+i*5; 
        servidores[i].numeros_atendidos = 0; 
        servidores[i].tiempo_acumulado = 0; 
    } 
} 
 
int cola_mas_corta(){ 
    int min, i, j; 
 
    j=0; 
    min=ColaCuenta(&colas[0]); 
    for(i=1; i<NUMERO_COLAS; i++) 
        if(min > ColaCuenta(&colas[i])){ 
            min = ColaCuenta(&colas[i]); 
            j = i; 
        } 
    return j; 
} 
 
void actualiza_estadisticas_colas(int cola,int intervalo){ 
    if(estadisticas_colas[cola].minimo > intervalo) 
        estadisticas_colas[cola].minimo = intervalo; 
    if(estadisticas_colas[cola].maximo < intervalo) 
        estadisticas_colas[cola].maximo = intervalo; 
    estadisticas_colas[cola].acumulado += intervalo; 
    estadisticas_colas[cola].cantidad ++; 
    if(estadisticas_colas[cola].max_longitud < ColaCuenta(&colas[cola])) 
        estadisticas_colas[cola].max_longitud = ColaCuenta(&colas[cola]); 
} 
 
void resumen_colas(void){ 
    int i, acumulado=0, cantidad=0; 
 
    printf("\nEstadisticas Colas\n\n"); 
    printf("\tCola Clientes Minimo Maximo Promedio Max_Cant\n"); 
    printf("\t=============================================\n"); 
    for(i=0;i<NUMERO_COLAS;i++){ 
        printf("\t%4d %8d %6d %6d %8.2f %8d\n",i,estadisticas_colas[i].cantidad, 
            estadisticas_colas[i].minimo,estadisticas_colas[i].maximo, 
            (float)estadisticas_colas[i].acumulado/estadisticas_colas[i].cantidad, 
            estadisticas_colas[i].max_longitud); 
            acumulado += estadisticas_colas[i].acumulado; 
            cantidad += estadisticas_colas[i].cantidad; 
    } 
    printf("\n\t Cantidad Atendida: %d Promedio: %.2f\n", 
            cantidad,(float)acumulado/cantidad); 
    printf("\n\t Intervalo de llegada medio: %.2f\n",(float)t_cierre/cantidad); 
} 
 
void resumen_servidores(void){ 
    int i, acumulado=0, cantidad=0; 
 
    printf("\nEstadisticas Servidores\n\n"); 
    printf("\tServidor Clientes Promedio T_Ocupado T_Desocupado\n"); 
    printf("\t=================================================\n"); 
    for(i=0;i<SERVIDORES;i++){ 
        printf("\t%8d %8d %8.2f %9d %12d\n",i,servidores[i].numeros_atendidos, 
            (float)servidores[i].tiempo_acumulado/servidores[i].numeros_atendidos, 
            servidores[i].tiempo_acumulado, t_simulacion-servidores[i].tiempo_acumulado); 
            acumulado += servidores[i].tiempo_acumulado; 
            cantidad += servidores[i].numeros_atendidos; 
    } 
    printf("\n\t Cantidad Atendida: %d Promedio: %.2f\n", 
            cantidad,(float)acumulado/cantidad); 
} 
 
// Calcula el intervarlo entre llegadas segun una distribucion exponencial 
 
int intervalo(float lambda){ 
    float u,x; 
 
    u = (float)rand() / RAND_MAX; 
    x = -1.0*(float)log((double)(1.0-u)) * lambda; 
    return (int)x; 
} 
 
int main(void) { 
    int t_actual = 0, t_proximo; 
    int t, c, i; 
    int lambda_cliente = 60; 
 
    inicia_servidores(); 
    inicia_colas(); 
    t_proximo = intervalo(lambda_cliente); 
    while(t_actual <= t_simulacion){ 
        while(t_actual <= t_cierre && t_actual == t_proximo){ 
            c = cola_mas_corta(); 
            ColaMeter(&colas[c],t_actual); 
            t_proximo = t_actual + intervalo(lambda_cliente); 
        } 
        for(i=0;i<SERVIDORES;i++){ 
            if(servidores[i].ocupado && servidores[i].ocupado_hasta == t_actual) 
                servidores[i].ocupado = 0; 
            if(!servidores[i].ocupado){ 
                c = servidores[i].cola_que_atiende; 
                for(i=0;i<SERVIDORES;i++){ 
                    actualiza_estadisticas_colas(c,t_actual-t); 
                    t = intervalo(servidores[i].media_atencion); 
                    servidores[i].ocupado = 1; 
                    servidores[i].numeros_atendidos++; 
                    servidores[i].tiempo_acumulado +=t ; 
                    servidores[i].ocupado_hasta = t_actual + t + 5; 
                } 
            } 
        } 
        t_actual++; 
    } 
    resumen_colas(); 
    resumen_servidores(); 
    return EXIT_SUCCESS; 
}
Is a discrete event-based simulation.

And then, just need to work with 5 servers, but with a single queue ... I did it that way as you can see in the code from the link above, but not how to make me work well with 5 servers with the same configuration, but using only a single queue. Can someone help me to modify my code? .