hmon: rework heartbeat monitor state

Rework heartbeat monitor state into two atomics.

Author: arkjedrz

src/health_monitoring_lib/rust/common.rs

@@ -92,30 +92,38 @@ impl MonitorEvaluator for MonitorEvalHandle {
     }
 }
 
-/// Get offset between HMON and monitor starting time points as [`u32`].
-pub(crate) fn hmon_time_offset(hmon_starting_point: Instant, monitor_starting_point: Instant) -> u32 {
+/// Get offset between HMON and monitor starting time points as integers.
+pub(crate) fn hmon_time_offset<T>(hmon_starting_point: Instant, monitor_starting_point: Instant) -> T
+where
+    T: TryFrom<u128>,
+    <T as TryFrom<u128>>::Error: core::fmt::Debug,
+{
     let result = hmon_starting_point.checked_duration_since(monitor_starting_point);
     let duration_since = result.expect("HMON starting point is earlier than monitor starting point");
-    duration_to_u32(duration_since)
+    duration_to_int(duration_since)
 }
 
-/// Get duration as [`u32`].
-pub(crate) fn duration_to_u32(duration: Duration) -> u32 {
+/// Get duration as an integer.
+pub(crate) fn duration_to_int<T>(duration: Duration) -> T
+where
+    T: TryFrom<u128>,
+    <T as TryFrom<u128>>::Error: core::fmt::Debug,
+{
     let millis = duration.as_millis();
-    u32::try_from(millis).expect("Monitor running for too long")
+    T::try_from(millis).expect("Monitor running for too long")
 }
 
 #[cfg(all(test, not(loom)))]
 mod tests {
-    use crate::common::{duration_to_u32, hmon_time_offset};
+    use crate::common::{duration_to_int, hmon_time_offset};
     use core::time::Duration;
     use std::time::Instant;
 
     #[test]
     fn hmon_time_offset_valid() {
         let monitor_starting_point = Instant::now();
         let hmon_starting_point = Instant::now();
-        let offset = hmon_time_offset(hmon_starting_point, monitor_starting_point);
+        let offset: u32 = hmon_time_offset(hmon_starting_point, monitor_starting_point);
         // Allow small offset.
         assert!(offset < 10);
     }
@@ -125,7 +133,7 @@ mod tests {
     fn hmon_time_offset_wrong_order() {
         let hmon_starting_point = Instant::now();
         let monitor_starting_point = Instant::now();
-        let _offset = hmon_time_offset(hmon_starting_point, monitor_starting_point);
+        let _offset: u32 = hmon_time_offset(hmon_starting_point, monitor_starting_point);
     }
 
     #[test]
@@ -136,19 +144,19 @@ mod tests {
         let hmon_starting_point = Instant::now()
             .checked_add(Duration::from_secs(HUNDRED_DAYS_AS_SECS))
             .unwrap();
-        let _offset = hmon_time_offset(hmon_starting_point, monitor_starting_point);
+        let _offset: u32 = hmon_time_offset(hmon_starting_point, monitor_starting_point);
     }
 
     #[test]
-    fn duration_to_u32_valid() {
-        let result = duration_to_u32(Duration::from_millis(1234));
+    fn duration_to_int_valid() {
+        let result: u32 = duration_to_int(Duration::from_millis(1234));
         assert_eq!(result, 1234);
     }
 
     #[test]
     #[should_panic(expected = "Monitor running for too long")]
-    fn duration_to_u32_too_large() {
+    fn duration_to_int_too_large() {
         const HUNDRED_DAYS_AS_SECS: u64 = 100 * 24 * 60 * 60;
-        let _result = duration_to_u32(Duration::from_secs(HUNDRED_DAYS_AS_SECS));
+        let _result: u32 = duration_to_int(Duration::from_secs(HUNDRED_DAYS_AS_SECS));
     }
 }

src/health_monitoring_lib/rust/deadline/deadline_monitor.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 // *******************************************************************************
-use crate::common::{duration_to_u32, Monitor, MonitorEvalHandle, MonitorEvaluationError, MonitorEvaluator, TimeRange};
+use crate::common::{duration_to_int, Monitor, MonitorEvalHandle, MonitorEvaluationError, MonitorEvaluator, TimeRange};
 use crate::deadline::common::{DeadlineTemplate, StateIndex};
 use crate::deadline::deadline_state::{DeadlineState, DeadlineStateSnapshot};
 use crate::log::{error, warn, ScoreDebug};
@@ -152,7 +152,7 @@ impl Deadline {
     /// Caller must ensure that deadline is not used until it's stopped.
     /// After this call You shall assure there's only a single owner of the `Deadline` instance and it does not call start before stopping.
     pub(super) unsafe fn start_internal(&mut self) -> Result<(), DeadlineError> {
-        let now = duration_to_u32(self.monitor.monitor_starting_point.elapsed());
+        let now = duration_to_int::<u32>(self.monitor.monitor_starting_point.elapsed());
         let max_time = now + self.range.max.as_millis() as u32;
 
         let mut is_broken = false;
@@ -177,7 +177,7 @@ impl Deadline {
     }
 
     pub(super) fn stop_internal(&mut self) {
-        let now = duration_to_u32(self.monitor.monitor_starting_point.elapsed());
+        let now = duration_to_int::<u32>(self.monitor.monitor_starting_point.elapsed());
         let max = self.range.max.as_millis() as u32;
         let min = self.range.min.as_millis() as u32;
 
@@ -274,7 +274,7 @@ impl MonitorEvaluator for DeadlineMonitorInner {
                     "Deadline snapshot cannot be both running and stopped"
                 );
 
-                let now = duration_to_u32(self.monitor_starting_point.elapsed());
+                let now = duration_to_int::<u32>(self.monitor_starting_point.elapsed());
                 let expected = snapshot.timestamp_ms();
                 if now > expected {
                     // Deadline missed, report