クラス sc_core::sc_thread_process

#include <sc_thread_process.h>

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

[凡例]

すべてのメンバ一覧

Public メソッド
	sc_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)
virtual	~sc_thread_process ()
virtual const char *	kind () const
Protected メソッド
virtual void	kill_process ()
sc_thread_handle	next_exist ()
sc_thread_handle	next_runnable ()
virtual void	prepare_for_simulation ()
bool	ready_to_run ()
void	set_next_exist (sc_thread_handle next_p)
void	set_next_runnable (sc_thread_handle next_p)
void	set_stack_size (std::size_t size)
void	suspend_me ()
bool	trigger_dynamic (sc_event *)
void	wait (const sc_event &)
void	wait (sc_event_or_list &)
void	wait (sc_event_and_list &)
void	wait (const sc_time &)
void	wait (const sc_time &, const sc_event &)
void	wait (const sc_time &, sc_event_or_list &)
void	wait (const sc_time &, sc_event_and_list &)
void	wait_cycles (int n=1)
void	add_monitor (sc_process_monitor *monitor_p)
void	remove_monitor (sc_process_monitor *monitor_p)
void	signal_monitors (int type=0)
Protected 変数
sc_cor *	m_cor_p
std::vector< sc_process_monitor * >	m_monitor_q
std::size_t	m_stack_size
int	m_wait_cycle_n
Static Protected 変数
static sc_cor *	m_dead_cor_p
Private メソッド
	sc_thread_process (const sc_thread_process &)
const sc_thread_process &	operator= (const sc_thread_process &)
フレンド
class	sc_event
class	sc_join
class	sc_module
class	sc_process_handle
class	sc_process_table
class	sc_simcontext
class	sc_runnable
void	sc_thread_cor_fn (void *)
void	sc_cthread_cor_fn (void *)
void	sc_set_stack_size (sc_thread_handle, std::size_t)
sc_cor *	get_cor_pointer (sc_process_b *process_p)
void	wait (sc_simcontext *)
void	wait (const sc_event &, sc_simcontext *)
void	wait (sc_event_or_list &, sc_simcontext *)
void	wait (sc_event_and_list &, sc_simcontext *)
void	wait (const sc_time &, sc_simcontext *)
void	wait (const sc_time &, const sc_event &, sc_simcontext *)
void	wait (const sc_time &, sc_event_or_list &, sc_simcontext *)
void	wait (const sc_time &, sc_event_and_list &, sc_simcontext *)

---

説明

sc_thread_process.h の 108 行で定義されています。

---

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

sc_core::sc_thread_process::sc_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_thread_process.cpp の 173 行で定義されています。

 :
    sc_process_b(
        name_p && name_p[0] ? name_p : sc_gen_unique_name("thread_p"), 
        free_host, method_p, host_p, opt_p),
        m_cor_p(0), m_stack_size(SC_DEFAULT_STACK_SIZE), 
        m_wait_cycle_n(0)
{

    // CHECK IF THIS IS AN sc_module-BASED PROCESS AND SIMUALTION HAS STARTED:

    if ( DCAST<sc_module*>(host_p) != 0 && sc_is_running() )
    {
        SC_REPORT_ERROR( SC_ID_MODULE_THREAD_AFTER_START_, "" );
    }

    // INITIALIZE VALUES:
    //
    // If there are spawn options use them.

    m_process_kind = SC_THREAD_PROC_;

    if (opt_p) {
        m_dont_init = opt_p->m_dont_initialize;
        if ( opt_p->m_stack_size ) m_stack_size = opt_p->m_stack_size;

        // traverse event sensitivity list
        for (unsigned int i = 0; i < opt_p->m_sensitive_events.size(); i++) {
            sc_sensitive::make_static_sensitivity(
                this, *opt_p->m_sensitive_events[i]);
        }

        // traverse port base sensitivity list
        for ( unsigned int i = 0; i < opt_p->m_sensitive_port_bases.size(); i++)
        {
            sc_sensitive::make_static_sensitivity(
                this, *opt_p->m_sensitive_port_bases[i]);
        }

        // traverse interface sensitivity list
        for ( unsigned int i = 0; i < opt_p->m_sensitive_interfaces.size(); i++)
        {
            sc_sensitive::make_static_sensitivity(
                this, *opt_p->m_sensitive_interfaces[i]);
        }

        // traverse event finder sensitivity list
        for ( unsigned int i = 0; i < opt_p->m_sensitive_event_finders.size();
            i++)
        {
            sc_sensitive::make_static_sensitivity(
                this, *opt_p->m_sensitive_event_finders[i]);
        }
    }

    else
    {
        m_dont_init = false;
    }

}

