sysc/kernel/sc_method_process.h

Go to the documentation of this file.

/*****************************************************************************

  The following code is derived, directly or indirectly, from the SystemC
  source code Copyright (c) 1996-2014 by all Contributors.
  All Rights reserved.

  The contents of this file are subject to the restrictions and limitations
  set forth in the SystemC Open Source License (the "License");
  You may not use this file except in compliance with such restrictions and
  limitations. You may obtain instructions on how to receive a copy of the
  License at http://www.accellera.org/. Software distributed by Contributors
  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
  ANY KIND, either express or implied. See the License for the specific
  language governing rights and limitations under the License.

 *****************************************************************************/

/*****************************************************************************

  sc_method_process.h -- Method process declarations

  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
               

  CHANGE LOG AT THE END OF THE FILE
 *****************************************************************************/

// $Log: sc_method_process.h,v $
// Revision 1.23  2011/09/05 21:20:22  acg
//  Andy Goodrich: result of automake invocation.
//
// Revision 1.22  2011/08/29 18:04:32  acg
//  Philipp A. Hartmann: miscellaneous clean ups.
//
// Revision 1.21  2011/08/26 20:46:10  acg
//  Andy Goodrich: moved the modification log to the end of the file to
//  eliminate source line number skew when check-ins are done.
//

#if !defined(sc_method_process_h_INCLUDED)
#define sc_method_process_h_INCLUDED

#include "sysc/kernel/sc_process.h"
#include "sysc/kernel/sc_spawn_options.h"
#include "sysc/kernel/sc_cor.h"
#include "sysc/kernel/sc_event.h"
#include "sysc/kernel/sc_except.h"


// DEBUGGING MACROS:
//
// DEBUG_MSG(NAME,P,MSG)
//     MSG  = message to print
//     NAME = name that must match the process for the message to print, or
//            null if the message should be printed unconditionally.
//     P    = pointer to process message is for, or NULL in which case the
//            message will not print.
#if 0
#   define DEBUG_NAME ""
#   define DEBUG_MSG(NAME,P,MSG) \
    { \
        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
          std::cout << "**** " << sc_time_stamp() << " ("  \
                    << sc_get_current_process_name() << "): " << MSG \
                    << " - " << P->name() << std::endl; \
    }
#else
#   define DEBUG_MSG(NAME,P,MSG) 
#endif


namespace sc_core {

// forward function and class declarations:

void sc_method_cor_fn( void* );
void sc_cmethod_cor_fn( void* );
void sc_set_stack_size( sc_method_handle, std::size_t );
class sc_event;
class sc_module;
class sc_process_table;
class sc_process_handle;
class sc_simcontext;
class sc_runnable;

// 05/22/2015 GL: get m_cor_p
sc_cor* get_cor_pointer( sc_process_b* process_p );

void next_trigger( int, sc_simcontext* );
void next_trigger( const sc_event&, int, sc_simcontext* );
void next_trigger( const sc_event_or_list&, int, sc_simcontext* );
void next_trigger( const sc_event_and_list&, int, sc_simcontext* );
void next_trigger( const sc_time&, int, sc_simcontext* );
void next_trigger( const sc_time&, const sc_event&, int, sc_simcontext* );
void next_trigger( const sc_time&, const sc_event_or_list&, int, sc_simcontext* );
void next_trigger( const sc_time&, const sc_event_and_list&, int, sc_simcontext* );

struct sc_invoke_method; 
/**************************************************************************/
class sc_method_process : public sc_process_b {
    friend struct sc_invoke_method; 
    friend void sc_method_cor_fn( void* );
    friend void sc_cmethod_cor_fn( void* );
    friend void sc_set_stack_size( sc_method_handle, std::size_t );
    friend class sc_event;
    friend class sc_module;

    // 04/07/2015 GL: a new sc_channel class is derived from sc_module
    friend class sc_channel;

    friend class sc_process_table;
    friend class sc_process_handle;
    friend class sc_simcontext;
    friend class sc_runnable;

    // 05/22/2015 GL: get m_cor_p
    friend sc_cor* get_cor_pointer( sc_process_b* process_p );

