#include <stdio.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include <conio.h>
#include "snoopy.h"
#include "rnum.h"
//#define  queue_size 20000
//#define  hold_operation 400000
#define  UPPERTIME 1000000000.0 /* Events are within 0 and 1000 seconds */
#define ANUM 0.9

#define EVTALLOC(evt) \
if (evtfreelist) {\
	(evt) = evtfreelist;\
   evtfreelist = (evt)->next;\
} else {\
	(evt) = (struct event *)malloc(sizeof(*(evt)));\
   evt->next = NULL; \
}\

#define EVTFREE(evt) \
{\
	evt->next = evtfreelist;\
   evtfreelist = evt;\
}\

extern double TotQsch, TotSumQsch;
extern double TotBsch, TotSumBsch;
extern int	calNBuckets,calQSize,calBucketWidth,SmplIntv; 
extern int rescnt;  

// extern int Qsearch,Bsearch;  // not for scalq
/*
extern double QOP,BOP;		// not for dcalq
extern double myT,SumQsearch,SumBsearch; // not for dcalq
extern int  MAAECR,MAADCR,MAAECcnt,MAADCcnt;  // not for dcalq
extern int 	  Blsearch;  // not for dcalq
extern int Bs1,N1;  // not for dcalq
extern double BOP1;  // not for dcalq
*/


double MRT=0.0;


int queue_size,choice,typebench;
int hold_operation,UDOps=50;
struct event *evtfreelist = NULL;
double alldist();
void amain();
void resetall();
int mycnt=0;

void main(){
choice=6;typebench=1;
int u;
queue_size=800;hold_operation=100*800;
amain();
resetall();

	for(u=1000;u<31000;u=u+1000){
       queue_size=u;hold_operation=100*u;
       amain();
   	 resetall();
	}

 //getch();

}

void resetall(){
	TotQsch=0, TotSumQsch=0;
	TotBsch=0, TotSumBsch=0;

    rescnt=0;
//	Qsearch    =0; Bsearch    = 0;  // not for scalq
   mycnt=mycnt%4000;
   MRT=0.0;

   // not for dcalq
   /*
   QOP=0;BOP=0;
   MAAECR=0,MAADCR=0,MAAECcnt=0,MAADCcnt=0;
   SumQsearch =0; SumBsearch = 0;
   myT=2.0;
   Bs1=0;
   N1=0;
   BOP1=0;
   Blsearch=0;
	*/

}

