Performance improvement changes

hhenson · hhenson · commit 706ea1fb67c0 · 2026-01-18T15:36:52.000+04:00
diff --git a/cpp/include/hgraph/types/tsd.h b/cpp/include/hgraph/types/tsd.h
@@ -215,7 +215,9 @@ namespace hgraph
 
         VISITOR_SUPPORT()
 
-        void create(const value::ConstValueView &key);
+        // Creates a new time series for the given key and returns it.
+        // This allows get_or_create to avoid a second lookup after creation.
+        value_type create(const value::ConstValueView &key);
 
         [[nodiscard]] const value::TypeMeta* key_type_meta() const { return _key_type; }
 
@@ -251,6 +253,9 @@ namespace hgraph
         map_type _modified_items;
         removed_items_map_type _removed_items;  // Stores pair<value, was_valid>
         mutable map_type _valid_items_cache;
+        mutable map_type _added_items_cache;  // Instance member instead of static for thread safety
+        mutable engine_time_t _valid_items_cache_time{MIN_DT};  // Track when valid_items cache was built
+        mutable engine_time_t _added_items_cache_time{MIN_DT};  // Track when added_items cache was built
 
         output_builder_s_ptr _ts_builder;
         output_builder_s_ptr _ts_ref_builder;
@@ -351,7 +356,8 @@ namespace hgraph
 
         [[nodiscard]] engine_time_t last_modified_time() const override;
 
-        void create(const value::ConstValueView &key);
+        // Creates a new time series for the given key and returns it.
+        value_type create(const value::ConstValueView &key);
 
         [[nodiscard]] TimeSeriesDictOutputImpl &output_t();
 
@@ -406,6 +412,8 @@ namespace hgraph
         mutable map_type _added_items_cache;
         mutable map_type _removed_items_cache;
         mutable map_type _modified_items_cache;
+        mutable engine_time_t _valid_items_cache_time{MIN_DT};  // Track when valid_items cache was built
+        mutable engine_time_t _added_items_cache_time{MIN_DT};  // Track when added_items cache was built
         static inline map_type empty_{};
 
         input_builder_s_ptr _ts_builder;
