/*******
 **
 **   To compile:  mc cqnf2.m -o cqnf2 -lmaisie -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 "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)
extern entity basic_stats{};
extern entity router{};
extern entity queue{};
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{njobs,mtrips,qids}
int njobs, mtrips;
e_name 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())));
	invoke qids[iurand(0,N-1)] with job=j1;}
    }
}

entity queue{nsrvr, mtime, statid}
int nsrvr,mtime; ename statid;
{ int i,t1,lastj[NSRVR];
  ename rid;
  message job{int stime; int count;} 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(b,t)
  int b,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(mean)
  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);

}