Additional thead safety and cleanups

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

Author: markfoodyburton

src/sysc/kernel/sc_event.cpp

@@ -92,7 +92,7 @@ void
 sc_event::notify()
 {
     if (m_simc != sc_get_curr_simcontext()) {
-        m_async_helper.pending_notify(SC_ZERO_TIME);
+        m_async_helper.pending_notify();
         return;
     }
     // immediate notification
@@ -113,7 +113,6 @@ 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;
     }
@@ -182,6 +181,10 @@ static void sc_warn_notify_delayed()
 void
 sc_event::notify_delayed()
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        m_async_helper.pending_notify();
+        return;
+    }
     sc_warn_notify_delayed();
     if( m_notify_type != NONE ) {
         SC_REPORT_ERROR( SC_ID_NOTIFY_DELAYED_, 0 );
@@ -194,6 +197,11 @@ sc_event::notify_delayed()
 void
 sc_event::notify_delayed( const sc_time& t )
 {
+    if (m_simc != sc_get_curr_simcontext()) {
+        m_async_helper.pending_notify(t);
+        return;
+    }
+
     sc_warn_notify_delayed();
     if( m_notify_type != NONE ) {
         SC_REPORT_ERROR( SC_ID_NOTIFY_DELAYED_, 0 );
@@ -557,7 +565,7 @@ union sc_event_timed_u
     char              dummy[sizeof( sc_event_timed )];
 };
 
-static
+thread_local static
 sc_event_timed_u* free_list = 0;
 
 void*

src/sysc/kernel/sc_event.h

@@ -282,6 +282,7 @@ class SC_API sc_event
 
         bool valid=false;
         bool cancel=false;
+        bool timed=false;
         sc_time time;
 
         void update(void) {
@@ -294,9 +295,13 @@ class SC_API sc_event
                 } else {
                     valid=false;
                     auto t=time;
+                    auto t_valid=timed;
                     mutex.unlock();
-                    event->cancel();
-                    event->notify(t);
+                    if (t_valid) {
+                        event->notify(t);
+                    } else {
+                        event->notify();
+                    }
                 }
             } else {
                 mutex.unlock();
@@ -305,17 +310,22 @@ class SC_API sc_event
 
         public:
         void pending_notify(sc_time t) {
-            mutex.lock();
+            std::lock_guard<std::mutex> lg(mutex);
             time=t;
+            timed=true;
+            valid=true;
+            async_request_update();
+        }
+        void pending_notify() {
+            std::lock_guard<std::mutex> lg(mutex);
+            timed=false;
             valid=true;
-            mutex.unlock();
             async_request_update();
         }
         void pending_cancel() {
-            mutex.lock();
+            std::lock_guard<std::mutex> lg(mutex);
             valid=true;
             cancel=true;
-            mutex.unlock();
             async_request_update();
         }
 

src/sysc/kernel/sc_name_gen.cpp

@@ -45,6 +45,7 @@ sc_name_gen::sc_name_gen() : m_unique_name_map(), m_unique_name()
 
 sc_name_gen::~sc_name_gen()
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
     sc_strhash<int*>::iterator it( m_unique_name_map );
     for( ; ! it.empty(); it ++ ) {
 	delete it.contents();
@@ -58,6 +59,7 @@ sc_name_gen::~sc_name_gen()
 const char*
 sc_name_gen::gen_unique_name( const char* basename_, bool preserve_first )
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
     if( basename_ == 0 || *basename_ == 0 ) {
         SC_REPORT_ERROR( SC_ID_GEN_UNIQUE_NAME_, 0 );
         basename_ = "unnamed"; // usually not reached

src/sysc/kernel/sc_name_gen.h

@@ -30,6 +30,7 @@
 #ifndef SC_NAME_GEN
 #define SC_NAME_GEN
 
+#include <mutex>
 #include <string>
 #include "sysc/utils/sc_hash.h"
 
@@ -52,7 +53,7 @@ class sc_name_gen
                                  bool preserve_first = false );
 
 private:
-
+    std::mutex       m_mutex;
     sc_strhash<int*> m_unique_name_map;
     std::string      m_unique_name;
 

src/sysc/kernel/sc_object_manager.cpp

@@ -98,7 +98,9 @@ sc_object_manager::~sc_object_manager()
 // | Result is an std::string containing the name.
 // +----------------------------------------------------------------------------
 std::string sc_object_manager::create_name(const char* leaf_name) 
-{ 
+{
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     bool        clash;                  // true if path name exists in obj table
     std::string leafname_string;        // string containing the leaf name.
     std::string parentname_string;      // parent path name 
@@ -337,6 +339,8 @@ sc_object_manager::hierarchy_size()
 bool
 sc_object_manager::insert_external_name(const std::string& name)
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     if(!name_exists(name)) {
         m_instance_table[name].m_element_p = NULL;
         m_instance_table[name].m_name_origin = SC_NAME_EXTERNAL;
@@ -368,6 +372,8 @@ sc_object_manager::insert_external_name(const std::string& name)
 void
 sc_object_manager::insert_event(const std::string& name, sc_event* event_p)
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     m_instance_table[name].m_element_p = static_cast<void*>(event_p);
     m_instance_table[name].m_name_origin = SC_NAME_EVENT;
 }
@@ -385,6 +391,8 @@ sc_object_manager::insert_event(const std::string& name, sc_event* event_p)
 void
 sc_object_manager::insert_object(const std::string& name, sc_object* object_p)
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     m_instance_table[name].m_element_p = static_cast<void*>(object_p);
     m_instance_table[name].m_name_origin = SC_NAME_OBJECT;
 }
@@ -479,6 +487,8 @@ sc_object_manager::top_of_module_name_stack_name() const
 void
 sc_object_manager::remove_event(const std::string& name)
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     instance_table_t::iterator it;     // instance table iterator.
     it = m_instance_table.find(name);
     if(it != m_instance_table.end()
@@ -501,6 +511,8 @@ sc_object_manager::remove_event(const std::string& name)
 void
 sc_object_manager::remove_object(const std::string& name)
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     instance_table_t::iterator it;     // instance table iterator.
     it = m_instance_table.find(name);
     if(it != m_instance_table.end()
@@ -523,6 +535,8 @@ sc_object_manager::remove_object(const std::string& name)
 bool
 sc_object_manager::remove_external_name(const std::string& name)
 {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
     instance_table_t::iterator it;     // instance table iterator.
     it = m_instance_table.find(name);
     if(it != m_instance_table.end()

src/sysc/kernel/sc_object_manager.h

@@ -31,6 +31,7 @@
 #define SC_OBJECT_MANAGER_H
 
 #include <map>
+#include <mutex>
 #include <vector>
 
 namespace sc_core {
@@ -110,6 +111,7 @@ class sc_object_manager
     bool                       m_event_walk_ok;     // true if can walk events.
     instance_table_t           m_instance_table;    // table of instances.
     sc_module_name*            m_module_name_stack; // sc_module_name stack.
+    std::mutex                 m_mutex;             // Mutex to ensure thread safety.
     instance_table_t::iterator m_object_it;         // object instance iterator.
     object_vector_t            m_object_stack;      // sc_object stack.
     bool                       m_object_walk_ok;    // true if can walk objects.

src/sysc/kernel/sc_simcontext.cpp

@@ -372,6 +372,7 @@ sc_simcontext::init()
 void
 sc_simcontext::clean()
 {
+    if (m_parent_context) return;           // assume the parent will delete us
     // remove remaining zombie processes
     do_collect_processes();
 
@@ -385,13 +386,15 @@ sc_simcontext::clean()
     delete m_null_event_p;
     delete m_timed_events;
     delete m_process_table;
-    delete m_name_gen;
     delete m_stage_cb_registry;
     delete m_prim_channel_registry;
     delete m_export_registry;
     delete m_port_registry;
     delete m_module_registry;
-    delete m_object_manager;
+    if (!m_parent_context) {
+        delete m_name_gen;
+        delete m_object_manager;
+    }
 
     m_delta_events.clear();
     m_child_objects.clear();
@@ -1703,7 +1706,7 @@ sc_start( const sc_time& duration, sc_starvation_policy p )
         exit_time = context_p->m_curr_time + duration;
 
     // called with duration = SC_ZERO_TIME for the first time
-    static bool init_delta_or_pending_updates =
+    thread_local static bool init_delta_or_pending_updates =
          ( starting_delta == 0 && exit_time == SC_ZERO_TIME );
 
     // If the simulation status is bad issue the appropriate message:

src/sysc/utils/sc_mempool.cpp

@@ -244,7 +244,7 @@ sc_mempool_int::~sc_mempool_int()
     delete[] allocators;
 }
 
-static sc_mempool_int* the_mempool = 0;
+thread_local static sc_mempool_int* the_mempool = 0;
 
 void*
 sc_mempool_int::do_allocate(std::size_t sz)

src/sysc/utils/sc_ob_event.h

@@ -35,83 +35,63 @@
 #include <string>
 
 namespace sc_core {
-class sc_ob_event : public sc_core::sc_module, public sc_core::sc_event, public sc_core::sc_stage_callback_if
-{
+class sc_ob_event : public sc_core::sc_module,
+                    public sc_core::sc_event,
+                    public sc_core::sc_stage_callback_if {
 
 private:
-    sc_core::sc_event m_update;
-    sc_core::sc_time m_scheduled;
-    sc_core::sc_process_handle m_th;
-
-    void update_m()
-    {
-        auto now = sc_core::sc_time_stamp();
-        if (now >= m_scheduled) {
-            sc_core::sc_event::notify();
-        } else {
-            sc_core::sc_time pending = now;
-            if (sc_core::sc_pending_activity_at_future_time()) {
-                pending = now + sc_core::sc_time_to_pending_activity();
-            }
-            if (pending >= m_scheduled) {
-                sc_core::sc_event::notify(m_scheduled - now);
-            } else {
-                if (pending > now) {
-                    m_update.notify(pending - now);
-                } else {
-                    sc_core::sc_register_stage_callback(*this, sc_core::SC_POST_UPDATE);
-                }
-            }
-        }
-    }
-
-    void future_events_notify_th()
-    {
-        while (true) {
-            m_th.suspend();
-            update_m();
-        }
+  sc_core::sc_time m_scheduled;
+  sc_core::sc_process_handle m_th;
+
+  void future_events_notify_th() {
+    while (true) {
+      m_th.suspend();
+
+      auto now = sc_core::sc_time_stamp();
+      if (now >= m_scheduled) {
+        sc_core::sc_event::notify();
+      } else {
+        sc_core::sc_event::notify(m_scheduled - now);
+      }
     }
+  }
 
 public:
-    sc_ob_event(const sc_core::sc_module_name& n = sc_core::sc_gen_unique_name("sc_ob_event"))
-        : sc_module(n)
-        , sc_core::sc_event((std::string(n) + "_notifier_event").c_str())
-        , m_update((std::string(n) + "_update_event").c_str())
-        , m_scheduled(sc_core::SC_ZERO_TIME)
-    {
-        SC_METHOD(update_m);
-        sensitive << m_update;
-        dont_initialize();
-        SC_THREAD(future_events_notify_th);
-        m_th = sc_core::sc_get_current_process_handle();
-    }
-    void notify()
-    {
-        m_scheduled = sc_core::sc_time_stamp();
-        m_update.notify(sc_core::SC_ZERO_TIME);
-    }
-    void notify(double delay, sc_core::sc_time_unit unit)
-    {
-        m_scheduled = sc_core::sc_time_stamp() + sc_core::sc_time(delay, unit);
-        m_update.notify(sc_core::SC_ZERO_TIME);
-    }
-    void notify(sc_core::sc_time delay)
-    {
-        m_scheduled = sc_core::sc_time_stamp() + delay;
-        m_update.notify(sc_core::SC_ZERO_TIME);
-    }
-
-    void stage_callback(const sc_core::sc_stage& stage)
-    {
-        if (sc_core::sc_pending_activity_at_future_time()) {
-            m_th.resume();
-            sc_core::sc_unregister_stage_callback(*this, sc_core::SC_POST_UPDATE);
-        }
-    }
-
-    ~sc_ob_event() {}
+  sc_ob_event(const sc_core::sc_module_name &n =
+                  sc_core::sc_gen_unique_name("sc_ob_event"))
+      : sc_module(n), m_scheduled(sc_core::SC_ZERO_TIME) {
+    SC_THREAD(future_events_notify_th);
+    m_th = sc_core::sc_get_current_process_handle();
+  }
+  void notify() {
+    sc_core::sc_event::notify();
+    sc_core::sc_unregister_stage_callback(*this, sc_core::SC_POST_UPDATE);
+  }
+  void notify(double delay, sc_core::sc_time_unit unit) {
+    notify(sc_core::sc_time(delay, unit));
+  }
+  void notify(sc_core::sc_time delay) {
+    sc_core::sc_event::cancel();
+    m_scheduled = sc_core::sc_time_stamp() + delay;
+    sc_core::sc_register_stage_callback(*this, sc_core::SC_POST_UPDATE);
+  }
+
+  void stage_callback(const sc_core::sc_stage &stage) {
+//    if (sc_core::sc_pending_activity()) {    // should the event fire is there is pending activity, or if we arrive at the time?
+      sc_core::sc_time pending = sc_core::sc_time_stamp();
+      if (sc_core::sc_pending_activity_at_future_time()) {
+        pending += sc_core::sc_time_to_pending_activity();
+      }
+
+      if (pending >= m_scheduled) {
+        m_th.resume();
+        sc_core::sc_unregister_stage_callback(*this, sc_core::SC_POST_UPDATE);
+      }
+//    }
+  }
+
+  ~sc_ob_event() {}
 };
-} // namespace 
+} // namespace sc_core
 
 #endif // _SC_OB_EVENT_