    // 08/14/2015 GL: modified for the OoO simulation
    friend void next_trigger( int, sc_simcontext* );
    friend void next_trigger( const sc_event&, int,
                  sc_simcontext* );
    friend void next_trigger( const sc_event_or_list&, int,
                  sc_simcontext* );
    friend void next_trigger( const sc_event_and_list&, int,
                  sc_simcontext* );
    friend void next_trigger( const sc_time&, int,
                  sc_simcontext* );
    friend void next_trigger( const sc_time&, const sc_event&, int,
                  sc_simcontext* );
    friend void next_trigger( const sc_time&, const sc_event_or_list&, int,
                  sc_simcontext* );
    friend void next_trigger( const sc_time&, const sc_event_and_list&, int,
                  sc_simcontext* );

  public:
    sc_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 );

    virtual const char* kind() const
        { return "sc_method_process"; }

  protected:
    void check_for_throws();
    virtual void disable_process(
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    virtual void enable_process(
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    inline bool run_process();
    virtual void kill_process(
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    sc_method_handle next_exist();
    sc_method_handle next_runnable();

    // 11/13/2014 GL.
    virtual void prepare_for_simulation();

    // 08/14/2015 GL: modified for the OoO simulation
    void clear_trigger( int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_event&, int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_event_or_list&, int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_event_and_list&, int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_time&, int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_time&, const sc_event&, int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_time&, const sc_event_or_list&, int );

    // 08/14/2015 GL: modified for the OoO simulation
    void next_trigger( const sc_time&, const sc_event_and_list&, int );

    virtual void resume_process(
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    void set_next_exist( sc_method_handle next_p );
    void set_next_runnable( sc_method_handle next_p );

    // 11/13/2014 GL. 
    void set_stack_size( std::size_t size );

    virtual void suspend_process( 
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    virtual void throw_reset( bool async );
    virtual void throw_user( const sc_throw_it_helper& helper,
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    bool trigger_dynamic( sc_event* );

    // 08/14/2015 GL: add a new parameter to update the local time stamp
    //inline void trigger_static();
    inline void trigger_static( sc_event* );

  protected:
    sc_cor*                          m_cor_p;      // Thread's coroutine.
    std::size_t                      m_stack_size; // Thread stack size.
    std::vector<sc_process_monitor*> m_monitor_q;  // Thread monitors.

  private:
    // may not be deleted manually (called from sc_process_b)
    virtual ~sc_method_process();

  private: // disabled
    sc_method_process( const sc_method_process& );
    const sc_method_process& operator = ( const sc_method_process& );

};

//------------------------------------------------------------------------------
//"sc_method_process::set_stack_size"
//
// (04/03/2015 GL)
//------------------------------------------------------------------------------
inline void sc_method_process::set_stack_size( std::size_t size )
{
    assert( size );
    m_stack_size = size;
}

//------------------------------------------------------------------------------
//"sc_method_process::next_trigger"
//
// Notes:
//   (1) The correct order to lock and unlock channel locks (to avoid deadlocks
//       and races) for SystemC functions without context switch:
//
//       outer_channel.lock_and_push
//           [outer channel work]
//           inner_channel.lock_and_push
//               [inner channel work]
//   +------------------------------NEXT_TRIGGER------------------------------+
//   |   +------------------------Simulation Kernel------------------------+  |
//   |   |       acquire kernel lock                                       |  |
//   |   |           [kernel work]                                         |  |
//   |   |       release kernel lock                                       |  |
//   |   +-----------------------------------------------------------------+  |
//   +------------------------------------------------------------------------+
//               [inner channel work]
//           inner_channel.pop_and_unlock
//           [outer channel work]
//       outer_channel.pop_and_unlock
//
//   (2) For more information, please refer to sc_thread_process.h: 272
//
// (02/20/2015 GL)
//------------------------------------------------------------------------------
inline
void
sc_method_process::next_trigger( const sc_event& e, int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    e.add_dynamic( this );
    m_event_p = &e;
    m_trigger_type = EVENT;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void
sc_method_process::next_trigger( const sc_event_or_list& el, int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    el.add_dynamic( this );
    m_event_list_p = &el;
    m_trigger_type = OR_LIST;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void
sc_method_process::next_trigger( const sc_event_and_list& el, int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    el.add_dynamic( this );
    m_event_list_p = &el;
    m_event_count = el.size();
    m_trigger_type = AND_LIST;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void
sc_method_process::next_trigger( const sc_time& t, int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    m_trigger_type = TIMEOUT;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void
sc_method_process::next_trigger( const sc_time& t, const sc_event& e, 
                                 int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    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;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void
sc_method_process::next_trigger( const sc_time& t, const sc_event_or_list& el,
                                 int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    el.add_dynamic( this );
    m_event_list_p = &el;
    m_trigger_type = OR_LIST_TIMEOUT;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void
sc_method_process::next_trigger( const sc_time& t, const sc_event_and_list& el,
                                 int seg_id )
{
    // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
    sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */
    clear_trigger( seg_id );
    m_timeout_event_p->notify_internal( t );
    m_timeout_event_p->add_dynamic( this );
    el.add_dynamic( this );
    m_event_list_p = &el;
    m_event_count = el.size();
    m_trigger_type = AND_LIST_TIMEOUT;
    // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
}

inline
void sc_method_process::set_next_exist(sc_method_handle next_p)
{
    m_exist_p = next_p;
}

inline
sc_method_handle sc_method_process::next_exist()
{
    return (sc_method_handle)m_exist_p;
}


inline
void sc_method_process::set_next_runnable(sc_method_handle next_p)
{
    m_runnable_p = next_p;
}

inline
sc_method_handle sc_method_process::next_runnable()
{
    return (sc_method_handle)m_runnable_p;
}

// +----------------------------------------------------------------------------
// |"sc_method_process::run_process"
// | 
// | This method executes this object instance, including fielding exceptions.
// |
// | Result is false if an unfielded exception occurred, true if not.
// +----------------------------------------------------------------------------
inline bool sc_method_process::run_process()
{
    // Execute this object instance's semantics and catch any exceptions that
    // are generated:

    bool restart = false;
    do {
        try {
            DEBUG_MSG(DEBUG_NAME,this,"executing method semantics");
            semantics();
            restart = false;
        }
        catch( sc_unwind_exception& ex ) {
            DEBUG_MSG(DEBUG_NAME,this,"caught unwind exception");
            ex.clear();
            restart = ex.is_reset();
        }
        catch( ... ) {
            sc_report* err_p = sc_handle_exception();
            simcontext()->set_error( err_p );
            return false;
        }
    } while( restart );

    return true;
}

//------------------------------------------------------------------------------
//"sc_method_process::trigger_static"
//
// This inline method adds the current method to the queue of runnable
// processes, if required.  This is the case if the following criteria
// are met:
//   (1) The process is in a runnable state.
//   (2) The process is not already on the run queue.
//   (3) The process is expecting a static trigger, 
//       dynamic event waits take priority.
//
//
// If the triggering process is the same process, the trigger is
// ignored as well, unless SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
// is defined.
//------------------------------------------------------------------------------
inline
void
// 08/14/2015 GL: add a new parameter to update the local time stamp
//sc_method_process::trigger_static()
sc_method_process::trigger_static( sc_event* e )
{
    // 05/05/2015 GL: we may or may not have acquired the kernel lock upon here
    // 1) this function is invoked in sc_simcontext::prepare_to_simulate(), 
    //    where the kernel lock is not acquired as it is in the initialization
    //    phase
    // 2) this function is also invoked in sc_event::notify(), where the kernel
    //    lock is acquired

    if ( (m_state & ps_bit_disabled) || is_runnable() ||
          m_trigger_type != STATIC )
        return;

#if ! defined( SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS )
    if( SC_UNLIKELY_( sc_get_current_process_b() == this ) )
    {
        report_immediate_self_notification();
        return;
    }
#endif // SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS

    // If we get here then the method is has satisfied its wait, if its 
    // suspended mark its state as ready to run. If its not suspended then 
    // push it onto the runnable queue.

    if ( m_state & ps_bit_suspended )
    {
        m_state = m_state | ps_bit_ready_to_run;
    }
    else
    {
        // 12/22/2016 GL: store the current time before updating
        sc_time curr_time = m_timestamp.get_time_count();

        // 08/14/2015 GL: update the local time stamp of this method process
        sc_timestamp ts = e->get_notify_timestamp();
        switch( e->m_notify_type )
        {
            case sc_event::DELTA: // delta notification
                if ( ts > m_timestamp ) {
                    set_timestamp( sc_timestamp( ts.get_time_count(),
                                                 ts.get_delta_count() + 1 ) );
                } else {
                    set_timestamp( sc_timestamp( m_timestamp.get_time_count(),
                                                 m_timestamp.get_delta_count() 
                                                     + 1 ) );
                }
                break;
            case sc_event::TIMED: // timed notification
                set_timestamp( ts );
                break;
            case sc_event::NONE:
                assert( 0 ); // wrong type
        }

        simcontext()->push_runnable_method(this);

        // 12/22/2016 GL: update m_oldest_time in sc_simcontext if necessary
        simcontext()->update_oldest_time( curr_time );
    }
}

#undef DEBUG_MSG

} // namespace sc_core 

// Revision 1.20  2011/08/24 22:05:50  acg
//  Torsten Maehne: initialization changes to remove warnings.
//
// Revision 1.19  2011/07/29 22:43:15  acg
//  Andy Goodrich: addition of check_for_throws() method.
//
// Revision 1.18  2011/07/24 11:18:09  acg
//  Philipp A. Hartmann: add code to restart a method process after a
//  self-reset.
//
// Revision 1.17  2011/05/09 04:07:48  acg
//  Philipp A. Hartmann:
//    (1) Restore hierarchy in all phase callbacks.
//    (2) Ensure calls to before_end_of_elaboration.
//
// Revision 1.16  2011/04/13 02:41:34  acg
//  Andy Goodrich: eliminate warning messages generated when the DEBUG_MSG
//  macro is used.
//
// Revision 1.15  2011/04/10 22:12:32  acg
//  Andy Goodrich: adding debugging macros.
//
// Revision 1.14  2011/04/08 22:31:21  acg
//  Andy Goodrich: added new inline method run_process() to hide the process
//  implementation for sc_simcontext.
//
// Revision 1.13  2011/04/05 20:50:56  acg
//  Andy Goodrich:
//    (1) changes to make sure that event(), posedge() and negedge() only
//        return true if the clock has not moved.
//    (2) fixes for method self-resumes.
//    (3) added SC_PRERELEASE_VERSION
//    (4) removed kernel events from the object hierarchy, added
//        sc_hierarchy_name_exists().
//
// Revision 1.12  2011/04/01 21:24:57  acg
//  Andy Goodrich: removed unused code.
//
// Revision 1.11  2011/02/19 08:30:53  acg
//  Andy Goodrich: Moved process queueing into trigger_static from
//  sc_event::notify.
//
// Revision 1.10  2011/02/18 20:27:14  acg
//  Andy Goodrich: Updated Copyrights.
//
// Revision 1.9  2011/02/17 19:51:34  acg
//  Andy Goodrich:
//    (1) Changed the signature of trigger_dynamic back to a bool.
//    (2) Removed ready_to_run().
//    (3) Simplified process control usage.
//
// Revision 1.8  2011/02/16 22:37:30  acg
//  Andy Goodrich: clean up to remove need for ps_disable_pending.
//
// Revision 1.7  2011/02/13 21:47:37  acg
//  Andy Goodrich: update copyright notice.
//
// Revision 1.6  2011/02/01 21:05:05  acg
//  Andy Goodrich: Changes in trigger_dynamic methods to handle new
//  process control rules about event sensitivity.
//
// Revision 1.5  2011/01/18 20:10:44  acg
//  Andy Goodrich: changes for IEEE1666_2011 semantics.
//
// Revision 1.4  2009/07/28 01:10:53  acg
//  Andy Goodrich: updates for 2.3 release candidate.
//
// Revision 1.3  2009/05/22 16:06:29  acg
//  Andy Goodrich: process control updates.
//
// Revision 1.2  2008/05/22 17:06:25  acg
//  Andy Goodrich: updated copyright notice to include 2008.
//
// Revision 1.1.1.1  2006/12/15 20:20:05  acg
// SystemC 2.3
//
// Revision 1.7  2006/05/08 17:57:13  acg
//  Andy Goodrich: Added David Long's forward declarations for friend functions
//  to keep the Microsoft C++ compiler happy.
//
// Revision 1.6  2006/04/20 17:08:17  acg
//  Andy Goodrich: 3.0 style process changes.
//
// Revision 1.5  2006/04/11 23:13:21  acg
//   Andy Goodrich: Changes for reduced reset support that only includes
//   sc_cthread, but has preliminary hooks for expanding to method and thread
//   processes also.
//
// Revision 1.4  2006/01/24 20:49:05  acg
// Andy Goodrich: changes to remove the use of deprecated features within the
// simulator, and to issue warning messages when deprecated features are used.
//
// Revision 1.3  2006/01/13 18:44:29  acg
// Added $Log to record CVS changes into the source.

#endif // !defined(sc_method_process_h_INCLUDED)

---