sc_thread_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_thread_process.h -- Thread process declarations

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

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


#if !defined(sc_thread_process_h_INCLUDED)
#define sc_thread_process_h_INCLUDED

#include "sysc/kernel/sc_spawn_options.h"
#include "sysc/kernel/sc_process.h"
#include "sysc/kernel/sc_cor.h"
#include "sysc/kernel/sc_event.h"
#include "sysc/kernel/sc_except.h"
#include "sysc/kernel/sc_reset.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

// 02/22/2016 ZC: to enable verbose display or not
#ifndef _SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR
#define _SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR "SYSC_PRINT_VERBOSE_MESSAGE"
#endif
namespace sc_core {

// forward references:
class sc_event_and_list;
class sc_event_or_list;
class sc_reset;
void sc_thread_cor_fn( void* );
void sc_set_stack_size( sc_thread_handle, std::size_t );
class sc_event;
class sc_join;
class sc_module;
class sc_process_handle;
class sc_process_table;
class sc_simcontext;
class sc_runnable;

class Invoker; //DM 05/16/2019

sc_cor* get_cor_pointer( sc_process_b* process_p );
void sc_set_stack_size( sc_thread_handle thread_h, std::size_t size );
void wait( int , sc_simcontext* );
void wait( const sc_event&, int , sc_simcontext* );
void wait( const sc_event_or_list&, int , sc_simcontext* );
void wait( const sc_event_and_list&, int , sc_simcontext* );
void wait( const sc_time&, int , sc_simcontext* );
void wait( const sc_time&, const sc_event&, int , sc_simcontext* );
void wait( const sc_time&, const sc_event_or_list&, int , sc_simcontext* );
void wait( const sc_time&, const sc_event_and_list&, int , sc_simcontext* );

/**************************************************************************/
class sc_thread_process : public sc_process_b {
    friend void sc_thread_cor_fn( void* );
    friend void sc_set_stack_size( sc_thread_handle, std::size_t );
    friend class sc_event;
    friend class sc_join;
    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_b;
    friend class sc_process_handle;
    friend class sc_process_table;
    friend class sc_simcontext;
    friend class sc_runnable;
    friend sc_cor* get_cor_pointer( sc_process_b* process_p );

    friend class Invoker; //DM 05/16/2019

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

  public:
    
        sc_event* waiting_event;
        sc_timestamp first_triggerable_time;
  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 const char* kind() const
  { return "sc_thread_process"; }
        
        void aux_boundary();
  protected: 
    // may not be deleted manually (called from sc_process_b)
    virtual ~sc_thread_process();

