クラス sc_core::sc_simcontext

#include <sc_simcontext.h>

すべてのメンバ一覧

Public メソッド
	sc_simcontext ()
	~sc_simcontext ()
void	initialize (bool=false)
void	cycle (const sc_time &)
void	simulate (const sc_time &duration)
void	stop ()
void	end ()
void	reset ()
int	sim_status () const
bool	elaboration_done () const
sc_object_manager *	get_object_manager ()
void	hierarchy_push (sc_module *)
sc_module *	hierarchy_pop ()
sc_module *	hierarchy_curr () const
sc_object *	first_object ()
sc_object *	next_object ()
sc_object *	find_object (const char *name)
sc_module_registry *	get_module_registry ()
sc_port_registry *	get_port_registry ()
sc_export_registry *	get_export_registry ()
sc_prim_channel_registry *	get_prim_channel_registry ()
const char *	gen_unique_name (const char *basename_, bool preserve_first=false)
sc_process_handle	create_cthread_process (const char *name_p, bool free_host, SC_ENTRY_FUNC method_p, sc_process_host *host_p, const sc_spawn_options *opt_p)
sc_process_handle	create_method_process (const char *name_p, bool free_host, SC_ENTRY_FUNC method_p, sc_process_host *host_p, const sc_spawn_options *opt_p)
sc_process_handle	create_thread_process (const char *name_p, bool free_host, SC_ENTRY_FUNC method_p, sc_process_host *host_p, const sc_spawn_options *opt_p)
sc_curr_proc_handle	get_curr_proc_info ()
sc_object *	get_current_writer () const
bool	write_check () const
void	set_curr_proc (sc_process_b *)
void	reset_curr_proc ()
int	next_proc_id ()
void	add_trace_file (sc_trace_file *)
const sc_time &	time_stamp () const
sc_dt::uint64	delta_count () const
bool	event_occurred (sc_dt::uint64 last_change_count) const
bool	is_running () const
bool	update_phase () const
bool	get_error ()
void	set_error ()
sc_cor_pkg *	cor_pkg ()
sc_cor *	next_cor ()
const ::std::vector< sc_object * > &	get_child_objects () const
void	elaborate ()
void	prepare_to_simulate ()
void	initial_crunch (bool no_crunch)
const sc_time	next_time ()
Private 型
enum	execution_phases { phase_initialize = 0, phase_evaluate, phase_update, phase_notify }
Private メソッド
void	init ()
void	clean ()
void	add_child_object (sc_object *)
void	remove_child_object (sc_object *)
void	crunch (bool once=false)
int	add_delta_event (sc_event *)
void	remove_delta_event (sc_event *)
void	add_timed_event (sc_event_timed *)
void	trace_cycle (bool delta_cycle)
const ::std::vector< sc_object * > &	get_child_objects_internal () const
void	push_runnable_method (sc_method_handle)
void	push_runnable_thread (sc_thread_handle)
void	push_runnable_method_front (sc_method_handle)
void	push_runnable_thread_front (sc_thread_handle)
sc_method_handle	pop_runnable_method ()
sc_thread_handle	pop_runnable_thread ()
void	remove_runnable_method (sc_method_handle)
void	remove_runnable_thread (sc_thread_handle)
void	do_sc_stop_action ()
	sc_simcontext (const sc_simcontext &)
sc_simcontext &	operator= (const sc_simcontext &)
Private 変数
sc_object_manager *	m_object_manager
sc_module_registry *	m_module_registry
sc_port_registry *	m_port_registry
sc_export_registry *	m_export_registry
sc_prim_channel_registry *	m_prim_channel_registry
sc_name_gen *	m_name_gen
sc_process_table *	m_process_table
sc_curr_proc_info	m_curr_proc_info
sc_object *	m_current_writer
bool	m_write_check
int	m_next_proc_id
std::vector< sc_object * >	m_child_objects
std::vector< sc_event * >	m_delta_events
sc_ppq< sc_event_timed * > *	m_timed_events
std::vector< sc_trace_file * >	m_trace_files
bool	m_something_to_trace
sc_runnable *	m_runnable
sc_time_params *	m_time_params
sc_time	m_curr_time
sc_dt::uint64	m_delta_count
bool	m_forced_stop
bool	m_ready_to_simulate
bool	m_elaboration_done
execution_phases	m_execution_phase
bool	m_error
bool	m_in_simulator_control
bool	m_end_of_simulation_called
bool	m_start_of_simulation_called
sc_event *	m_until_event
sc_cor_pkg *	m_cor_pkg
sc_cor *	m_cor
フレンド
class	sc_event
class	sc_module
class	sc_object
class	sc_time
class	sc_clock
class	sc_method_process
class	sc_process_b
class	sc_prim_channel
class	sc_thread_process
sc_dt::uint64	sc_delta_count ()
const std::vector< sc_object * > &	sc_get_top_level_objects (const sc_simcontext *simc_p)
bool	sc_is_running (const sc_simcontext *simc_p)
bool	sc_end_of_simulation_invoked ()
bool	sc_pending_activity_at_current_time ()
bool	sc_start_of_simulation_invoked ()
void	sc_set_time_resolution (double, sc_time_unit)
sc_time	sc_get_time_resolution ()
void	sc_set_default_time_unit (double, sc_time_unit)
sc_time	sc_get_default_time_unit ()

