Using duration_cast

Author: davidhjp01

include/cosim/timer.hpp

@@ -44,7 +44,7 @@ struct real_time_config
      *  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<int> sampling_period_to_monitor = -1;
+    std::atomic<std::chrono::milliseconds> sampling_period_to_monitor = std::chrono::milliseconds(-1);
 };
 
 } // namespace cosim
@@ -63,7 +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());
+        boost::hash_combine(seed, v.sampling_period_to_monitor.load().count());
         return seed;
     }
 };

src/cosim/timer.cpp

@@ -37,8 +37,8 @@ class real_time_timer::impl
         if (newHash != configHashValue_) {
             start(currentTime);
             const auto sampling_period = config_->sampling_period_to_monitor.load();
-            if (sampling_period > 0) {
-                sampling_period_to_monitor_ = std::chrono::milliseconds(sampling_period);
+            if (sampling_period.count() > 0) {
+                sampling_period_to_monitor_ = sampling_period;
             } else {
                 sampling_period_to_monitor_ = std::nullopt;
             }
@@ -78,46 +78,37 @@ class real_time_timer::impl
     size_t configHashValue_;
     std::shared_ptr<real_time_metrics> metrics_;
     std::optional<std::chrono::milliseconds> sampling_period_to_monitor_ = std::nullopt;
-    const volatile bool tick_period_match_ = std::is_same<cosim::time_point::period, Time::time_point::period>::value;
 
+    template<typename Rep, typename Period>
     void update_rolling_average_real_time_factor(
-        Time::time_point& currentTime,
-        time_point& currentSimulationTime,
-        const cosim::duration& elapsedRealTime)
+        const Time::time_point& currentTime,
+        const time_point& currentSimulationTime,
+        const std::chrono::duration<Rep, Period>& elapsedRealTime)
     {
         const auto elapsedSimTime = currentSimulationTime - rtSimulationStartTime_;
-        if (tick_period_match_) {
-            metrics_->rolling_average_real_time_factor = elapsedSimTime.count() / (1.0 * elapsedRealTime.count());
-        } else {
-            metrics_->rolling_average_real_time_factor =
-                std::chrono::duration_cast<cosim::duration>(elapsedSimTime).count() / (1.0 * std::chrono::duration_cast<cosim::duration>(elapsedRealTime).count());
-        }
+
+        metrics_->rolling_average_real_time_factor =
+            std::chrono::duration_cast<cosim::duration>(elapsedSimTime).count() / (1.0 * std::chrono::duration_cast<cosim::duration>(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_;
-
-        if (tick_period_match_) {
-            metrics_->total_average_real_time_factor = relativeSimTime.count() / (1.0 * relativeRealTime.count());
-        } else {
-            metrics_->total_average_real_time_factor =
-                std::chrono::duration_cast<cosim::duration>(relativeSimTime).count() / (1.0 * std::chrono::duration_cast<cosim::duration>(relativeRealTime).count());
-        }
+        const auto relativeSimTime =  std::chrono::duration_cast<cosim::duration>(currentSimulationTime - simulationStartTime_);
+        const auto relativeRealTime =  std::chrono::duration_cast<cosim::duration>(currentTime - startTime_);
+        metrics_->total_average_real_time_factor = relativeSimTime.count() / (1.0 * relativeRealTime.count());
 
         if (sampling_period_to_monitor_.has_value()) {
             const auto elapsedRealTime = currentTime - rtStartTime_;
 
             if (elapsedRealTime > sampling_period_to_monitor_.value()) {
+                const auto elapsedSimTime = currentSimulationTime - rtSimulationStartTime_;
                 update_rolling_average_real_time_factor(currentTime, currentSimulationTime, elapsedRealTime);
             }
         } else if (rtCounter_ >= config_->steps_to_monitor.load()) {
             const auto elapsedRealTime = currentTime - rtStartTime_;
-
             update_rolling_average_real_time_factor(currentTime, currentSimulationTime, elapsedRealTime);
         }
         rtCounter_++;