Method feed

clock-bound/src/daemon/clock_sync_algorithm/ff/phc.rs:82–187

Feed an event into this algorithm Returns [`Some`] if the event has improved this source's [`ClockParameters`].

(&mut self, event: event::Phc)

    ///
    /// Returns [`Some`] if the event has improved this source's [`ClockParameters`].
    pub fn feed(&mut self, event: event::Phc) -> Option<&ClockParameters> {
        // FIXME: take a MONOTONIC_COARSE timestamp *before* computing the clock error bound.
        //
        // The only use of this timestamp is to support and maintain the behavior for clients built
        // against ClockBound 2.0. These clients grow the CEB by calculating the time elapsed
        // between the instant the ClockParameters were computed, and the instant they read the
        // system clock. This needs to be a bit pessimistic, hence the as_of_monotonic timestamp is
        // taken *before* computing the clock error bound.
        //
        // This could be eliminated once we decide to stop supporting ClockBound 2.0 clients.
        let as_of_monotonic = MonotonicCoarse.get_time();

        let tsc_midpoint = event.tsc_midpoint();

        // First update the internal local (current SKM) and estimate (long term)
        // sample buffers
        let within_threshold = self
            .feed_internal_buffers(event)
            .inspect_err(|error_msg| match error_msg {
                FeedError::Old { event, .. } => {
                    tracing::warn!(?event, ?error_msg);
                }
            })
            .ok()?; // early exit if there was an error with the sample

        if !within_threshold {
            // At this point, if the input does not meet our expectations on the rtt threshold,
            // there is no more processing to do. The end calculation will not be more accurate than
            // the previous value (if we have one)
            tracing::trace!("Early exit. Event not within threshold");
            return None;
        }

        // Functionality from this point will fill out the equation
        // `C(t) = TSC(t) × p^ + K − θ^(t)` where:
        // - `C(t)` is the absolute time. Corrected. This is effectively the output of the clock sync algorithm
        // - `TSC(t)` is the tsc reading at a time
        // - `p^` is the estimation of the clock period
        // - `K` is the "epoch" (the uncorrected time at `TSC(0)`)
        // - `θ^(t)` is the time correction

        // Calculate uncorrected clock, aka `p^` and `K`
        self.uncorrected_clock = Self::calculate_uncorrected_clock(&self.local, &self.estimate);

        // Then calculate the local period using just the local event buffer
        //
        // This value is not used in the above equation, but IS reported in the final clock parameters
        let Some(local_period) = Self::calculate_local_period_and_error(&self.local) else {
            tracing::debug!("Early exit. Calculate local period returned none");
            return None;
        };

        // expect because not having an uncorrected clock is a bug at this point
        //
        // If we are able to calculate a local period, then uncorrected clock must be available
        #[expect(clippy::missing_panics_doc, reason = "comment above")]
        let uncorrected_clock = self
            .uncorrected_clock