---

説明

sc_simcontext.h の 175 行で定義されています。

---

列挙型

enum sc_core::sc_simcontext::execution_phases [private]

列挙型の値:

phase_initialize
phase_evaluate
phase_update
phase_notify

sc_simcontext.h の 311 行で定義されています。

                          {
            phase_initialize = 0,
            phase_evaluate,
            phase_update,
            phase_notify
        };

---

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

sc_core::sc_simcontext::sc_simcontext

(

)

sc_simcontext.cpp の 488 行で定義されています。

{
    init();
}

sc_core::sc_simcontext::~sc_simcontext

(

)

sc_simcontext.cpp の 493 行で定義されています。

{
    clean();
}

sc_core::sc_simcontext::sc_simcontext

(

const sc_simcontext &

)

[private]

---

関数

void sc_core::sc_simcontext::init

(

)

[private]

sc_simcontext.cpp の 415 行で定義されています。

{

    // ALLOCATE VARIOUS MANAGERS AND REGISTRIES:

    m_object_manager = new sc_object_manager;
    m_module_registry = new sc_module_registry( *this );
    m_port_registry = new sc_port_registry( *this );
    m_export_registry = new sc_export_registry( *this );
    m_prim_channel_registry = new sc_prim_channel_registry( *this );
    m_name_gen = new sc_name_gen;
    m_process_table = new sc_process_table;
    m_current_writer = 0;


    // CHECK FOR ENVIRONMENT VARIABLES THAT MODIFY SIMULATOR EXECUTION:

    const char* write_check = std::getenv("SC_SIGNAL_WRITE_CHECK");
    m_write_check = ( (write_check==0) || strcmp(write_check,"DISABLE") ) ?
      true : false;


    // FINISH INITIALIZATIONS:

    reset_curr_proc();
    m_next_proc_id = -1;
    m_timed_events = new sc_ppq<sc_event_timed*>( 128, sc_notify_time_compare );
    m_something_to_trace = false;
    m_runnable = new sc_runnable;
    m_time_params = new sc_time_params;
    m_curr_time = SC_ZERO_TIME;
    m_delta_count = 0;
    m_forced_stop = false;
    m_ready_to_simulate = false;
    m_elaboration_done = false;
    m_execution_phase = phase_initialize;
    m_error = false;
    m_until_event = 0;
    m_cor_pkg = 0;
    m_cor = 0;
    m_in_simulator_control = false;
    m_start_of_simulation_called = false;
    m_end_of_simulation_called = false;
}

void sc_core::sc_simcontext::clean

(

)

[private]

sc_simcontext.cpp の 461 行で定義されています。

{
    delete m_object_manager;
    delete m_module_registry;
    delete m_port_registry;
    delete m_export_registry;
    delete m_prim_channel_registry;
    delete m_name_gen;
    delete m_process_table;
    m_child_objects.resize(0);
    m_delta_events.resize(0);
    delete m_timed_events;
    for( int i = m_trace_files.size() - 1; i >= 0; -- i ) {
        delete m_trace_files[i];
    }
    m_trace_files.resize(0);
    delete m_runnable;
    delete m_time_params;
    if( m_until_event != 0 ) {
        delete m_until_event;
    }
    if( m_cor_pkg != 0 ) {
        delete m_cor_pkg;
    }
}

void sc_core::sc_simcontext::initialize

(

bool

no_crunch = false

)

sc_simcontext.cpp の 798 行で定義されています。

{
    m_in_simulator_control = true;
    elaborate();
    prepare_to_simulate();
    initial_crunch(no_crunch);
    m_in_simulator_control = false;
}

void sc_core::sc_simcontext::cycle

(

const sc_time &

t

)

[inline]

sc_simcontext.cpp の 616 行で定義されています。

{
    sc_time next_event_time;

    m_in_simulator_control = true;
    m_runnable->toggle();
    crunch(); 
    trace_cycle( /* delta cycle? */ false );
    m_curr_time += t;
    next_event_time = next_time();
    if ( next_event_time != SC_ZERO_TIME && next_event_time <= m_curr_time) {
        SC_REPORT_WARNING(SC_ID_CYCLE_MISSES_EVENTS_, "");
    }
    m_in_simulator_control = false;
}

void sc_core::sc_simcontext::simulate

(

const sc_time &

duration

)

sc_simcontext.cpp の 808 行で定義されています。

