Timed event optimization

src/sysc/kernel/sc_event.cpp

@@ -58,6 +58,28 @@ sc_event::basename() const
     return p ? (p + 1) : m_name.c_str();
 }
 
+void
+sc_event::cancel_timed() {
+    auto head = m_timed->m_event;
+    if( head == this) {
+        m_timed->m_event = head->m_event_with_the_same_stamp;
+        if (m_timed->m_event == nullptr) {
+            m_timed->m_event_tail = 0;
+        }
+    } else {
+        while( head != nullptr) {
+            if( head->m_event_with_the_same_stamp == this) {
+                m_timed->m_event_tail = head;
+                head->m_event_with_the_same_stamp = this->m_event_with_the_same_stamp;
+                break;
+            }
+            head = head->m_event_with_the_same_stamp;
+        }
+    }
+    this->m_event_with_the_same_stamp = {};
+    m_timed = 0;
+}
+
 void
 sc_event::cancel()
 {
@@ -72,8 +94,7 @@ sc_event::cancel()
     case TIMED: {
         // remove this event from the timed events set
         sc_assert( m_timed != 0 );
-        m_timed->m_event = 0;
-        m_timed = 0;
+        this->cancel_timed();
         m_notify_type = NONE;
         break;
     }
@@ -120,8 +141,7 @@ sc_event::notify( const sc_time& t )
         if( m_notify_type == TIMED ) {
             // remove this event from the timed events set
             sc_assert( m_timed != 0 );
-            m_timed->m_event = 0;
-            m_timed = 0;
+            this->cancel_timed();
         }
         // add this event to the delta events set
         m_delta_event_index = m_simc->add_delta_event( this );
@@ -144,14 +164,10 @@ sc_event::notify( const sc_time& t )
             return;
         }
         // remove this event from the timed events set
-        m_timed->m_event = 0;
-        m_timed = 0;
+        this->cancel_timed();
     }
     // add this event to the timed events set
-    sc_event_timed* et = new sc_event_timed( this, m_simc->time_stamp() + t );
-    m_simc->add_timed_event( et );
-    m_timed = et;
-    m_notify_type = TIMED;
+    m_simc->add_timed_event(this, m_simc->time_stamp() + t);
 }
 
 static void sc_warn_notify_delayed()
@@ -190,11 +206,7 @@ sc_event::notify_delayed( const sc_time& t )
         m_notify_type = DELTA;
     } else {
         // add this event to the timed events set
-        sc_event_timed* et = new sc_event_timed( this,
-                                                 m_simc->time_stamp() + t );
-        m_simc->add_timed_event( et );
-        m_timed = et;
-        m_notify_type = TIMED;
+        m_simc->add_timed_event(this, m_simc->time_stamp() + t);
     }
 }
 

src/sysc/kernel/sc_event.h

@@ -280,7 +280,7 @@ class SC_API sc_event
     ~sc_event();
 
     void cancel();
-
+    void cancel_timed();
     const char* basename() const;
     const char* name() const
       { return m_name.c_str(); }
@@ -328,6 +328,9 @@ class SC_API sc_event
 
     void trigger();
 
+public:
+    sc_event*       m_event_with_the_same_stamp{};
+
 private:
 
     enum notify_t { NONE, DELTA, TIMED };
@@ -375,8 +378,18 @@ class SC_API sc_event_timed
         : m_event( e ), m_notify_time( t )
         {}
 
-    ~sc_event_timed()
-        { if( m_event != 0 ) { m_event->m_timed = 0; } }
+    ~sc_event_timed() {
+        auto event = m_event;
+        sc_event* tmp{};
+        while( event != nullptr ) {
+            event->m_timed = 0;
+            tmp = event;
+            event = event->m_event_with_the_same_stamp;
+            tmp->m_event_with_the_same_stamp = {};
+        }
+
+        m_event = {};
+    }
 
     sc_event* event() const
         { return m_event; }
@@ -400,6 +413,7 @@ class SC_API sc_event_timed
 
     sc_event* m_event;
     sc_time   m_notify_time;
+    sc_event* m_event_tail;
 
 private:
 
@@ -429,11 +443,7 @@ sc_event::notify_internal( const sc_time& t )
         m_delta_event_index = m_simc->add_delta_event( this );
         m_notify_type = DELTA;
     } else {
-        sc_event_timed* et =
-		new sc_event_timed( this, m_simc->time_stamp() + t );
-        m_simc->add_timed_event( et );
-        m_timed = et;
-        m_notify_type = TIMED;
+        m_simc->add_timed_event(this, m_simc->time_stamp() + t);
     }
 }
 

