クラス sc_core::vcd_trace_file

#include <sc_vcd_trace.h>

sc_core::vcd_trace_fileに対する継承グラフ

[凡例]

すべてのメンバ一覧

Public 型
enum	vcd_enum { VCD_WIRE = 0, VCD_REAL = 1, VCD_LAST }
Public メソッド
void	sc_set_vcd_time_unit (int exponent10_seconds)
	vcd_trace_file (const char *name)
	~vcd_trace_file ()
std::string	obtain_name ()
Public 変数
std::vector< vcd_trace * >	traces
Protected メソッド
void	trace (const bool &object, const std::string &name)
virtual void	trace (const sc_dt::sc_bit &object, const std::string &name)
void	trace (const sc_dt::sc_logic &object, const std::string &name)
void	trace (const unsigned char &object, const std::string &name, int width)
void	trace (const unsigned short &object, const std::string &name, int width)
void	trace (const unsigned int &object, const std::string &name, int width)
void	trace (const unsigned long &object, const std::string &name, int width)
void	trace (const char &object, const std::string &name, int width)
void	trace (const short &object, const std::string &name, int width)
void	trace (const int &object, const std::string &name, int width)
void	trace (const long &object, const std::string &name, int width)
void	trace (const sc_dt::int64 &object, const std::string &name, int width)
void	trace (const sc_dt::uint64 &object, const std::string &name, int width)
void	trace (const float &object, const std::string &name)
void	trace (const double &object, const std::string &name)
void	trace (const sc_dt::sc_uint_base &object, const std::string &name)
void	trace (const sc_dt::sc_int_base &object, const std::string &name)
void	trace (const sc_dt::sc_unsigned &object, const std::string &name)
void	trace (const sc_dt::sc_signed &object, const std::string &name)
void	trace (const sc_dt::sc_fxval &object, const std::string &name)
void	trace (const sc_dt::sc_fxval_fast &object, const std::string &name)
void	trace (const sc_dt::sc_fxnum &object, const std::string &name)
void	trace (const sc_dt::sc_fxnum_fast &object, const std::string &name)
template<class T>
void	traceT (const T &object, const std::string &name, vcd_enum type=VCD_WIRE)
virtual void	trace (const sc_dt::sc_bv_base &object, const std::string &name)
virtual void	trace (const sc_dt::sc_lv_base &object, const std::string &name)
void	trace (const unsigned &object, const std::string &name, const char **enum_literals)
void	write_comment (const std::string &comment)
void	delta_cycles (bool flag)
void	cycle (bool delta_cycle)
Private メソッド
void	initialize ()
void	create_vcd_name (std::string *p_destination)
Private 変数
FILE *	fp
bool	trace_delta_cycles
unsigned	vcd_name_index
unsigned	previous_time_units_low
unsigned	previous_time_units_high

---

説明

sc_vcd_trace.h の 66 行で定義されています。

---

列挙型

enum sc_core::vcd_trace_file::vcd_enum

列挙型の値:

VCD_WIRE
VCD_REAL
VCD_LAST

sc_vcd_trace.h の 71 行で定義されています。

{VCD_WIRE=0, VCD_REAL=1, VCD_LAST};

---

コンストラクタとデストラクタ

sc_core::vcd_trace_file::vcd_trace_file

(

const char *

name

)

sc_vcd_trace.cpp の 1710 行で定義されています。

{
    std::string file_name = name ;
    file_name += ".vcd";
    fp = fopen(file_name.c_str(), "w");
    if (!fp) {
        std::string msg = std::string("Cannot write trace file '") +
                        file_name + "'";
        ::std::cerr << "FATAL: " << msg << "\n";
        exit(1);
    }
    trace_delta_cycles = false; // Make this the default
    initialized = false;
    vcd_name_index = 0;

    // default time step is the time resolution
    timescale_unit = sc_get_time_resolution().to_seconds();

    timescale_set_by_user = false;
}

sc_core::vcd_trace_file::~vcd_trace_file

(

)

sc_vcd_trace.cpp の 2184 行で定義されています。

{
    int i;
    for (i = 0; i < (int)traces.size(); i++) {
        vcd_trace* t = traces[i];
        delete t;
    }
    fclose(fp);
}

---

関数

void sc_core::vcd_trace_file::sc_set_vcd_time_unit

(

int

exponent10_seconds

)

[inline]

sc_vcd_trace.h の 73 行で定義されています。

        { set_time_unit(exponent10_seconds); }

void sc_core::vcd_trace_file::trace	(	const bool &	object,
		const std::string &	name
	)			[protected]