{
    initialize( true );

    if (sim_status() != SC_SIM_OK) {
        return;
    }

    sc_time non_overflow_time = 
        sc_time(~sc_dt::UINT64_ZERO, false) - m_curr_time;
    if ( duration > non_overflow_time )
    {
        SC_REPORT_ERROR(SC_ID_SIMULATION_TIME_OVERFLOW_, "");
        return;
    }
    else if ( duration < SC_ZERO_TIME )
    {
        SC_REPORT_ERROR(SC_ID_NEGATIVE_SIMULATION_TIME_,"");
    }
    m_in_simulator_control = true;

    sc_time until_t = m_curr_time + duration;

    m_until_event->cancel();  // to be on the safe side
    m_until_event->notify_internal( duration );

    sc_time t;

    // IF DURATION WAS ZERO WE ONLY CRUNCH:
    //
    // We duplicate the code so that we don't add the overhead of the
    // check to each loop in the do below.
    if ( duration == SC_ZERO_TIME ) 
    {
        m_runnable->toggle();
        crunch( true );
        if( m_error ) return;
        if( m_something_to_trace ) trace_cycle( /* delta cycle? */ false );
        if( m_forced_stop ) 
            do_sc_stop_action(); 
        return;
    }


    // NON-ZERO DURATION: EXECUTE UP TO THAT TIME:
    do {
        m_runnable->toggle();

        crunch();
        if( m_error ) {
            m_in_simulator_control = false;
            return;
        }
        if( m_something_to_trace ) {
            trace_cycle( false );
        }
        // check for call(s) to sc_stop
        if( m_forced_stop ) {
            do_sc_stop_action();
            return;
        }
        
        do {
            t = next_time();

            // PROCESS TIMED NOTIFICATIONS

            do {
                sc_event_timed* et = m_timed_events->extract_top();
                sc_event* e = et->event();
                delete et;
                if( e != 0 ) {
                    e->trigger();
                }
            } while( m_timed_events->size() &&
                     m_timed_events->top()->notify_time() == t );

        } while( m_runnable->is_empty() && t != until_t );
        if ( t > m_curr_time ) m_curr_time = t;

    } while( t != until_t );
    m_in_simulator_control = false;
}

void sc_core::sc_simcontext::stop

(

)

sc_simcontext.cpp の 920 行で定義されています。

{
    static bool stop_warning_issued = false;
    if (m_forced_stop)
    {
        if ( !stop_warning_issued )
        {
            stop_warning_issued = true; // This must be before the WARNING!!!
            SC_REPORT_WARNING(SC_ID_SIMULATION_STOP_CALLED_TWICE_, "");
        }
        return;
    }
    if ( stop_mode == SC_STOP_IMMEDIATE ) m_runnable->init();
    m_forced_stop = true;
    if ( !m_in_simulator_control  )
    {
        do_sc_stop_action();
    } 
}

void sc_core::sc_simcontext::end

(

)

sc_simcontext.cpp の 948 行で定義されています。

{
    m_ready_to_simulate = false;
    m_port_registry->simulation_done();
    m_export_registry->simulation_done();
    m_prim_channel_registry->simulation_done();
    m_module_registry->simulation_done();
    m_end_of_simulation_called = true;
}

void sc_core::sc_simcontext::reset

(

)

sc_simcontext.cpp の 941 行で定義されています。

{
    clean();
    init();
}

int sc_core::sc_simcontext::sim_status

(

)

const [inline]

sc_simcontext.h の 402 行で定義されています。

{
    if( m_error ) {
        return SC_SIM_ERROR;
    }
    if( m_forced_stop ) {
        return SC_SIM_USER_STOP;
    }
    return SC_SIM_OK;
}

bool sc_core::sc_simcontext::elaboration_done

(

)

const [inline]

sc_simcontext.h の 394 行で定義されています。

{
    return m_elaboration_done;
}

sc_object_manager * sc_core::sc_simcontext::get_object_manager

(

)

[inline]

sc_simcontext.h の 416 行で定義されています。

{
    return m_object_manager;
}

void sc_core::sc_simcontext::hierarchy_push

(

sc_module *

mod

)

sc_simcontext.cpp の 959 行で定義されています。

{
    m_object_manager->hierarchy_push( mod );
}

sc_module * sc_core::sc_simcontext::hierarchy_pop

(

)

sc_simcontext.cpp の 965 行で定義されています。

{
        return DCAST<sc_module*>( m_object_manager->hierarchy_pop() );
}

sc_module * sc_core::sc_simcontext::hierarchy_curr

(

)

const

sc_simcontext.cpp の 971 行で定義されています。

{
    return DCAST<sc_module*>( m_object_manager->hierarchy_curr() );
}

sc_object * sc_core::sc_simcontext::first_object

(

)

sc_simcontext.cpp の 977 行で定義されています。

{
    return m_object_manager->first_object();
}

sc_object * sc_core::sc_simcontext::next_object

(

)

sc_simcontext.cpp の 983 行で定義されています。

{
    return m_object_manager->next_object();
}

sc_object * sc_core::sc_simcontext::find_object

(

const char *

name

)

sc_simcontext.cpp の 989 行で定義されています。

{
    static bool warn_find_object=true;
    if ( warn_find_object )
    {
        warn_find_object = false;
        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
            "sc_simcontext::find_object() is deprecated,\n" \
            " use sc_find_object()" );
    }
    return m_object_manager->find_object( name );
}

sc_module_registry * sc_core::sc_simcontext::get_module_registry

(

)

[inline]

sc_simcontext.h の 423 行で定義されています。

{
    return m_module_registry;
}

sc_port_registry * sc_core::sc_simcontext::get_port_registry

(

)

[inline]

sc_simcontext.h の 430 行で定義されています。

{
    return m_port_registry;
}

sc_export_registry * sc_core::sc_simcontext::get_export_registry

(

)

[inline]

sc_simcontext.h の 437 行で定義されています。