src/sysc/kernel/sc_simcontext.cpp

@@ -210,6 +210,40 @@ sc_notify_time_compare( const void* p1, const void* p2 )
     }
 }
 
+void
+sc_simcontext::add_timed_event( sc_event* e, const sc_time& t)
+{
+    if( SC_LIKELY_((m_timed_events->size() > 0) && (t >= m_timed_events->top()->notify_time()) && (t <= this->m_max_event_time))) {
+        for(int i = 1; i <= m_timed_events->size(); ++i) {
+            auto pq_item = this->m_timed_events->operator[](i);
+            if(( t == pq_item->notify_time())) {
+                //e->m_event_with_the_same_stamp = pq_item->m_event;
+                if (pq_item->m_event_tail == nullptr) {
+                    pq_item->m_event = e;
+                    pq_item->m_event_tail = e;
+                }
+                else {
+                    pq_item->m_event_tail->m_event_with_the_same_stamp = e;
+                    pq_item->m_event_tail = e;
+                }
+                // pq_item->m_event = e;
+                e->m_timed = pq_item;
+                e->m_notify_type = sc_event::TIMED;
+                return;
+            }
+        }
+    }
+
+    sc_event_timed* et = new sc_event_timed(e, t);
+    this->m_timed_events->insert(et);
+    et->m_event_tail = e;
+    e->m_timed = et;
+    e->m_event_with_the_same_stamp = {};
+    e->m_notify_type = sc_event::TIMED;
+
+    if( t > this->m_max_event_time ) { this->m_max_event_time = t; }
+
+}
 
 // +============================================================================
 // | CLASS sc_invoke_method - class to invoke sc_method's to support
@@ -950,11 +984,12 @@ sc_simcontext::simulate( const sc_time& duration )
 
 	    do {
 		sc_event_timed* et = m_timed_events->extract_top();
-		sc_event* e = et->event();
-		delete et;
-		if( e != 0 ) {
-		    e->trigger();
-		}
+		auto tmp_event = et->event();
+        while( tmp_event != nullptr) {
+            tmp_event->trigger();
+            tmp_event = tmp_event->m_event_with_the_same_stamp;
+        }
+        delete et;
 	    } while( m_timed_events->size() &&
 		     m_timed_events->top()->notify_time() == t );
 

src/sysc/kernel/sc_simcontext.h

@@ -343,7 +343,7 @@ class SC_API sc_simcontext
 
     int add_delta_event( sc_event* );
     void remove_delta_event( sc_event* );
-    void add_timed_event( sc_event_timed* );
+    void add_timed_event( sc_event*, const sc_time& );
 
     void trace_cycle( bool delta_cycle );
 
@@ -421,6 +421,7 @@ class SC_API sc_simcontext
 
     sc_time_params*             m_time_params;
     sc_time                     m_curr_time;
+    sc_time                     m_max_event_time{};
 
     sc_invoke_method*           m_method_invoker_p;
     sc_dt::uint64               m_change_stamp; // "time" change occurred.
@@ -676,12 +677,6 @@ sc_simcontext::add_delta_event( sc_event* e )
     return static_cast<int>( m_delta_events.size() - 1 );
 }
 
-inline
-void
-sc_simcontext::add_timed_event( sc_event_timed* et )
-{
-    m_timed_events->insert( et );
-}
 
 // ----------------------------------------------------------------------------
 

src/sysc/utils/sc_pq.cpp

@@ -75,7 +75,7 @@ sc_ppq_base::insert( void* elem )
     int i = m_heap_size;
 
     // resize the heap in case there's not enough memory
-    if( m_heap_size > m_size_alloc ) {
+    if( SC_UNLIKELY_( m_heap_size > m_size_alloc )) {
         m_size_alloc += m_size_alloc / 2;
         void** new_heap = new void*[m_size_alloc + 1];
         for( int j = 1; j < m_heap_size; ++ j ) {

src/sysc/utils/sc_pq.h

@@ -64,6 +64,10 @@ class SC_API sc_ppq_base
     bool empty() const
 	{ return (m_heap_size == 0); }
 
+    void* operator [](int index) {
+        return m_heap[index];
+    }
+
 protected:
 
     int parent( int i ) const
@@ -119,6 +123,9 @@ class sc_ppq
     T extract_top()
 	{ return (T) sc_ppq_base::extract_top(); }
 
+    T operator [](int index)
+    { return (T) sc_ppq_base::operator[](index); }
+
     // insert a new element to the priority queue.
 
     void insert( T elem )