Add NearEWventsStorage

Author: PaulRalnikov

source/scheduler/event/event.cpp

@@ -0,0 +1,7 @@
+#include "event.hpp"
+
+namespace sim {
+bool Event::operator>(const Event &other) const {
+    return m_time > other.m_time;
+}
+}  // namespace sim

source/scheduler/near_events_storage.cpp

@@ -0,0 +1,85 @@
+#include "near_events_storage.hpp"
+
+namespace sim {
+
+void NearEventsStorage::add(std::unique_ptr<Event> event, TimeNs current_time) {
+    std::uint32_t relative_event_time =
+        (event->get_time() - current_time).value_nanoseconds();
+
+    auto add_to_storage =
+        [](std::deque<std::queue<std::unique_ptr<Event> > >& storage,
+           std::size_t index, std::unique_ptr<Event> event) {
+            if (index >= storage.size()) {
+                storage.resize(index + 1);
+            }
+            storage[index].emplace(std::move(event));
+        };
+
+    std::uint32_t first_storage_bucket_index =
+        m_current_bucket + relative_event_time;
+    if (first_storage_bucket_index < m_max_buckets_count) {
+        // its enough place to put event to first bucket; use it
+        add_to_storage(m_first_event_buckets_storage,
+                       first_storage_bucket_index, std::move(event));
+        m_first_bucket_empty = false;
+    } else {
+        // event could not be stores in first bucket; put it to second one
+        add_to_storage(m_second_event_buckets_storage,
+                       first_storage_bucket_index - m_max_buckets_count,
+                       std::move(event));
+        m_second_bucket_empty = false;
+    }
+}
+
+std::unique_ptr<Event> NearEventsStorage::pop_first() {
+    correctify_state();
+    // state is correct
+    if (empty()) {
+        throw std::runtime_error("call from on empty storage");
+    }
+    std::unique_ptr<Event> event =
+        std::move(m_first_event_buckets_storage[m_current_bucket].front());
+    // be careful: after next line state should be correctified (current bucket
+    // might become empty or all m_first_storage)
+    m_first_event_buckets_storage[m_current_bucket].pop();
+    return event;
+}
+
+bool NearEventsStorage::empty() {
+    correctify_state();
+    return m_first_bucket_empty;
+}
+
+void NearEventsStorage::correctify_state() {
+    if (!m_first_bucket_empty) {
+        while (m_current_bucket < m_first_event_buckets_storage.size() &&
+               m_first_event_buckets_storage[m_current_bucket].empty()) {
+            m_current_bucket++;
+        }
+        if (m_current_bucket != m_first_event_buckets_storage.size()) {
+            // m_first_event_buckets_storage[m_current_bucket] is not empty ->
+            // state is correct
+            return;
+        }
+    }
+
+    // all events in first storages are done => first bucket is <<empty>>
+    m_first_bucket_empty = true;
+    m_current_bucket = 0;
+
+    if (m_second_bucket_empty) {
+        // second bucket is empty => all buckets are empty
+        return;
+    }
+
+    while (m_current_bucket < m_first_event_buckets_storage.size() &&
+           m_second_event_buckets_storage[m_current_bucket].empty()) {
+        m_current_bucket++;
+    }
+
+    // swap storages
+    m_first_event_buckets_storage.swap(m_second_event_buckets_storage);
+    std::swap(m_first_bucket_empty, m_second_bucket_empty);
+}
+
+}  // namespace sim

source/scheduler/near_events_storage.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include <deque>
+#include <queue>
+
+#include "event/event.hpp"
+#include "types.hpp"
+
+namespace sim {
+
+class NearEventsStorage {
+public:
+    explicit NearEventsStorage(std::size_t a_max_buckets_count)
+        : m_current_bucket(0), m_max_buckets_count(a_max_buckets_count) {
+        m_first_event_buckets_storage.emplace_back(
+            std::queue<std::unique_ptr<Event> >());
+        m_second_event_buckets_storage.emplace_back(
+            std::queue<std::unique_ptr<Event> >());
+    }
+
+    void add(std::unique_ptr<Event> event, TimeNs current_time);
+    std::unique_ptr<Event> pop_first();
+    bool empty();
+
+private:
+    // forwards m_current_bucket while it points to empty bucket
+    void correctify_state();
+
+    std::deque<std::queue<std::unique_ptr<Event> > >
+        m_first_event_buckets_storage;
+    std::deque<std::queue<std::unique_ptr<Event> > >
+        m_second_event_buckets_storage;
+
+    std::size_t m_current_bucket;
+    std::size_t m_max_buckets_count;
+
+    bool m_first_bucket_empty = true;
+    bool m_second_bucket_empty = true;
+};
+
+}  // namespace sim