    virtual void disable_process( 
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    virtual void enable_process( 
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    virtual void kill_process(
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    sc_thread_handle next_exist(); 
    sc_thread_handle next_runnable();
    virtual void prepare_for_simulation();
    virtual void resume_process( 
        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
    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 );
    inline void suspend_me();
    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*, bool& );
    bool deliver_event_at_time( sc_event* e, sc_timestamp e_delivery_time );

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

        
        
    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_event&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_event_or_list&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_event_and_list&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_time&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_time&, const sc_event&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_time&, const sc_event_or_list&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait( const sc_time&, const sc_event_and_list&, int = -1 );

    // 06/12/2015 GL: modified for the OoO simulation
    void wait_cycles( int, int n=1 );

  protected:
    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;        // Thread's coroutine.
    std::vector<sc_process_monitor*> m_monitor_q;    // Thread monitors.
    std::size_t                      m_stack_size;   // Thread stack size.
    int                              m_wait_cycle_n; // # of waits to be done.

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

//DM 07/31/2019 experiment
struct pairhash {
public:
  template <typename T, typename U>
  std::size_t operator()(const std::pair<T, U> &x) const
  {
    return std::hash<T>()(x.first) ^ std::hash<U>()(x.second);
  }
};

    //std::unordered_set<std::pair<int,int>,pairhash > dependency_checked_segs;
    std::unordered_set<int> dependency_checked_segs;

    std::unordered_map<int,std::vector<sc_method_process*> > m_contingent_methods;
    //std::unordered_map<int,std::unordered_map<std::pair<double, long long>,std::unordered_set<sc_thread_process*>,pairhash > > m_contingent_threads;

    std::unordered_map<int,std::unordered_set<sc_thread_process*> > m_contingent_threads;

    std::unordered_map<int,std::unordered_set<sc_method_process*> > dependent_methods;
    std::unordered_map<int,std::unordered_set<sc_thread_process*> > dependent_threads;

    //std::map<sc_timestamp,std::unordered_set<sc_thread_process*> > dependent_threads;

    std::unordered_map<int, std::unordered_set<sc_method_process*> > combined_data_conflict_methods;
    std::unordered_map<int, std::unordered_set<sc_thread_process*> > combined_data_conflict_threads;


};

//------------------------------------------------------------------------------
//"sc_thread_process::set_stack_size"
//
//------------------------------------------------------------------------------
inline void sc_thread_process::set_stack_size( std::size_t size )
{
    assert( size );
    m_stack_size = size;
}

//------------------------------------------------------------------------------
//"sc_thread_process::suspend_me"
//
// This method suspends this object instance in favor of the next runnable
// process. Upon awakening we check to see if an exception should be thrown. 
// There are two types of exceptions that can be thrown, synchronous reset
// and asynchronous reset. At a future time there may be more asynchronous
// exceptions.  If an asynchronous reset is seen and there is not static reset
// specified, or the static reset is not active then clear the throw
// type for the next time this method is called.
//
// Notes:
//   (1) For an explanation of how the reset mechanism works see the top of
//       the file sc_reset.cpp.
//   (2) The m_sticky_reset field is used to handle synchronous resets that
//       are enabled via the sc_process_handle::sync_reset_on() method. These
//       resets are not generated by a signal, but rather are modal by 
//       method call: sync_reset_on() - sync_reset_off().
//------------------------------------------------------------------------------
inline void sc_thread_process::suspend_me()
{
    // 11/21/2014 GL: assume we have acquired the kernel lock upon here
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

    // remember, if we're currently unwinding

    bool unwinding_preempted = m_unwinding;

    sc_simcontext* simc_p = simcontext();
    //sc_cor*         cor_p = simc_p->next_cor();
    simc_p->new_waiting_proc.push_back(this);
    simc_p->remove_running_process( (sc_process_b*)this ); 
        
        //the following code should not be here, because suspend_me only removes
        //a process from running queue
        //put it into waiting queue and set its state 10:23 2017/3/10 ZC
        //simc_p->add_to_wait_queue( (sc_process_b*)this );
        //this->m_process_state=12;
        
        //printf("calling oooschedule() from process %s",this->process_name);
    // simc_p->schedule( m_cor_p );
        // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
        //      printf("%s is calling suspend_me()\n",this->name());
    /*DM 07/24/2019*/
    simc_p->update_dependency_set();

    pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
    int cur_kernel_requests = sc_get_curr_simcontext()->num_kernel_requests;
    sc_get_curr_simcontext()->num_kernel_requests--;
    pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );

    if(cur_kernel_requests == 1) {
    simc_p->oooschedule( m_cor_p ); // 08/19/2015 GL: OoO scheduling
    }

    // do not switch, if we're about to execute next (e.g. suicide)

    //if( m_cor_p != cor_p )
    //{
    //    DEBUG_MSG( DEBUG_NAME , this, "suspending thread");
    //    simc_p->cor_pkg()->yield( cor_p );
    //    DEBUG_MSG( DEBUG_NAME , this, "resuming thread");
    //}

    // if I am not scheduled to execute again
    if ( !simc_p->is_running_process( (sc_process_b*)this ) )
    {
        DEBUG_MSG( DEBUG_NAME , this, "suspending thread");
        simc_p->suspend_cor( m_cor_p );
        DEBUG_MSG( DEBUG_NAME , this, "resuming thread");
    }

    // IF THERE IS A THROW TO BE DONE FOR THIS PROCESS DO IT NOW:
    //
    // (1) Optimize THROW_NONE for speed as it is the normal case.
    // (2) If this thread is already unwinding then suspend_me() was
    //     called from the catch clause to throw an exception on another
    //     process, so just go back to the catch clause.

    if ( m_throw_status == THROW_NONE ) return;

    if ( m_unwinding ) return;

    switch( m_throw_status )
    {
      case THROW_ASYNC_RESET:
      case THROW_SYNC_RESET:
        DEBUG_MSG( DEBUG_NAME , this, "throwing reset for");
        if ( m_reset_event_p ) m_reset_event_p->notify();
        throw sc_unwind_exception( this, true ); 

      case THROW_USER:
        DEBUG_MSG( DEBUG_NAME, this, "invoking throw_it for");
        m_throw_status = m_active_areset_n ? THROW_ASYNC_RESET :
                                          (m_active_reset_n ? THROW_SYNC_RESET :
                                          THROW_NONE);
        m_throw_helper_p->throw_it();
        break;

      case THROW_KILL:
        DEBUG_MSG( DEBUG_NAME, this, "throwing kill for");
        throw sc_unwind_exception( this, false );

      default: // THROWING_NOW
        sc_assert( unwinding_preempted );
        DEBUG_MSG( DEBUG_NAME, this, "restarting thread");
        break;
    }
}


//------------------------------------------------------------------------------
//"sc_thread_process::wait"
//
// Notes:
//   (1) The correct order to lock and unlock channel locks (to avoid deadlocks
//       and races) for SystemC functions with context switch:
//
//       outer_channel.lock_and_push
//           [outer channel work]
//           inner_channel.lock_and_push
//               [inner channel work]
//   +----------------------------------WAIT----------------------------------+
//   |   +------------------------Simulation Kernel------------------------+  |
//   |   |       acquire kernel lock                                       |  |
//   |   |       +------unlock_all_channels-----+                          |  |
//   |   |       |       inner_channel.unlock   |                          |  |
//   |   |       |   outer_channel.unlock       |                          |  |
//   |   |       +------------------------------+                          |  |
//   |   |           [kernel work]                                         |  |
//   |   |           pthread_cond_wait: release kernel lock                |  |
//   |   |           [sleep]                                               |  |
//   |   |           pthread_cond_wait (upon wakeup): acquire kernel lock  |  |
//   |   |           [kernel work]                                         |  |
//   |   |       release kernel lock                                       |  |
//   |   +-----------------------------------------------------------------+  |
//   |           [no lock/no work]                                            |
//   |           +------lock_all_channels-------+                             |
//   |           |   outer_channel.lock         |                             |
//   |           |       inner_channel.lock     |                             |
//   |           +------------------------------+                             |
//   +------------------------------------------------------------------------+
//               [inner channel work]
//           inner_channel.pop_and_unlock
//           [outer channel work]
//       outer_channel.pop_and_unlock
//
//   (2) If we did not consider immediate notification, a more cleaner locking
//       order should be:
//
//       outer_channel.lock_and_push
//           [outer channel work]
//           inner_channel.lock_and_push
//               [inner channel work]
//   +----------------------------------WAIT----------------------------------+
//   | +----unlock_all_channels----+                                          |
//   | |     inner_channel.unlock  |                                          |
//   | | outer_channel.unlock      |                                          |
//   | +---------------------------+                                          |
//   |   [no lock/no work]                                                    |        
//   | +-------------------------Simulation Kernel-------------------------+  |
//   | | acquire kernel lock                                               |  |
//   | |     [kernel work]                                                 |  |
//   | |     pthread_cond_wait: release kernel lock                        |  |
//   | |     [sleep]                                                       |  |
//   | |     pthread_cond_wait (upon wakeup): acquire kernel lock          |  |
//   | |     [kernel work]                                                 |  |
//   | | release kernel lock                                               |  |
//   | +-------------------------------------------------------------------+  |
//   |   [no lock/no work]                                                    |
//   | +-----lock_all_channels-----+                                          |
//   | | outer_channel.lock        |                                          |
//   | |     inner_channel.lock    |                                          |
//   | +---------------------------+                                          |
//   +------------------------------------------------------------------------+
//               [inner channel work]
//           inner_channel.pop_and_unlock
//           [outer channel work]
//       outer_channel.pop_and_unlock
//
//   (3) When acquiring the channel locks, we may encounter the same lock for 
//       several times (a channel method calls another one in the same channel).
//       But we should encounter them one right after another, so the same lock
//       is at the end of the lock queue. If we encounter a lock that is in the
//       middle of the queue, then it is a bad coding style and simulation may 
//       break (meaning an inner channel method calls an outer channel method).
//
//   (4) For more information, please refer to the following files:
//       sc_method_process.h: 184       (sc_method_process::next_trigger)
//       sc_event.cpp: 79               (sc_event::notify)
//
// (02/19/2015 GL)
//------------------------------------------------------------------------------
inline
void
sc_thread_process::aux_boundary()
{
        
        
        
        
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 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 */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( -2 ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
       
                
                //ZC 9:06 2017/3/14
                // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
                //      printf("\n%s is calling wait for nothing\n",this->name());
                
                
        sc_get_curr_simcontext()->oooschedule( m_cor_p );
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
        
        
        
}

inline
void
sc_thread_process::wait( const sc_event& e, int seg_id )
{   

        
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );

        sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        m_event_p = &e; // for cleanup.
        e.add_dynamic( this );
                
                
        m_trigger_type = EVENT;
                
                //ZC 9:06 2017/3/14
                // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
                //      printf("\n%s is calling wait for event %s\n",this->name(),e.name());
                this->m_process_state=2;
                sc_get_curr_simcontext()->add_to_wait_queue( (sc_process_b*)this )              ;
                
        
        
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

inline
void
sc_thread_process::wait( const sc_event_or_list& el, int seg_id )
{   

    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );

        sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        el.add_dynamic( this );
        m_event_list_p = &el;
        m_event_count = el.size(); //ZC 2018/7/9
        //std::cout << "wait for or_list m_event_count = " << m_event_count << std::endl;
        m_trigger_type = OR_LIST;
        
        //ZC 19:59 2018/7/9 copied for the andlist downward
        //I dont know why I didnt do this before
                // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
                //      printf("\n%s is calling wait for event list\n",this->name());
                this->m_process_state=2;
                sc_get_curr_simcontext()->add_to_wait_queue( (sc_process_b*)this )              ;
                
    
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

inline
void
sc_thread_process::wait( const sc_event_and_list& el, int seg_id )
{
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );


        sc_kernel_lock lock; 

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        el.add_dynamic( this );
        m_event_list_p = &el;
        m_event_count = el.size();
        //this->m_process_state=7;
        //std::cout << "wait for and_list m_event_count = " << m_event_count << std::endl;
        m_trigger_type = AND_LIST;
                
                //ZC 9:06 2017/3/14
                // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
                //      printf("\n%s is calling wait for event list\n",this->name());
                this->m_process_state=2;
                sc_get_curr_simcontext()->add_to_wait_queue( (sc_process_b*)this )              ;
                
                
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

inline
void
sc_thread_process::wait( const sc_time& t, int seg_id )
{
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );

        sc_kernel_lock lock; 

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id );

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        m_timeout_event_p->notify_internal( t );
        m_timeout_event_p->add_dynamic( this );
                
