Subversion Repositories openrisc_me

// ----------------------------------------------------------------------------
 
// SystemC trace 
 
// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>
 
// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
// This file is part of the cycle accurate model of the OpenRISC 1000 based
// system-on-chip, ORPSoC, built using Verilator.
 
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
 
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
 
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
// ----------------------------------------------------------------------------
 
// $Id: TraceSC.cpp 302 2009-02-13 17:22:07Z jeremy $
 
#include "TraceSC.h"
#include <systemc.h>
 
using namespace std;
 
#define DEBUG_TRACESC 1
 
SC_HAS_PROCESS( TraceSC );
 
//! Constructor for the trace module
 
//! @param name           Name of this module, passed to the parent
//!                       constructor.
//! @param _trace_target  ORPSoC module to trace
 
TraceSC::TraceSC (sc_core::sc_module_name  name,
		  Vorpsoc_top        *_traceTarget,
		  int argc,
		  char              *argv[]) :
  sc_module (name),
  traceTarget (_traceTarget)
{
#if VM_TRACE
 
  // Setup the name of the VCD dump file
  string dumpNameDefault("vlt-dump.vcd");
  string testNameString;
  string vcdDumpFile;
 
  // Search through the command line parameters for VCD dump options
  dump_start_delay = 0;
  dump_stop_set = 0;
  int time_val;
  int cmdline_name_found=0;
  if (argc > 1)
  {
    for(int i=1; i<argc; i++)
    {
      if ((strcmp(argv[i], "-vcd")==0) ||
	  (strcmp(argv[i], "--vcd")==0))
        {
          testNameString = (argv[i+1]);
          vcdDumpFile = testNameString;
          cmdline_name_found=1;
         }
      else if ( (strcmp(argv[i], "-vcdstart")==0) ||
	   (strcmp(argv[i], "--vcdstart")==0) )
        {
          time_val = atoi(argv[i+1]);	  
	  sc_time dump_start_time(time_val,SC_NS);
	  dump_start = dump_start_time;
	  if (DEBUG_TRACESC) cout << "TraceSC(): Dump start time set at " << dump_start.to_string() << endl;
	  dump_start_delay = 1;
	  break;
         }
      else if ( (strcmp(argv[i], "-vcdstop")==0) ||
	   (strcmp(argv[i], "--vcdstop")==0) )
        {
          time_val = atoi(argv[i+1]);	  
	  sc_time dump_stop_time(time_val,SC_NS);
	  dump_stop = dump_stop_time;
	  if (DEBUG_TRACESC) cout << "TraceSC(): Dump stop time set at " << dump_stop.to_string() << endl;
	  dump_stop_set = 1;
	  break;
	}
    }
  }
 
  if(cmdline_name_found==0) // otherwise use our default VCD dump file name
    vcdDumpFile = dumpNameDefault;
 
  Verilated::traceEverOn (true);
 
  cout << "* Enabling VCD trace";
 
  if (dump_start_delay)
    cout << ", on at time " << dump_start.to_string();
  if (dump_stop_set)
    cout << ", off at time " << dump_stop.to_string();
 
  cout << endl;
 
 
  printf("* VCD dumpfile: %s\n", vcdDumpFile.c_str());
 
  // Establish a new trace with its correct time resolution, and trace to
  // great depth.
  spTraceFile = new SpTraceVcdCFile ();
  setSpTimeResolution (sc_get_time_resolution ());
  traceTarget->trace (spTraceFile, 99);
  spTraceFile->open (vcdDumpFile.c_str());
 
  if (dump_start_delay == 1)
    dumping_now = 0; // We'll wait for the time to dump
  else
    dumping_now = 1; // Begin with dumping turned on
 
 
  // Method to drive the dump on each clock edge
  //SC_METHOD (driveTrace);
  //sensitive << clk;
 
#endif
 
}	// TraceSC ()
 
 
//! Destructor for the trace module.
 
//! Used to close the tracefile
 
TraceSC::~TraceSC ()
{
#if VM_TRACE
  spTraceFile->close ();
#endif
 
}	// ~TraceSC ()
 
 
//! Method to drive the trace. We're called on every clock edge, and also at
//! initialization (to get initial values into the dump).
void
TraceSC::driveTrace()
{
#if VM_TRACE
 
  if (DEBUG_TRACESC) cout << "TraceSC(): " << endl;
  if (dumping_now == 0)
    {
      // Check the time, see if we should enable dumping
      if (sc_time_stamp() >=  dump_start)
	{
	  // Give a message
	  cout << "* VCD tracing turned on at time " << dump_start.to_string() << endl;	  
	  dumping_now = 1;
	}
    }
 
  if (dumping_now == 1)
    spTraceFile->dump (sc_time_stamp().to_double());
 
 
  // Should we turn off tracing?
  if ((dumping_now == 1) && (dump_stop_set == 1))
    {
      if (sc_time_stamp() >=  dump_stop)
	{
	  // Give a message
	  cout << "* VCD tracing turned off at time " << dump_stop.to_string() << endl;	  
	  dumping_now = 0; // Turn off the dump
	}
    }
 
#endif
 
}	// driveTrace()
 
 
//! Utility method to set the SystemPerl trace time resolution.
 
//! This should be automatic, but is missed in Verilator 3.700.
 
//! @param t  The desired time resolution (as a SC time)
 
void
TraceSC::setSpTimeResolution (sc_time  t)
{
#if VM_TRACE
 
  double      secs = t.to_seconds();
  int         val;			// Integral value of the precision
  const char *units;			// Units as text
 
  if (secs < 1.0e-15)
    {
      cerr << "* VCD time resolution " << secs << " too small: ignored" << endl;
      return;
    }
  else if (secs < 1.0e-12)
    {
      val   = secs / 1.0e-15;
      units = "f";
    }
  else if (secs < 1.0e-9)
    {
      val   = secs / 1.0e-12;
      units = "p";
    }
  else if (secs < 1.0e-6)
    {
      val   = secs / 1.0e-9;
      units = "n";
    }
  else if (secs < 1.0e-3)
    {
      val   = secs / 1.0e-6;
      units = "u";
    }
  else if (secs < 1.0)
    {
      val   = secs / 1.0e-3;
      units = "m";
    }
  else
    {
      val   = secs;
      units = "s";
    }
 
  // Val must be a power of 10
  switch (val)
    {
    case 1:
    case 10:
    case 100:
    case 1000:
    case 10000:
    case 100000:
    case 1000000:
    case 10000000:
    case 100000000:
    case 1000000000:
 
      break;			// OK
 
    default:
      cerr << "VCD time resolution " << secs << " not power of 10: ignored"
	   << endl;
      return;
    }
 
  // Set the time resolution for the trace file
  char str[32];
  sprintf (str, "%d %s", val, units);
  spTraceFile->spTrace()->set_time_resolution (str);
 
#endif
 
}	// setSpTimeResolution()