{
    return m_export_registry;
}

sc_prim_channel_registry * sc_core::sc_simcontext::get_prim_channel_registry

(

)

[inline]

sc_simcontext.h の 444 行で定義されています。

{
    return m_prim_channel_registry;
}

const char * sc_core::sc_simcontext::gen_unique_name	(	const char *	basename_,
		bool	preserve_first = false
	)

sc_simcontext.cpp の 1005 行で定義されています。

{
    return m_name_gen->gen_unique_name( basename_, preserve_first );
}

sc_process_handle sc_core::sc_simcontext::create_cthread_process	(	const char *	name_p,
		bool	free_host,
		SC_ENTRY_FUNC	method_p,
		sc_process_host *	host_p,
		const sc_spawn_options *	opt_p
	)

sc_simcontext.cpp の 1012 行で定義されています。

{
    sc_cthread_handle handle = 
        new sc_cthread_process(name_p, free_host, method_p, host_p, opt_p);
    if ( m_ready_to_simulate ) 
    {
        handle->prepare_for_simulation();
    } else {
        m_process_table->push_front( handle );
    }
    return sc_process_handle(handle);
}

sc_process_handle sc_core::sc_simcontext::create_method_process	(	const char *	name_p,
		bool	free_host,
		SC_ENTRY_FUNC	method_p,
		sc_process_host *	host_p,
		const sc_spawn_options *	opt_p
	)

sc_simcontext.cpp の 1029 行で定義されています。

{
    sc_method_handle handle = 
        new sc_method_process(name_p, free_host, method_p, host_p, opt_p);
    if ( m_ready_to_simulate ) {
        if ( !handle->dont_initialize() ) {
            push_runnable_method( handle );
        }
    } else {
        m_process_table->push_front( handle );
    }
    return sc_process_handle(handle);
}

sc_process_handle sc_core::sc_simcontext::create_thread_process	(	const char *	name_p,
		bool	free_host,
		SC_ENTRY_FUNC	method_p,
		sc_process_host *	host_p,
		const sc_spawn_options *	opt_p
	)

sc_simcontext.cpp の 1047 行で定義されています。

{
    sc_thread_handle handle = 
        new sc_thread_process(name_p, free_host, method_p, host_p, opt_p);
    if ( m_ready_to_simulate ) {
        handle->prepare_for_simulation();
        if ( !handle->dont_initialize() ) {
            push_runnable_thread( handle );
        }
    } else {
        m_process_table->push_front( handle );
    }
    return sc_process_handle(handle);
}

sc_curr_proc_handle sc_core::sc_simcontext::get_curr_proc_info

(

)

[inline]

sc_simcontext.h の 452 行で定義されています。

{
    return &m_curr_proc_info;
}

sc_object * sc_core::sc_simcontext::get_current_writer

(

)

const [inline]

sc_simcontext.h の 519 行で定義されています。

{
    return m_current_writer;
}

bool sc_core::sc_simcontext::write_check

(

)

const [inline]

sc_simcontext.h の 525 行で定義されています。

{
    return m_write_check;
}

void sc_core::sc_simcontext::set_curr_proc

(

sc_process_b *

process_h

)

[inline]

sc_simcontext_int.h の 72 行で定義されています。

{
    m_curr_proc_info.process_handle = process_h;
    m_curr_proc_info.kind           = process_h->proc_kind();
        m_current_writer = m_write_check ? process_h : (sc_object*)0;
}

void sc_core::sc_simcontext::reset_curr_proc

(

)

[inline]

sc_simcontext_int.h の 81 行で定義されています。

{
    m_curr_proc_info.process_handle = 0;
    m_curr_proc_info.kind           = SC_NO_PROC_;
    m_current_writer                = 0;
    sc_process_b::m_last_created_process_p = 0; 
}

int sc_core::sc_simcontext::next_proc_id

(

)

[inline]

sc_simcontext.h の 460 行で定義されています。

{
    return ( ++ m_next_proc_id );
}

void sc_core::sc_simcontext::add_trace_file

(

sc_trace_file *

tf

)

sc_simcontext.cpp の 1065 行で定義されています。

{
    m_trace_files.push_back( tf );
    m_something_to_trace = true;
}

const sc_time & sc_core::sc_simcontext::time_stamp

(

)

const [inline]

sc_simcontext.h の 468 行で定義されています。

{
    return m_curr_time;
}

sc_dt::uint64 sc_core::sc_simcontext::delta_count

(

)

const

sc_simcontext.cpp の 1129 行で定義されています。

{
    static bool warn_delta_count=true;
    if ( warn_delta_count )
    {
        warn_delta_count = false;
        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
            "sc_simcontext::delta_count() is deprecated, use sc_delta_count()" );
    }
    return m_delta_count;
}

bool sc_core::sc_simcontext::event_occurred

(

sc_dt::uint64

last_change_count

)

const [inline]

sc_simcontext.h の 476 行で定義されています。

{
        return m_delta_count == last_change_count;
}

bool sc_core::sc_simcontext::is_running

(

)

const

sc_simcontext.cpp の 1142 行で定義されています。

