Implemented missing fields in the current dataset.

Author: davidv1992

statime-linux/src/main.rs

@@ -294,7 +294,7 @@ async fn actual_main() {
     let (instance_state_sender, instance_state_receiver) =
         tokio::sync::watch::channel(ObservableInstanceState {
             default_ds: instance.default_ds(),
-            current_ds: instance.current_ds(),
+            current_ds: instance.current_ds(None),
             parent_ds: instance.parent_ds(),
             time_properties_ds: instance.time_properties_ds(),
             path_trace_ds: instance.path_trace_ds(),
@@ -502,7 +502,12 @@ async fn run(
         // We don't care if isn't anybody on the other side
         let _ = instance_state_sender.send(ObservableInstanceState {
             default_ds: instance.default_ds(),
-            current_ds: instance.current_ds(),
+            current_ds: instance.current_ds(
+                mut_bmca_ports
+                    .iter()
+                    .filter_map(|v| v.port_current_ds_contribution())
+                    .next(),
+            ),
             parent_ds: instance.parent_ds(),
             time_properties_ds: instance.time_properties_ds(),
             path_trace_ds: instance.path_trace_ds(),

statime-linux/src/metrics/format.rs

@@ -136,7 +136,19 @@ pub fn format_current_ds(
         Some(Unit::Nanoseconds),
         vec![Measurement {
             labels: labels.clone(),
-            value: current_ds.offset_from_master,
+            value: current_ds.offset_from_master.seconds(),
+        }],
+    )?;
+
+    format_metric(
+        w,
+        "mean_delay",
+        "Packet delay between a Master PTP Instance as calculated by the Slave instance",
+        MetricType::Gauge,
+        Some(Unit::Nanoseconds),
+        vec![Measurement {
+            labels: labels.clone(),
+            value: current_ds.mean_delay.seconds(),
         }],
     )?;
 

statime/src/datastructures/datasets/current.rs

@@ -1,7 +1,4 @@
-use crate::time::Duration;
-
 #[derive(Default, Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub(crate) struct InternalCurrentDS {
     pub(crate) steps_removed: u16,
-    pub(crate) offset_from_master: Duration,
 }

statime/src/filters/basic.rs

@@ -32,6 +32,9 @@ pub struct BasicFilter {
     gain: f64,
 
     cur_freq: f64,
+
+    last_offset: Duration,
+    last_delay: Duration,
 }
 
 impl Filter for BasicFilter {
@@ -44,17 +47,21 @@ impl Filter for BasicFilter {
             freq_confidence: 1e-4,
             gain,
             cur_freq: 0.0,
+            last_offset: Duration::ZERO,
+            last_delay: Duration::ZERO,
         }
     }
 
     fn measurement<C: Clock>(&mut self, measurement: Measurement, clock: &mut C) -> FilterUpdate {
         let mut update = FilterUpdate::default();
 
         if let Some(delay) = measurement.delay {
+            self.last_delay = delay;
             update.mean_delay = Some(delay);
         }
 
         if let Some(peer_delay) = measurement.peer_delay {
+            self.last_delay = peer_delay;
             update.mean_delay = Some(peer_delay);
         }
 
@@ -63,6 +70,8 @@ impl Filter for BasicFilter {
             return update;
         };
 
+        self.last_offset = offset;
+
         // Reset on too-large difference
         if offset.abs() > Duration::from_nanos(1_000_000_000) {
             log::debug!("Offset too large, stepping {}", offset);
@@ -154,4 +163,11 @@ impl Filter for BasicFilter {
         // ignore
         Default::default()
     }
+
+    fn current_estimates(&self) -> super::FilterEstimate {
+        super::FilterEstimate {
+            offset_from_master: self.last_offset,
+            mean_delay: self.last_delay,
+        }
+    }
 }

statime/src/filters/kalman.rs

@@ -1,4 +1,7 @@
-use super::matrix::{Matrix, Vector};
+use super::{
+    matrix::{Matrix, Vector},
+    FilterEstimate,
+};
 #[allow(unused_imports)]
 use crate::float_polyfill::FloatPolyfill;
 use crate::{
@@ -622,6 +625,13 @@ impl Filter for KalmanFilter {
         // of correct
         self.change_frequency(0.0, clock);
     }
+
+    fn current_estimates(&self) -> super::FilterEstimate {
+        FilterEstimate {
+            offset_from_master: Duration::from_seconds(self.running_filter.offset()),
+            mean_delay: Duration::from_seconds(self.running_filter.mean_delay()),
+        }
+    }
 }
 
 impl KalmanFilter {

statime/src/filters/mod.rs

@@ -23,6 +23,15 @@ pub struct FilterUpdate {
     pub mean_delay: Option<Duration>,
 }
 
+/// Current estimate of various dataset members as generated by the filter.
+pub struct FilterEstimate {
+    /// Offset from the remote master, see also (IEEE 1588-2019 section 8.2.2.3)
+    pub offset_from_master: Duration,
+    /// Estimate of packet propagation delay, see also (IEEE 1588-2019 section
+    /// 8.2.2.4)
+    pub mean_delay: Duration,
+}
+
 /// A filter for post-processing time measurements.
 ///
 /// Filters are responsible for dealing with the network noise, and should
@@ -51,4 +60,8 @@ pub trait Filter {
     /// Handle ending of time synchronization from the source
     /// associated with this filter.
     fn demobilize<C: Clock>(self, clock: &mut C);
+
+    /// Provide estimates for the Current dataset
+    /// mean delay and
+    fn current_estimates(&self) -> FilterEstimate;
 }

statime/src/observability/current.rs

@@ -1,4 +1,4 @@
-use crate::datastructures::datasets::InternalCurrentDS;
+use crate::{datastructures::datasets::InternalCurrentDS, filters::FilterEstimate, time::Duration};
 
 /// A concrete implementation of the PTP Current dataset (IEEE1588-2019 section
 /// 8.2.2)
@@ -11,14 +11,27 @@ pub struct CurrentDS {
     /// See *IEEE1588-2019 section 8.2.2.2*.
     pub steps_removed: u16,
     /// See *IEEE1588-2019 section 8.2.2.3*.
-    pub offset_from_master: i128,
+    pub offset_from_master: Duration,
+    /// See *IEEE1588-2019 section 8.2.2.3*.
+    pub mean_delay: Duration,
 }
 
-impl From<&InternalCurrentDS> for CurrentDS {
-    fn from(v: &InternalCurrentDS) -> Self {
-        Self {
-            steps_removed: v.steps_removed,
-            offset_from_master: v.offset_from_master.nanos_rounded(),
+impl CurrentDS {
+    pub(crate) fn from_state(
+        current_ds: &InternalCurrentDS,
+        port_contribution: Option<FilterEstimate>,
+    ) -> Self {
+        match port_contribution {
+            Some(port_contribution) => Self {
+                steps_removed: current_ds.steps_removed,
+                offset_from_master: port_contribution.offset_from_master,
+                mean_delay: port_contribution.mean_delay,
+            },
+            None => Self {
+                steps_removed: current_ds.steps_removed,
+                offset_from_master: Duration::ZERO,
+                mean_delay: Duration::ZERO,
+            },
         }
     }
 }

statime/src/port/bmca.rs

@@ -162,7 +162,6 @@ impl<A, C: Clock, F: Filter, R: Rng, S: PtpInstanceStateMutex> Port<'_, InBmca,
                 debug_assert!(!default_ds.slave_only);
 
                 current_ds.steps_removed = 0;
-                current_ds.offset_from_master = Duration::ZERO;
 
                 parent_ds.parent_port_identity.clock_identity = defaultds.clock_identity;
                 parent_ds.parent_port_identity.port_number = 0;

statime/src/port/mod.rs

@@ -29,7 +29,7 @@ use crate::{
         common::PortIdentity,
         messages::{Message, MessageBody},
     },
-    filters::Filter,
+    filters::{Filter, FilterEstimate},
     observability::{self, port::PortDS},
     ptp_instance::{PtpInstanceState, PtpInstanceStateMutex},
     time::{Duration, Time},
@@ -639,6 +639,16 @@ impl<L, A, R, C, F: Filter, S> Port<'_, L, A, R, C, F, S> {
             master_only: self.config.master_only,
         }
     }
+
+    /// If this port is in the slave state, this returns the current estimate
+    /// of the current_ds offset_to_master and mean_delay fields.
+    pub fn port_current_ds_contribution(&self) -> Option<FilterEstimate> {
+        if matches!(self.port_state, PortState::Slave(_)) {
+            Some(self.filter.current_estimates())
+        } else {
+            None
+        }
+    }
 }
 
 impl<'a, A, C, F: Filter, R: Rng, S: PtpInstanceStateMutex> Port<'a, InBmca, A, R, C, F, S> {

statime/src/port/slave.rs

@@ -617,6 +617,10 @@ mod tests {
         fn update<C: Clock>(&mut self, _clock: &mut C) -> FilterUpdate {
             Default::default()
         }
+
+        fn current_estimates(&self) -> crate::filters::FilterEstimate {
+            unimplemented!()
+        }
     }
 
     #[test]