<pre style='margin:0'>
Christopher Nielsen (mascguy) pushed a commit to branch master
in repository macports-legacy-support.

</pre>
<p><a href="https://github.com/macports/macports-legacy-support/commit/cccb15a4fa75983edeac21ebc9cfbc248578af07">https://github.com/macports/macports-legacy-support/commit/cccb15a4fa75983edeac21ebc9cfbc248578af07</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit cccb15a4fa75983edeac21ebc9cfbc248578af07
</span>Author: Fred Wright <fw@fwright.net>
AuthorDate: Fri Mar 14 13:00:58 2025 -0700

<span style='display:block; white-space:pre;color:#404040;'>    test_clocks: Add cross-check reporting.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    This adds reports of comparisons between various clocks and
</span><span style='display:block; white-space:pre;color:#404040;'>    mac_absolute_time, which is considered to be the reference clock.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    TESTED:
</span><span style='display:block; white-space:pre;color:#404040;'>    Passes and provides plausible info on all platforms, with both old and
</span><span style='display:block; white-space:pre;color:#404040;'>    new clock implementations.
</span>---
 test/test_clocks.c | 398 +++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 389 insertions(+), 9 deletions(-)

<span style='display:block; white-space:pre;color:#808080;'>diff --git a/test/test_clocks.c b/test/test_clocks.c
</span><span style='display:block; white-space:pre;color:#808080;'>index f95468a..c87032d 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/test/test_clocks.c
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/test/test_clocks.c
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -273,6 +273,19 @@ typedef struct cstats_s {
</span>   int maxsame;
 } cstats_t;
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Struct for info on clock comparisons */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+typedef struct dstats_s {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t refdiff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t refmean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t testdiff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t testmean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t offset;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  double slope;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  double sqmin;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  double sqmax;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  double sqmean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} dstats_t;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span> /* Struct for info on clock errors */
 typedef struct errinfo_s {
   ns_time_t first;
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -299,6 +312,10 @@ static ns_time_t tvnsbuf[NUM_SAMPLES];
</span> static ns_time_t mtnsbuf[NUM_SAMPLES];
 static ns_time_t tsnsbuf[NUM_SAMPLES];
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Additional buffers for mach time as a comparison basis */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static mach_time_t refbuf[NUM_SAMPLES];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static ns_time_t refnsbuf[NUM_SAMPLES];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span> /* Pointers to buffers, by clock type */
 #define CLOCK_TYPE(name,buf) &buf[0],
 static ns_time_t * const nsbufp[] = {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -583,13 +600,14 @@ getres(clock_idx_t clkidx, ns_time_t *np)
</span> 
 /* Check collected samples (nanosecond version) */
 static int
<span style='display:block; white-space:pre;background:#ffe0e0;'>-check_samples(clock_idx_t clkidx, errinfo_t *ei)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+check_samples(clock_idx_t clkidx, const ns_time_t buf[],
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+              int mode, errinfo_t *ei)
</span> {
   int ret, maxsame, cursame = 0;
   ns_time_t last, cur = 0, res = 0, nzmin = ~0ULL;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  const ns_time_t *buf = nsbufp[clock_types[clkidx]];
</span>   const ns_time_t *nsp = buf;
   sns_time_t diff;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  int numitems = mode ? NUM_DIFFS : NUM_SAMPLES;
</span> 
   /* Determine maximum consecutive repeated values */
   if ((ret = getres(clkidx, &res))) return ret;
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -598,7 +616,7 @@ check_samples(clock_idx_t clkidx, errinfo_t *ei)
</span>   ei->errnum = 0;
 
   last = *nsp++;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  while (nsp < &buf[NUM_SAMPLES]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (nsp < &buf[numitems]) {
</span>     cur = *nsp++;
     diff = cur - last;
     if (diff < 0) {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -620,7 +638,7 @@ check_samples(clock_idx_t clkidx, errinfo_t *ei)
</span>     last = cur;
   }
 
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  ei->first = buf[0]; ei->last = buf[NUM_SAMPLES - 1];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ei->first = buf[0]; ei->last = buf[numitems - 1];
</span>   ei->index = ret ? nsp - buf : -1;
   ei->prev = last; ei->cur = cur;
   ei->nzmin = nzmin < ~0ULL ? nzmin : 0;
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -669,7 +687,8 @@ check_clock(clock_idx_t clkidx, cstats_t *sp, errinfo_t *ei)
</span>   do {
     usleepx(sleepus);
     if ((ret = collect_samples(clkidx, ei))) break;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    if ((ret = check_samples(clkidx, ei)) <= 0) break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ret = check_samples(clkidx, nsbufp[clock_types[clkidx]], 0, ei);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (ret <= 0) break;
</span>     sleepus = MIN(sleepus * 2, MAX_SLEEP_US);
   } while (++tries < MAX_STEP_TRIES);
 
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -680,12 +699,14 @@ check_clock(clock_idx_t clkidx, cstats_t *sp, errinfo_t *ei)
</span> 
 /* Report error getting time */
 static void
<span style='display:block; white-space:pre;background:#ffe0e0;'>-report_clock_err(clock_idx_t clkidx, const errinfo_t *ei, int verbose)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+report_clock_err(clock_idx_t clkidx, const errinfo_t *ei,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                 int mode, int verbose)
</span> {
   const char *indent = verbose ? "    " : "";
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  const char *modestr = mode < 0 ? "" : mode ? "test " : "ref ";
</span> 
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  printf("%s*** clock %s failed (%d): %s\n",
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-         indent, clock_names[clkidx],
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  printf("%s*** %sclock %s failed (%d): %s\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         indent, modestr, clock_names[clkidx],
</span>          ei->errnum, get_errstr(ei->errnum));
   if (!verbose) {
     printf("  @%d: %llu->%llu(%llu), numsame = %d/%d, retries = %d\n",
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -803,7 +824,7 @@ report_clock(clock_idx_t clkidx, int dump, int verbose, int quiet)
</span>   if (vnq) printf(" (resolution = %d ns)\n", (int) clock_res[clkidx]);
 
   if ((err = check_clock(clkidx, &stats, &info))) {
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    report_clock_err(clkidx, &info, verbose);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    report_clock_err(clkidx, &info, -1, verbose);
</span>     ret = 1;
   }
   if (vnq && !ret) print_stats(&stats, &info);
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -825,6 +846,364 @@ report_all_clocks(int dump, int verbose, int quiet)
</span>   return ret;
 }
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Cross-checking other clocks against mach clock */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/*
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ * Functions to collect samples of target clock, interleaved with samples
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ * of the basic mach clock.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+sandwich_mach(void *arg, errinfo_t *ei)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_fn_t *func = (mach_time_fn_t *) arg;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_t *mtp = &mtbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsp = &mtnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_t *mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsrp = &refnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) ei;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Throwaways as cache warmup */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  time_scratch.mach = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  time_scratch.mach = (*func)();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (mtp < &mtbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *mtp++ = (*func)();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mtp = &mtbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (nsp < &mtnsbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsp++ = mt2nsec(*mtp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+sandwich_timeofday(void *arg, errinfo_t *ei)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  timeval_t *tvp = &tvbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsp = &tvnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_t *mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsrp = &refnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) arg;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Throwaways as cache warmup */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  time_scratch.mach = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) gettimeofday(tvp, NULL);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (tvp < &tvbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if ((ret = gettimeofday(tvp++, NULL))) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->errnum = errno; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  tvp = &tvbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (nsp < &tvnsbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if ((unsigned int) tvp->tv_usec >= MILLION) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->errnum = -err_badmicros;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->badtv = *tvp;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ret = -1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsp++ = tv2nsec(tvp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+sandwich_gettime(void *arg, errinfo_t *ei)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  clockid_t clkid = (clockid_t) (pointer_int_t) arg;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  timespec_t *tsp = &tsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsp = &tsnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_t *mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsrp = &refnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Throwaways as cache warmup */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  time_scratch.mach = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) clock_gettime(clkid, tsp);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (tsp < &tsbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if ((ret = clock_gettime(clkid, tsp++))) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->errnum = errno; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  tsp = &tsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (nsp < &tsnsbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if ((unsigned int) tsp->tv_nsec >= BILLION) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->errnum = -err_badnanos;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->badts = *tsp;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ret = -1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsp++ = ts2nsec(tsp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+sandwich_gettime_ns(void *arg, errinfo_t *ei)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  clockid_t clkid = (clockid_t) (pointer_int_t) arg;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsp = &tsnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_t *mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t *nsrp = &refnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Throwaways as cache warmup */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  time_scratch.mach = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  time_scratch.ns_time = clock_gettime_nsec_np(clkid);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (nsp < &tsnsbuf[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (!(*nsp++ = clock_gettime_nsec_np(clkid))) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->errnum = errno; return -1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *mtrp++ = mach_absolute_time();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mtrp = &refbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (nsrp < &refnsbuf[NUM_SAMPLES]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    *nsrp++ = mt2nsec(*mtrp++);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+sandwich_samples(clock_idx_t clkidx, errinfo_t *ei)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret = -1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ei->errnum = errno = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define CLOCK_TYPE(name,buf) \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    case clock_type_##name: \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ret = sandwich_##name(clock_args[clkidx], ei); break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  switch (clock_types[clkidx]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    CLOCK_TYPES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#undef CLOCK_TYPE
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Get and check one clock and reference */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+check_clock_sandwich(clock_idx_t clkidx, errinfo_t *ei, errinfo_t *eir)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret, tries = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  useconds_t sleepus = STD_SLEEP_US;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  do {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ei->errnum = eir->errnum = errno = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    usleepx(sleepus);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if ((ret = sandwich_samples(clkidx, ei))) break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    sleepus = MIN(sleepus * 2, MAX_SLEEP_US);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ret = check_samples(clock_idx_mach_absolute, refnsbuf, 0, eir);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (ret) { if (ret < 0) break; continue; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ret = check_samples(clkidx, nsbufp[clock_types[clkidx]], 1, ei);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (ret <= 0) break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  } while (++tries < MAX_STEP_TRIES);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ei->retries = eir->retries = tries;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Compare clocks */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+compare_clocks(clock_idx_t clkidx, dstats_t *dp)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  const ns_time_t *refbp = &refnsbuf[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  const ns_time_t *testbp = nsbufp[clock_types[clkidx]];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  const ns_time_t *refp = refbp, *testp = testbp;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t last, cur, mean, tstcur, expected;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t refofs, diff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int numdiffs = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  long double slope, diffsqr, difftot;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Use mean values of straddling reference pairs as comparison reference */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->refdiff = (refbp[NUM_SAMPLES - 1] + refbp[NUM_SAMPLES - 2]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                 - refbp[0] - refbp[1]) / 2;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->refmean = (refbp[NUM_SAMPLES - 1] + refbp[NUM_SAMPLES - 2]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                 + refbp[0] + refbp[1]) / 4;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->testdiff = testbp[NUM_DIFFS - 1] - testbp[0];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->testmean = (testbp[NUM_DIFFS - 1] + testbp[0]) / 2;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->offset = dp->testmean - dp->refmean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->slope = slope = (long double) dp->testdiff / dp->refdiff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->sqmin = HUGE_VAL; dp->sqmax = 0.0; difftot = 0.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  last = *refp++;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (testp < &testbp[NUM_DIFFS]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    tstcur = *testp++; cur = *refp++; mean = (last + cur) / 2;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    last = cur;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    refofs = mean - (sns_time_t) dp->refmean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    expected = (sns_time_t) (refofs * slope) + dp->testmean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    diff = tstcur - expected; diffsqr = (long double) diff * diff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (diffsqr < dp->sqmin) dp->sqmin = diffsqr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (diffsqr > dp->sqmax) dp->sqmax = diffsqr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    difftot += diffsqr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ++numdiffs;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dp->sqmean = difftot / numdiffs;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Print comparison stats */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static void
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+print_dstats(clock_idx_t clkidx, dstats_t *dp)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  printf("    mach spread/mean = %llu/%llu\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         ULL dp->refdiff, ULL dp->refmean);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  printf("    test spread/mean = %llu/%llu\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         ULL dp->testdiff, ULL dp->testmean);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (!clock_approx[clkidx]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("    offset = %lld, slope = %f, err = %f ppm\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           LL dp->offset, dp->slope, (dp->slope - 1.0) * 1E6);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  } else {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("    offset = %lld, slope = %f\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           LL dp->offset, dp->slope);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  printf("    linear fit minerr/rmserr/maxerr = %.3f/%.3f/%.3f\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         sqrt(dp->sqmin), sqrt(dp->sqmean), sqrt(dp->sqmax));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Dump all clock comparisons */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static void
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+clock_dump_dual_ns(clock_idx_t clkidx, errinfo_t *ei, errinfo_t *eir,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                   int verbose, int quiet)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int idx;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mach_time_t *rmp = refbuf;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ns_time_t cur, next, tstcur, *nsbuf = nsbufp[clock_types[clkidx]];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t last = refnsbuf[0], mean, diff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t ref_mean, tst_mean, mean_diff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  FILE *fp;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ref_mean = mt2nsec(rmp[0] + rmp[1] + rmp[NUM_DIFFS-1] + rmp[NUM_DIFFS]) / 4;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  tst_mean = (nsbuf[0] + nsbuf[NUM_DIFFS-1]) / 2;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  mean_diff = tst_mean - ref_mean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (!(fp = open_log(clkidx, "-vs-mach", quiet))) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (verbose >= 2) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "# Comparison of %d %s samples vs. mach (%s)\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            NUM_DIFFS, clock_names[clkidx],
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            ei->errnum ? "error" : "no error");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "# Nonzero min ref delta = %d, min test delta = %d,"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            " max consecutive same = %d\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            (int) eir->nzmin, (int) ei->nzmin, ei->badsame);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "# First ref value = %llu, last = %llu, diff = %llu\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            ULL eir->first, ULL eir->last, ULL (eir->last - eir->first));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "# First test value = %llu, last = %llu, diff = %llu\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            ULL ei->first, ULL ei->last, ULL (ei->last - ei->first));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "# Average time per sample = %.1f ns, retries = %d\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            (double) (ei->last - ei->first) / (NUM_DIFFS - 1), ei->retries);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "# Mean ref = %lld, mean test = %lld, diff = %lld\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            LL ref_mean, LL tst_mean, LL mean_diff);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (eir->errnum) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      fprintf(fp, "#\n");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      fprintf(fp, "#   *** Reference Clock Error %d (%s)\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+              eir->errnum, get_errstr(eir->errnum));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      fprintf(fp, "#   *** Failed @%d: %llu -> %llu (%lld)\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+              eir->index, ULL eir->prev, ULL eir->cur,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+              LL eir->cur - LL eir->prev);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (ei->errnum) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      fprintf(fp, "#\n");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      fprintf(fp, "#   *** Test Clock Error %d (%s)\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+              ei->errnum, get_errstr(ei->errnum));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      fprintf(fp, "#   *** Failed @%d: %llu\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+              ei->index, ULL ei->cur);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "#\n");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (verbose) fprintf(fp, "# Index         Reference   Delta"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                       "        Test_Value         Adj_Ref_Mean     Ofs\n");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  for (idx = 0; idx < NUM_DIFFS; ++idx) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    cur = refnsbuf[idx];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    next = refnsbuf[idx+1];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    mean = (cur + next) / 2 + mean_diff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    tstcur = nsbuf[idx];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    diff = tstcur - mean;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    fprintf(fp, "%7d %19llu %5d %19llu %+20lld %+5lld\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            idx, ULL cur, (int) (cur - last),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            ULL tstcur, LL mean, LL diff);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    last = cur;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  cur = refnsbuf[idx];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  fprintf(fp, "%7d %19llu %5d\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         idx, ULL cur, (int) (cur - last));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  fclose(fp);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Report info about one clock comparison */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+report_clock_compare(clock_idx_t clkidx, int dump, int verbose, int quiet)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret = 0, vnq = verbose && !quiet;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  const char *name = clock_names[clkidx];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  errinfo_t info = {0}, refinfo = {0};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  dstats_t dstats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (vnq) printf("  Comparing %s to mach_absolute_time\n", name);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (check_clock_sandwich(clkidx, &info, &refinfo)) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (refinfo.errnum) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      report_clock_err(clock_idx_mach_absolute, &refinfo, 0, verbose);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (info.errnum) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      report_clock_err(clkidx, &info, 1, verbose);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ret = 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  } else {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ret |= compare_clocks(clkidx, &dstats);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (vnq & !ret) print_dstats(clkidx, &dstats);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if ((dump && ret) || dump > 1) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clock_dump_dual_ns(clkidx, &info, &refinfo, verbose, quiet);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+/* Report info about all clock comparisons */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+static int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+report_all_clock_compares(int dump, int verbose, int quiet)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  clock_idx_t clkidx = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  while (clkidx < (clock_idx_t) clock_idx_max) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    /* As sanity check, don't exclude self-compare */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ret |= report_clock_compare(clkidx, dump, verbose, quiet);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ++clkidx;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span> /* Main function */
 int
 main(int argc, char *argv[])
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -856,6 +1235,7 @@ main(int argc, char *argv[])
</span> 
   while (!err) {
     err |= report_all_clocks(dump, verbose, quiet);
<span style='display:block; white-space:pre;background:#e0ffe0;'>+    err |= report_all_clock_compares(dump, verbose, quiet);
</span>     if (!continuous) break;
   }
 
</pre><pre style='margin:0'>

</pre>