source/scheduler/scheduler.cpp

@@ -18,34 +18,27 @@ bool Scheduler::tick() {
         event->operator()();
     };
 
-    while (!m_near_events.empty() && m_near_events.front().empty()) {
-        m_near_events.pop_front();
-    }
-    // now m_near_events is empty or its first storage is not empty
-
     if (!m_near_events.empty()) {
-        // run first near event
-        std::unique_ptr<Event> event = std::move(m_near_events[0].front());
-        m_near_events[0].pop();
-        run_event(std::move(event));
+        run_event(m_near_events.pop_first());
         return true;
     }
+    // no near events
 
-    if (!m_far_events.empty()) {
-        // no near events, but have some far ones => run first from far ones
-        run_event(take_top_far_event());
-        return true;
+    if (m_far_events.empty()) {
+        return false;
     }
 
+    // no near events, but have some far ones => run first from far ones
+    run_event(take_top_far_event());
+    return true;
+
     // no near nor fat events => nothing to do
     return false;
 }
 
 void Scheduler::clear() {
-    std::priority_queue<std::unique_ptr<Event>,
-                        std::vector<std::unique_ptr<Event>>, EventComparator>()
-        .swap(m_far_events);
-    std::deque<std::queue<std::unique_ptr<Event>>>().swap(m_near_events);
+    m_near_events =
+        NearEventsStorage(M_MAX_COUNTSORT_CAPACITY.value_nanoseconds());
     m_current_event_local_time = TimeNs(0);
 }
 

source/scheduler/scheduler.hpp

@@ -5,6 +5,7 @@
 #include <queue>
 
 #include "event/event.hpp"
+#include "near_events_storage.hpp"
 #include "types.hpp"
 
 namespace sim {
@@ -41,7 +42,7 @@ class Scheduler {
         }
 
         if (is_near_event(event)) {
-            add_near_event(std::move(event));
+            m_near_events.add(std::move(event), m_current_event_local_time);
         } else {
             m_far_events.emplace(std::move(event));
         }
@@ -52,10 +53,13 @@ class Scheduler {
     TimeNs get_current_time();
 
 private:
-    static constexpr inline TimeNs M_MAX_COUNTSORT_CAPACITY = TimeNs(100'000);
+    static constexpr inline TimeNs M_MAX_COUNTSORT_CAPACITY = TimeNs(50'000);
 
     // Private constructor to prevent instantiation
-    Scheduler() : m_current_event_local_time(TimeNs(0)) {}
+    Scheduler()
+        : m_near_events(M_MAX_COUNTSORT_CAPACITY.value_nanoseconds()),
+          m_current_event_local_time(TimeNs(0)) {}
+
     // No copy constructor and assignment operators
     Scheduler(const Scheduler&) = delete;
     Scheduler& operator=(const Scheduler&) = delete;
@@ -66,18 +70,6 @@ class Scheduler {
                m_current_event_local_time + M_MAX_COUNTSORT_CAPACITY;
     }
 
-    inline void add_near_event(std::unique_ptr<Event> event) {
-        std::uint32_t relative_event_time =
-            (event->get_time() - m_current_event_local_time)
-                .value_nanoseconds();
-
-        if (m_near_events.size() <= relative_event_time) {
-            m_near_events.resize(relative_event_time + 1);
-        }
-
-        m_near_events[relative_event_time].emplace(std::move(event));
-    }
-
     inline std::unique_ptr<Event> take_top_far_event() {
         std::unique_ptr<Event> event =
             std::move(const_cast<std::unique_ptr<Event>&>(m_far_events.top()));
@@ -90,14 +82,15 @@ class Scheduler {
             const std::unique_ptr<Event>& event = m_far_events.top();
 
             if (is_near_event(event)) {
-                add_near_event(take_top_far_event());
+                m_near_events.add(take_top_far_event(),
+                                  m_current_event_local_time);
             } else {
                 break;
             }
         }
     }
 
-    std::deque<std::queue<std::unique_ptr<Event>>> m_near_events;
+    NearEventsStorage m_near_events;
 
     std::priority_queue<std::unique_ptr<Event>,
                         std::vector<std::unique_ptr<Event>>, EventComparator>