                if(t==SC_ZERO_TIME){
                        this->m_process_state=3;
                        //sc_get_curr_simcontext()->add_to_wait_queue( (sc_process_b*)this )            ;
                        // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
                        //      printf("\n%s is calling wait for delta time\n",this->name());
                }
                else {
                        this->m_process_state=3; //ZC
                        // if(getenv(_SYSC_PRINT_VERBOSE_MESSAGE_ENV_VAR))
                        //      printf("\n%s is calling wait for time\n",this->name());
                }
        m_trigger_type = TIMEOUT;
                
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

inline
void
sc_thread_process::wait( const sc_time& t, const sc_event& e, int seg_id )
{
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );

        sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        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();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

inline
void
sc_thread_process::wait( const sc_time& t, const sc_event_or_list& el, int seg_id )
{
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );

        sc_kernel_lock lock; 

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        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;
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

inline
void
sc_thread_process::wait( const sc_time& t, const sc_event_and_list& el, int seg_id )
{
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );


        sc_kernel_lock lock; 

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id ); 

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        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;
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

//------------------------------------------------------------------------------
//"sc_thread_process::wait_cycles"
//
// This method suspends this object instance for the specified number of cycles.
// A cycle is defined as the event the thread is set up to staticly wait on.
// The field m_wait_cycle_n is set to one less than the number of cycles to
// be waited for, since the value is tested before being decremented in 
// the simulation kernel.
//------------------------------------------------------------------------------
inline
void
sc_thread_process::wait_cycles( int seg_id, int n )
{   
    if( m_unwinding )
        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );

    {
        // 05/25/2015 GL: sc_kernel_lock constructor acquires the kernel lock
        /*DM 07/24/2019 */      
        pthread_mutex_lock( &sc_get_curr_simcontext()->kernel_request_mutex );
        sc_get_curr_simcontext()->num_kernel_requests++;
        pthread_mutex_unlock( &sc_get_curr_simcontext()->kernel_request_mutex );


        sc_kernel_lock lock;

#ifdef SC_LOCK_CHECK
        assert( sc_get_curr_simcontext()->is_locked_and_owner() );
#endif /* SC_LOCK_CHECK */

        // 08/14/2015 GL: set the new segment ID of this thread
        set_segment_id( seg_id );

        unlock_all_channels(); // 02/16/2015 GL: release all the channel locks
        m_wait_cycle_n = n-1;
        suspend_me();
        // 05/25/2015 GL: sc_kernel_lock destructor releases the kernel lock
    }
#ifdef SC_LOCK_CHECK
    assert( sc_get_curr_simcontext()->is_not_owner() );
#endif /* SC_LOCK_CHECK */
    lock_all_channels(); // 02/16/2015 GL: acquire all the channel locks
}

//------------------------------------------------------------------------------
//"sc_thread_process::miscellaneous support"
//
//------------------------------------------------------------------------------
inline
void sc_thread_process::add_monitor(sc_process_monitor* monitor_p)
{
    m_monitor_q.push_back(monitor_p);
}