sc_core::sc_thread_process::~sc_thread_process

(

)

[virtual]

sc_thread_process.cpp の 242 行で定義されています。

{

    // DESTROY THE COROUTINE FOR THIS THREAD:

    if( m_cor_p != 0 ) {
        m_cor_p->stack_protect( false );
        delete m_cor_p;
        m_cor_p = 0;
    }
}

sc_core::sc_thread_process::sc_thread_process

(

const sc_thread_process &

)

[private]

---

関数

virtual const char* sc_core::sc_thread_process::kind

(

)

const [inline, virtual]

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

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.h の 143 行で定義されています。

        { return "sc_thread_process"; }

void sc_core::sc_thread_process::kill_process

(

)

[protected, virtual]

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

sc_thread_process.cpp の 114 行で定義されています。

{
    // SIGNAL ANY MONITORS WAITING FOR THIS THREAD TO EXIT:

    int mon_n = m_monitor_q.size();
    if ( mon_n )
    {   
        for ( int mon_i = 0; mon_i < mon_n; mon_i++ )
            m_monitor_q[mon_i]->signal( this, sc_process_monitor::spm_exit);
    }

    // CLEAN UP THE LOW LEVEL STUFF ASSOCIATED WITH THIS DATA STRUCTURE:

    sc_process_b::kill_process();


    // IF THIS IS THE ACTIVE PROCESS THEN ABORT IT AND SWITCH TO A NEW ONE:
    //
    // Note we do not use an sc_process_handle, by making a call to
    // sc_get_current_process_handle(), since we don't want to increment the 
    // usage count in case it is already zero. (We are being deleted, and this
    // call to kill_process() may have been the result of the usage count going
    // to zero.) So we get a raw sc_process_b pointer instead.
 
    sc_process_b* active_p = sc_get_current_process_b();
    sc_simcontext*    simc_p = simcontext();
    if ( active_p == (sc_process_b*)this )
    {
        simc_p->cor_pkg()->abort( simc_p->next_cor() );
    }

    // IF THIS WAS NOT THE ACTIVE PROCESS REMOVE IT FROM ANY RUN QUEUES:

    else
    {
        simc_p->remove_runnable_thread( this );
    }
}

sc_thread_handle sc_core::sc_thread_process::next_exist

(

)

[inline, protected]

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.h の 366 行で定義されています。

{
    return (sc_thread_handle)m_exist_p;
}

sc_thread_handle sc_core::sc_thread_process::next_runnable

(

)

[inline, protected]

sc_thread_process.h の 378 行で定義されています。

{
    return (sc_thread_handle)m_runnable_p;
}

void sc_core::sc_thread_process::prepare_for_simulation

(

)

[protected, virtual]

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.cpp の 160 行で定義されています。

{
    m_cor_p = simcontext()->cor_pkg()->create( m_stack_size,
                         sc_thread_cor_fn, this );
    m_cor_p->stack_protect( true );
}

bool sc_core::sc_thread_process::ready_to_run

(

)

[inline, protected]

sc_thread_process.h の 192 行で定義されています。

{
    if ( (m_throw_type == THROW_NONE) && ( m_wait_cycle_n > 0 ) )
    {
        --m_wait_cycle_n;
        return false;
    }
    return true;
}

void sc_core::sc_thread_process::set_next_exist

(

sc_thread_handle

next_p

)

[inline, protected]

sc_thread_process.h の 360 行で定義されています。

{
    m_exist_p = next_p;
}

void sc_core::sc_thread_process::set_next_runnable

(

sc_thread_handle

next_p

)

[inline, protected]

sc_thread_process.h の 372 行で定義されています。

{
    m_runnable_p = next_p;
}

void sc_core::sc_thread_process::set_stack_size

(

std::size_t

size

)

[inline, protected]

sc_thread_process.h の 207 行で定義されています。

{
    assert( size );
    m_stack_size = size;
}

void sc_core::sc_thread_process::suspend_me

(

)

[inline, protected]

sc_thread_process.h の 219 行で定義されています。

{
    sc_simcontext* simc_p = simcontext();
    simc_p->cor_pkg()->yield( simc_p->next_cor() );

    switch ( m_throw_type )
    {
      case THROW_NONE:
        break;
      case THROW_RESET:
        throw sc_user();
      default:
        break;
    }
}

