/*******
 **
 **   To compile:  pcc cqnf2.pc -o cqnf2.seq -lm
 **   Converted to PARSEC on 10-9-97 by Monnica Terwilliger
 **
 *******/

/******************************************************************
 **
 **     Simulation of a Closed Queueing Network with FCFS servers
 **    
 **     This is a simulation of a closed network with N fully connected
 **     switches. Each switch is a tandem queue of Q fifo servers.
 **     A job that arrives at a queue is served sequentially (FCFS)
 **     by the Q servers and is thereafter routed to one of the 
 **     N neighboring switches (including itself) with equal 
 **     probability.
 ** 
 **     Entities defined in the program:
 **              (1) driver: initiates the simulation
 **              (2) router: distributes jobs to N neighbors
 **              (3) queue:  models the tandem queue
 **
 ******************************************************************/

#include <stdio.h>

#define N 		16
#define NSRVR		10
#define NJOB		16
#define MAXTRIP		10
#define MEAN		10
#define MAX(A, B)	(A>B?A:B)

#define MAXTITLE	70
#define LARGE 		1.0e19
#define MAXNAME		64

message Value { float val;};
message Clear {};
message Output { char filename[MAXNAME]; };
message Terminate {};
message job { int stime; int count;};
message idmsg { ename id;};

entity queue(int, int, int, ename);
entity router(int, int, int, ename [N]);
entity basic_stats (char [MAXTITLE]);

int iurand(int, int, unsigned short[3]);
int expon(int, unsigned short[3]);

entity basic_stats (char title[MAXTITLE])
{
  float total, minimum, temp, maximum, mean, t1;
  int count;
  FILE *out;

  out = NULL;
  total=0; minimum=LARGE; maximum=0; count=0;
  for (;;)
  { 	receive (Value value) {
		count++;
		temp=value.val;
		total+=temp;
		if (temp>maximum) maximum=temp;
		if (temp<minimum) minimum=temp;
       	} 
     or receive (Output output) {
	 	out = fopen(output.filename,"w");
       	} 
      or receive (Terminate signal) break;
  }
  if(out != stdout)
    fclose(out);
  finalize {
	   	if (!out) out = stdout;
	   	mean = total/ (count*1.0);
	   	t1= (float) simclock();
	   	fprintf(out,"\nBasic Statistics dump at simulation time: %f\n",t1);
	   	fprintf(out,"\nStatistics Collected: %s\n",title);
	   	fprintf(out,"Total number of values: %d\n", count);
	   	fprintf(out,"            Mean value: %.5f\n", mean);
	   	fprintf(out,"         Maximum value: %.5f\n", maximum);
	   	fprintf(out,"         Minimum value: %.5f\n", minimum);
	   	fflush(out);
   }

}

entity driver ()
{  ename rtr[N],q[N],stat1;
   int i;
   stat1 = new basic_stats("Average System Time");
   for (i=0;i<N;i++)
     q[i] = new queue(i, NSRVR, MEAN, stat1);
   for (i=0;i<N;i++)
     rtr[i] = new router(i, NJOB, MAXTRIP, q);
   for (i=0;i<N;i++)
     send idmsg{rtr[i]} to q[i];  

  finalize {
    printf("\nCQNF Configuration simulated:\n");
    printf("\t         Number of routers =\t%d\n", N);
    printf("\tInitial no. of jobs/router =\t%d\n", NJOB);
    printf("\t   Number of servers/queue =\t%d\n", NSRVR);
    printf("\t       Number of trips/job =\t%d\n", MAXTRIP);
  }
}

entity router (int id, int njobs, int mtrips, ename qids[N])
{
  int i;
  unsigned short seed[3];
  seed[0] = seed[1] = seed[2] = id;

  for (i=0;i<njobs;i++) {
    send job{0,0} to qids[i%N];
  }
  for (;;)
    receive (job j1) {
      if (j1.count < mtrips) {
	hold (j1.stime-(int)simclock());
	send j1 to qids[iurand(0,N-1,seed)];}
    }
}

entity queue(int id, int nsrvr, int mtime, ename statid)
{ int i,t1,lastj[NSRVR];
  ename rid;
  unsigned short seed[3];
  seed[0] = seed[1] = seed[2] = id;

  receive (idmsg dummy_idmsg) rid=dummy_idmsg.id;   
  for (i=0;i<nsrvr;i++)
    lastj[i]=0;
  for (;;)
    receive(job j1) 
    {
      t1=j1.stime;
      for (i=0;i<nsrvr;i++) {
		lastj[i]=MAX(t1,lastj[i]) + expon(mtime,seed);
		t1=lastj[i];
      }
      send job{t1,j1.count+1} to rid;
      send Value{(float)(t1-j1.stime)} to statid;
    }
}

int iurand(int b, int t, unsigned short seed[3])
{
  int v = (int) pc_erand(seed);
  if(t > 0)
    return((v % t) + b);
  else {
    fprintf(stderr,"iurand: wrong range (%d -- %d)\n", b, t);
    return -1;
  }
}

int expon(int mean, unsigned short seed[3])
{ 
  extern double log();
  return(int)((-log((double)(1.0-pc_erand(seed)))) * ((double) mean));
}