virtual void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_bit &	object,
		const std::string &	name
	)			[protected, virtual]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_logic &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const unsigned char &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const unsigned short &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const unsigned int &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const unsigned long &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const char &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const short &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const int &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const long &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::int64 &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::uint64 &	object,
		const std::string &	name,
		int	width
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const float &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const double &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_uint_base &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_int_base &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_unsigned &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_signed &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_fxval &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_fxval_fast &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_fxnum &	object,
		const std::string &	name
	)			[protected]

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_fxnum_fast &	object,
		const std::string &	name
	)			[protected]

template<class T>

void sc_core::vcd_trace_file::traceT	(	const T &	object,
		const std::string &	name,
		vcd_enum	type = VCD_WIRE
	)			[inline, protected]

sc_vcd_trace.h の 170 行で定義されています。

    {
      if(initialized)
         put_error_message("No traces can be added once simulation has"
         " started.\nTo add traces, create a new vcd trace file.", false);
      else
        traces.push_back(new vcd_T_trace<T>(object, name, obtain_name(),type));
    }

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_bv_base &	object,
		const std::string &	name
	)			[protected, virtual]

sc_vcd_trace.cpp の 284 行で定義されています。

{
   traceT(object,name);
}   

void sc_core::vcd_trace_file::trace	(	const sc_dt::sc_lv_base &	object,
		const std::string &	name
	)			[protected, virtual]

sc_vcd_trace.cpp の 292 行で定義されています。

{
   traceT(object,name);
}

void sc_core::vcd_trace_file::trace	(	const unsigned &	object,
		const std::string &	name,
		const char **	enum_literals
	)			[protected]

sc_vcd_trace.cpp の 1961 行で定義されています。

{
    if( initialized ) {
        put_error_message(
            "No traces can be added once simulation has started.\n"
            "To add traces, create a new vcd trace file.", false );
    }
    std::string temp_vcd_name;
    create_vcd_name( &temp_vcd_name );
    traces.push_back( new vcd_enum_trace( object_,
                                          name_,
                                          temp_vcd_name,
                                          enum_literals_ ) );
}

void sc_core::vcd_trace_file::write_comment

(

const std::string &

comment

)

[protected, virtual]

sc_core::sc_trace_fileを実装しています。

sc_vcd_trace.cpp の 1980 行で定義されています。

{
    //no newline in comments allowed, as some viewers may crash
    std::fputs("$comment\n", fp);
    std::fputs(comment.c_str(), fp);
    std::fputs("\n$end\n\n", fp);
}

void sc_core::vcd_trace_file::delta_cycles

(

bool

flag

)

[protected, virtual]

sc_core::sc_trace_fileを再定義しています。

sc_vcd_trace.cpp の 1989 行で定義されています。

{
    trace_delta_cycles = flag;
}

void sc_core::vcd_trace_file::cycle

(

bool

delta_cycle

)

[protected, virtual]

sc_core::sc_trace_fileを実装しています。

sc_vcd_trace.cpp の 1995 行で定義されています。

