Method feed

clock-bound/src/daemon/clock_sync_algorithm/ff/ntp.rs:69–189

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

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

    ///
    /// Returns [`Some`] if the event has improved this source's [`ClockParameters`].
    pub fn feed(&mut self, event: event::Ntp) -> 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, and the `as_of_monotonic` timestamp
        // should be taken *before* the time at which the CEB is calculated.
        //
        // Here this should be *before* the TSC post read of event fed to the algorithm. That would
        // require carrying this `as_of_monotonic` timestamp from the IO components. Instead, we
        // are taking a short cut and placing this timestamp slightly in the past, by 10
        // milliseconds to account for possible events where the daemon is scheduled out.
        //
        // The CEB is made worse by around 150 nanoseconds (assuming a 15PPM oscillator drift),
        // which is negligible for ClockBound 2.0 clients. Moving this timestamp in the past may
        // also help reduce the risk of causality breach errors seen when using the
        // CLOCK_MONOTONIC_COARSE clock.
        //
        // This will be eliminated once we decide to stop supporting ClockBound 2.0 clients.
        let as_of_monotonic = MonotonicCoarse.get_time();
        let as_of_monotonic = if as_of_monotonic > Instant::from_millis(10) {
            as_of_monotonic - Duration::from_millis(10)
        } else {
            Instant::from_millis(0)
        };

        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);