summaryrefslogtreecommitdiffstats
path: root/hwclock.c
diff options
context:
space:
mode:
Diffstat (limited to 'hwclock.c')
-rw-r--r--hwclock.c334
1 files changed, 334 insertions, 0 deletions
diff --git a/hwclock.c b/hwclock.c
new file mode 100644
index 0000000..86c7e51
--- /dev/null
+++ b/hwclock.c
@@ -0,0 +1,334 @@
+/*
+ chronyd/chronyc - Programs for keeping computer clocks accurate.
+
+ **********************************************************************
+ * Copyright (C) Miroslav Lichvar 2016-2018, 2022
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ **********************************************************************
+
+ =======================================================================
+
+ Tracking of hardware clocks (e.g. RTC, PHC)
+ */
+
+#include "config.h"
+
+#include "sysincl.h"
+
+#include "array.h"
+#include "hwclock.h"
+#include "local.h"
+#include "logging.h"
+#include "memory.h"
+#include "quantiles.h"
+#include "regress.h"
+#include "util.h"
+
+/* Minimum and maximum number of samples per clock */
+#define MIN_SAMPLES 2
+#define MAX_SAMPLES 64
+
+/* Maximum acceptable frequency offset of the clock */
+#define MAX_FREQ_OFFSET (2.0 / 3.0)
+
+/* Quantiles for filtering readings by delay */
+#define DELAY_QUANT_MIN_K 1
+#define DELAY_QUANT_MAX_K 2
+#define DELAY_QUANT_Q 10
+#define DELAY_QUANT_REPEAT 7
+#define DELAY_QUANT_MIN_STEP 1.0e-9
+
+struct HCL_Instance_Record {
+ /* HW and local reference timestamp */
+ struct timespec hw_ref;
+ struct timespec local_ref;
+
+ /* Samples stored as intervals (uncorrected for frequency error)
+ relative to local_ref and hw_ref */
+ double *x_data;
+ double *y_data;
+
+ /* Minimum, maximum and current number of samples */
+ int min_samples;
+ int max_samples;
+ int n_samples;
+
+ /* Maximum error of the last sample */
+ double last_err;
+
+ /* Minimum interval between samples */
+ double min_separation;
+
+ /* Expected precision of readings */
+ double precision;
+
+ /* Flag indicating the offset and frequency values are valid */
+ int valid_coefs;
+
+ /* Estimated offset and frequency of HW clock relative to local clock */
+ double offset;
+ double frequency;
+
+ /* Estimated quantiles of reading delay */
+ QNT_Instance delay_quants;
+};
+
+/* ================================================== */
+
+static void
+handle_slew(struct timespec *raw, struct timespec *cooked, double dfreq,
+ double doffset, LCL_ChangeType change_type, void *anything)
+{
+ HCL_Instance clock;
+ double delta;
+
+ clock = anything;
+
+ if (clock->n_samples)
+ UTI_AdjustTimespec(&clock->local_ref, cooked, &clock->local_ref, &delta, dfreq, doffset);
+ if (clock->valid_coefs)
+ clock->frequency /= 1.0 - dfreq;
+}
+
+/* ================================================== */
+
+HCL_Instance
+HCL_CreateInstance(int min_samples, int max_samples, double min_separation, double precision)
+{
+ HCL_Instance clock;
+
+ min_samples = CLAMP(MIN_SAMPLES, min_samples, MAX_SAMPLES);
+ max_samples = CLAMP(MIN_SAMPLES, max_samples, MAX_SAMPLES);
+ max_samples = MAX(min_samples, max_samples);
+
+ clock = MallocNew(struct HCL_Instance_Record);
+ clock->x_data = MallocArray(double, max_samples);
+ clock->y_data = MallocArray(double, max_samples);
+ clock->x_data[max_samples - 1] = 0.0;
+ clock->y_data[max_samples - 1] = 0.0;
+ clock->min_samples = min_samples;
+ clock->max_samples = max_samples;
+ clock->n_samples = 0;
+ clock->valid_coefs = 0;
+ clock->min_separation = min_separation;
+ clock->precision = precision;
+ clock->delay_quants = QNT_CreateInstance(DELAY_QUANT_MIN_K, DELAY_QUANT_MAX_K,
+ DELAY_QUANT_Q, DELAY_QUANT_REPEAT,
+ DELAY_QUANT_MIN_STEP);
+
+ LCL_AddParameterChangeHandler(handle_slew, clock);
+
+ return clock;
+}
+
+/* ================================================== */
+
+void HCL_DestroyInstance(HCL_Instance clock)
+{
+ LCL_RemoveParameterChangeHandler(handle_slew, clock);
+ QNT_DestroyInstance(clock->delay_quants);
+ Free(clock->y_data);
+ Free(clock->x_data);
+ Free(clock);
+}
+
+/* ================================================== */
+
+int
+HCL_NeedsNewSample(HCL_Instance clock, struct timespec *now)
+{
+ if (!clock->n_samples ||
+ fabs(UTI_DiffTimespecsToDouble(now, &clock->local_ref)) >= clock->min_separation)
+ return 1;
+
+ return 0;
+}
+
+/* ================================================== */
+
+int
+HCL_ProcessReadings(HCL_Instance clock, int n_readings, struct timespec tss[][3],
+ struct timespec *hw_ts, struct timespec *local_ts, double *err)
+{
+ double delay, raw_delay, min_delay, low_delay, high_delay, e, pred_err;
+ double delay_sum, hw_sum, local_sum, local_prec, freq;
+ int i, min_reading, combined;
+ struct timespec ts1, ts2;
+
+ if (n_readings < 1)
+ return 0;
+
+ /* Work out the current correction multiplier needed to get cooked delays */
+ LCL_CookTime(&tss[0][0], &ts1, NULL);
+ LCL_CookTime(&tss[n_readings - 1][2], &ts2, NULL);
+ if (UTI_CompareTimespecs(&tss[0][0], &tss[n_readings - 1][2]) < 0)
+ freq = UTI_DiffTimespecsToDouble(&ts1, &ts2) /
+ UTI_DiffTimespecsToDouble(&tss[0][0], &tss[n_readings - 1][2]);
+ else
+ freq = 1.0;
+
+ for (i = 0; i < n_readings; i++) {
+ delay = freq * UTI_DiffTimespecsToDouble(&tss[i][2], &tss[i][0]);
+
+ if (delay < 0.0) {
+ /* Step in the middle of a reading? */
+ DEBUG_LOG("Bad reading delay=%e", delay);
+ return 0;
+ }
+
+ if (i == 0 || min_delay > delay) {
+ min_delay = delay;
+ min_reading = i;
+ }
+
+ QNT_Accumulate(clock->delay_quants, delay);
+ }
+
+ local_prec = LCL_GetSysPrecisionAsQuantum();
+
+ low_delay = QNT_GetQuantile(clock->delay_quants, DELAY_QUANT_MIN_K);
+ high_delay = QNT_GetQuantile(clock->delay_quants, DELAY_QUANT_MAX_K);
+ low_delay = MIN(low_delay, high_delay);
+ high_delay = MAX(high_delay, low_delay + local_prec);
+
+ /* Combine readings with delay in the expected interval */
+ for (i = combined = 0, delay_sum = hw_sum = local_sum = 0.0; i < n_readings; i++) {
+ raw_delay = UTI_DiffTimespecsToDouble(&tss[i][2], &tss[i][0]);
+ delay = freq * raw_delay;
+
+ if (delay < low_delay || delay > high_delay)
+ continue;
+
+ delay_sum += delay;
+ hw_sum += UTI_DiffTimespecsToDouble(&tss[i][1], &tss[0][1]);
+ local_sum += UTI_DiffTimespecsToDouble(&tss[i][0], &tss[0][0]) + raw_delay / 2.0;
+ combined++;
+ }
+
+ DEBUG_LOG("Combined %d readings lo=%e hi=%e", combined, low_delay, high_delay);
+
+ if (combined > 0) {
+ UTI_AddDoubleToTimespec(&tss[0][1], hw_sum / combined, hw_ts);
+ UTI_AddDoubleToTimespec(&tss[0][0], local_sum / combined, local_ts);
+ *err = MAX(delay_sum / combined / 2.0, clock->precision);
+ return 1;
+ }
+
+ /* Accept the reading with minimum delay if its interval does not contain
+ the current offset predicted from previous samples */
+
+ *hw_ts = tss[min_reading][1];
+ UTI_AddDoubleToTimespec(&tss[min_reading][0], min_delay / freq / 2.0, local_ts);
+ *err = MAX(min_delay / 2.0, clock->precision);
+
+ pred_err = 0.0;
+ LCL_CookTime(local_ts, &ts1, NULL);
+ if (!HCL_CookTime(clock, hw_ts, &ts2, &e) ||
+ ((pred_err = UTI_DiffTimespecsToDouble(&ts1, &ts2)) > *err)) {
+ DEBUG_LOG("Accepted reading err=%e prerr=%e", *err, pred_err);
+ return 1;
+ }
+
+ return 0;
+}
+
+/* ================================================== */
+
+void
+HCL_AccumulateSample(HCL_Instance clock, struct timespec *hw_ts,
+ struct timespec *local_ts, double err)
+{
+ double hw_delta, local_delta, local_freq, raw_freq;
+ int i, n_runs, best_start;
+
+ local_freq = 1.0 - LCL_ReadAbsoluteFrequency() / 1.0e6;
+
+ /* Shift old samples */
+ if (clock->n_samples) {
+ if (clock->n_samples >= clock->max_samples)
+ clock->n_samples--;
+
+ hw_delta = UTI_DiffTimespecsToDouble(hw_ts, &clock->hw_ref);
+ local_delta = UTI_DiffTimespecsToDouble(local_ts, &clock->local_ref) / local_freq;
+
+ if (hw_delta <= 0.0 || local_delta < clock->min_separation / 2.0) {
+ clock->n_samples = 0;
+ DEBUG_LOG("HW clock reset interval=%f", local_delta);
+ }
+
+ for (i = clock->max_samples - clock->n_samples; i < clock->max_samples; i++) {
+ clock->y_data[i - 1] = clock->y_data[i] - hw_delta;
+ clock->x_data[i - 1] = clock->x_data[i] - local_delta;
+ }
+ }
+
+ clock->n_samples++;
+ clock->hw_ref = *hw_ts;
+ clock->local_ref = *local_ts;
+ clock->last_err = err;
+
+ /* Get new coefficients */
+ clock->valid_coefs =
+ RGR_FindBestRobustRegression(clock->x_data + clock->max_samples - clock->n_samples,
+ clock->y_data + clock->max_samples - clock->n_samples,
+ clock->n_samples, 1.0e-10, &clock->offset, &raw_freq,
+ &n_runs, &best_start);
+
+ if (!clock->valid_coefs) {
+ DEBUG_LOG("HW clock needs more samples");
+ return;
+ }
+
+ clock->frequency = raw_freq / local_freq;
+
+ /* Drop unneeded samples */
+ if (clock->n_samples > clock->min_samples)
+ clock->n_samples -= MIN(best_start, clock->n_samples - clock->min_samples);
+
+ /* If the fit doesn't cross the error interval of the last sample,
+ or the frequency is not sane, drop all samples and start again */
+ if (fabs(clock->offset) > err ||
+ fabs(clock->frequency - 1.0) > MAX_FREQ_OFFSET) {
+ DEBUG_LOG("HW clock reset");
+ clock->n_samples = 0;
+ clock->valid_coefs = 0;
+ }
+
+ DEBUG_LOG("HW clock samples=%d offset=%e freq=%e raw_freq=%e err=%e ref_diff=%e",
+ clock->n_samples, clock->offset, clock->frequency - 1.0, raw_freq - 1.0, err,
+ UTI_DiffTimespecsToDouble(&clock->hw_ref, &clock->local_ref));
+}
+
+/* ================================================== */
+
+int
+HCL_CookTime(HCL_Instance clock, struct timespec *raw, struct timespec *cooked, double *err)
+{
+ double offset, elapsed;
+
+ if (!clock->valid_coefs)
+ return 0;
+
+ elapsed = UTI_DiffTimespecsToDouble(raw, &clock->hw_ref);
+ offset = elapsed / clock->frequency - clock->offset;
+ UTI_AddDoubleToTimespec(&clock->local_ref, offset, cooked);
+
+ /* Fow now, just return the error of the last sample */
+ if (err)
+ *err = clock->last_err;
+
+ return 1;
+}