Make sc_event thread safe

Signed-off-by: Mark Burton <mburton@quicinc.com>

Author: markfoodyburton

src/sysc/communication/sc_prim_channel.cpp

@@ -63,6 +63,17 @@ sc_prim_channel::sc_prim_channel( const char* name_ )
     m_registry->insert( *this );
 }
 
+sc_prim_channel::sc_prim_channel( bool is_kernel )
+: sc_object( ),
+  m_registry( simcontext()->get_prim_channel_registry() ),
+  m_update_next_p( 0 )
+{
+    if (is_kernel) {
+        m_registry->insert_internal( *this );
+    } else {
+        m_registry->insert( *this );
+    }
+}
 
 // destructor
 
@@ -237,18 +248,8 @@ class sc_prim_channel_registry::async_update_list
 // ----------------------------------------------------------------------------
 
 void
-sc_prim_channel_registry::insert( sc_prim_channel& prim_channel_ )
+sc_prim_channel_registry::insert_internal( sc_prim_channel& prim_channel_ )
 {
-    if( sc_is_running() ) {
-       SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "simulation running" );
-       return;
-    }
-
-    if( m_simc->elaboration_done() ) {
-       SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "elaboration done" );
-       return;
-    }
-
 #ifdef DEBUG_SYSTEMC
     // check if prim_channel_ is already inserted
     for( int i = 0; i < size(); ++ i ) {
@@ -264,6 +265,21 @@ sc_prim_channel_registry::insert( sc_prim_channel& prim_channel_ )
 
 }
 
+void
+sc_prim_channel_registry::insert( sc_prim_channel& prim_channel_ )
+{
+    if( sc_is_running() ) {
+       SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "simulation running" );
+       return;
+    }
+
+    if( m_simc->elaboration_done() ) {
+       SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "elaboration done" );
+       return;
+    }
+    insert_internal( prim_channel_ );
+}
+
 void
 sc_prim_channel_registry::remove( sc_prim_channel& prim_channel_ )
 {

src/sysc/communication/sc_prim_channel.h

@@ -66,6 +66,7 @@ class SC_API sc_prim_channel
     // constructors
     sc_prim_channel();
     explicit sc_prim_channel( const char* );
+    explicit sc_prim_channel( bool );
 
     // destructor
     virtual ~sc_prim_channel();
@@ -229,7 +230,9 @@ class SC_API sc_prim_channel
 class sc_prim_channel_registry
 {
     friend class sc_simcontext;
+    friend class sc_prim_channel;
 
+    void insert_internal( sc_prim_channel& );
 public:
 
     void insert( sc_prim_channel& );

src/sysc/kernel/sc_event.cpp

@@ -30,6 +30,7 @@
 #include <cstring>
 
 #include "sysc/kernel/sc_event.h"
+#include "sc_simcontext.h"
 #include "sysc/kernel/sc_kernel_ids.h"
 #include "sysc/kernel/sc_stage_callback_registry.h"
 #include "sysc/kernel/sc_process.h"
@@ -61,6 +62,10 @@ sc_event::basename() const
 void
 sc_event::cancel()
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        m_async_helper.pending_cancel();
+        return;
+    }
     // cancel a delta or timed notification
     switch( m_notify_type ) {
     case DELTA: {
@@ -86,6 +91,10 @@ sc_event::cancel()
 void
 sc_event::notify()
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        m_async_helper.pending_notify(SC_ZERO_TIME);
+        return;
+    }
     // immediate notification
     if( !m_simc->evaluation_phase() )
         // coming from
@@ -103,6 +112,11 @@ sc_event::notify()
 void
 sc_event::notify( const sc_time& t )
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        std::cout << name()<<"HERE: ("<<t<<")\n";
+        m_async_helper.pending_notify(t);
+        return;
+    }
     if( m_notify_type == DELTA ) {
         return;
     }
@@ -287,6 +301,7 @@ sc_event::sc_event( const char* name )
   , m_threads_dynamic()
   , m_name()
   , m_parent_with_hierarchy_flag(NULL)
+  , m_async_helper(this)
 {
     register_event( name );
 }
@@ -310,6 +325,7 @@ sc_event::sc_event()
   , m_threads_dynamic()
   , m_name()
   , m_parent_with_hierarchy_flag(NULL)
+  , m_async_helper(this)
 {
     register_event( NULL );
 }
@@ -333,6 +349,7 @@ sc_event::sc_event( kernel_tag, const char* name )
   , m_threads_dynamic()
   , m_name()
   , m_parent_with_hierarchy_flag(NULL)
+  , m_async_helper(this)
 {
     register_event( name, /* is_kernel_event = */ true );
 }

src/sysc/kernel/sc_event.h

@@ -34,7 +34,9 @@
 #include "sysc/kernel/sc_kernel_ids.h"
 #include "sysc/kernel/sc_simcontext.h"
 #include "sysc/communication/sc_writer_policy.h"
+#include "sysc/communication/sc_prim_channel.h"
 #include "sysc/utils/sc_ptr_flag.h"
+#include <mutex>
 
 #if defined(_MSC_VER) && !defined(SC_WIN_DLL_WARN)
 #pragma warning(push)
@@ -273,6 +275,56 @@ class SC_API sc_event
     friend class sc_join;
     friend class sc_trace_file;
 
+    class pending_helper : public sc_prim_channel
+    {
+        std::mutex mutex;
+        class sc_event *event;
+
+        bool valid=false;
+        bool cancel=false;
+        sc_time time;
+
+        void update(void) {
+            mutex.lock();
+            if (valid) {
+                if (cancel) {
+                    valid=false;
+                    mutex.unlock();
+                    event->cancel();
+                } else {
+                    valid=false;
+                    auto t=time;
+                    mutex.unlock();
+                    event->cancel();
+                    event->notify(t);
+                }
+            } else {
+                mutex.unlock();
+            }
+        }
+
+        public:
+        void pending_notify(sc_time t) {
+            mutex.lock();
+            time=t;
+            valid=true;
+            mutex.unlock();
+            async_request_update();
+        }
+        void pending_cancel() {
+            mutex.lock();
+            valid=true;
+            cancel=true;
+            mutex.unlock();
+            async_request_update();
+        }
+
+        pending_helper(sc_event *e) : sc_prim_channel(true) {
+            event=e;
+        }
+
+    };
+    friend class pending_helper;
 public:
 
     sc_event();
@@ -354,6 +406,9 @@ class SC_API sc_event
     // disabled
     sc_event( const sc_event& );
     sc_event& operator = ( const sc_event& );
+
+    pending_helper m_async_helper;
+
 };
 
 // ----------------------------------------------------------------------------
@@ -424,6 +479,10 @@ inline
 void
 sc_event::notify_internal( const sc_time& t )
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        m_async_helper.pending_notify(t);
+        return;
+    }
     if( t == SC_ZERO_TIME ) {
         // add this event to the delta events set
         m_delta_event_index = m_simc->add_delta_event( this );
@@ -441,6 +500,10 @@ inline
 void
 sc_event::notify_next_delta()
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        m_async_helper.pending_notify(SC_ZERO_TIME);
+        return;
+    }
     if( m_notify_type != NONE ) {
         SC_REPORT_ERROR( SC_ID_NOTIFY_DELAYED_, 0 );
     }