{
    static bool warn_is_running=true;
    if ( warn_is_running )
    {
        warn_is_running = false;
        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
            "sc_simcontext::is_running() is deprecated, use sc_is_running()" );
    }
    return m_ready_to_simulate;
}

bool sc_core::sc_simcontext::update_phase

(

)

const [inline]

sc_simcontext.h の 483 行で定義されています。

{
    return m_execution_phase == phase_update;
}

bool sc_core::sc_simcontext::get_error

(

)

[inline]

sc_simcontext.h の 498 行で定義されています。

{
    return m_error;
}

void sc_core::sc_simcontext::set_error

(

)

[inline]

sc_simcontext.h の 490 行で定義されています。

{
    m_error = true;
}

sc_cor_pkg* sc_core::sc_simcontext::cor_pkg

(

)

[inline]

sc_simcontext.h の 269 行で定義されています。

        { return m_cor_pkg; }

sc_cor * sc_core::sc_simcontext::next_cor

(

)

sc_simcontext.cpp の 1073 行で定義されています。

{
    if( m_error ) {
        return m_cor;
    }
    
    sc_thread_handle thread_h = pop_runnable_thread();
    while( thread_h != 0 ) {
        if ( thread_h->ready_to_run() ) break;
        thread_h = pop_runnable_thread();
    }
    
    if( thread_h != 0 ) {
        return thread_h->m_cor_p;
    } else {
        return m_cor;
    }
}

const ::std::vector< sc_object * > & sc_core::sc_simcontext::get_child_objects

(

)

const

sc_simcontext.cpp の 1094 行で定義されています。

{
    static bool warn_get_child_objects=true;
    if ( warn_get_child_objects )
    {
        warn_get_child_objects = false;
        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
            "sc_simcontext::get_child_objects() is deprecated,\n" \
            " use sc_get_top_level_objects()" );
    }
    return m_child_objects;
}

void sc_core::sc_simcontext::elaborate

(

)

sc_simcontext.cpp の 633 行で定義されています。

{
    if( m_elaboration_done || sim_status() != SC_SIM_OK ) {
        return;
    }

    m_port_registry->construction_done();
    m_export_registry->construction_done();
    m_prim_channel_registry->construction_done();
    m_module_registry->construction_done();

    // check for call(s) to sc_stop
    if( m_forced_stop ) {
        do_sc_stop_action();
        return;
    }

    // SIGNAL THAT ELABORATION IS DONE
    //
    // We set the switch before the calls in case someone creates a process 
    // in an end_of_elaboration callback. We need the information to flag 
    // the process as being dynamic.

    m_elaboration_done = true;

    m_port_registry->elaboration_done();
    m_export_registry->elaboration_done();
    m_prim_channel_registry->elaboration_done();
    m_module_registry->elaboration_done();
    sc_reset::reconcile_resets();

    // check for call(s) to sc_stop
    if( m_forced_stop ) {
        do_sc_stop_action();
        return;
    }
}

void sc_core::sc_simcontext::prepare_to_simulate

(

)

sc_simcontext.cpp の 672 行で定義されています。

{
    sc_cthread_handle cthread_p; // Pointer to cthread process accessing.
    sc_method_handle  method_p;  // Pointer to method process accessing.
    sc_thread_handle  thread_p;  // Pointer to thread process accessing.

    if( m_ready_to_simulate || sim_status() != SC_SIM_OK ) {
        return;
    }

    // instantiate the coroutine package
#   if defined(WIN32)
        m_cor_pkg = new sc_cor_pkg_fiber( this );
#   else
#       if defined(SC_USE_PTHREADS)
            m_cor_pkg = new sc_cor_pkg_pthread( this );
#       else
                        m_cor_pkg = new sc_cor_pkg_qt( this );
#       endif
#   endif
    m_cor = m_cor_pkg->get_main();

    // NOTIFY ALL OBJECTS THAT SIMULATION IS ABOUT TO START:

    m_port_registry->start_simulation();
    m_export_registry->start_simulation();
    m_prim_channel_registry->start_simulation();
    m_module_registry->start_simulation();
    m_start_of_simulation_called = true;

    // CHECK FOR CALL(S) TO sc_stop 

    if( m_forced_stop ) {
        do_sc_stop_action();
        return;
    }

    // PREPARE ALL (C)THREAD PROCESSES FOR SIMULATION:

    for ( thread_p = m_process_table->thread_q_head(); 
          thread_p; thread_p = thread_p->next_exist() )
    {
        thread_p->prepare_for_simulation();
    }

    for ( cthread_p = m_process_table->cthread_q_head(); 
          cthread_p; cthread_p = cthread_p->next_exist() )
    {
        cthread_p->prepare_for_simulation();
    }

    m_ready_to_simulate = true;
    m_runnable->init();

    // update phase

    m_execution_phase = phase_update;
    m_prim_channel_registry->perform_update();
    m_execution_phase = phase_notify;

    int size;

    // make all method processes runnable

    for ( method_p = m_process_table->method_q_head(); 
          method_p; method_p = method_p->next_exist() )
    {
        if( !method_p->dont_initialize() ) {
            push_runnable_method_front( method_p );
        }
    }

    // make all thread processes runnable

    for ( thread_p = m_process_table->thread_q_head(); 
          thread_p; thread_p = thread_p->next_exist() )
    {
        if( !thread_p->dont_initialize() ) {
            push_runnable_thread_front( thread_p );
        }
    }


    // process delta notifications

    if( ( size = m_delta_events.size() ) != 0 ) {
        sc_event** l_delta_events = &m_delta_events[0];
        int i = size - 1;
        do {
            l_delta_events[i]->trigger();
        } while( -- i >= 0 );
        m_delta_events.resize(0);
    }

    // used in 'simulate()'
    m_until_event = new sc_event;

    if( m_runnable->is_empty() ) {
        m_delta_count++;
    }
}

