Syntactic cleanups

Signed-off-by: Mark Burton <[email protected]>

Author: markfoodyburton

src/sysc/kernel/sc_event.h

@@ -275,64 +275,44 @@ 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;
-        bool timed=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;
-                    auto t_valid=timed;
-                    mutex.unlock();
-                    if (t_valid) {
-                        event->notify(t);
-                    } else {
-                        event->notify();
-                    }
-                }
+    class pending_helper : public sc_prim_channel {
+      std::mutex mutex;
+      class sc_event *event;
+
+      bool cancel = false;
+      sc_time time;
+
+      void update(void) {
+        std::lock_guard<std::mutex> lg(mutex);
+        if (cancel) {
+          event->cancel();
+        } else {
+            if (time < sc_time_stamp()) {
+                event->notify(SC_ZERO_TIME);
             } else {
-                mutex.unlock();
+                event->notify(time-sc_time_stamp());
             }
         }
-
-        public:
-        void pending_notify(sc_time t) {
-            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;
-            async_request_update();
-        }
-        void pending_cancel() {
-            std::lock_guard<std::mutex> lg(mutex);
-            valid=true;
-            cancel=true;
-            async_request_update();
-        }
-
-        pending_helper(sc_event *e) : sc_prim_channel(true) {
-            event=e;
-        }
-
+      }
+
+    public:
+      void pending_notify(sc_time t) {
+        std::lock_guard<std::mutex> lg(mutex);
+        time = t+sc_time_stamp();
+        async_request_update();
+      }
+      void pending_notify() {
+        std::lock_guard<std::mutex> lg(mutex);
+        time = SC_ZERO_TIME;
+        async_request_update();
+      }
+      void pending_cancel() {
+        std::lock_guard<std::mutex> lg(mutex);
+        cancel = true;
+        async_request_update();
+      }
+
+      pending_helper(sc_event *e) : sc_prim_channel(true) { event = e; }
     };
     friend class pending_helper;
 public:

src/sysc/utils/sc_ob_event.h

@@ -16,7 +16,8 @@
 
 /*****************************************************************************
 
-  sc_ob_event.h -- Event that fires only when there are subsequent events
+ sc_ob_event.h -- Event that fires only when the simulator arrives at the
+ notification time, or there are subsequent events
 
   Original Author: Mark burton
 
@@ -75,19 +76,20 @@ class sc_ob_event : public sc_core::sc_module,
     m_scheduled = sc_core::sc_time_stamp() + delay;
     sc_core::sc_register_stage_callback(*this, sc_core::SC_POST_UPDATE);
   }
-
+  void cancel() {
+    sc_core::sc_event::cancel();
+    sc_core::sc_unregister_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();
-      }
+    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);
-      }
-//    }
+    if (pending >= m_scheduled) {
+      m_th.resume();
+      sc_core::sc_unregister_stage_callback(*this, sc_core::SC_POST_UPDATE);
+    }
   }
 
   ~sc_ob_event() {}

src/sysc/utils/sc_on_context.h

@@ -223,7 +223,7 @@ class sc_on_context : public sc_core::sc_module
                 }
             }
 
-            m_jobs_handler_event.notify(sc_core::SC_ZERO_TIME);
+            m_jobs_handler_event.notify();
 
             if (wait) {
                 /* Wait for job completion */

src/sysc/utils/sc_parallel.h

