wip: add waiting for PTP to stabilize

Signed-off-by: Kasiewicz, Marek <[email protected]>

Author: Sakoram

tests/tools/RxTxApp/src/app_base.h

@@ -639,6 +639,8 @@ struct st_app_var_params {
   uint64_t sch_force_sleep_us;
 };
 
+#define PTP_DELTA_HISTORY_SIZE 5 /* number of samples for moving average */
+
 struct st_app_context {
   st_json_context_t* json_ctx;
   struct mtl_init_params para;
@@ -672,6 +674,11 @@ struct st_app_context {
   int force_rx_audio_numa;
 
   bool ptp_systime_sync;
+  int ptp_wait_stable_s; /* seconds to wait for PTP to stabilize, 0 means no wait */
+  int64_t ptp_wait_stable_threshold_ns; /* threshold in ns for PTP delta to be considered
+                                           stable */
+  int64_t ptp_delta_history[PTP_DELTA_HISTORY_SIZE]; /* circular buffer for moving avg */
+  int ptp_delta_history_idx; /* current index in circular buffer */
   int ptp_sync_cnt;
   int64_t ptp_sync_delta_sum;
   int64_t ptp_sync_delta_max;

tests/tools/RxTxApp/src/args.c

@@ -155,6 +155,8 @@ enum st_args_cmd {
   ST_ARG_TX_USER_CLOCK_OFFSET,
   ST_ARG_AUTO_STOP,
   ST_ARG_RX_MAX_FILE_SIZE,
+  ST_ARG_PTP_WAIT_STABLE_S,
+  ST_ARG_PTP_WAIT_STABLE_THRESHOLD_NS,
   ST_ARG_MAX,
 };
 
@@ -307,6 +309,9 @@ static struct option st_app_args_options[] = {
     {"timestamp_epoch", no_argument, 0, ST_ARG_TIMESTAMP_EPOCH},
     {"auto_stop", no_argument, 0, ST_ARG_AUTO_STOP},
     {"rx_max_file_size", required_argument, 0, ST_ARG_RX_MAX_FILE_SIZE},
+    {"ptp_wait_stable", required_argument, 0, ST_ARG_PTP_WAIT_STABLE_S},
+    {"ptp_wait_stable_threshold", required_argument, 0,
+     ST_ARG_PTP_WAIT_STABLE_THRESHOLD_NS},
 
     {0, 0, 0, 0}};
 
@@ -943,6 +948,12 @@ int st_app_parse_args(struct st_app_context* ctx, struct mtl_init_params* p, int
       case ST_ARG_RX_MAX_FILE_SIZE:
         ctx->rx_max_file_size = strtoul(optarg, NULL, 0);
         break;
+      case ST_ARG_PTP_WAIT_STABLE_S:
+        ctx->ptp_wait_stable_s = atoi(optarg);
+        break;
+      case ST_ARG_PTP_WAIT_STABLE_THRESHOLD_NS:
+        ctx->ptp_wait_stable_threshold_ns = strtoll(optarg, NULL, 0);
+        break;
       case '?':
         break;
       default:

tests/tools/RxTxApp/src/rxtx_app.c

@@ -102,6 +102,12 @@ static void app_stat(void* priv) {
 
 static void app_ptp_sync_notify(void* priv, struct mtl_ptp_sync_notify_meta* meta) {
   struct st_app_context* ctx = priv;
+
+  /* Store abs(delta) in circular buffer for moving average */
+  ctx->ptp_delta_history[ctx->ptp_delta_history_idx] = labs(meta->delta);
+  ctx->ptp_delta_history_idx = (ctx->ptp_delta_history_idx + 1) % PTP_DELTA_HISTORY_SIZE;
+  ctx->ptp_sync_cnt++;
+
   if (!ctx->ptp_systime_sync) return;
 
   /* sync raw ptp to sys time */
@@ -112,9 +118,8 @@ static void app_ptp_sync_notify(void* priv, struct mtl_ptp_sync_notify_meta* met
   from_ts.tv_sec += meta->master_utc_offset; /* utc offset */
   uint64_t from_ns = st_timespec_to_ns(&from_ts);
 
-  /* record the sync delta */
+  /* record the sync delta for stats */
   int64_t delta = to_ns - from_ns;
-  ctx->ptp_sync_cnt++;
   ctx->ptp_sync_delta_sum += delta;
   if (delta > ctx->ptp_sync_delta_max) ctx->ptp_sync_delta_max = delta;
   if (delta < ctx->ptp_sync_delta_min) ctx->ptp_sync_delta_min = delta;
@@ -436,7 +441,10 @@ int main(int argc, char** argv) {
     ctx->para.nb_rx_hdr_split_queues = ctx->rx_video_session_cnt;
   }
 
-  if (ctx->ptp_systime_sync) ctx->para.ptp_sync_notify = app_ptp_sync_notify;
+  /* Register ptp_sync_notify for ptp_systime_sync or ptp_wait_stable */
+  if (ctx->ptp_systime_sync || ctx->ptp_wait_stable_s > 0) {
+    ctx->para.ptp_sync_notify = app_ptp_sync_notify;
+  }
 
   ctx->st = mtl_init(&ctx->para);
   if (!ctx->st) {
@@ -475,6 +483,93 @@ int main(int argc, char** argv) {
     }
   }
 
+  /* Wait for PTP to stabilize if requested */
+  if (ctx->ptp_wait_stable_s > 0) {
+    int wait_s = ctx->ptp_wait_stable_s;
+    int64_t threshold_ns = ctx->ptp_wait_stable_threshold_ns;
+    if (threshold_ns <= 0) threshold_ns = 100; /* default 100ns threshold */
+    bool stable = false;
+
+    info("%s, waiting up to %d seconds for PTP delta to be below %" PRId64 " ns...\n",
+         __func__, wait_s, threshold_ns);
+
+    /* Start the device if not already started (needed for PTP to work) */
+    if (!ctx->runtime_session) {
+      ret = mtl_start(ctx->st);
+      if (ret < 0) {
+        err("%s, start dev fail for ptp wait %d\n", __func__, ret);
+        st_app_ctx_free(ctx);
+        return -EIO;
+      }
+    }
+
+    /* Initialize delta tracking */
+    for (int j = 0; j < PTP_DELTA_HISTORY_SIZE; j++) {
+      ctx->ptp_delta_history[j] = INT64_MAX;
+    }
+    ctx->ptp_delta_history_idx = 0;
+    ctx->ptp_sync_cnt = 0;
+
+    for (int i = 0; i < wait_s * 10 && !stable; i++) {
+      st_usleep(100 * 1000); /* 100ms sleep */
+      if (ctx->stop) {
+        err("%s, aborted during PTP wait\n", __func__);
+        st_app_ctx_free(ctx);
+        return -EIO;
+      }
+
+      int sync_cnt = ctx->ptp_sync_cnt;
+
+      /* Check if we have enough samples for moving average */
+      if (sync_cnt >= PTP_DELTA_HISTORY_SIZE) {
+        /* Compute moving average from circular buffer */
+        int64_t sum = 0;
+        for (int j = 0; j < PTP_DELTA_HISTORY_SIZE; j++) {
+          sum += ctx->ptp_delta_history[j];
+        }
+        int64_t avg_delta = sum / PTP_DELTA_HISTORY_SIZE;
+
+        if (avg_delta < threshold_ns) {
+          info("%s, PTP stable after %d.%d seconds (moving avg delta: %" PRId64
+               " ns, sync cnt: %d)\n",
+               __func__, i / 10, (i % 10) * 100, avg_delta, sync_cnt);
+          stable = true;
+        } else if ((i % 10) == 0) {
+          info("%s, PTP sync in progress, moving avg delta: %" PRId64
+               " ns (threshold: %" PRId64 " ns, sync cnt: %d)\n",
+               __func__, avg_delta, threshold_ns, sync_cnt);
+        }
+      } else if ((i % 10) == 0) {
+        info("%s, waiting for PTP sync messages (cnt: %d, need: %d)...\n", __func__,
+             sync_cnt, PTP_DELTA_HISTORY_SIZE);
+      }
+    }
+
+    if (!stable) {
+      int64_t avg_delta = 0;
+      if (ctx->ptp_sync_cnt >= PTP_DELTA_HISTORY_SIZE) {
+        int64_t sum = 0;
+        for (int j = 0; j < PTP_DELTA_HISTORY_SIZE; j++) {
+          sum += ctx->ptp_delta_history[j];
+        }
+        avg_delta = sum / PTP_DELTA_HISTORY_SIZE;
+      }
+      warn("%s, PTP did not stabilize within %d seconds (moving avg delta: %" PRId64
+           " ns), continuing anyway\n",
+           __func__, wait_s, avg_delta);
+    }
+
+    /* Stop the device if we started it just for PTP wait (will be started later) */
+    if (!ctx->runtime_session) {
+      ret = mtl_stop(ctx->st);
+      if (ret < 0) {
+        err("%s, stop dev fail after ptp wait %d\n", __func__, ret);
+        st_app_ctx_free(ctx);
+        return -EIO;
+      }
+    }
+  }
+
   if (ctx->json_ctx->user_time_offset) {
     ctx->user_time.user_time_offset = ctx->json_ctx->user_time_offset;
   }

tests/validation/mtl_engine/RxTxApp.py

@@ -548,6 +548,8 @@ def execute_test(
 
     if ptp:
         command += " --ptp"
+        command += " --ptp_wait_stable 30"
+        command += " --ptp_wait_stable_threshold 100"
 
     if auto_stop:
         command += " --auto_stop"
@@ -1926,6 +1928,8 @@ def execute_dual_test(
         base_command += " --rx_timing_parser"
     if ptp:
         base_command += " --ptp"
+        base_command += " --ptp_wait_stable 20"
+        base_command += " --ptp_wait_stable_threshold 100"
 
     tx_command = f"{base_command} --config_file {tx_config_file}"
     rx_command = f"{base_command} --config_file {rx_config_file}"

tests/validation/tests/single/ptp/test_mode/mixed/test_mixed_format.py

@@ -54,7 +54,7 @@ def test_ptp_mixed_format(
     media_file,
     output_files,
 ):
-    test_time = max(test_time, 50)  # Ensure at least 50 seconds for this test
+    test_time = max(test_time, 100)  # Ensure at least 100 seconds for this test
     media_file_info, media_file_path = media_file
     host = list(hosts.values())[0]
     if interface_profile["mode"] == "vf_only":