{
    char message[4000];
    unsigned this_time_units_high, this_time_units_low;
    
    // Just to make g++ shut up in the optimized mode
    this_time_units_high = this_time_units_low = 0;

    // Trace delta cycles only when enabled
    if (!trace_delta_cycles && this_is_a_delta_cycle) return;

    // Check for initialization
    if (!initialized) {
        initialize();
        initialized = true;
        return;
    };


    double now_units = sc_time_stamp().to_seconds() / timescale_unit;
    unsigned now_units_high, now_units_low;
    double_to_special_int64(now_units, &now_units_high, &now_units_low );

    bool now_later_than_previous_time = false;
    if( now_units_low > previous_time_units_low 
        && now_units_high == previous_time_units_high
        || now_units_high > previous_time_units_high){
        now_later_than_previous_time = true;
    }

    bool now_equals_previous_time = false;
    if(now_later_than_previous_time){
        this_time_units_high = now_units_high;
        this_time_units_low = now_units_low;
    } else {
        if( now_units_low == previous_time_units_low
            && now_units_high == previous_time_units_high){
            now_equals_previous_time = true;
            this_time_units_high = now_units_high;
            this_time_units_low = now_units_low;
        }
    }

    // Since VCD does not understand 0 time progression, we have to fake
    // delta cycles with progressing time by one unit
    if(this_is_a_delta_cycle){
        this_time_units_high = previous_time_units_high;
        this_time_units_low = previous_time_units_low + 1;
        if(this_time_units_low == 1000000000){
            this_time_units_high++;
            this_time_units_low=0;
        }
        static bool warned = false;
        if(!warned){
            ::std::cout << "Note: VCD delta cycling with pseudo timesteps (1 unit) "
                    "is performed.\n" << ::std::endl;
            warned = true;
        }
    }


    // Not a delta cycle and time has not progressed
    if( ! this_is_a_delta_cycle && now_equals_previous_time &&
        ( now_units_high != 0 || now_units_low != 0 ) ) {
        // Don't print the message at time zero
        static bool warned = false;
        if( ! warned && ! running_regression ) {
            std::sprintf(message,
                    "Multiple cycles found with same (%u) time units count.\n"
                    "Waveform viewers will only show the states of the last one.\n"
                    "Use ((vcd_trace_file*)vcdfile)->sc_set_vcd_time_unit(int exponent10_seconds)\n"
                    "to increase time resolution.",
                    now_units_low
                    );
            put_error_message(message, true);
            warned = true;
        }
    }

    // Not a delta cycle and time has gone backward
    // This will happen with large number of delta cycles between two real
    // advances of time
    if(!this_is_a_delta_cycle && !now_equals_previous_time && 
        !now_later_than_previous_time){
        static bool warned = false;
        if(!warned){
            std::sprintf(message,
                    "Cycle found with falling (%u -> %u) time units count.\n"
                    "This can occur when delta cycling is activated.\n"
                    "Cycles with falling time are not shown.\n"
                    "Use ((vcd_trace_file*)vcdfile)->sc_set_vcd_time_unit(int exponent10_seconds)\n"
                    "to increase time resolution.",
                    previous_time_units_low, now_units_low);
            put_error_message(message, true);
            warned = true;
        }
        // Note that we don't set this_time_units_high/low to any value only
        // in this case because we are not going to do any tracing. In the
        // optimized mode, the compiler complains because of this. Therefore,
        // we include the lines at the very beginning of this function to make
        // the compiler shut up.
        return; 
    }

    // Now do the actual printing 
    bool time_printed = false;
    vcd_trace* const* const l_traces = &traces[0];
    for (int i = 0; i < (int)traces.size(); i++) {
        vcd_trace* t = l_traces[i];
        if(t->changed()){
            if(time_printed == false){
                char buf[200];
                if(this_time_units_high){
                    std::sprintf(buf, "#%u%09u", this_time_units_high, this_time_units_low);
                }
                else{ 
                    std::sprintf(buf, "#%u", this_time_units_low);
                }
                std::fputs(buf, fp);
                std::fputc('\n', fp);
                time_printed = true;
            }

            // Write the variable
            t->write(fp);
            std::fputc('\n', fp);
        }
    }
    // Put another newline after all values are printed
    if(time_printed) std::fputc('\n', fp);

    if(time_printed){
        // We update previous_time_units only when we print time because
        // this field stores the previous time that was printed, not the
        // previous time this function was called
        previous_time_units_high = this_time_units_high;
        previous_time_units_low = this_time_units_low;
    }
}

void sc_core::vcd_trace_file::initialize

(

)

[private]

sc_vcd_trace.cpp の 1732 行で定義されています。