void sc_core::sc_simcontext::initial_crunch

(

bool

no_crunch

)

[inline]

sc_simcontext.cpp の 775 行で定義されています。

{
    if( no_crunch || m_runnable->is_empty() ) {
        return;
    }
    m_runnable->toggle();

    // run the delta cycle loop

    crunch();
    if( m_error ) {
        return;
    }
    if( m_something_to_trace ) {
        trace_cycle( false );
    }
    // check for call(s) to sc_stop
    if( m_forced_stop ) {
        do_sc_stop_action();
    }
}

const sc_time sc_core::sc_simcontext::next_time

(

)

sc_simcontext.cpp の 1155 行で定義されています。

{
    while( m_timed_events->size() ) {
        sc_event_timed* et = m_timed_events->top();
        if( et->event() != 0 ) {
            return et->notify_time();
        }
        delete m_timed_events->extract_top();
    }
    return SC_ZERO_TIME;
}

void sc_core::sc_simcontext::add_child_object

(

sc_object *

object_

)

[private]

sc_simcontext.cpp の 1108 行で定義されています。

{
    // no check if object_ is already in the set
    m_child_objects.push_back( object_ );
}

void sc_core::sc_simcontext::remove_child_object

(

sc_object *

object_

)

[private]

sc_simcontext.cpp の 1115 行で定義されています。

{
    int size = m_child_objects.size();
    for( int i = 0; i < size; ++ i ) {
        if( object_ == m_child_objects[i] ) {
            m_child_objects[i] = m_child_objects[size - 1];
            m_child_objects.resize(size-1);
            return;
        }
    }
    // no check if object_ is really in the set
}

void sc_core::sc_simcontext::crunch

(

bool

once = false

)

[inline, private]

sc_simcontext.cpp の 499 行で定義されています。

{
#ifdef DEBUG_SYSTEMC
    int num_deltas = 0;  // number of delta cycles
#endif

    while ( true ) {

        // EVALUATE PHASE
        
        m_execution_phase = phase_evaluate;
        while( true ) {


            // execute method processes

            sc_method_handle method_h = pop_runnable_method();
            while( method_h != 0 ) {
                try {
                    method_h->semantics();
                }
                catch( const sc_report& ex ) {
                    ::std::cout << "\n" << ex.what() << ::std::endl;
                    m_error = true;
                    return;
                }
                method_h = pop_runnable_method();
            }

            // execute (c)thread processes

            sc_thread_handle thread_h = pop_runnable_thread();
            while( thread_h != 0 ) {
                if ( thread_h->ready_to_run() ) break;
                thread_h = pop_runnable_thread();
            }
            if( thread_h != 0 ) {
                m_cor_pkg->yield( thread_h->m_cor_p );
            }
            if( m_error ) {
                return;
            }

            // check for call(s) to sc_stop
            if( m_forced_stop ) {
                if ( stop_mode == SC_STOP_IMMEDIATE ) return;
            }

            if( m_runnable->is_empty() ) {
                // no more runnable processes
                break;
            }
            m_runnable->toggle();
        }

        // UPDATE PHASE
        //
        // The delta count must be updated first so that event_occurred()
        // will work.

        m_execution_phase = phase_update;
        m_delta_count ++;
        m_prim_channel_registry->perform_update();
        m_execution_phase = phase_notify;
        
        if( m_something_to_trace ) {
            trace_cycle( /* delta cycle? */ true );
        }

        // m_delta_count ++;

        // check for call(s) to sc_stop
        if( m_forced_stop ) {
            break;
        }

#ifdef DEBUG_SYSTEMC
        // check for possible infinite loops
        if( ++ num_deltas > SC_MAX_NUM_DELTA_CYCLES ) {
            ::std::cerr << "SystemC warning: "
                 << "the number of delta cycles exceeds the limit of "
                 << SC_MAX_NUM_DELTA_CYCLES
                 << ", defined in sc_constants.h.\n"
                 << "This is a possible sign of an infinite loop.\n"
                 << "Increase the limit if this warning is invalid.\n";
            break;
        }
#endif

        // PROCESS DELTA NOTIFICATIONS:

        int size = m_delta_events.size();
        if ( size != 0 )
        {
            sc_event** l_events = &m_delta_events[0];
            int i = size - 1;
            do {
                l_events[i]->trigger();
            } while( -- i >= 0 );
            m_delta_events.resize(0);
        }
        
        if( m_runnable->is_empty() ) {
            // no more runnable processes
            break;
        }

        // IF ONLY DOING ONE CYCLE, WE ARE DONE. OTHERWISE GET NEW CALLBACKS

        if ( once ) break;

        m_runnable->toggle();
    } 
}