bool sc_core::sc_thread_process::trigger_dynamic

(

sc_event *

e

)

[protected]

sc_thread_process.cpp の 274 行で定義されています。

{
    if( is_runnable() ) {
        return false;
    }
    m_timed_out = false;
    switch( m_trigger_type ) {
    case EVENT: {
        m_trigger_type = STATIC;
        return true;
    }
    case OR_LIST: {
        m_event_list_p->remove_dynamic( this, e );
        m_event_list_p->auto_delete();
        m_event_list_p = 0;
        m_trigger_type = STATIC;
        return true;
    }
    case AND_LIST: {
        if( -- m_event_count == 0 ) {
            // no need to remove_dynamic
            m_event_list_p->auto_delete();
            m_event_list_p = 0;
            m_trigger_type = STATIC;
            return true;
        }
        return false;
    }
    case TIMEOUT: {
        m_trigger_type = STATIC;
        return true;
    }
    case EVENT_TIMEOUT: {
        if( e == m_event_p ) {
            m_timeout_event_p->cancel();
            m_timeout_event_p->reset();
        } else {
            m_timed_out = true;
            m_event_p->remove_dynamic( this );
        }
        m_event_p = 0;
        m_trigger_type = STATIC;
        return true;
    }
    case OR_LIST_TIMEOUT: {
        if( e != m_timeout_event_p ) {
            m_timeout_event_p->cancel();
            m_timeout_event_p->reset();
        } else {
            m_timed_out = true;
        }
        m_event_list_p->remove_dynamic( this, e );
        m_event_list_p->auto_delete();
        m_event_list_p = 0;
        m_trigger_type = STATIC;
        return true;
    }
    case AND_LIST_TIMEOUT: {
        if( e == m_timeout_event_p ) {
            m_timed_out = true;
            m_event_list_p->remove_dynamic( this, e );
            m_event_list_p->auto_delete();
            m_event_list_p = 0;
            m_trigger_type = STATIC;
            return true;
        } else if( -- m_event_count == 0 ) {
            m_timeout_event_p->cancel();
            m_timeout_event_p->reset();
            // no need to remove_dynamic
            m_event_list_p->auto_delete();
            m_event_list_p = 0;
            m_trigger_type = STATIC;
            return true;
        }
        return false;
    }
    case STATIC: {
        // we should never get here
        assert( false );
    }
    }
    return false;
}

void sc_core::sc_thread_process::wait

(

const sc_event &

e

)

[inline, protected]

sc_thread_process.h の 241 行で定義されています。

{
    e.add_dynamic( this );
    m_trigger_type = EVENT;
    suspend_me();
}

void sc_core::sc_thread_process::wait

(

sc_event_or_list &

el

)

[inline, protected]

sc_thread_process.h の 250 行で定義されています。

{
    el.add_dynamic( this );
    m_event_list_p = ⪙
    m_trigger_type = OR_LIST;
    suspend_me();
}

void sc_core::sc_thread_process::wait

(

sc_event_and_list &

el

)

[inline, protected]

sc_thread_process.h の 260 行で定義されています。

{
    el.add_dynamic( this );
    m_event_list_p = ⪙
    m_event_count = el.size();
    m_trigger_type = AND_LIST;
    suspend_me();
}

void sc_core::sc_thread_process::wait

(

const sc_time &

t

)

[inline, protected]

sc_thread_process.h の 271 行で定義されています。

{
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    m_trigger_type = TIMEOUT;
    suspend_me();
}

void sc_core::sc_thread_process::wait	(	const sc_time &	t,
		const sc_event &	e
	)			[inline, protected]

sc_thread_process.h の 281 行で定義されています。

{
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    e.add_dynamic( this );
    m_event_p = &e;
    m_trigger_type = EVENT_TIMEOUT;
    suspend_me();
}

void sc_core::sc_thread_process::wait	(	const sc_time &	t,
		sc_event_or_list &	el
	)			[inline, protected]

sc_thread_process.h の 293 行で定義されています。

{
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    el.add_dynamic( this );
    m_event_list_p = ⪙
    m_trigger_type = OR_LIST_TIMEOUT;
    suspend_me();
}

void sc_core::sc_thread_process::wait	(	const sc_time &	t,
		sc_event_and_list &	el
	)			[inline, protected]

sc_thread_process.h の 305 行で定義されています。

