sc_isdb_trace.cpp

来自「基于4个mips核的noc设计」· C++ 代码 · 共 1,876 行 · 第 1/4 页

{
  isdb_id = ISDB_DefineSignal (database, ISDB_Integer, name);
  write(database);
}

bool isdb_signed_int_trace::changed()
{
    return object != old_value;
}

void isdb_signed_int_trace::write(ISDB_Conn database)
{
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}

/*****************************************************************************/

class isdb_signed_short_trace : public isdb_trace {
public:
    isdb_signed_short_trace(const short& object, const sc_string& name_, const sc_string& isdb_name_, int width_);
    void declare_variable(ISDB_Conn database);
    void write(ISDB_Conn database);
    bool changed();

protected:
    const short& object;
    short old_value;
    unsigned short mask; 
};


isdb_signed_short_trace::isdb_signed_short_trace(const short& object_, const sc_string& name_, const sc_string& isdb_name_, int width_) 
  : isdb_trace( name_, isdb_name_), object( object_)
{
    bit_width = width_;
    if (bit_width < 16) {
        mask = static_cast<unsigned short>( ~(-1 << bit_width) );
    } else {
        mask = static_cast<unsigned short>( -1 ); // 0xffff
    }

    isdb_var_typ_name = "wire";
    old_value = object;
}

void isdb_signed_short_trace::declare_variable (ISDB_Conn database)
{
  isdb_id = ISDB_DefineSignal (database, ISDB_Integer, name);
  write(database);
}


bool isdb_signed_short_trace::changed()
{
    return object != old_value;
}


void isdb_signed_short_trace::write(ISDB_Conn database)
{
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}

/*****************************************************************************/

class isdb_signed_char_trace : public isdb_trace {
public:
    isdb_signed_char_trace(const char& object, const sc_string& name_, const sc_string& isdb_name_, int width_);
    void declare_variable(ISDB_Conn database);
    void write(ISDB_Conn database);
    bool changed();

protected:
    const char& object;
    char old_value;
    unsigned char mask; 
};


isdb_signed_char_trace::isdb_signed_char_trace(const char& object_, const sc_string& name_, const sc_string& isdb_name_, int width_) 
  : isdb_trace( name_, isdb_name_), object( object_)
{
    bit_width = width_;
    if (bit_width < 8) {
        mask = static_cast<unsigned char>( ~(-1 << bit_width) );
    } else {
        mask = static_cast<unsigned char>( -1 ); // 0xff
    }

    isdb_var_typ_name = "wire";
    old_value = object;
}

void isdb_signed_char_trace::declare_variable (ISDB_Conn database)
{
  isdb_id = ISDB_DefineSignal (database, ISDB_Integer, name);
  write(database);
}


bool isdb_signed_char_trace::changed()
{
    return object != old_value;
}


void isdb_signed_char_trace::write(ISDB_Conn database)
{
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}

/*****************************************************************************/

class isdb_signed_long_trace : public isdb_trace {
public:
    isdb_signed_long_trace(const long& object, const sc_string& name_, const sc_string& isdb_name_, int width_);
    void declare_variable(ISDB_Conn database);
    void write(ISDB_Conn database);
    bool changed();

protected:
    const long& object;
    long old_value;
    unsigned long mask; 
};


isdb_signed_long_trace::isdb_signed_long_trace(const long& object_, const sc_string& name_, const sc_string& isdb_name_, int width_) 
  : isdb_trace( name_, isdb_name_), object( object_)
{
    bit_width = width_;
    if (bit_width < 32) {
        mask = ~(-1 << bit_width);
    } else {
        mask = static_cast<unsigned long>( -1 ); // 0xffffffff
    }

    isdb_var_typ_name = "wire";
    old_value = object;
}

void isdb_signed_long_trace::declare_variable (ISDB_Conn database)
{
  isdb_id = ISDB_DefineSignal (database, ISDB_Integer, name);
  write(database);
}


bool isdb_signed_long_trace::changed()
{
    return object != old_value;
}


void isdb_signed_long_trace::write(ISDB_Conn database)
{
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}


/*****************************************************************************/

class isdb_float_trace : public isdb_trace {
public:
    isdb_float_trace(const float& object, const sc_string& name_, const sc_string& isdb_name_);
    void declare_variable(ISDB_Conn database);
    void write(ISDB_Conn database);
    bool changed();

protected:    
    const float& object;
    float old_value;
};

isdb_float_trace::isdb_float_trace(const float& object_, const sc_string& name_, const sc_string& isdb_name_)
  : isdb_trace( name_, isdb_name_), object( object_)
{
    isdb_var_typ_name = "real";
    bit_width = 1;
    old_value = object;
}

