#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include "version.h"
#include "types.h"
#include "functs.h"
#include "help.h"
#include "parse_settings.h"

#define TOP_LIST_LEN 10
#define EPOCH_LENGTH 1

int list_len=0;
int top_list_len=TOP_LIST_LEN;
int epoch_length=EPOCH_LENGTH;
int def_table_size=10007;

extern int settings[];

/***************************************
 * This program is modified for use in * 
 * benchmarking puposes. The complete  *
 * program was used in computer system *
 * research at Chalmers University of  *
 * Technology, Sweden. Chalmers has    *
 * nothing to do with this program.    *
 *                                     *
 * Plese feel free to distribute this  *
 * program as you like.                *
 *                                     *
 * Peter Rundberg, biff@ce.chalmers.se *
 ***************************************/


conf_list_t *list=NULL;
int first=1;
def_list_t **def_table=NULL;
hard_raw_t *hard_raw_list=NULL;


void init_def_table(int def_size) 
{
  int i;

  def_table=(def_list_t **)malloc(def_size*sizeof(def_list_t *));
 
  if (def_table==NULL) {
    fprintf(stderr,"Out of memory...\n");
    exit(1);
  }

  for (i=0;i<def_size;i++)
    def_table[i]=NULL;
}

void error(char *name)
{
  exit(1);
}