{
    char buf[2000];

    //date:
    time_t long_time;
    time(&long_time);
    struct tm* p_tm;
    p_tm = localtime(&long_time);
    strftime(buf, 199, "%b %d, %Y       %H:%M:%S", p_tm);
    std::fprintf(fp, "$date\n     %s\n$end\n\n", buf);

    //version:
    std::fprintf(fp, "$version\n %s\n$end\n\n", sc_version());

    //timescale:
    static struct SC_TIMESCALE_TO_TEXT {
        double       unit;
        const char*  text;
    } timescale_to_text [] = {
        { sc_time(1, SC_FS).to_seconds(), "1 fs" },
        { sc_time(10, SC_FS).to_seconds(), "10 fs" },
        { sc_time(100, SC_FS).to_seconds(),"100 fs" },
        { sc_time(1, SC_PS).to_seconds(),  "1 ps" },
        { sc_time(10, SC_PS).to_seconds(), "10 ps" },
        { sc_time(100, SC_PS).to_seconds(),"100 ps" },
        { sc_time(1, SC_NS).to_seconds(),  "1 ns" },
        { sc_time(10, SC_NS).to_seconds(), "10 ns" },
        { sc_time(100, SC_NS).to_seconds(),"100 ns" },
        { sc_time(1, SC_US).to_seconds(),  "1 us" },
        { sc_time(10, SC_US).to_seconds(), "10 us" },
        { sc_time(100, SC_US).to_seconds(),"100 us" },
        { sc_time(1, SC_MS).to_seconds(),  "1 ms" },
        { sc_time(10, SC_MS).to_seconds(), "10 ms" },
        { sc_time(100, SC_MS).to_seconds(),"100 ms" },
        { sc_time(1, SC_SEC).to_seconds(),  "1 sec" },
        { sc_time(10, SC_SEC).to_seconds(), "10 sec" },
        { sc_time(100, SC_SEC).to_seconds(),"100 sec" }
    };
    static int timescale_to_text_n =
        sizeof(timescale_to_text)/sizeof(SC_TIMESCALE_TO_TEXT);

    for ( int time_i = 0; time_i < timescale_to_text_n; time_i++ )
    {
        if (timescale_unit == timescale_to_text[time_i].unit)
        {
            std::fprintf(fp,"$timescale\n     %s\n$end\n\n",
                timescale_to_text[time_i].text);
            break;
        }
    }


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

    // Create a dummy scope
    std::fputs("$scope module SystemC $end\n", fp);

    //variable definitions:
    int i;
    for (i = 0; i < (int)traces.size(); i++) {
        vcd_trace* t = traces[i];
        t->set_width(); // needed for all vectors
        t->print_variable_declaration_line(fp);
    }

    std::fputs("$upscope $end\n", fp);

    std::fputs("$enddefinitions  $end\n\n", fp);

    // double inittime = sc_simulation_time();
    double inittime = sc_time_stamp().to_seconds();
    
    std::sprintf(buf,
            "All initial values are dumped below at time "
            "%g sec = %g timescale units.",
            inittime, inittime/timescale_unit
            );
    write_comment(buf);

    double_to_special_int64(inittime/timescale_unit,
                            &previous_time_units_high,
                            &previous_time_units_low );


    std::fputs("$dumpvars\n",fp);
    for (i = 0; i < (int)traces.size(); i++) {
        vcd_trace* t = traces[i];
        t->write(fp);
        std::fputc('\n', fp);
    }
    std::fputs("$end\n\n", fp);
}

void sc_core::vcd_trace_file::create_vcd_name

(

std::string *

p_destination

)

[private]

sc_vcd_trace.cpp の 2136 行で定義されています。

{
    const char first_type_used = 'a';
    const int used_types_count = 'z' - 'a' + 1;
    int result;

    char char4 = (char)(vcd_name_index % used_types_count);

    result = vcd_name_index / used_types_count;
    char char3 = (char)(result % used_types_count);

    result = result / used_types_count;
    char char2 = (char)(result % used_types_count);

    char buf[20];
    std::sprintf(buf, "%c%c%c",
            char2 + first_type_used,
            char3 + first_type_used,
            char4 + first_type_used);
    *p_destination = buf;
    vcd_name_index++;
}

std::string sc_core::vcd_trace_file::obtain_name

(

)

sc_vcd_trace.cpp の 2161 行で定義されています。

{
    const char first_type_used = 'a';
    const int used_types_count = 'z' - 'a' + 1;
    int result;

    char char4 = (char)(vcd_name_index % used_types_count);

    result = vcd_name_index / used_types_count;
    char char3 = (char)(result % used_types_count);

    result = result / used_types_count;
    char char2 = (char)(result % used_types_count);

    char buf[20];
    std::sprintf(buf, "%c%c%c",
            char2 + first_type_used,
            char3 + first_type_used,
            char4 + first_type_used);
    vcd_name_index++;
    return std::string(buf);
}

---

変数

FILE* sc_core::vcd_trace_file::fp [private]

sc_vcd_trace.h の 210 行で定義されています。

bool sc_core::vcd_trace_file::trace_delta_cycles [private]

sc_vcd_trace.h の 212 行で定義されています。

unsigned sc_core::vcd_trace_file::vcd_name_index [private]

sc_vcd_trace.h の 214 行で定義されています。

unsigned sc_core::vcd_trace_file::previous_time_units_low [private]

sc_vcd_trace.h の 216 行で定義されています。

unsigned sc_core::vcd_trace_file::previous_time_units_high [private]

sc_vcd_trace.h の 216 行で定義されています。

std::vector<vcd_trace*> sc_core::vcd_trace_file::traces

sc_vcd_trace.h の 221 行で定義されています。

---

このクラスの説明は次のファイルから生成されました:

• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/tracing/sc_vcd_trace.h
• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/tracing/sc_vcd_trace.cpp