diff --git a/cpp/src/cpp/runtime/evaluation_engine.cpp b/cpp/src/cpp/runtime/evaluation_engine.cpp
@@ -279,19 +279,20 @@ namespace hgraph {
 
         // Process all alarms that are due and adjust the next scheduled time
         while (!_alarms.empty()) {
-            const auto &next_alarm = *_alarms.begin();
-            if (now >= next_alarm.first) {
-                auto alarm = *_alarms.begin();
-                _alarms.erase(_alarms.begin());
+            auto it = _alarms.begin();
+            if (now >= it->first) {
+                // Extract the alarm key before erasing to avoid redundant copy
+                auto alarm_key = std::move(*it);
+                _alarms.erase(it);
                 next_scheduled_time = std::max(next_scheduled_time, evaluation_time() + MIN_TD);
 
-                auto cb = _alarm_callbacks.find(alarm);
+                auto cb = _alarm_callbacks.find(alarm_key);
                 if (cb != _alarm_callbacks.end()) {
                     cb->second(next_scheduled_time);
                     _alarm_callbacks.erase(cb);
                 }
-            } else if (next_scheduled_time > next_alarm.first) {
-                next_scheduled_time = next_alarm.first;
+            } else if (next_scheduled_time > it->first) {
+                next_scheduled_time = it->first;
                 break;
             } else {
                 break;
@@ -342,12 +343,13 @@ namespace hgraph {
 
         // Process alarms again after updating evaluation_time
         while (!_alarms.empty()) {
-            const auto &next_alarm = *_alarms.begin();
-            if (now >= next_alarm.first) {
-                auto alarm = *_alarms.begin();
-                _alarms.erase(_alarms.begin());
+            auto it = _alarms.begin();
+            if (now >= it->first) {
+                // Extract the alarm key before erasing to avoid redundant copy
+                auto alarm_key = std::move(*it);
+                _alarms.erase(it);
 
-                auto cb = _alarm_callbacks.find(alarm);
+                auto cb = _alarm_callbacks.find(alarm_key);
                 if (cb != _alarm_callbacks.end()) {
                     cb->second(evaluation_time());
                     _alarm_callbacks.erase(cb);
@@ -447,30 +449,25 @@ namespace hgraph {
     }
 
     void EvaluationEngineImpl::notify_before_evaluation() {
-        // Copy the callback list and clear the original to prevent iterator invalidation
-        auto todo = std::move(_before_evaluation_notification);
-        _before_evaluation_notification.clear();
-
-        for (auto &notification_receiver: todo) {
-            notification_receiver();
-            // If new notifications were added during callback execution, process them recursively
-            if (!_before_evaluation_notification.empty()) {
-                notify_before_evaluation();
+        // Process all notifications iteratively, including any added during callback execution
+        while (!_before_evaluation_notification.empty()) {
+            auto todo = std::move(_before_evaluation_notification);
+            _before_evaluation_notification.clear();
+
+            for (auto &notification_receiver: todo) {
+                notification_receiver();
             }
         }
     }
 
     void EvaluationEngineImpl::notify_after_evaluation() {
-        // Copy the callback list and clear the original, matching Python's behavior.
-        // This prevents iterator invalidation if callbacks add more callbacks.
-        auto todo = std::move(_after_evaluation_notification);
-        _after_evaluation_notification.clear();
-
-        for (auto it = todo.rbegin(); it != todo.rend(); ++it) {
-            (*it)();
-            // If new notifications were added during callback execution, process them recursively
-            if (!_after_evaluation_notification.empty()) {
-                notify_after_evaluation();
+        // Process all notifications iteratively in reverse order, including any added during callback execution
+        while (!_after_evaluation_notification.empty()) {
+            auto todo = std::move(_after_evaluation_notification);
+            _after_evaluation_notification.clear();
+
+            for (auto it = todo.rbegin(); it != todo.rend(); ++it) {
+                (*it)();
             }
         }
     }
diff --git a/cpp/src/cpp/types/tsd.cpp b/cpp/src/cpp/types/tsd.cpp
@@ -435,27 +435,47 @@ namespace hgraph
     }
 
     const TimeSeriesDictOutputImpl::map_type &TimeSeriesDictOutputImpl::valid_items() const {
-        // Rebuild cache each call to ensure freshness
+        // Use cached result if cache was built at or after our last modification time
+        // This avoids expensive iteration and key cloning when nothing changed
+        auto lmt = last_modified_time();
+        if (_valid_items_cache_time >= lmt && !_valid_items_cache.empty()) {
+            return _valid_items_cache;
+        }
+
+        // Rebuild cache
         _valid_items_cache.clear();
         for (const auto &[pv_key, val] : _ts_values) {
             if (val->valid()) {
                 _valid_items_cache.emplace(pv_key.const_view().clone(), val);
             }
         }
+        _valid_items_cache_time = lmt;
         return _valid_items_cache;
     }
 
     const TimeSeriesDictOutputImpl::map_type &TimeSeriesDictOutputImpl::added_items() const {
-        // Return items that were added, fetched from the key_set's added view
-        static map_type added_cache;  // Static to persist across calls
-        added_cache.clear();
+        // Early return if no items were added (avoids iteration entirely)
+        if (key_set().added_view().empty()) {
+            _added_items_cache.clear();
+            return _added_items_cache;
+        }
+
+        // Use cached result if key_set hasn't been modified since cache was built
+        auto ks_lmt = key_set().last_modified_time();
+        if (_added_items_cache_time >= ks_lmt && !_added_items_cache.empty()) {
+            return _added_items_cache;
+        }
+
+        // Rebuild cache - uses instance member instead of static for thread safety
+        _added_items_cache.clear();
         for (auto elem : key_set().added_view()) {
             auto it = _ts_values.find(elem);
             if (it != _ts_values.end()) {
-                added_cache.emplace(elem.clone(), it->second);
+                _added_items_cache.emplace(elem.clone(), it->second);
             }
         }
-        return added_cache;
+        _added_items_cache_time = ks_lmt;
+        return _added_items_cache;
     }
 
     TimeSeriesSetOutput &TimeSeriesDictOutputImpl::key_set() { return *_key_set; }
@@ -535,11 +555,11 @@ namespace hgraph
 
     TimeSeriesDictOutputImpl::value_type TimeSeriesDictOutputImpl::get_or_create(const value::ConstValueView &key) {
         auto it = _ts_values.find(key);
-        if (it == _ts_values.end()) {
-            create(key);
-            it = _ts_values.find(key);
+        if (it != _ts_values.end()) {
+            return it->second;
         }
-        return it->second;
+        // Create returns the new item, avoiding a second hash lookup
+        return create(key);
     }
 
     bool TimeSeriesDictOutputImpl::has_reference() const { return _ts_builder->has_reference(); }
@@ -650,17 +670,37 @@ namespace hgraph
     }
 
     const TimeSeriesDictInputImpl::map_type &TimeSeriesDictInputImpl::valid_items() const {
-        // Rebuild cache each call to ensure freshness
+        // Use cached result if cache was built at or after our last modification time
+        // This avoids expensive iteration and key cloning when nothing changed
+        auto lmt = last_modified_time();
+        if (_valid_items_cache_time >= lmt && !_valid_items_cache.empty()) {
+            return _valid_items_cache;
+        }
+
+        // Rebuild cache
         _valid_items_cache.clear();
         for (const auto &[pv_key, val] : _ts_values) {
             if (val->valid()) {
                 _valid_items_cache.emplace(pv_key.const_view().clone(), val);
             }
         }
+        _valid_items_cache_time = lmt;
         return _valid_items_cache;
     }
 
     const TimeSeriesDictInputImpl::map_type &TimeSeriesDictInputImpl::added_items() const {
+        // Early return if no items were added (avoids collect_added() and iteration)
+        if (!has_added()) {
+            _added_items_cache.clear();
+            return _added_items_cache;
+        }
+
+        // Use cached result if key_set hasn't been modified since cache was built
+        auto ks_lmt = key_set().last_modified_time();
+        if (_added_items_cache_time >= ks_lmt && !_added_items_cache.empty()) {
+            return _added_items_cache;
+        }
+
         // Rebuild cache using key_set's collect_added() which handles _prev_output
         _added_items_cache.clear();
         auto added_keys = key_set().collect_added();
@@ -670,6 +710,7 @@ namespace hgraph
                 _added_items_cache.emplace(elem.clone(), it->second);
             }
         }
+        _added_items_cache_time = ks_lmt;
         return _added_items_cache;
     }
 
@@ -1074,17 +1115,18 @@ namespace hgraph
         BaseTimeSeriesInput::notify_parent(this, modified_time);
     }
 
-    void TimeSeriesDictInputImpl::create(const value::ConstValueView &key_view) {
+    TimeSeriesDictInputImpl::value_type TimeSeriesDictInputImpl::create(const value::ConstValueView &key_view) {
         auto item{_ts_builder->make_instance(this)};
         // For non-peered inputs that are active, make the newly created item active too
         // This ensures proper notification chain for fast non-peer TSD scenarios
         if (!has_peer() and active()) { item->make_active(); }
         // Use emplace with cloned key for move-only PlainValue storage
         _ts_values.emplace(key_view.clone(), item);
         _add_key_value(key_view, item);
+        return item;  // Return the created item
     }
 
-    void TimeSeriesDictOutputImpl::create(const value::ConstValueView &key_view) {
+    TimeSeriesDictOutputImpl::value_type TimeSeriesDictOutputImpl::create(const value::ConstValueView &key_view) {
         // Add key to TSS (already Value-based)
         key_set().add(key_view);
 
@@ -1114,6 +1156,8 @@ namespace hgraph
                 }
             });
         }
+
+        return item;  // Return the created item to avoid second lookup in get_or_create
     }
 
     void TimeSeriesDictOutputImpl::add_key_observer(TSDKeyObserver *observer) {
