add approximation coefficient

vvfedorenko · facebook-github-bot · commit e4e39b629fe9 · 2025-06-06T09:03:42.000-07:00
Summary:
The difference between system clock speed and PHC speed may be so huge that the linear approximation will fail to provide monotonically increasing time. For example, we run PHC time reader every ~10ms, the observed situation on dns09.28.lla1 was:
```
oldSysTimeNS=1749167822494826022 newSysTimeNS=1749167822504951677 diff=10125655ns
oldPhcTimeNS=1749167859494830869 newPhcTimeNS=1749167859504956519 diff=10125650ns
```
That means that the system time on the hosts went faster then PHC time during one of 10ms interval. Now if we will take a system time of 1749167822504951676 ( 1 ns before new system time) and try to linearly extrapolate PHC time using the diff between previous system time and the time point we chose, we will get PHC time equal to 1749167859504956523. But this value is 4 ns bigger than the next PHC value we read. That means the PHC time is not monotonic anymore. But if will apply correction coefficient of -493 PPB (ns/s), the corrected value will not be bigger then new read.

Re-arrange structure to fill in gaps and reduce the growth by only 4 bytes.

Reviewed By: t3lurid3

Differential Revision: D76096414

fbshipit-source-id: 608d79183c1c105fff99df45c8f24d8bc69fef44
diff --git a/fbclock/cpp_test/test.cpp b/fbclock/cpp_test/test.cpp
@@ -151,9 +151,9 @@ int writer_thread_v2(int sfd_rw, int tries) {
       .ingress_time_ns = 1,
       .error_bound_ns = 2,
       .holdover_multiplier_ns = 3,
+      .clockId = CLOCK_MONOTONIC_RAW,
       .phc_time_ns = 1748164346441310791,
       .sysclock_time_ns = 1748164309441310791,
-      .clockId = CLOCK_MONOTONIC_RAW,
   };
   for (int i = 0; i < tries; i++) {
     err = fbclock_clockdata_store_data_v2(sfd_rw, &data);
@@ -290,6 +290,63 @@ TEST(fbclockTest, test_fbclock_calculate_time) {
   EXPECT_EQ(truetime.latest_ns, 1647290691804195223);
 }
 
+TEST(fbclockTest, test_fbclock_calculate_time_v2) {
+  int err;
+  fbclock_truetime truetime;
+  fbclock_clockdata_v2 state = {
+      .ingress_time_ns = 1647269091803102957,
+      .clockId = CLOCK_MONOTONIC_RAW,
+      // phc time is before ingress time, error
+      .phc_time_ns = 1647269082943150996,
+  };
+  double error_bound = 172.0;
+  double h_value = 50.5;
+
+  struct timespec tp = {};
+  clock_gettime(CLOCK_MONOTONIC_RAW, &tp);
+
+  int64_t sysclock_time_ns = tp.tv_sec * 1000000000 + tp.tv_nsec;
+  state.sysclock_time_ns = sysclock_time_ns;
+
+  err = fbclock_calculate_time_v2(
+      error_bound,
+      h_value,
+      &state,
+      sysclock_time_ns + 1000, // + 1us
+      &truetime,
+      FBCLOCK_TAI);
+  ASSERT_EQ(err, FBCLOCK_E_PHC_IN_THE_PAST);
+
+  // phc time is after ingress time, all good
+  state = {
+      .ingress_time_ns = 1647269082943150996,
+      .clockId = CLOCK_MONOTONIC_RAW,
+      .phc_time_ns = 1647269091803102957,
+      .sysclock_time_ns = sysclock_time_ns,
+      .coef_ppb = 12,
+  };
+  err = fbclock_calculate_time_v2(
+      error_bound,
+      h_value,
+      &state,
+      sysclock_time_ns + 1000,
+      &truetime,
+      FBCLOCK_TAI);
+  ASSERT_EQ(err, 0);
+
+  EXPECT_EQ(truetime.earliest_ns, 1647269091803103381);
+  EXPECT_EQ(truetime.latest_ns, 1647269091803104619);
+
+  // WOU is very big
+  error_bound = 1000.0;
+  sysclock_time_ns += 6 * 3600 * 1000000000ULL; // + 6 hours
+  err = fbclock_calculate_time_v2(
+      error_bound, h_value, &state, sysclock_time_ns, &truetime, FBCLOCK_TAI);
+  ASSERT_EQ(err, 0);
+  EXPECT_EQ(truetime.earliest_ns, 1647290691803360857);
+  EXPECT_EQ(truetime.latest_ns, 1647290691803363751);
+}
+
 TEST(fbclockTest, test_fbclock_apply_smear_after_2017_leap_second) {
   uint64_t offset_pre_ns = 36e9;
   uint64_t offset_post_ns = 37e9;
diff --git a/fbclock/fbclock.c b/fbclock/fbclock.c
@@ -310,26 +310,25 @@ int fbclock_calculate_time_v2(
     uint64_t error_bound_ns,
     double h_value_ns,
     fbclock_clockdata_v2* state,
-    int64_t phc_time_ns,
-    int64_t sysclock_time_ns,
     int64_t sysclock_time_now_ns,
     fbclock_truetime* truetime,
     int time_standard) {
+  int64_t phc_time_ns = state->phc_time_ns;
   if (state->ingress_time_ns > phc_time_ns) {
     return FBCLOCK_E_PHC_IN_THE_PAST;
   }
   // check how far back since last SYNC message from GM (in seconds)
   double seconds =
       (double)(phc_time_ns - state->ingress_time_ns) / NANOSECONDS_IN_SECONDS;
 
+  int64_t diff_ns = sysclock_time_now_ns - state->sysclock_time_ns;
+  phc_time_ns += diff_ns + diff_ns * state->coef_ppb / NANOSECONDS_IN_SECONDS;
+
   // UTC offset applied if time standard used is UTC (and not TAI)
   if (time_standard == FBCLOCK_UTC) {
     phc_time_ns = fbclock_apply_utc_offset_v2(state, phc_time_ns);
   }
 
-  int64_t diff_ns = sysclock_time_now_ns - sysclock_time_ns;
-  phc_time_ns += diff_ns;
-
   // calculate the Window of Uncertainty (WOU) (in nanoseconds)
   uint64_t wou_ns =
       fbclock_window_of_uncertainty(seconds, error_bound_ns, h_value_ns);
@@ -403,7 +402,7 @@ int fbclock_gettime_tz_v2(
   double h_value = (double)state.holdover_multiplier_ns / FBCLOCK_POW2_16;
 
   struct timespec ts;
-  if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) == -1) {
+  if (clock_gettime(state.clockId, &ts) == -1) {
     return FBCLOCK_E_PTP_READ_OFFSET;
   }
   int64_t sysclock_time_now_ns =
@@ -413,8 +412,6 @@ int fbclock_gettime_tz_v2(
       error_bound,
       h_value,
       &state,
-      state.phc_time_ns,
-      state.sysclock_time_ns,
       sysclock_time_now_ns,
       truetime,
       time_standard);
diff --git a/fbclock/fbclock.h b/fbclock/fbclock.h
@@ -80,15 +80,17 @@ typedef struct fbclock_clockdata_v2 {
   // end time (TAI) to stop smearing clock
   uint64_t clock_smearing_end_s;
   // UTC offset before latest published leap second (tzdata)
-  int32_t utc_offset_pre_s;
+  int16_t utc_offset_pre_s;
   // UTC offset after latest published leap second (tzdata)
-  int32_t utc_offset_post_s;
+  int16_t utc_offset_post_s;
+  // we may have sys clock read with MONOTONIC_RAW or REALTIME clock source
+  uint32_t clockId;
   // periodically updated PHC time
   int64_t phc_time_ns;
   // system clock time received during periodical update of PHC time
   int64_t sysclock_time_ns;
-  // we may have sys clock read with MONOTONIC_RAW or REALTIME clock source
-  uint32_t clockId;
+  // extrapolation coefficient in PPB
+  int64_t coef_ppb;
 
 } fbclock_clockdata_v2;
 
@@ -148,6 +150,13 @@ int fbclock_calculate_time(
     int64_t phctime_ns,
     fbclock_truetime* truetime,
     int timezone);
+int fbclock_calculate_time_v2(
+    uint64_t error_bound_ns,
+    double h_value_ns,
+    fbclock_clockdata_v2* state,
+    int64_t sysclock_time_now_ns,
+    fbclock_truetime* truetime,
+    int timezone);
 uint64_t fbclock_apply_utc_offset(fbclock_clockdata* state, int64_t phctime_ns);
 uint64_t fbclock_apply_utc_offset_v2(
     fbclock_clockdata_v2* state,
diff --git a/fbclock/shmem.go b/fbclock/shmem.go
@@ -94,11 +94,12 @@ type DataV2 struct {
 	HoldoverMultiplierNS float64 // float stored as multiplier of 2**16
 	SmearingStartS       uint64  // Smearing starts before the Leap Second Event Time (midnight on June-30 or Dec-31)
 	SmearingEndS         uint64  // Smearing ends after the Leap Second Event Time (midnight on June-30 or Dec-31)
-	UTCOffsetPreS        int32   // UTC Offset before Leap Second Event
-	UTCOffsetPostS       int32   // UTC Offset after Leap Second Event
+	UTCOffsetPreS        int16   // UTC Offset before Leap Second Event
+	UTCOffsetPostS       int16   // UTC Offset after Leap Second Event
+	ClockID              uint32  // Clock ID of SysclockTimeNS (MONOTONIC_RAW or REALTIME)
 	PHCTimeNS            int64   // Periodically updated PHC time used to calculate real PHC time
 	SysclockTimeNS       int64   // Periodically updated system clock time (MONOTONIC_RAW or REALTIME) received with PHC time
-	ClockID              uint32  // Clock ID of SysclockTimeNS (MONOTONIC_RAW or REALTIME)
+	CoefPPB              int64   // Coefficient of the approximation of the PHC time
 }
 
 // OpenFBClockShmCustom returns opened POSIX shared mem used by fbclock,
@@ -227,11 +228,12 @@ func StoreFBClockDataV2(fd uintptr, d DataV2) error {
 		holdover_multiplier_ns: C.uint32_t(FloatAsUint32(d.HoldoverMultiplierNS)),
 		clock_smearing_start_s: C.uint64_t(d.SmearingStartS),
 		clock_smearing_end_s:   C.uint64_t(d.SmearingEndS),
-		utc_offset_pre_s:       C.int32_t(d.UTCOffsetPreS),
-		utc_offset_post_s:      C.int32_t(d.UTCOffsetPostS),
+		utc_offset_pre_s:       C.int16_t(d.UTCOffsetPreS),
+		utc_offset_post_s:      C.int16_t(d.UTCOffsetPostS),
+		clockId:                C.uint32_t(d.ClockID),
 		phc_time_ns:            C.int64_t(d.PHCTimeNS),
 		sysclock_time_ns:       C.int64_t(d.SysclockTimeNS),
-		clockId:                C.uint32_t(d.ClockID),
+		coef_ppb:               C.int64_t(d.CoefPPB),
 	}
 	// fbclock_clockdata_store_data comes from fbclock.c
 	res := C.fbclock_clockdata_store_data_v2(C.uint(fd), cData)
@@ -257,5 +259,6 @@ func ReadFBClockDataV2(shmp unsafe.Pointer) (*DataV2, error) {
 		PHCTimeNS:            int64(cData.phc_time_ns),
 		SysclockTimeNS:       int64(cData.sysclock_time_ns),
 		ClockID:              uint32(cData.clockId),
+		CoefPPB:              int64(cData.coef_ppb),
 	}, nil
 }
