/*******
 **
 **   To compile:  mc cqnf2-new.m -o cqnf2-new -lm
 **
 *******/

/******************************************************************
 **
 **     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>
#include "maisie.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

entity basic_stats{char title[MAXTITLE]}
{
  message value {float val;} value;
  message clear {} clear;
  message output { char filename[MAXNAME]; } output;
  message dump {} dump;
  message terminate {} terminat;
  float total,minimum,temp,maximum,mean, t1;
  int count;
  int notdump;
  FILE *out;

  out = NULL;
  total=0;minimum=LARGE;maximum=0;count=0;
  notdump=1;
  for (;;)
    wait until 
      { mtype(value) {
	count++;
	temp=msg.value.val;
	total+=temp;
	if (temp>maximum) maximum=temp;
	if (temp<minimum) minimum=temp;
       } or mtype(output) {
	 out = fopen(msg.output.filename,"w");
       } or mtype(dump) {
	 notdump = 0;
	 if(!out)
	   out = stdout;
	 mean = total/ (count*1.0);
	 t1=ctf(sclock(self));
	 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);
       }or mtype(endsim) {
	 if(notdump) {
	   if(!out)
	     out = stdout;
	   mean = total/ (count*1.0);
	   t1=ctf(sclock(self));
	   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);
	 }
	 break;
       } or mtype(terminate) break;
      }
  if(out != stdout)
    fclose(out);
  terminate();
}

entity driver{}
{  ename rtr[N],q[N],stat1;
   int i;
   srand48(1000);
   stat1 = new basic_stats{"Average System Time"};
   for (i=0;i<N;i++)
     q[i] = new queue{NSRVR,MEAN,stat1};
   for (i=0;i<N;i++)
     rtr[i] = new router{NJOB,MAXTRIP,q};
   for (i=0;i<N;i++)
     invoke q[i] with idmsg{rtr[i]};  
   wait until mtype(endsim) {
     print_info();
     invoke stat1 with dump;
   }
 }

entity router{int njobs, int mtrips, ename qids[N]}
{
 message job{int stime; int count;} j1;
  int i;
  for (i=0;i<njobs;i++) {
    invoke qids[i%N] with job{0,0};
  }
  for (;;)
    wait until mtype(job) {
      j1=msg.job;
      if (j1.count < mtrips) {
	hold ((j1.stime-cti(sclock(self))));
	invoke qids[iurand(0,N-1)] with job=j1;}
    }
}

entity queue{int nsrvr, int mtime, ename statid}
{ int i,t1,lastj[NSRVR];
  ename rid;
  message job j1;
  message idmsg{ ename id;}	dummy_idmsg;
  wait until mtype(idmsg) rid= msg.idmsg.id;   
  for (i=0;i<nsrvr;i++)
    lastj[i]=0;
  for (;;)
    wait until mtype(job) {
      j1=msg.job;  
      t1=j1.stime;
      for (i=0;i<nsrvr;i++) {
	lastj[i]=MAX(t1,lastj[i]) + expon(mtime);
	t1=lastj[i];
      }
      invoke rid with job{t1,j1.count+1};
      invoke statid with value{(float)(t1-j1.stime)};
    }
}

int iurand(int b, int t)
{
  extern double drand48();

  int v = (int) drand48();
  if(t > 0)
    return((v % t) + b);
  else {
    fprintf(stderr,"iurand: wrong range (%d -- %d)\n", b, t);
    return -1;
  }
}

int expon(int mean)
{ 
  extern double drand48();
  extern double log();
  return(int)((-log((double)(1.0-drand48()))) * ((double) mean));
}

print_info()
{
  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);

}