inline
void sc_thread_process::remove_monitor(sc_process_monitor* monitor_p)
{
    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);
        }
    }
}

inline
void sc_thread_process::set_next_exist(sc_thread_handle next_p)
{
    m_exist_p = next_p;
}

inline
sc_thread_handle sc_thread_process::next_exist()
{
    return (sc_thread_handle)m_exist_p;
}

inline
void sc_thread_process::set_next_runnable(sc_thread_handle next_p)
{
    m_runnable_p = next_p;
}

inline
sc_thread_handle sc_thread_process::next_runnable()
{
    return (sc_thread_handle)m_runnable_p;
}

//------------------------------------------------------------------------------
//"sc_thread_process::trigger_static"
//
// This inline method adds the current thread 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.
//   (4) The process' static wait count is zero.
//
// 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_thread_process::trigger_static()
sc_thread_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

    // No need to try queueing this thread if one of the following is true:
    //    (a) its disabled
    //    (b) its already queued for execution
    //    (c) its waiting on a dynamic event
    //    (d) its wait count is not satisfied

    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 ( m_wait_cycle_n > 0 )
    {
        --m_wait_cycle_n;
        return;
    }

    // If we get here then the thread is has satisfied its wait criteria, 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 thread 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_thread(this);

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

#undef DEBUG_MSG
#undef DEBUG_NAME

} // namespace sc_core 