void isdb_float_trace::declare_variable (ISDB_Conn database)
{
  isdb_id = ISDB_DefineSignal (database, ISDB_Float, name);
  write(database);
}

bool isdb_float_trace::changed()
{
    return object != old_value;
}

void isdb_float_trace::write(ISDB_Conn database)
{
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}

/*****************************************************************************/

class isdb_double_trace : public isdb_trace {
public:
    isdb_double_trace(const double& object, const sc_string& name_, const sc_string& isdb_name_);
    void declare_variable(ISDB_Conn database);
    void write(ISDB_Conn database);
    bool changed();

protected:    
    const double& object;
    double old_value;
};

isdb_double_trace::isdb_double_trace(const double& object_, const sc_string& name_, const sc_string& isdb_name_)
  : isdb_trace( name_, isdb_name_), object( object_)
{
    isdb_var_typ_name = "real";
    bit_width = 1;
    old_value = object;
}

void isdb_double_trace::declare_variable (ISDB_Conn database)
{
  isdb_id = ISDB_DefineSignal (database, ISDB_Float, name);
  write(database);
}

bool isdb_double_trace::changed()
{
    return object != old_value;
}

void isdb_double_trace::write(ISDB_Conn database)
{
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}


/*****************************************************************************/

class isdb_enum_trace : public isdb_trace {
public:
    isdb_enum_trace(const unsigned& object_, const sc_string& name_, const sc_string& isdb_name_, const char** enum_literals);
    void declare_variable(ISDB_Conn database);
    void write(ISDB_Conn database);
    bool changed();

protected:
    const unsigned& object;
    unsigned old_value;
    unsigned mask;
    const char** literals;
    unsigned nliterals;
};


isdb_enum_trace::isdb_enum_trace(const unsigned& object_, const sc_string& name_, const sc_string& isdb_name_, const char** enum_literals_) 
  : isdb_trace( name_, isdb_name_), object( object_), literals(enum_literals_)
{
    // find number of bits required to represent enumeration literal - counting loop
    for (nliterals = 0; enum_literals_[nliterals]; nliterals++);

    // Figure out number of bits required to represent the number of literals
    bit_width = 0;
    unsigned shifted_maxindex = nliterals-1;
    while(shifted_maxindex != 0){
        shifted_maxindex >>= 1;
        bit_width++;
    }

    // Set the mask
    if (bit_width < 32) {
      mask = ~(-1 << bit_width);
    } else {
      mask = static_cast<unsigned int>( -1 ); // 0xffffffff
    }

    isdb_var_typ_name = "wire";
    old_value = object;
}       

void isdb_enum_trace::declare_variable (ISDB_Conn database)
{
  isdb_id = ISDB_DefineSignal (database, ISDB_Integer, name);
  write(database);
}

bool isdb_enum_trace::changed()
{
    return object != old_value;
}

void isdb_enum_trace::write(ISDB_Conn database)
{
  /* TBD: this may be not good enough. Do we need to consider the mask? */
  ISDB_SetValue (database, isdb_id, object);

  old_value = object;
}





/*****************************************************************************
           isdb_trace_file functions
 *****************************************************************************/


void isdb_trace_error_handler (ISDB_Conn /* database */, 
			       ISDB_ErrorType /* type */, 
			       char *msg)
{
  cout << "WARNING: error reported from ISDB: " << msg << endl;
}


isdb_trace_file::isdb_trace_file(const char *name)
{
  sc_string file_name = name ;
  file_name += ".isdb";

  //
  // Establish an error handler
  //
  ISDB_InstallErrorHandler (isdb_trace_error_handler);

  // ISDB_CreateDB takes only char* but not const char*,
  // therefore must perform a dreaded conversion to char*
  int len = file_name.length();
  char* fname = (char*)malloc(len+1 *sizeof(char));
  for (int n=0; n<len; n++) {
    fname[n] = file_name[n];
  }
  fname[len] = '\0';
			      
  database = ISDB_CreateDB (fname, 
			    ISDB_IncludeDeltaCycle);
  free(fname);

  if (!database) {
    sc_string msg = sc_string("Cannot write trace file '") + file_name + "'";
    cerr << "FATAL: " << msg << "\n";
    exit(1);
  }

  trace_delta_cycles = false;
  initialized = false;
  isdb_name_index = 0;
  
  //default timestep = 1 sec
  timescale_unit = 1; 
  timescale_set_by_user = false;
}


