/******************************************************************
**
**     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"
#include <values.h>
#define MAXN 		16
#define MAXNSRVR	20 	
#define NSWTCH 		16
#define NSRVR		5
#define NJOB 		96
#define MAXCLOK		"3000"
#define MEAN		10
#define MAXTRIP		20
#define MAX(A, B)	(A>B?A:B)
entity driver{argc,argv}
int argc;
char **argv;
{  
   	ename q[MAXNSRVR+1][MAXN];
   	int i,j;
  	printf("\nCQNF Configuration simulated:\n");
  	printf("\t         Number of routers =\t%d\n", NSWTCH);
  	printf("\tInitial no. of jobs/router =\t%d\n", NJOB);
  	printf("\t   Number of servers/queue =\t%d\n", NSRVR);
  	printf("\t       MAXCLOCK            =\t%s\n", MAXCLOK);
   	maxclock(MAXCLOK);
   	if(NSRVR < 1 || NSWTCH < 1){
	  	printf(" can't simulate less than 1 servers or switches\n");
   	}
   	for (i=0;i<NSWTCH;i++){
        	for(j=0;j<NSRVR;j++){
		   	q[j][i]=new queue{self,MEAN,i*NSRVR+j,NSWTCH} at i;
   		}
        	q[NSRVR][i]= new router{self,i,NJOB,NSWTCH} at i;
   	}
   	for(i=0;i<NSWTCH;i++){
       		invoke q[NSRVR][i] with your_dests{q[0]};
       		for(j=0;j<NSRVR;j++)
		  	invoke q[j][i] with your_dest{q[j+1][i]};  
   	}
}

entity router{creator,r_id,njobs,nswitches}
ename creator;
int r_id,njobs, nswitches;
{ 
  message job{int id,count,t_wait,t_serv,dep;} j1;
  message your_dests{ename ids[MAXN];} yo;
  int i;
  unsigned short seed[3];
  e_name qids[MAXN];   
  wait until mtyp(your_dests);
  for(i=0;i<nswitches;i++){
	qids[i]=msg.your_dests.ids[i];
  }
  seed[0]=seed[1]=seed[2]=r_id;
  for (i=0;i<njobs;i++) {
    invoke qids[i%nswitches] with job{r_id*njobs+i,0,0,0,sclock()};
  }
  while(1){
    wait until mtype(job) {
      j1=msg.job;
      j1.count++;
      j1.dep=sclock();
      invoke qids[iurand(r_id,nswitches,seed)] with job=j1;
    }
  }
}

entity queue{creator,mtime,sseed,nswitches}
ename creator;
int mtime,sseed,nswitches;
{ 
  ename rid;
  message job{int id,count,t_wait,t_serv,dep;} j1;
  message your_dest{ ename id;} idm;
  unsigned short seed[3];
  int ntime,i,j;
  seed[0]=seed[1]=seed[2]=sseed;
  wait until mtyp(your_dest);
  rid=msg.your_dest.id;
  ntime=expon(mtime,seed);
  for (;;)
    wait until mtype(job) {
      j1=msg.job;
      j1.t_wait += sclock()-j1.dep;
      j1.t_serv++;
      hold(ntime);
      ntime=expon(mtime,seed);
      j1.dep=sclock();
      invoke rid with job=j1;
    }
}

int iurand(b,t,seed)
  int b,t;
  unsigned short seed[3];
{
  extern long nrand48();

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

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