// $Log: sc_thread_process.h,v $
// Revision 1.30  2011/08/26 20:46:11  acg
//  Andy Goodrich: moved the modification log to the end of the file to
//  eliminate source line number skew when check-ins are done.
//
// Revision 1.29  2011/08/24 23:36:12  acg
//  Andy Goodrich: removed break statements that can never be reached and
//  which causes warnings in the Greenhills C++ compiler.
//
// Revision 1.28  2011/04/14 22:34:27  acg
//  Andy Goodrich: removed dead code.
//
// Revision 1.27  2011/04/13 05:02:18  acg
//  Andy Goodrich: added missing check to the wake up code in suspend_me()
//  so that we just return if the call to suspend_me() was issued from a
//  stack unwinding.
//
// Revision 1.26  2011/04/13 02:44:26  acg
//  Andy Goodrich: added m_unwinding flag in place of THROW_NOW because the
//  throw status will be set back to THROW_*_RESET if reset is active and
//  the check for an unwind being complete was expecting THROW_NONE as the
//  clearing of THROW_NOW.
//
// Revision 1.25  2011/04/11 22:05:14  acg
//  Andy Goodrich: use the DEBUG_NAME macro in DEBUG_MSG invocations.
//
// Revision 1.24  2011/04/10 22:12:32  acg
//  Andy Goodrich: adding debugging macros.
//
// Revision 1.23  2011/04/08 22:41:28  acg
//  Andy Goodrich: added comment pointing to the description of the reset
//  mechanism in sc_reset.cpp.
//
// Revision 1.22  2011/04/08 18:27:33  acg
//  Andy Goodrich: added check to make sure we don't schedule a running process
//  because of it issues a notify() it is sensitive to.
//
// Revision 1.21  2011/04/05 06:22:38  acg
//  Andy Goodrich: expanded comment for trigger_static() initial vetting.
//
// Revision 1.20  2011/04/01 21:24:57  acg
//  Andy Goodrich: removed unused code.
//
// Revision 1.19  2011/02/19 08:30:53  acg
//  Andy Goodrich: Moved process queueing into trigger_static from
//  sc_event::notify.
//
// Revision 1.18  2011/02/18 20:27:14  acg
//  Andy Goodrich: Updated Copyrights.
//
// Revision 1.17  2011/02/17 19:55:58  acg
//  Andy Goodrich:
//    (1) Changed signature of trigger_dynamic() back to a bool.
//    (2) Simplified process control usage.
//    (3) Changed trigger_static() to recognize process controls and to
//        do the down-count on wait(N), allowing the elimination of
//        ready_to_run().
//
// Revision 1.16  2011/02/16 22:37:31  acg
//  Andy Goodrich: clean up to remove need for ps_disable_pending.
//
// Revision 1.15  2011/02/13 21:47:38  acg
//  Andy Goodrich: update copyright notice.
//
// Revision 1.14  2011/02/13 21:35:54  acg
//  Andy Goodrich: added error for performing a wait() during unwinding.
//
// Revision 1.13  2011/02/11 13:25:24  acg
//  Andy Goodrich: Philipp A. Hartmann's changes:
//    (1) Removal of SC_CTHREAD method overloads.
//    (2) New exception processing code.
//
// Revision 1.12  2011/02/01 23:01:53  acg
//  Andy Goodrich: removed dead code.
//
// Revision 1.11  2011/02/01 21:18:01  acg
//  Andy Goodrich:
//  (1) Changes in throw processing for new process control rules.
//  (2) Support of new process_state enum values.
//
// Revision 1.10  2011/01/25 20:50:37  acg
//  Andy Goodrich: changes for IEEE 1666 2011.
//
// Revision 1.9  2011/01/19 23:21:50  acg
//  Andy Goodrich: changes for IEEE 1666 2011
//
// Revision 1.8  2011/01/18 20:10:45  acg
//  Andy Goodrich: changes for IEEE1666_2011 semantics.
//
// Revision 1.7  2011/01/06 17:59:58  acg
//  Andy Goodrich: removed debugging output.
//
// Revision 1.6  2010/07/22 20:02:33  acg
//  Andy Goodrich: bug fixes.
//
// Revision 1.5  2009/07/28 01:10:53  acg
//  Andy Goodrich: updates for 2.3 release candidate.
//
// Revision 1.4  2009/05/22 16:06:29  acg
//  Andy Goodrich: process control updates.
//
// Revision 1.3  2009/03/12 22:59:58  acg
//  Andy Goodrich: updates for 2.4 stuff.
//
// Revision 1.2  2008/05/22 17:06:06  acg
//  Andy Goodrich: formatting and comments.
//
// 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:30  acg
// Added $Log to record CVS changes into the source.

#endif // !defined(sc_thread_process_h_INCLUDED)