void isdb_trace_file::initialize()
{
  char timescale[10];
  ISDB_Time isdb_time;

  //
  // convert timescale into string
  //
  if     (timescale_unit == 1e-15) sprintf(timescale, "1fs");
  else if(timescale_unit == 1e-14) sprintf(timescale, "10fs");
  else if(timescale_unit == 1e-13) sprintf(timescale, "100fs");
  else if(timescale_unit == 1e-12) sprintf(timescale, "1ps");
  else if(timescale_unit == 1e-11) sprintf(timescale, "10ps");
  else if(timescale_unit == 1e-10) sprintf(timescale, "100ps");
  else if(timescale_unit == 1e-9)  sprintf(timescale, "1ns");
  else if(timescale_unit == 1e-8)  sprintf(timescale, "10ns");
  else if(timescale_unit == 1e-7)  sprintf(timescale, "100ns");
  else if(timescale_unit == 1e-6)  sprintf(timescale, "1us");
  else if(timescale_unit == 1e-5)  sprintf(timescale, "10us");
  else if(timescale_unit == 1e-4)  sprintf(timescale, "100us");
  else if(timescale_unit == 1e-3)  sprintf(timescale, "1ms");
  else if(timescale_unit == 1e-2)  sprintf(timescale, "10ms");
  else if(timescale_unit == 1e-1)  sprintf(timescale, "100ms");
  else if(timescale_unit == 1e0)   sprintf(timescale, "1s");
  else if(timescale_unit == 1e1)   sprintf(timescale, "10s");
  else if(timescale_unit == 1e2)   sprintf(timescale, "100s");

  //
  // Set previous-time
  // Convert init time to ISDB_Time
  // 
  
  // double inittime = sc_simulation_time();
  double inittime = sc_time_stamp().to_double();

  double_to_special_int64(inittime/timescale_unit,
			  &previous_time_units_high,
			  &previous_time_units_low );
  isdb_time.low = previous_time_units_low;
  isdb_time.high = previous_time_units_high;

  //
  // Configure ISDB database
  //
  ISDB_Configure (database, 
		  ISDB_TimeUnits,       timescale, 
		  ISDB_StartTime,       &isdb_time,
		  ISDB_PathSeparator,   "/",
		  ISDB_StructSeparator, "/",
		  NULL);

  running_regression = ( getenv( "SYSTEMC_REGRESSION" ) != NULL );
  // Don't print message if running regression
  if( ! timescale_set_by_user && ! running_regression ) {
      cout << "WARNING: Default time step is used for ISDB tracing." << endl;
  }

  // Define variables
  int i;
  for (i = 0; i < traces.size(); i++) {
    isdb_trace* t = traces[i];
    t->set_width(); // needed for all vectors
    t->declare_variable(database);
  }

}


void isdb_trace_file::sc_set_isdb_time_unit(int exponent10_seconds)
{
  /* TBD: save the exponent, exponent10_seconds, internally and use
     it later to compute the TimeScale_string more easily  */

  if(initialized){
    isdb_put_error_message("ISDB trace timescale unit cannot be changed once tracing has begun.\n"
			   "To change the scale, create a new trace file.",
			   false);
    return;
  }

  
  if(exponent10_seconds < -15 || exponent10_seconds >  2){
        isdb_put_error_message("set_isdb_time_unit() has valid exponent range -15...+2.", false);
        return;
  }

  if     (exponent10_seconds == -15) timescale_unit = 1e-15;
  else if(exponent10_seconds == -14) timescale_unit = 1e-14;
  else if(exponent10_seconds == -13) timescale_unit = 1e-13;
  else if(exponent10_seconds == -12) timescale_unit = 1e-12;
  else if(exponent10_seconds == -11) timescale_unit = 1e-11;
  else if(exponent10_seconds == -10) timescale_unit = 1e-10;
  else if(exponent10_seconds ==  -9) timescale_unit = 1e-9;
  else if(exponent10_seconds ==  -8) timescale_unit = 1e-8;
  else if(exponent10_seconds ==  -7) timescale_unit = 1e-7;
  else if(exponent10_seconds ==  -6) timescale_unit = 1e-6;
  else if(exponent10_seconds ==  -5) timescale_unit = 1e-5;
  else if(exponent10_seconds ==  -4) timescale_unit = 1e-4;
  else if(exponent10_seconds ==  -3) timescale_unit = 1e-3;
  else if(exponent10_seconds ==  -2) timescale_unit = 1e-2;
  else if(exponent10_seconds ==  -1) timescale_unit = 1e-1;
  else if(exponent10_seconds ==   0) timescale_unit = 1e0;