Subversion Repositories openrisc

// ----------------------------------------------------------------------------

// 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()