//========================================================== file = gen.c =====
//=  A simulation of multiple traffic generators using pointers to functions  =
//=============================================================================
//=  Notes: This program is an example for Simulation (Spring 2005).          =
//=---------------------------------------------------------------------------=
//=  Build: Standard CSIM build                                               =
//=---------------------------------------------------------------------------=
//=  History: KJC (03/20/05) - Genesis                                        =
//=============================================================================
//----- Includes --------------------------------------------------------------
#include <stdio.h>        // Needed for printf()
#include "csim.h"         // Needed for CSIM18 stuff

//----- Constants -------------------------------------------------------------
#define SIM_TIME   4.0e4  // Simulation time
#define    MAX_N    1000  // Maximum number of generators

//----- Globals ---------------------------------------------------------------
FACILITY Server;          // CSIM facility for server

//----- Prototypes ------------------------------------------------------------
void generate(double lambda, double mu);       // Generate process
void queue1(double service_time);              // Queue process
void (* gen[MAX_N])(double lambda, double mu); // Pointer to a generate process

//=============================================================================
//==  Main program                                                           ==
//=============================================================================
void sim(void)
{
  double   lambda;      // Mean arrival rate (jobs/sec)
  double       mu;      // Mean service rate (jobs/sec
  int           n;      // Number of generators
  int           i;      // Loop couner

  // Increase the maximum processes
  max_processes(1000000);

  // Iterate for increasing number of generators
  for (n=25; n<501; n=n+25)
  {
    // Create the simulation
    create("sim");

    // Initializations
    Server = facility("Server for queue");
    mu = 100;
    lambda = (0.90 * mu) / n;
    for (i=0; i<n; i++)
      gen[i] = generate;

    // Output begin-of-simulation banner
    printf(">>> Simulation is running (SIM_TIME = %f sec) \n", SIM_TIME);

    // Initiate generate functions and hold for SIM_TIME
    for (i=0; i<n; i++)
      gen[i](lambda, mu);
    hold(SIM_TIME);

    // Output results
    printf("============================================================= \n");
    printf("==       *** CSIM multiple generators simulation ***       == \n");
    printf("============================================================= \n");
    printf("= SIM_TIME               = %f sec      \n", SIM_TIME);
    printf("= lambda                 = %f jobs/sec \n", lambda);
    printf("= Number of generators   = %d          \n", n);
    printf("=------------------------------------------------------------ \n");
    printf("= Utilization            = %f %%       \n", 100.0 * util(Server));
    printf("= Mean number in system  = %f jobs     \n", qlen(Server));
    printf("= Mean number in queue   = %f jobs     \n",
      qlen(Server) - util(Server));
    printf("= Response time          = %f sec      \n", resp(Server));
    printf("============================================================= \n");
    // One line output (grep on "&&)
    printf("&& %4d -- %f \n", n, qlen(Server));

    // Reset everything for a possible rerun
    rerun();
    reset_prob(1);
  }
}

//=============================================================================
//==  Process to generate arrivals                                           ==
//=============================================================================
void generate(double lambda, double mu)
{
  double  service_time;      // Service time

  create("generate");

  // Loop forever to create background traffic packets
  while(1)
  {
    // Hold for a packet interarrival time
    // hold(uniform(0.0, 2.0 / lambda));
    hold(exponential(1.0 / lambda));

    // Set the service time
    service_time = exponential(1.0 / mu);

    // Queue the customer
    queue1(service_time);
  }
}

//=============================================================================
//==  Process for queue                                                      ==
//=============================================================================
void queue1(double service_time)
{
  create("queue #1");

  // Reserve, hold, and release the node
  reserve(Server);
  hold(service_time);
  release(Server);
}