//====================================================== file = as3_2_1.c =====
//=  Simulation of data transfer reliability using N block transfers          =
//=============================================================================
//=  Notes:                                                                   =
//=    1) This program is for assignment #2 for CAP 4800 (Simulation) for     =
//=       Summer 2013. This is an example of a Monte Carlo simulation.        =
//=    2) The key input parameters are N and PR_BAD in the constants section  =
//=---------------------------------------------------------------------------=
//=  Build: bcc32 as3_2_1.c, cl as3_2_1.c, gcc as3_2_1.c -o as3_2_1           =
//=---------------------------------------------------------------------------=
//=  Execute: as3_2_1                                                         =
//=---------------------------------------------------------------------------=
//=  Sample execution:                                                        =
//=                                                                           =
//=   >>> The simulation is running...                                        =
//=   =============================================================           =
//=   ==      *** Results from data transfer simulation ***      ==           =
//=   =============================================================           =
//=   =  MODEL INPUT:                                                         =
//=   =    Number of transfer iterations      = 10000000                      =
//=   =    Number of blocks per transfer      = 3                             =
//=   =    Probability of a block being bad   = 0.100000                      =
//=   =============================================================           =
//=   =  MODEL OUTPUT:                                                        =
//=   =    Success percentage = 99.898240 %                                   =
//=   =============================================================           =
//=---------------------------------------------------------------------------=
//=  History: KJC (05/21/13) - Genesis (from as3_2_1.c from summer 2011)      =
//=============================================================================
//----- Include files ---------------------------------------------------------
#include <stdio.h>            // Needed for printf()

//----- Constants -------------------------------------------------------------
#define NUM_ITER 10000000     // Number of iterations to simulate
#define N               5     // Number of blocks transferred per iteration
#define PR_BAD       0.05     // Probability that a given block is corrupted

//----- Function prototypes ---------------------------------------------------
double rand_val(void);        // Generate uniform RV between 0.0 and 1.0

//===== Main program ==========================================================
void main(void)
{
  int    lostDataCount;   // Count for lost data (none of N nlocks are good)
  int    goodDataCount;   // Count for good data (at least 1 block is good)
  int    lostBlockCount;  // Count for lost blocks
  double successPercent;  // Success percentage
  int    i, j;            // Loop counters

  // Output a "running" banner
  printf(">>> The simulation is running... \n");

  // Run the simulation for NUM_PKTS unqiue packets
  lostDataCount = goodDataCount = 0;
  for (i=0; i<NUM_ITER; i++)
  {
    // Transfer the block N times and simulate corruption
    lostBlockCount = 0;
    for (j=0; j<N; j++)
      if (rand_val() <= PR_BAD)
        lostBlockCount++;

    // Are all blocks lost or did some make it through?
    if (lostBlockCount == N)
      lostDataCount++;
    else
      goodDataCount++;
  }

  // Compute success percentage
  successPercent =
    100.0 * ((double) goodDataCount / (goodDataCount + lostDataCount));

  // Output results
  printf("============================================================= \n");
  printf("==      *** Results from data transfer simulation ***      == \n");
  printf("============================================================= \n");
  printf("=  MODEL INPUT:                                               \n");
  printf("=    Number of transfer iterations      = %d \n", NUM_ITER);
  printf("=    Number of blocks per transfer      = %d \n", N);
  printf("=    Probability of a block being bad   = %f \n", PR_BAD);
  printf("============================================================= \n");
  printf("=  MODEL OUTPUT:                                              \n");
  printf("=    Success percentage = %f %%              \n", successPercent);
  printf("============================================================= \n");
}

//=========================================================================
//= Multiplicative LCG for generating uniform(0.0, 1.0) random numbers    =
//=   - x_n = 7^5*x_(n-1)mod(2^31 - 1)                                    =
//=   - With x seeded to 1 the 10000th x value should be 1043618065       =
//=   - From R. Jain, "The Art of Computer Systems Performance Analysis," =
//=     John Wiley & Sons, 1991. (Page 443, Figure 26.2)                  =
//=========================================================================
double rand_val(void)
{
  const long  a =      16807;  // Multiplier
  const long  m = 2147483647;  // Modulus
  const long  q =     127773;  // m div a
  const long  r =       2836;  // m mod a
  static long x = 1;           // Random int value (seed is set to 1)
  long        x_div_q;         // x divided by q
  long        x_mod_q;         // x modulo q
  long        x_new;           // New x value

  // RNG using integer arithmetic
  x_div_q = x / q;
  x_mod_q = x % q;
  x_new = (a * x_mod_q) - (r * x_div_q);
  if (x_new > 0)
    x = x_new;
  else
    x = x_new + m;

  // Return a random value between 0.0 and 1.0
  return((double) x / m);
}