//==>>> SOLUTION FOR SUMMER 2013 CAP 4800 PROJECT <<<== file = cluster4.c =====
//=  Simple model of a cluster of single server queues (nodes)                =
//=   - Round robin load balancing of requests                                =
//=   - Setting number of active servers by a utilization threshold           =
//=   - Read arrival times from a trace file                                  =
//=============================================================================
//=  Notes:                                                                   =
//=    1) Need to set key parameters in #define                               =
//=    2) Adds code to compute 99%-tile                                       =
//=---------------------------------------------------------------------------=
//= Example execution (for server trace, CSIM report() elided):               =
//=                                                                           =
//=   =============================================================           =
//=   ==         *** Model of a cluster of servers ***           ==           =
//=   =============================================================           =
//=   = N                = 10 nodes                                           =
//=   = Mu               = 5.000000 req/sec                                   =
//=   = SAMPLE_INTERVAL  = 60.000000 sec                                      =
//=   = LOW_THRESH       = 7.100000 %                                         =
//=   = HIGH_THRESH      = 7.200000 %                                         =
//=   = INCREMENT        = 1                                                  =
//=   = DECREMENT        = 1                                                  =
//=   =============================================================           =
//=   = Total CPU time   = 4.634000 sec                                       =
//=   = Total sim time   = 2579428.218140 sec                                 =
//=   =------------------------------------------------------------           =
//=   = >>> Simulation results                                    -           =
//=   =------------------------------------------------------------           =
//=   = Mean number active = 3.246290 nodes                                   =
//=   = Mean response time = 0.233915 sec                                     =
//=   = 50% response time  = 0.200000 sec                                     =
//=   = 98% response time  = 0.332041 sec                                     =
//=   = 99% response time  = 0.498199 sec                                     =
//=   =------------------------------------------------------------           =
//=---------------------------------------------------------------------------=
//=  Build: Standard CSIM build                                               =
//=---------------------------------------------------------------------------=
//=  Execute: cluster4                                                        =
//=---------------------------------------------------------------------------=
//=  Author: Ken Christensen                                                  =
//=          University of South Florida                                      =
//=          WWW: http://www.csee.usf.edu/~christen                           =
//=          Email: christen@csee.usf.edu                                     =
//=---------------------------------------------------------------------------=
//=  History:   KJC (05/26/13) - Genesis                                      =
//=============================================================================
//----- Includes --------------------------------------------------------------
#include "csim.h"               // Needed for CSIM stuff
#include <stdlib.h>             // Needed for exit()

//----- Constants -------------------------------------------------------------
#define N                   10  // Number of nodes
#define SERVICE_TIME      0.20  // Service time
#define TRACE_FILE "trace.dat"  // Name of trace file
#define MAX_SIZE      10000000  // Maximum size of array X

#define SAMPLE_INTERVAL   60.0  // Sample interval for control
#define LOW_THRESH       0.071  // Low utilization threshold
#define HIGH_THRESH      0.072  // High utilization threshold
#define INCREMENT            1  // Increment value
#define DECREMENT            1  // Decrement value

//----- Globals ---------------------------------------------------------------
FACILITY Server[N];             // Server facilities
EVENT    DoneEvent;             // Done event
TABLE    ActiveTable;           // Table of number of active nodes
TABLE    ResponseTable;         // Table of response time
int      NumActive;             // Number of active nodes
int      CustCount[N];          // Customer count for each node
int      Count;                 // Overall customer count
double   *X;                    // Time series of response times

//----- Prototypes ------------------------------------------------------------
void generate(void);                      // Generator
void control(void);                       // Control
void balancer(void);                      // Balancer
void queue_node(int sta_id);              // Queue node
int  comp(const void *p, const void *q);  // Compare p and q for qsort()