int main(int c, char *v[])
{
  FILE *fp,*graphfile=NULL;
  /* Benchmark stuff */
  char **indata_lines;
  int counter=0;
  uint32 mem_ops=0;
  /* End Benchmark stuff */
  int varv=-1;   /* We want to start counting at 0 */
  int place_in_varv=0;
  int place_in_epoch=0;
  int varv_in_epoch;
  char string[100];
  uint32 address;
  uint32 issue_no;
  int i;
  /* Settings */
  int data=1,name=0,verbose=0,speed=1,forward=1,fastspeed=0,imix=1;
  int load_pen=0,store_pen=0,nofile=1,kernel=3,cpulimit=0,configs=0;
  int show_speedup=3,thread_pen=0,commit_pen=0,use_epoch_length_as_num_of_epochs=0;
  /* End -- settings */
  uint32 data_pen_tot=0;
  epoch_t *epoch=NULL;
  int num_epochs=0,loops=0;
  trans_t *trans;
  load_store_t load_store; 
  char *settingsfile="analyzer.conf"; 

  fprintf(stderr,"Compile date: %s\n", COMPDATE);
  fprintf(stderr,"Compiler switches: %s\n", CFLAGS);

  if (c<2) {
    error(v[0]);
  }
 
  if (!nofile) {  
    parse_settings(settingsfile);
    
    /* Applying the setting determined by the settingsfile */
    load_pen=settings[0];
    store_pen=settings[1];
    data=settings[2];
    name=settings[3];
    speed=settings[4];
    fastspeed=settings[5];
    forward=!settings[6];
    imix=settings[7];
    verbose=!settings[8];
    epoch_length=settings[9];
    kernel=settings[10];
    cpulimit=settings[11];
    configs=settings[12];
    show_speedup=settings[13];
    thread_pen=settings[14];
    commit_pen=settings[15];
    use_epoch_length_as_num_of_epochs=settings[16];
  }
 
  init_def_table(def_table_size);

  fp=fopen(v[c-1],"r");
  if (!fp) {
    fprintf(stderr,"ERROR: \tCould not find file: %s\n\n",v[c-1]);
    error(v[0]);
  }
  
  do {
    fgets(string,100,fp);
  } while (string[0]!='E');
  
  num_epochs = atoi(string+5);
  loops=num_epochs;
  if (loops<epoch_length) {
    fprintf(stderr,"ERROR: Number of loop iterations is less than epoch length: %d<%d\n",num_epochs,epoch_length);
    exit(0); 
  }
  if (use_epoch_length_as_num_of_epochs) {
    epoch_length=num_epochs/epoch_length;
  }    
   
  if (num_epochs%epoch_length)
    num_epochs = num_epochs/epoch_length+1;
  else
    num_epochs = num_epochs/epoch_length;
  

  if (num_epochs==0) {
    fprintf(stderr,"File %s is empty\n",v[c-1]);
    exit(0);    
  }
  printf("Num_epochs: %d\n",num_epochs);
  rewind(fp);

  if (fastspeed)
    speedup_test(fp);
  
  if (imix)
    mem_ops=imix_test(fp);
  
  if (data || name || speed) {
    epoch=(epoch_t *)malloc(num_epochs*sizeof(epoch_t));
    if (!epoch) {
      fprintf(stderr,"ALERT: \tOut of memory, aborting...\n");
      exit(1);
    }
    for (i=0;i<num_epochs;i++) {
      epoch[i].trans=NULL;
      epoch[i].last=NULL;
      epoch[i].first_trans=1;
    }

    /* Read the indata file to memory before processing begins. */
    /* To eliminate effects of a slow disk subsystem. */
    /* We only want to benchmark CPU & Memory performance. */
    {
      char *indata_line;
      
      indata_lines=(char **)malloc((mem_ops+loops+10)*sizeof(char *));
      while(!feof(fp)) {
	indata_line=(char *)malloc(50*sizeof(char));
	fgets(indata_line,50,fp);
	indata_lines[counter++]=indata_line;
      }
    }
    
    counter=0;

    sscanf(indata_lines[counter++],"%s %lu",string,&issue_no);
 
  /* fprintf(stderr,"DEBUG: \tLabel %s at cycle %lu...\n",string,issue_no); */
    epoch[0].start_time=issue_no;
    varv_in_epoch=-1;
    place_in_varv=0;
    while (1) {
      if (!strcmp(string,"START:")) { 
	varv++;
	varv_in_epoch++;
	
	if (varv_in_epoch==epoch_length) {
	  place_in_varv=0;
	  varv_in_epoch=0;

	  sprintf(string,"%lx", address);

	  sscanf(string,"%lu",&issue_no);

	  issue_no+=data_pen_tot;
	  epoch[varv/epoch_length].start_time=issue_no;
	  if (varv/epoch_length)
	    epoch[varv/epoch_length-1].end_time=issue_no;
	}
	while(1) {

	  sscanf(indata_lines[counter++],"%s %lx %lu",string,&address,&issue_no);

	  issue_no+=data_pen_tot; 
	  if (!strcmp(string,"LD:")) {
	    data_pen_tot+=(uint32)load_pen;
	    load_store=load_op;
	    trans=(trans_t *)malloc(sizeof(trans_t));
	    trans->load_store=load_op;
	    trans->address=address;
	    trans->issue_no=issue_no-epoch[varv/epoch_length].start_time;
	    trans->next=NULL;
	    if (epoch[varv/epoch_length].first_trans) { 
	      epoch[varv/epoch_length].trans=trans;
	      epoch[varv/epoch_length].last=trans;
	      epoch[varv/epoch_length].first_trans=0;
	    } else {
	      epoch[varv/epoch_length].last->next=trans;
	      epoch[varv/epoch_length].last=trans;
	    }
	  } else if (!strcmp(string,"ST:")) {
	    data_pen_tot+=(uint32)store_pen;
	    load_store=store_op;
	    trans=(trans_t *)malloc(sizeof(trans_t));
	    trans->load_store=store_op;
	    trans->address=address;
	    trans->issue_no=issue_no-epoch[varv/epoch_length].start_time; 
	    trans->next=NULL;
	    def_list_mod(address,varv/epoch_length,place_in_varv); 
	    if (epoch[varv/epoch_length].first_trans) { 
	      epoch[varv/epoch_length].trans=trans; 
	      epoch[varv/epoch_length].last=trans;
	      epoch[varv/epoch_length].first_trans=0;
	    } else {
	      epoch[varv/epoch_length].last->next=trans; 
	      epoch[varv/epoch_length].last=trans;
	    }
	  } else {
	    break;
	  }
	  /* Place to put processing... */
	  if (data || speed) {
	    /* Search the epochs read so far for RAW conflicts */
	    if (load_store==load_op) {  
	      for (i=0;i<varv/epoch_length;i++) {
		trans=epoch[i].trans;
		place_in_epoch=-1;
		while (trans!=NULL) {   
		  place_in_epoch++;
		  if (trans->load_store==store_op && trans->address==address) {
		    def_list_t *def_placeholder=NULL;
		    def_placeholder=def_list_lookup(address);
		    if (def_placeholder!=NULL) {
		      if ((def_placeholder->epoch==i) && 
			  (def_placeholder->place_in_epoch==place_in_epoch)) {
			conflict_list(address);
			hard_raw_mod(address, i, place_in_epoch, trans->issue_no, varv/epoch_length, place_in_varv, issue_no-epoch[varv/epoch_length].start_time);
		      }
		    }
		  }
		  trans=(trans_t *)trans->next;
		}
	      }
	    } else {
	      
	    }
	  }
	  if (name) {
	    fprintf(stderr,"ALERT: \tName dependecy testing not implemented\n");
	    exit(1);
	  }
	  if (verbose && !(varv%10))
	    fprintf(stderr,"\rProcessing %3.2f %%    ", 100*(float)varv/(float)loops);
	  place_in_varv++;
	}
      } else if (!strcmp(string,"END:")) {
	if (verbose)
	  fprintf(stderr,"\rProcessing 100.00 %%    \n");
	break;
      } else {
	if (verbose)
	  fprintf(stderr,"\n");
	fprintf(stderr,"ERROR: \tWrong format on file %s\n",v[c-1]);
	exit(1);
      }
    }
  }
  
  
  if (data) {
    conf_list_t *conf_iterator=list;
    while (conf_iterator!=NULL) {
      printf("%d RAW:s for 0x%lx\n",conf_iterator->accesser, conf_iterator->address);
      conf_iterator=(conf_list_t *)conf_iterator->next;
    }
  }
  
  if (speed) { 
    epoch[varv/epoch_length].end_time=epoch[varv/epoch_length].start_time+epoch[varv/epoch_length].last->issue_no;
    
    if (forward)
      find_hard_raws();
    
    speedup_test(fp);
    
    if (kernel ==1) {
      specul_time_o(epoch, num_epochs,graphfile,show_speedup,thread_pen,commit_pen);
    } else if (kernel == 2) {
      specul_time_r(epoch, num_epochs, cpulimit,graphfile,show_speedup,thread_pen,commit_pen);
      if (configs) {
	for (i=1;i<=configs;) {
	  specul_time_r(epoch, num_epochs, i,graphfile,show_speedup,thread_pen,commit_pen);
	  i=i*2;
	}
      }
    } else if (kernel == 3) {
      specul_time_o(epoch, num_epochs,graphfile,show_speedup,thread_pen,commit_pen);
      specul_time_r(epoch, num_epochs, cpulimit,graphfile,show_speedup,thread_pen,commit_pen);
      if (configs) {
	for (i=1;i<=configs;) {
	  specul_time_r(epoch, num_epochs, i,graphfile,show_speedup,thread_pen,commit_pen);
	  i=i*2;
	}
      }
    } else {
      fprintf(stderr,"ALERT: \tNo such kernel present\n");
      exit(1);
    }
    
  }


  return 0;
}