Subversion Repositories async_sdm_noc

/*
 Asynchronous SDM NoC
 (C)2011 Wei Song
 Advanced Processor Technologies Group
 Computer Science, the Univ. of Manchester, UK
 
 Authors: 
 Wei Song     wsong83@gmail.com
 
 License: LGPL 3.0 or later
 
 Simulation analyzer, gethering info. for performance analyses.
 
 Possible bugs:
 * the histograph function has not been tested yet.
 
 
 History:
 29/06/2010  Initial version. <wsong83@gmail.com>
 27/05/2011  Clean up for opensource. <wsong83@gmail.com>
 
*/
 
#include "sim_ana.h"
 
bool sim_ana::set_ana_parameters(double mwt, double mrp) {
  if((mwt < 0) || (mrp < 0))
    return false;
 
  warm_time = mwt;
  record_period = mrp;
  return true;
}
 
bool sim_ana::analyze_delay(string mfname) {
  ofstream file_handle;
 
  delay_ana = true;
  delay_file = mfname;
 
  file_handle.open(delay_file.data(), fstream::trunc);
  file_handle.close();
 
  return true;
}
 
bool sim_ana::analyze_throughput(string mfname) {
  ofstream file_handle;
 
  throughput_ana = true;
  throughput_file = mfname;
 
  file_handle.open(throughput_file.data(), fstream::trunc);
  file_handle.close();
 
  return true;
}
 
bool sim_ana::analyze_delay_histo(string mframe, double tstart, double tend, unsigned int binnum) {
  ofstream file_handle;
 
  if((tstart < 0) || (tend <= tstart) || (binnum < 3))
    return false;
 
  delay_histo_ana = true;
  delay_histo_file = mframe;
 
  file_handle.open(delay_histo_file.data(), fstream::trunc);
  file_handle.close();
 
  delay_histo_start = tstart;
  delay_histo_end = tend;
  delay_histo_gap = (tstart - tend) / (binnum - 2);
  delay_histo_binnum = binnum;
 
  histo_data = new unsigned long [binnum];
 
  for(unsigned int i=0; i<binnum; i++)
    histo_data[i] = 0;
 
  return true;
}
 
bool sim_ana::start(long mkey, double mtime) {
  sim_record<2> * mrd;
 
  mrd = new sim_record<2> (mtime, mkey);
 
  ANA.insert(*mrd);
 
  return true;
}
 
bool sim_ana::stop(long mkey, double mtime, unsigned int payload) {
  ofstream file_handle;
  sim_record<2> * mrd;
 
  mrd = ANA.find(mkey);
 
  if(mrd == NULL)
    return false;
 
  //  cout << mtime << "   "  << mtime - mrd->stamp[0] << endl;
 
  if(mtime < warm_time) {
    ANA.clear(mrd);
    return true;
  }
 
  if(delay_ana) {
    fm_dly += (mtime - mrd->stamp[0]);
    pth_dly += (mrd->stamp[1] -  mrd->stamp[0]);
  }
 
  if(throughput_ana) {
    th_value += payload;
  }
 
  if(delay_histo_ana) {
    double delay = mtime - mrd->stamp[0];
 
    if(delay >= delay_histo_end)
      histo_data[delay_histo_binnum-1]++;
    else {
      delay -= delay_histo_start;
      if(delay < 0)
	histo_data[0]++;
      else {
	histo_data[(unsigned long)(1 + delay/delay_histo_gap)]++;
      }
    }
  }
 
    ANA.clear(mrd);
 
  // check whether need to write out
  if(floor(mtime/record_period) > floor(last_time/record_period)) {
    if(delay_ana) {
      file_handle.open(delay_file.data(), fstream::app);
      file_handle << mtime << "\t" << fm_dly.avalue() << "\t" << pth_dly.avalue() << endl;
      file_handle.close();
    }
 
    if(throughput_ana) {
      file_handle.open(throughput_file.data(), fstream::app);
      file_handle << mtime << "\t" << th_value.value() << endl;
      file_handle.close();
    }
 
    last_time = mtime;
  }
 
 
  return true;
}
 
bool sim_ana::record(long mkey, double mtime) {
  sim_record<2> * mrd;
 
  mrd = ANA.find(mkey);
 
  if(mrd == NULL)
    return false;
 
  mrd->stamp[mrd->index] = mtime;
 
  return true;
}
 
 
sim_ana::~sim_ana() {
  ofstream file_handle;
 
  if(delay_histo_ana) {
    file_handle.open(delay_histo_file.data(), fstream::app);
 
    for(unsigned int i=0; i<delay_histo_binnum; i++)
      file_handle << (double)(delay_histo_start + i*delay_histo_gap) << "\t" << histo_data[i] << endl;
 
    file_handle.close();
  }
 
  if(histo_data != NULL)
    delete[] histo_data;
}