@@ -38,6 +38,7 @@
 
 namespace sc_core {
 
+template <typename T, class SYNC_POLICY> class sc_parallel;
 /**
  * @brief Simcontext handler, encapsulates a simcontext
  * This is required for the templated class to work, and hence is required in
@@ -46,7 +47,7 @@ namespace sc_core {
  */
 template <class SYNC_POLICY = sc_core::sc_sync_policy_in_sync>
 class _internal_simcontext_handler {
-
+  template <typename T, class S> friend class sc_parallel;
   /**
    * @brief Helper to capture start of simulation and start std::thread
    *
@@ -131,6 +132,7 @@ class _internal_simcontext_handler {
     sc_sync_windowed<SYNC_POLICY> *m_sync_child;
   };
 
+private:
   sc_core::sc_simcontext *m_old_simcontext =
       sc_get_curr_simcontext(); // Side effect create simcontext if we are the
                                 // first module
@@ -139,7 +141,6 @@ class _internal_simcontext_handler {
   control_module m_ctrl_module;
   sc_sync_windowed<SYNC_POLICY> m_sync_parent;
 
-public:
   void use_simcontext() {
     assert(sc_curr_simcontext != &m_simcontext);
     m_old_simcontext = sc_curr_simcontext;
@@ -148,6 +149,7 @@ class _internal_simcontext_handler {
 
   void revert_simcontext() { sc_curr_simcontext = m_old_simcontext; }
 
+public:
   _internal_simcontext_handler()
       : m_ctrl_module("ctrl_module", this), m_sync_parent("sync_parent") {
     SYNC_POLICY sync_policy;

src/sysc/utils/sc_sync_window.h

@@ -79,14 +79,14 @@ class sc_sync_windowed : public sc_core::sc_module,
   struct window {
     sc_core::sc_time from;
     sc_core::sc_time to;
-    bool operator==(window other) {
+    bool operator==(const window &other) const {
       return other.to == to && other.from == from;
     }
   };
 
-  const struct window zero_window = {sc_core::SC_ZERO_TIME,
+  static inline const struct window zero_window = {sc_core::SC_ZERO_TIME,
                                      sc_core::SC_ZERO_TIME};
-  const struct window open_window = {sc_core::SC_ZERO_TIME,
+  static inline const struct window open_window = {sc_core::SC_ZERO_TIME,
                                      sc_core::sc_max_time()};
 
 private:
@@ -98,7 +98,6 @@ class sc_sync_windowed : public sc_core::sc_module,
 
   void do_other_async_set_window_fn(window w) {
     if (m_other_async_set_window_fn) {
-      auto now = sc_core::sc_time_stamp();
       m_other_async_set_window_fn(w);
     }
   }
@@ -109,6 +108,8 @@ class sc_sync_windowed : public sc_core::sc_module,
     auto now = sc_core::sc_time_stamp();
     auto to = m_window.to;
 
+    /* The step helper has to handle both suspend and resume (because of
+     * SystemC) */
     if (now >= to) {
       sc_core::sc_unsuspend_all(); // such that pending activity is valid if
                                    // it's needed below.
@@ -122,17 +123,12 @@ class sc_sync_windowed : public sc_core::sc_module,
       sc_core::sc_suspend_all();
 
     } else {
+      /* the only way to get here is if we have a 'new' window from the other
+       * side. we are here just to unsuspend */
       sc_core::sc_unsuspend_all();
       if (!policy.keep_alive())
         async_detach_suspending();
-
-      // We are about to advance to the next event, so may as well set that as
-      // the window now
-      do_other_async_set_window_fn(
-          {now + (sc_core::sc_pending_activity()
-                      ? sc_core::sc_time_to_pending_activity()
-                      : sc_core::SC_ZERO_TIME),
-           now + policy.quantum()});
+    //do_other_async_set_window_fn({now, now + policy.quantum()});
 
       /* Re-notify event - maybe presumably moved */
       m_step_ev.notify(to - now);
@@ -162,6 +158,9 @@ class sc_sync_windowed : public sc_core::sc_module,
     }
     /* let stepper handle suspend/resume, must time notify */
     m_update_ev.notify(sc_core::SC_ZERO_TIME);
+//    std::ostringstream s;
+//    s << "Got Window: " << m_window.from << " - " << m_window.to;
+//    SC_REPORT_INFO(sc_core::sc_module::name(), s.str().c_str());
   }
 
 public:
@@ -171,7 +170,7 @@ class sc_sync_windowed : public sc_core::sc_module,
    * Input: window  - Window to set for sync. Sweep till the 'from' and step to
    * the 'to'.
    */
-  void async_set_window(window w) {
+  void async_set_window(const window &w) {
     /* Only accept updated windows so we dont re-send redundant updates
      * safe at this point to compair against m_window as we took the lock
      */
@@ -192,9 +191,7 @@ class sc_sync_windowed : public sc_core::sc_module,
           "m_other_async_set_window_fn was already registered or other "
           "sc_sync_windowed was already bound!");
     }
-    m_other_async_set_window_fn = [other](const window &w) {
-      other->async_set_window(w);
-    };
+    m_other_async_set_window_fn = std::bind(&sc_sync_windowed::async_set_window, other, std::placeholders::_1);
   }
   void register_sync_cb(std::function<void(const window &)> fn) {
     if (m_other_async_set_window_fn) {
@@ -216,7 +213,7 @@ class sc_sync_windowed : public sc_core::sc_module,
     dont_initialize();
     sensitive << m_step_ev << m_update_ev;
 
-    m_step_ev.notify(sc_core::SC_ZERO_TIME);
+    m_step_ev.notify(policy.quantum());
 
     this->sc_core::sc_prim_channel::async_attach_suspending();
   }

src/tlm_utils/simple_target_socket.h

@@ -313,8 +313,11 @@ class simple_target_socket_b
         // forward call
         sc_assert(m_mod);
         if (!m_on_ctx.is_on_sysc()) {
+          sc_time our_time=sc_core::sc_time_stamp();
+          sc_time their_time;
           m_on_ctx.run(
-              [this, &trans, &t]() { (m_mod->*m_b_transport_ptr)(trans, t); });
+              [this, &trans, &t, &our_time, &their_time]() { if (our_time>sc_time_stamp()) wait(our_time-sc_time_stamp()); (m_mod->*m_b_transport_ptr)(trans, t); their_time=sc_time_stamp(); });
+          if (their_time>sc_time_stamp()) wait(their_time-sc_time_stamp());
         } else {
           (m_mod->*m_b_transport_ptr)(trans, t);
         }