int sc_core::sc_simcontext::add_delta_event

(

sc_event *

e

)

[inline, private]

sc_simcontext.h の 505 行で定義されています。

{
    m_delta_events.push_back( e );
    return ( m_delta_events.size() - 1 );
}

void sc_core::sc_simcontext::remove_delta_event

(

sc_event *

e

)

[private]

sc_simcontext.cpp の 1169 行で定義されています。

{
    int i = e->m_delta_event_index;
    int j = m_delta_events.size() - 1;
    assert( i >= 0 && i <= j );
    if( i != j ) {
        sc_event** l_delta_events = &m_delta_events[0];
        l_delta_events[i] = l_delta_events[j];
        l_delta_events[i]->m_delta_event_index = i;
    }
    m_delta_events.resize(m_delta_events.size()-1);
    e->m_delta_event_index = -1;
}

void sc_core::sc_simcontext::add_timed_event

(

sc_event_timed *

et

)

[inline, private]

sc_simcontext.h の 513 行で定義されています。

{
    m_timed_events->insert( et );
}

void sc_core::sc_simcontext::trace_cycle

(

bool

delta_cycle

)

[private]

sc_simcontext.cpp の 1185 行で定義されています。

{
    int size;
    if( ( size = m_trace_files.size() ) != 0 ) {
        sc_trace_file** l_trace_files = &m_trace_files[0];
        int i = size - 1;
        do {
            l_trace_files[i]->cycle( delta_cycle );
        } while( -- i >= 0 );
    }
}

const ::std::vector<sc_object*>& sc_core::sc_simcontext::get_child_objects_internal

(

)

const [private]

void sc_core::sc_simcontext::push_runnable_method

(

sc_method_handle

method_h

)

[inline, private]

sc_simcontext_int.h の 91 行で定義されています。

{
        m_runnable->push_back_method( method_h );
}

void sc_core::sc_simcontext::push_runnable_thread

(

sc_thread_handle

thread_h

)

[inline, private]

sc_simcontext_int.h の 105 行で定義されています。

{
    m_runnable->push_back_thread( thread_h );
}

void sc_core::sc_simcontext::push_runnable_method_front

(

sc_method_handle

method_h

)

[inline, private]

sc_simcontext_int.h の 98 行で定義されています。

{
    m_runnable->push_front_method( method_h );
}

void sc_core::sc_simcontext::push_runnable_thread_front

(

sc_thread_handle

thread_h

)

[inline, private]

sc_simcontext_int.h の 112 行で定義されています。

{
    m_runnable->push_front_thread( thread_h );
}

sc_method_handle sc_core::sc_simcontext::pop_runnable_method

(

)

[inline, private]

sc_simcontext_int.h の 120 行で定義されています。

{
    sc_method_handle method_h = m_runnable->pop_method();
    if( method_h == 0 ) {
        reset_curr_proc();
        return 0;
    }
    set_curr_proc( (sc_process_b*)method_h );
    return method_h;
}

sc_thread_handle sc_core::sc_simcontext::pop_runnable_thread

(

)

[inline, private]

sc_simcontext_int.h の 133 行で定義されています。

{
    sc_thread_handle thread_h = m_runnable->pop_thread();
    if( thread_h == 0 ) {
        reset_curr_proc();
        return 0;
    }
    set_curr_proc( (sc_process_b*)thread_h );
    return thread_h;
}

void sc_core::sc_simcontext::remove_runnable_method

(

sc_method_handle

method_h

)

[inline, private]

sc_simcontext_int.h の 146 行で定義されています。

{
    m_runnable->remove_method( method_h );
}

void sc_core::sc_simcontext::remove_runnable_thread

(

sc_thread_handle

thread_h

)

[inline, private]

sc_simcontext_int.h の 153 行で定義されています。

{
    m_runnable->remove_thread( thread_h );
}

void sc_core::sc_simcontext::do_sc_stop_action

(

)

[private]

sc_simcontext.cpp の 893 行で定義されています。

{
    ::std::cout << "SystemC: simulation stopped by user." << ::std::endl;
    if (m_start_of_simulation_called) {
        end();
        m_in_simulator_control = false;
    }
}

sc_simcontext& sc_core::sc_simcontext::operator=

(

const sc_simcontext &

)

[private]

---

フレンドと関連する関数

friend class sc_event [friend]

sc_simcontext.h の 177 行で定義されています。

friend class sc_module [friend]

sc_simcontext.h の 178 行で定義されています。

friend class sc_object [friend]

sc_simcontext.h の 179 行で定義されています。

friend class sc_time [friend]

sc_simcontext.h の 180 行で定義されています。

friend class sc_clock [friend]

sc_simcontext.h の 181 行で定義されています。

friend class sc_method_process [friend]

sc_simcontext.h の 182 行で定義されています。

friend class sc_process_b [friend]

sc_simcontext.h の 183 行で定義されています。

friend class sc_prim_channel [friend]

sc_simcontext.h の 184 行で定義されています。

friend class sc_thread_process [friend]

sc_simcontext.h の 185 行で定義されています。

sc_dt::uint64 sc_delta_count

(

)

[friend]

