Sampling period for computing the rolling average real time factor

conanfile.py

@@ -40,7 +40,7 @@ def requirements(self):
         self.tool_requires("cmake/[>=3.19]")
         self.requires("fmilibrary/[~2.3]")
         self.requires("libzip/[>=1.7 <1.10]") # 1.10 deprecates some functions we use
-        self.requires("ms-gsl/[>=3 <5]", transitive_headers=True)
+        self.requires("ms-gsl/[>=3 <5]", transitive_headers=True, transitive_libs=True)
         if self.options.proxyfmu:
             self.requires("proxyfmu/0.3.2@osp/stable")
             self.requires("boost/[~1.81]", transitive_headers=True, transitive_libs=True) # Required by Thrift

include/cosim/timer.hpp

@@ -36,6 +36,15 @@ struct real_time_config
      * This value is used for monitoring purposes only.
      */
     std::atomic<int> steps_to_monitor = 5;
+
+    /**
+     *  A sampling period in second(s) used in the rolling average real time factor calculation.
+     *  This can be useful when simulation step size is small and a fixed value for `steps_to_monitor`
+     *  would not compute an accurate rolling average real time factor.
+     *  When the value is greater than zero, the real time factor is computed periodically using the
+     *  specified time instead of the `steps_to_monitor` value.
+     */
+    std::atomic<double> sampling_period_to_monitor = -1;
 };
 
 } // namespace cosim
@@ -54,6 +63,7 @@ class hash<cosim::real_time_config>
         boost::hash_combine(seed, v.real_time_simulation.load());
         boost::hash_combine(seed, v.real_time_factor_target.load());
         boost::hash_combine(seed, v.steps_to_monitor.load());
+        boost::hash_combine(seed, v.sampling_period_to_monitor.load());
         return seed;
     }
 };

src/cosim/timer.cpp

@@ -7,7 +7,6 @@
 
 #include <chrono>
 #include <thread>
-
 typedef std::chrono::steady_clock Time;
 constexpr std::chrono::microseconds MIN_SLEEP(100);
 
@@ -37,6 +36,12 @@ class real_time_timer::impl
         const auto newHash = std::hash<real_time_config>()(*config_);
         if (newHash != configHashValue_) {
             start(currentTime);
+            auto samping_period = config_->sampling_period_to_monitor.load();
+            if (samping_period > 0) {
+                sampling_period_to_monitor_ = to_duration(samping_period);
+            } else {
+                sampling_period_to_monitor_ = std::nullopt;
+            }
             configHashValue_ = newHash;
         }
         double rtfTarget = config_->real_time_factor_target.load();
@@ -72,21 +77,36 @@ class real_time_timer::impl
     std::shared_ptr<real_time_config> config_;
     size_t configHashValue_;
     std::shared_ptr<real_time_metrics> metrics_;
+    std::optional<duration> sampling_period_to_monitor_ = std::nullopt;
+
+    void update_rolling_average_real_time_factor(
+        Time::time_point& currentTime,
+        time_point& currentSimulationTime,
+        const duration& elapsedRealTime)
+    {
+        const auto elapsedSimTime = currentSimulationTime - rtSimulationStartTime_;
+        metrics_->rolling_average_real_time_factor = elapsedSimTime.count() / (1.0 * elapsedRealTime.count());
+        rtStartTime_ = currentTime;
+        rtSimulationStartTime_ = currentSimulationTime;
+        rtCounter_ = 0L;
+    }
 
     void update_real_time_factor(Time::time_point currentTime, time_point currentSimulationTime)
     {
         const auto relativeSimTime = currentSimulationTime - simulationStartTime_;
         const auto relativeRealTime = currentTime - startTime_;
         metrics_->total_average_real_time_factor = relativeSimTime.count() / (1.0 * relativeRealTime.count());
 
-        if (rtCounter_ >= config_->steps_to_monitor.load()) {
-            const auto elapsedSimTime = currentSimulationTime - rtSimulationStartTime_;
+        if (sampling_period_to_monitor_.has_value()) {
+            const auto elapsedRealTime = currentTime - rtStartTime_;
+
+            if (elapsedRealTime > sampling_period_to_monitor_.value()) {
+                update_rolling_average_real_time_factor(currentTime, currentSimulationTime, elapsedRealTime);
+            }
+        } else if (rtCounter_ >= config_->steps_to_monitor.load()) {
             const auto elapsedRealTime = currentTime - rtStartTime_;
 
-            metrics_->rolling_average_real_time_factor = elapsedSimTime.count() / (1.0 * elapsedRealTime.count());
-            rtStartTime_ = currentTime;
-            rtSimulationStartTime_ = currentSimulationTime;
-            rtCounter_ = 0L;
+            update_rolling_average_real_time_factor(currentTime, currentSimulationTime, elapsedRealTime);
         }
         rtCounter_++;
     }