{
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    el.add_dynamic( this );
    m_event_list_p = ⪙
    m_event_count = el.size();
    m_trigger_type = AND_LIST_TIMEOUT;
    suspend_me();
}

void sc_core::sc_thread_process::wait_cycles

(

int

n = 1

)

[inline, protected]

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

{
    m_wait_cycle_n = n-1;
    suspend_me();
}

void sc_core::sc_thread_process::add_monitor

(

sc_process_monitor *

monitor_p

)

[inline, protected]

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

{
    m_monitor_q.push_back(monitor_p);
}

void sc_core::sc_thread_process::remove_monitor

(

sc_process_monitor *

monitor_p

)

[inline, protected]

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

{
    int mon_n = m_monitor_q.size();

    for ( int mon_i = 0; mon_i < mon_n; mon_i++ )
    {
    if  ( m_monitor_q[mon_i] == monitor_p )
        {
            m_monitor_q[mon_i] = m_monitor_q[mon_n-1];
            m_monitor_q.resize(mon_n-1);
        }
    }
}

void sc_core::sc_thread_process::signal_monitors

(

int

type = 0

)

[protected]

sc_thread_process.cpp の 260 行で定義されています。

{       
    int mon_n;  // # of monitors present.
        
    mon_n = m_monitor_q.size();
    for ( int mon_i = 0; mon_i < mon_n; mon_i++ )
        m_monitor_q[mon_i]->signal(this, type);
}   

const sc_thread_process& sc_core::sc_thread_process::operator=

(

const sc_thread_process &

)

[private]

---

フレンドと関連する関数

friend class sc_event [friend]

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

friend class sc_join [friend]

sc_thread_process.h の 113 行で定義されています。

friend class sc_module [friend]

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

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.h の 114 行で定義されています。

friend class sc_process_handle [friend]

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

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.h の 115 行で定義されています。

friend class sc_process_table [friend]

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.h の 116 行で定義されています。

friend class sc_simcontext [friend]

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

sc_core::sc_cthread_processで再定義されています。

sc_thread_process.h の 117 行で定義されています。

friend class sc_runnable [friend]

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

sc_thread_process.h の 118 行で定義されています。

void sc_thread_cor_fn

(

void *

)

[friend]

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

void sc_cthread_cor_fn

(

void *

)

[friend]

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

sc_core::sc_cthread_processで再定義されています。

sc_cthread_process.cpp の 63 行で定義されています。

{
    sc_cthread_handle cthread_h = RCAST<sc_cthread_handle>( arg );

    // EXECUTE THE CTHREAD AND PROCESS ANY EXCEPTIONS THAT ARE THROWN:
    //
    // We set the wait state to unknown before invoking the semantics
    // in case we are reset, since the wait state will not be cleared, 
    // since that happens only if we are not reset.

    while( true ) {

        try {
            cthread_h->semantics();
        }
        catch( sc_user ) {
            continue;
        }
        catch( sc_halt ) {
            ::std::cout << "Terminating process "
                      << cthread_h->name() << ::std::endl;
        }
        catch( const sc_report& ex ) {
            ::std::cout << "\n" << ex.what() << ::std::endl;
            cthread_h->simcontext()->set_error();
        }

        break;
    }

    // SCHEDULE THREAD FOR DESTRUCTION:
    //
    // If control reaches this point the process semantics have returned
    // so the process should die.

    cthread_h->kill_process();

}

void sc_set_stack_size	(	sc_thread_handle	,
		std::size_t
	)			[friend]

sc_cor* get_cor_pointer

(

sc_process_b *

process_p

)

[friend]

void wait

(

sc_simcontext *

)

[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	const sc_event &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	sc_event_or_list &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	sc_event_and_list &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	const sc_time &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	const sc_time &	,
		const sc_event &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	const sc_time &	,
		sc_event_or_list &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

void wait	(	const sc_time &	,
		sc_event_and_list &	,
		sc_simcontext *
	)			[friend]

sc_core::sc_cthread_processで再定義されています。

---

変数

sc_cor* sc_core::sc_thread_process::m_cor_p [protected]

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

sc_cor* sc_core::sc_thread_process::m_dead_cor_p [static, protected]

sc_thread_process.h の 176 行で定義されています。

std::vector<sc_process_monitor*> sc_core::sc_thread_process::m_monitor_q [protected]

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

std::size_t sc_core::sc_thread_process::m_stack_size [protected]

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

int sc_core::sc_thread_process::m_wait_cycle_n [protected]

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

---

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

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