void amain()
{

  int i,cnt,ops;
  struct event *evt;
  struct event *evt1;
  double PROB;



calInit(0, 2, 1, 0.0);
srand(2);
double strt,lopstrt,lopstp;
if (typebench==1){					// HOLD MODEL
  if (choice == 1) {
    ops=0;
    while(calQSize!=queue_size){
    	PROB=frandom();
    	if(PROB<ANUM){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * rectangle();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         if(evt1){
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
         }
    	}
    }
    strt=clock();
    for (i = 1; i <= hold_operation; i++) {
      ++ops;
		PROB=frandom();
    	if(PROB<0.5){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * rectangle();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         MRT= evt1->evt_time;
         EVTFREE(evt1);
    	}
    }
  }
  else if (choice == 2) {
    ops=0;
    while(calQSize!=queue_size){
    	PROB=frandom();
    	if(PROB<ANUM){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * triangle();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         if(evt1){
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
         }
    	}
    }
    strt=clock();
    for (i = 1; i <= hold_operation; i++) {
      ++ops;
		PROB=frandom();
    	if(PROB<0.5){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * triangle();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         MRT= evt1->evt_time;
         EVTFREE(evt1);
    	}
    }
  }
  else if (choice == 3) {
    ops=0;
    while(calQSize!=queue_size){
    	PROB=frandom();
    	if(PROB<ANUM){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * negtriangle();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         if(evt1){
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
         }
    	}
    }
    strt=clock();
    for (i = 1; i <= hold_operation; i++) {
      ++ops;
		PROB=frandom();
    	if(PROB<0.5){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * negtriangle();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         MRT= evt1->evt_time;
         EVTFREE(evt1);
    	}
    }
  }
  else if (choice == 4) {
    ops=0;
    while(calQSize!=queue_size){
    	PROB=frandom();
    	if(PROB<ANUM){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * camel70_20();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         if(evt1){
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
         }
    	}
    }
    strt=clock();
    for (i = 1; i <= hold_operation; i++) {
      ++ops;
		PROB=frandom();
    	if(PROB<0.5){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * camel70_20();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         MRT= evt1->evt_time;
         EVTFREE(evt1);
    	}
    }
  }
  else if (choice == 5) {
    ops=0;
    while(calQSize!=queue_size){
    	PROB=frandom();
    	if(PROB<ANUM){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * camel98_1();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         if(evt1){
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
         }
    	}
    }
    strt=clock();
    for (i = 1; i <= hold_operation; i++) {
      ++ops;
		PROB=frandom();
    	if(PROB<0.5){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * camel98_1();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         MRT= evt1->evt_time;
         EVTFREE(evt1);
    	}
    }
 }
 else{
    ops=0;
    while(calQSize!=queue_size){
    	PROB=frandom();
    	if(PROB<ANUM){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * alldist();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         if(evt1){
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
         }
    	}
    }
    strt=clock();
    for (i = 1; i <= hold_operation; i++) {
      ++ops;
		PROB=frandom();
    	if(PROB<0.5){
      	EVTALLOC(evt);
      	evt->evt_time = MRT + UPPERTIME * alldist();
      	enqueue(evt->evt_time, 0, evt);
    	}
      else{
         evt1=dequeue();
         MRT= evt1->evt_time;
         EVTFREE(evt1);
    	}
    }
  }
}
else{								// UP_DOWN MODEL
	strt=clock();
	if (choice == 1) {				// Rectangle
    ops=0;
    for( cnt = 0; cnt < UDOps ; cnt++) {
    	while(calQSize!=queue_size){
         ++ops;
    		PROB=frandom();
    		if(PROB<ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * rectangle();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
            if(evt1){
         		MRT= evt1->evt_time;
         		EVTFREE(evt1);
            }
    		}
    	}
      while(calQSize!=0){
         ++ops;
    		PROB=frandom();
    		if(PROB>ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * rectangle();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
    		}
    	}
    }
  }
  else if (choice == 2) {			// Triangle
    ops=0;
    for( cnt = 0; cnt < UDOps ; cnt++) {
    	while(calQSize!=queue_size){
         ++ops;
    		PROB=frandom();
    		if(PROB<ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * triangle();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
            if(evt1){
         		MRT= evt1->evt_time;
         		EVTFREE(evt1);
            }
    		}
    	}
      while(calQSize!=0){
         ++ops;
    		PROB=frandom();
    		if(PROB>ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * triangle();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
    		}
    	}
      //calInit(0, 2, 1, 0.0);MRT=0;
    }
  }
  else if (choice == 3) {			// Neg Trig
    ops=0;
    for( cnt = 0; cnt < UDOps ; cnt++) {
    	while(calQSize!=queue_size){
         ++ops;
    		PROB=frandom();
    		if(PROB<ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * negtriangle();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
            if(evt1){
         		MRT= evt1->evt_time;
         		EVTFREE(evt1);
            }
    		}
    	}
      while(calQSize!=0){
         ++ops;
    		PROB=frandom();
    		if(PROB>ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * negtriangle();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
    		}
    	}
    }
  }
  else if (choice == 4) {			// camel70_20
    ops=0;
    for( cnt = 0; cnt < UDOps ; cnt++) {
    	while(calQSize!=queue_size){
         ++ops;
    		PROB=frandom();
    		if(PROB<ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * camel70_20();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
            if(evt1){
         		MRT= evt1->evt_time;
         		EVTFREE(evt1);
            }
    		}
    	}
      while(calQSize!=0){
         ++ops;
    		PROB=frandom();
    		if(PROB>ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * camel70_20();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
    		}
    	}
    }
  }
  else if (choice == 5) {			// camel98_1
    ops=0;
    for( cnt = 0; cnt < UDOps ; cnt++) {
    	while(calQSize!=queue_size){
         ++ops;
    		PROB=frandom();
    		if(PROB<ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * camel98_1();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
            if(evt1){
         		MRT= evt1->evt_time;
         		EVTFREE(evt1);
            }
    		}
    	}
      while(calQSize!=0){
         ++ops;
    		PROB=frandom();
    		if(PROB>ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * camel98_1();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
    		}
    	}
    }
  }
  else {							// alldist
   ops=0;
  	for( cnt = 0; cnt < UDOps ; cnt++) {
    	while(calQSize!=queue_size){
         ++ops;
    		PROB=frandom();
    		if(PROB<ANUM){
      		EVTALLOC(evt);
      		evt->evt_time =  MRT + UPPERTIME * alldist();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
            if(evt1){
         		MRT= evt1->evt_time;
         		EVTFREE(evt1);
            }
    		}
    	}
      while(calQSize!=0){
         ++ops;
    		PROB=frandom();
    		if(PROB>ANUM){
      		EVTALLOC(evt);
      		evt->evt_time = MRT + UPPERTIME * alldist();
      		enqueue(evt->evt_time, 0, evt);
    		}
      	else{
         	evt1=dequeue();
         	MRT= evt1->evt_time;
         	EVTFREE(evt1);
    		}
    	}
    }
  }
}
double stp=clock();
lopstrt=clock();
if (typebench==1){
	for (i = 1; i <= ops; i++) {
   	PROB=frandom();
   	if(PROB>0.5){
   	}
   	else{
   	}
   }
}
else{
	for (i = 0; i < ops; i++) {
   	PROB=frandom();
      if(PROB>0.5){
      }
      else{
      }
   }
}
lopstp=clock();
 cout<<queue_size<<",";
 if(typebench==1)
     cout<<(double)(stp-strt+lopstrt-lopstp)/hold_operation<<",";
 else
     cout<<(double)(stp-strt+lopstrt-lopstp)/(cnt*queue_size)<<",";

 cout<<TotSumQsch/TotQsch<<",";
 cout<<TotSumBsch/TotBsch<<","<<calNBuckets<<","<<rescnt<<","<<endl;
 //cout<<intelcopy/(double)totres<<","<<totres<<endl;
 // PrintBucks();
 int y=calQSize;
 int totE=0;
 for (i = 1; i <=y ; i++) {
  		evt = (struct event *)dequeue();
      ++totE;
      //cout<<evt->evt_time<<endl;
      EVTFREE(evt);
 }
 //cout<<"TotE "<<totE<<endl;
 }


double alldist(){
int selnum;
double arnum;
	++mycnt;
      selnum=mycnt%4000;
      if(selnum<2000){
      	//arnum=0.9+0.1*triangle();
      	arnum=0.9+0.1*camel98_1();
      	//arnum=camel98_1();
      }
      else if(selnum>=2000 && selnum <4000){
          //arnum=0.0001*rectangle();
         arnum=0.0001*triangle();
      	//arnum=rectangle();
      }
      return arnum;
}