// Test of random procedures to be used in CS 471 project.

//              **** BE WARNED! *****              

// I have modified this code but have NOT tested it.
// It is not my intent, but you may be in for some
// surprises.
//              **** BE WARNED! ***** 

// Code has been compiled using gcc release 3.3.2 and Visual C++

#include <iostream>
#include <iomanip>
#include <cmath>      // for log function
#include <cstdlib>    // for rand functon, RAND_MAX constant

using namespace std;

#define HIST_SIZE 10
#define NUM_PARMS 50
#define NUM_ADDRESSES 50
#define LIST_SIZE 50

// F_RAND computes uniformly generated random variables between 0 and 1
#define F_RAND (rand()/(float)RAND_MAX)

// Generate negexponential random variates with mean mean
float negexp(
      float mean )

  // Procedures called:
  //   rand:  to generate uniformly distributed random variates.

  // Discussion:  the justification for the code can be found in
  //   most any elementary simulation text.

{ // function negexp
  return -mean*log( F_RAND );
} // function negexp

// Generate program attributes:  program name, 
//   program size, program type, program priority
void task_characteristics(
      int   max_address,
      float percent_interactive, 
      int   *program_name,
      int   *program_size,
      int   *program_type,
      int   *program_priority )

  // Procedures called:
  //   rand:  to generate uniformly distributed random variates.

#define NUM_PROGS 25
#define MAX 10
#define MIN 4

{ // function task_characteristics

  *program_name = int( NUM_PROGS*F_RAND) + 1;
  *program_size = int( max_address*F_RAND ) + 1;

  if ( F_RAND<percent_interactive )
    *program_type = 1;
  else
    *program_type = 0;

  if ( *program_type == 1 )
	*program_priority = 3;
  else
	*program_priority = rand()%(MAX-MIN+1) + MIN;

} // function task_characteristics

// Generate tasks with properties for task list.
void task_list_characteristics(
      int   max_exec_time,
      float mean_interarrival_time,
      int   *interarrival_time,
      int   *execution_time )

  // Procedures called:
  //   negexp:  to generate negative exponentioa random variates.

{ // function task_list_characteristics

  *interarrival_time = int( negexp( mean_interarrival_time ) );
  *execution_time = int( max_exec_time*F_RAND ) + 1;

} // function task_list_characteristics

// Generate next memory address (with specified locality)
int next_address(
      int max_address,
      int this_address,
      float locality )

// Discussion:
//   The new address is likely to be near the current address
//   (we are using an exponential distribution).  Increasing
//   the "locality" will cause the addresses to be closer
//   (i.e. exhibit more locality).

// Procedures called:
//   rand:  used to generate uniformly distributed random
//          variates.

{ // function next_address

  int  random_address;
  int  address_diff;
  int  new_address;

  random_address = int( max_address*F_RAND  + 0.5);

  if ( random_address < this_address )
  {
    do
      address_diff = int( ( -this_address/locality )*
        log( F_RAND ) + 0.5 );
    while ( address_diff > this_address );
    new_address = this_address - address_diff;
  }
  else
  {
    do
    {
      random_address = max_address - this_address;
      address_diff = int( ( -random_address/locality )*
        log( F_RAND ) + 0.5 );
    } while ( address_diff > random_address );
    new_address = this_address + address_diff;
  }

  return new_address;

} // function next_address

int main()

{
  int i;

  // Initialize random stream
    srand( 56329 );

  //Simple test of function rand.
    int hist[ HIST_SIZE ], index, num_vars;
    cout << "Test of function rand" << endl;
    cout << "num_vars: "; cin >> num_vars;
    // Initialize array
      for ( i=0; i<HIST_SIZE; i++ )
        hist[ i ] = 0;
    for ( i=0; i<num_vars; i++ )
    {
      index = int( HIST_SIZE * F_RAND );
      hist[ index ]++;
    }
    cout << "  Index Count" << endl;
    for ( i= 0; i<HIST_SIZE; i++ )
      cout << setw( 5) << i << setw( 7 ) << hist[ i ] << endl;
    cout << endl;

  //Simple test of function negexp.
    float mean, x, sum=0;
    cout << "Test of function negexp" << endl;
    cout << "num_vars: "; cin >> num_vars;
    cout << "mean: "; cin >> mean;
    for ( i=0; i<num_vars; i++ )
    {
      x = negexp( mean );
      sum += x;
      cout << x << endl;
    }
    cout << "Avg: " << sum/num_vars << endl << endl;

  // Test of function task_characteristics.
    int max_address, program_name, program_size, program_type, program_priority;
    float percent_interactive;
    cout << "Test of function task_characteristics" << endl;
    cout << "max_address: "; cin >> max_address;
    cout << "percent_interactive: "; cin >> percent_interactive; cout << endl;
    cout << "  Program Program Program  Program" << endl;
    cout << "    Name    Size    Type  Priority" << endl;
    for ( i=1; i<NUM_PARMS; i++ )
    {
      task_characteristics( max_address, percent_interactive/100.0, &program_name,
         &program_size, &program_type, &program_priority );
      cout << setw( 8 ) << program_name << setw( 9 ) << program_size 
        << setw( 6 ) << program_type << setw( 7 ) << program_priority << endl;
    }
    cout << endl;

  // Test of function task_list_characteristics.
    int clock = 0;
    int max_exec_time, interarrival_time, execution_time;
    float mean_interarrival_time;

    cout << "Test of function task_list_characteristics" << endl;
    cout << "max_exec_time: "; cin >> max_exec_time;
    cout << "mean_interarrival_time: "; cin >> mean_interarrival_time; cout << endl;
    cout << "  Program Arrival Execution" << endl;
    cout << "    Name    Time    Time" << endl;
    for ( i=1; i<LIST_SIZE; i++ )
    {
      task_list_characteristics( max_exec_time, mean_interarrival_time,
	&interarrival_time, &execution_time );
      clock += interarrival_time;
      cout << setw( 8 ) << i << setw( 7 ) << clock
        << setw( 10 ) << execution_time << endl;
    }
    cout << endl;

  // Test of function next_address.
    int current_address;
    float locality;
    cout << "Test of function next_address" << endl;
    cout << "max_address: "; cin >> max_address;
    cout << "locality: "; cin >> locality;
    current_address = 0;
    cout << "  Maximum permissible address: " << max_address << endl;
    cout << "  Locality factor:             " << locality << endl;
    cout << "  Starting address:            " << current_address << endl << endl;
    cout << "           New" << endl;
    cout << "   Ct    Address" << endl;
    for ( i=1; i< NUM_ADDRESSES; i++ )
    {
      current_address = next_address( max_address, current_address, locality );
      cout << setw( 5 ) << i << setw( 10 ) << current_address << endl;
    }

    return 0;

  } // function main