const std::vector<sc_object*>& sc_get_top_level_objects

(

const sc_simcontext *

simc_p = sc_get_curr_simcontext()

)

[friend]

bool sc_is_running

(

const sc_simcontext *

simc_p = sc_get_curr_simcontext()

)

[friend]

bool sc_end_of_simulation_invoked

(

)

[friend]

bool sc_pending_activity_at_current_time

(

)

[friend]

sc_simcontext.cpp の 1285 行で定義されています。

{
    sc_simcontext* c_p = sc_get_curr_simcontext();
    return (c_p->m_delta_events.size() != 0) ||
            !c_p->m_runnable->is_empty() ||
            c_p->m_prim_channel_registry->pending_updates();
}

bool sc_start_of_simulation_invoked

(

)

[friend]

void sc_set_time_resolution	(	double	,
		sc_time_unit
	)			[friend]

sc_time sc_get_time_resolution

(

)

[friend]

void sc_set_default_time_unit	(	double	,
		sc_time_unit
	)			[friend]

sc_time sc_get_default_time_unit

(

)

[friend]

---

変数

sc_object_manager* sc_core::sc_simcontext::m_object_manager [private]

sc_simcontext.h の 317 行で定義されています。

sc_module_registry* sc_core::sc_simcontext::m_module_registry [private]

sc_simcontext.h の 319 行で定義されています。

sc_port_registry* sc_core::sc_simcontext::m_port_registry [private]

sc_simcontext.h の 320 行で定義されています。

sc_export_registry* sc_core::sc_simcontext::m_export_registry [private]

sc_simcontext.h の 321 行で定義されています。

sc_prim_channel_registry* sc_core::sc_simcontext::m_prim_channel_registry [private]

sc_simcontext.h の 322 行で定義されています。

sc_name_gen* sc_core::sc_simcontext::m_name_gen [private]

sc_simcontext.h の 324 行で定義されています。

sc_process_table* sc_core::sc_simcontext::m_process_table [private]

sc_simcontext.h の 326 行で定義されています。

sc_curr_proc_info sc_core::sc_simcontext::m_curr_proc_info [private]

sc_simcontext.h の 327 行で定義されています。

sc_object* sc_core::sc_simcontext::m_current_writer [private]

sc_simcontext.h の 328 行で定義されています。

bool sc_core::sc_simcontext::m_write_check [private]

sc_simcontext.h の 329 行で定義されています。

int sc_core::sc_simcontext::m_next_proc_id [private]

sc_simcontext.h の 330 行で定義されています。

std::vector<sc_object*> sc_core::sc_simcontext::m_child_objects [private]

sc_simcontext.h の 332 行で定義されています。

std::vector<sc_event*> sc_core::sc_simcontext::m_delta_events [private]

sc_simcontext.h の 334 行で定義されています。

sc_ppq<sc_event_timed*>* sc_core::sc_simcontext::m_timed_events [private]

sc_simcontext.h の 335 行で定義されています。

std::vector<sc_trace_file*> sc_core::sc_simcontext::m_trace_files [private]

sc_simcontext.h の 337 行で定義されています。

bool sc_core::sc_simcontext::m_something_to_trace [private]

sc_simcontext.h の 338 行で定義されています。

sc_runnable* sc_core::sc_simcontext::m_runnable [private]

sc_simcontext.h の 340 行で定義されています。

sc_time_params* sc_core::sc_simcontext::m_time_params [private]

sc_simcontext.h の 342 行で定義されています。

sc_time sc_core::sc_simcontext::m_curr_time [private]

sc_simcontext.h の 343 行で定義されています。

sc_dt::uint64 sc_core::sc_simcontext::m_delta_count [private]

sc_simcontext.h の 345 行で定義されています。

bool sc_core::sc_simcontext::m_forced_stop [private]

sc_simcontext.h の 346 行で定義されています。

bool sc_core::sc_simcontext::m_ready_to_simulate [private]

sc_simcontext.h の 347 行で定義されています。

bool sc_core::sc_simcontext::m_elaboration_done [private]

sc_simcontext.h の 348 行で定義されています。

execution_phases sc_core::sc_simcontext::m_execution_phase [private]

sc_simcontext.h の 349 行で定義されています。

bool sc_core::sc_simcontext::m_error [private]

sc_simcontext.h の 350 行で定義されています。

bool sc_core::sc_simcontext::m_in_simulator_control [private]

sc_simcontext.h の 351 行で定義されています。

bool sc_core::sc_simcontext::m_end_of_simulation_called [private]

sc_simcontext.h の 352 行で定義されています。

bool sc_core::sc_simcontext::m_start_of_simulation_called [private]

sc_simcontext.h の 353 行で定義されています。

sc_event* sc_core::sc_simcontext::m_until_event [private]

sc_simcontext.h の 356 行で定義されています。

sc_cor_pkg* sc_core::sc_simcontext::m_cor_pkg [private]

sc_simcontext.h の 358 行で定義されています。

sc_cor* sc_core::sc_simcontext::m_cor [private]

sc_simcontext.h の 359 行で定義されています。

---

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

• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/kernel/sc_simcontext.h
• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/kernel/sc_simcontext.cpp
• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/kernel/sc_simcontext_int.h