//=============================================================================
//==  Main program                                                           ==
//=============================================================================
void sim(void)
{
  double  lambda;        // Mean arrival rate (req/sec)
  double  median;        // Median value
  double  percent_98;    // 98%-tile value
  double  percent_99;    // 99%-tile value
  int     i;             // Loop counter

  // Create the simulation
  create("sim");

  // Malloc space for X
  X = (double *) malloc(sizeof(double) * MAX_SIZE);
  if (X == NULL)
  {
    printf("*** ERROR - Could not malloc() enough space \n");
    exit(1);
  }

  // Parameter initializations
  for (i=0; i<N; i++)
    CustCount[i] = 0;
  NumActive = N;

  // CSIM inializations
  DoneEvent = event("Done event");
  facility_set(Server, "Server for modeling of node queue", N);
  ActiveTable = table("Table for number of active servers");
  ResponseTable = table("Table for response time");

  // Initiate generate and control and wait for Done event to be set
  generate();
  control();
  wait(DoneEvent);

  // Sort the series X
  qsort(X, Count, sizeof(double), comp);

  // Compute median precisely
  if ((Count % 2) == 1)
    median = X[Count / 2];
  else
    median = 0.5 * (X[(Count - 1) / 2] + X[(Count + 1) / 2]);

  // Compute percentiles with a round-down of index
  percent_98 = X[(int) (0.98 * Count)];
  percent_99 = X[(int) (0.99 * Count)];

  // Output results
  printf("============================================================= \n");
  printf("==         *** Model of a cluster of servers ***           == \n");
  printf("============================================================= \n");
  printf("= N                = %d nodes    \n", N);
  printf("= Mu               = %f req/sec  \n", (1.0 / SERVICE_TIME));
  printf("= SAMPLE_INTERVAL  = %f sec      \n", SAMPLE_INTERVAL);
  printf("= LOW_THRESH       = %f %%       \n", (100.0 * LOW_THRESH));
  printf("= HIGH_THRESH      = %f %%       \n", (100.0 * HIGH_THRESH));
  printf("= INCREMENT        = %d          \n", INCREMENT);
  printf("= DECREMENT        = %d          \n", DECREMENT);
  printf("============================================================= \n");
  printf("= Total CPU time   = %f sec      \n", cputime());
  printf("= Total sim time   = %f sec      \n", clock);
  printf("=------------------------------------------------------------ \n");
  printf("= >>> Simulation results                                    - \n");
  printf("=------------------------------------------------------------ \n");
  printf("= Mean number active = %f nodes  \n", table_mean(ActiveTable));
  printf("= Mean response time = %f sec    \n", table_mean(ResponseTable));
  printf("= 50%% response time  = %f sec   \n", median);
  printf("= 98%% response time  = %f sec   \n", percent_98);
  printf("= 99%% response time  = %f sec   \n", percent_99);
  printf("=------------------------------------------------------------ \n");
  report();
}

//=============================================================================
//==  Process to generate customers                                          ==
//==   - Reads interarrival times from a trace file                          ==
//=============================================================================
void generate(void)
{
  FILE    *tf;                  // Trace file pointer
  char    inString[80];         // Input string
  double  timeStamp;            // Delta time in seconds from trace file

  create("generate");

  // Open trace file
  tf = fopen(TRACE_FILE, "r");
  if (tf == NULL)
  {
    printf("  >>> ERROR in opening trace file '%s' \n", TRACE_FILE);
    exit(1);
  }

  // Loop to create requests
  while(1)
  {
    // Read and hold for an interarrival time
    fscanf(tf, "%s \n", inString);
    if (feof(tf)) break;
    timeStamp = atof(inString);
    hold(timeStamp);

    // Send to load balancer
    balancer();
  }

  // Out of loop and now set DoneEvent
  set(DoneEvent);
}

//=============================================================================
//==  Process to determine and control how many nodes to use                 ==
//=============================================================================
void control()
{
  double   meanCustCount;       // Mean customer count
  double   meanUtil;            // Mean utilization for the interval
  int      i;                   // Loop counter

  create("control");

  // Execute control loop forever
  while(1)
  {
    hold(SAMPLE_INTERVAL);

    // Determine mean utilization of all nodes
    meanCustCount = 0.0;
    for (i=0; i<NumActive; i++)
      meanCustCount = meanCustCount + CustCount[i];
    meanCustCount = meanCustCount / NumActive;
    meanUtil = (meanCustCount / SAMPLE_INTERVAL) / (1.0 / SERVICE_TIME);

    // Use thresholding to increment or decrement active nodes
    if (meanUtil > HIGH_THRESH)
    {
      NumActive = NumActive + INCREMENT;
      if (NumActive > N)
        NumActive = N;
    }
    else if (meanUtil < LOW_THRESH)
    {
      NumActive = NumActive - DECREMENT;
      if (NumActive == 0)
        NumActive = 1;
    }

    // Clear the CustCount variable for all nodes for the next iteration
    for (i=0; i<N; i++)
      CustCount[i] = 0;

    // Record the number of activ nodes
    record(NumActive, ActiveTable);
  }
}
//=============================================================================
//==  Function to round robin load balance to NumActive nodes                ==
//=============================================================================
void balancer(void)
{
  static int index = 0;     // Node index

  // Round robin balancing to NumActive nodes
  index = index + 1;
  index = index % NumActive;
  queue_node(index);
}

//=============================================================================
//==  Process for indexed single server queue                                ==
//=============================================================================
void queue_node(int sta_id)
{
  double   arriveTime;            // Time of request arrival
  double   responseTime;          // Measured response time

  create("queue_node");

  // Timestamp the arriving request
  arriveTime = clock;

  // Reserve, hold, and release server
  reserve(Server[sta_id]);
  hold(SERVICE_TIME);
  release(Server[sta_id]);

  // Record response time in ResponseTable and array X
  responseTime = clock - arriveTime;
  record(responseTime, ResponseTable);
  X[Count] = responseTime;
  if (Count == MAX_SIZE)
  {
    printf("*** ERROR - Array X[] is not lare enough \n");
    exit(1);
  }

  // Increment overall Count and CustCount for this node
  Count++;
  CustCount[sta_id]++;
}

//===========================================================================
//=  Function to compare two aruguments in an array of double               =
//=   - Needed by qsort()                                                   =
//===========================================================================
int  comp(const void *p, const void *q)
{
  double *ptr1 = (double *)(p);
  double *ptr2 = (double *)(q);

  if (*ptr1 < *ptr2)
    return -1;
  else if (*ptr1 == *ptr2)
    return 0;
  else
    return 1;
}