<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/dc52667399ad8274b65f0a286f8d664496381e72">https://github.com/macports/macports-legacy-support/commit/dc52667399ad8274b65f0a286f8d664496381e72</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit dc52667399ad8274b65f0a286f8d664496381e72
</span>Author: Fred Wright <fw@fwright.net>
AuthorDate: Tue May 6 21:50:20 2025 -0700

<span style='display:block; white-space:pre;color:#404040;'>    test_clocks: Loosen approximate-clock criteria.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    This avoids some occasional false positives.  See the comments for
</span><span style='display:block; white-space:pre;color:#404040;'>    more details.
</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;'>    Tested on 10.4-10.5 ppc, 10.5-10.6 ppc (i386 Rosetta), 10.4-10.14
</span><span style='display:block; white-space:pre;color:#404040;'>    i386, 10.4-12.x x86_64, 11.x-15.x arm64, and 11.x-15.x x86_64 (arm64
</span><span style='display:block; white-space:pre;color:#404040;'>    Rosetta 2).
</span><span style='display:block; white-space:pre;color:#404040;'>    Ran continuously for several hours on each, with no hard errors.
</span>---
 test/test_clocks.c | 85 +++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 61 insertions(+), 24 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 a19139b..78387fd 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;'>@@ -81,13 +81,14 @@ typedef int64_t sns_time_t;
</span> #define BILLION64  1000000000ULL
 
 /* Parameters for collection sequence */
<span style='display:block; white-space:pre;background:#ffe0e0;'>-#define MAX_STEP_NS     700000  /* Maximum delta not considered a step */
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-#define MAX_STEP_TRIES      50  /* Maximum tries to avoid a step */
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-#define STD_SLEEP_US      1000  /* Standard sleep before collecting */
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-#define MAX_SLEEP_US    100000  /* Maximum sleep when retrying */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define MAX_STEP_NS           700000  /* Maximum delta not considered a step */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define MAX_APPROX_STEP_NS  10000000  /* Maximum approximate-clock step */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define MAX_RETRIES               50  /* Maximum soft-error retries */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define STD_SLEEP_US            1000  /* Standard sleep before collecting */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define MAX_SLEEP_US          100000  /* Maximum sleep when retrying */
</span> 
 /* Mach_time scaling tolerance */
<span style='display:block; white-space:pre;background:#ffe0e0;'>-#define MACH_SCALE_TOLER 10E-6
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#define MACH_SCALE_TOLER 10E-6  /* 10 ppm */
</span> 
 /* Parameters (microseconds) for process/thread time test */
 #define THREAD_RUN_TIME     100000  /* Wall clock time for thread runs */
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -636,13 +637,16 @@ check_samples(clock_idx_t clkidx, const ns_time_t buf[],
</span>   int ret, maxsame, cursame = 0;
   ns_time_t last, cur = 0, res = 0, nzmin = ~0ULL;
   const ns_time_t *nsp = buf;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  sns_time_t diff;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t diff, maxstep;
</span>   int numitems = mode ? NUM_DIFFS : NUM_SAMPLES;
 
   /* Determine maximum consecutive repeated values */
   if ((ret = getres(clkidx, &res))) return ret;
   maxsame = MAX(res, MIN_CLOCK_RES_NS) * 1000 / MIN_READ_TIME_PS;
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Maximum allowable step */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  maxstep = clock_approx[clkidx] ? MAX_APPROX_STEP_NS : MAX_STEP_NS;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span>   ei->errnum = 0;
 
   last = *nsp++;
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -656,7 +660,9 @@ check_samples(clock_idx_t clkidx, const ns_time_t buf[],
</span>         ei->errnum = -err_illbackstep; ret = -1; break;
       }
     }
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    if (diff > MAX_STEP_NS) { ei->errnum = -err_step; ret = 1; break; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (diff > maxstep) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      ei->errnum = -err_step; ret = 1; break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span>     if (!diff) {
       if (++cursame > maxsame && !clock_approx[clkidx]) {
         ei->errnum = -err_zerostep; ret = -1; break;
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -669,7 +675,7 @@ check_samples(clock_idx_t clkidx, const ns_time_t buf[],
</span>   }
 
   ei->first = buf[0]; ei->last = buf[numitems - 1];
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  ei->index = ret ? nsp - buf : -1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ei->index = ret ? nsp - buf - 1 : -1;
</span>   ei->prev = last; ei->cur = cur;
   ei->nzmin = nzmin < ~0ULL ? nzmin : 0;
   ei->badsame = cursame; ei->maxsame = maxsame;
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -728,7 +734,7 @@ check_clock(clock_idx_t clkidx, cstats_t *sp, errinfo_t *ei,
</span>     ret = check_samples(clkidx, nsbufp[clock_types[clkidx]], 0, ei);
     if (ret <= 0) break;
     sleepus = MIN(sleepus * 2, MAX_SLEEP_US);
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  } while (!replay && ++tries < MAX_STEP_TRIES);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  } while (!replay && ++tries < MAX_RETRIES);
</span> 
   ei->retries = tries;
   if (!ret && sp) get_stats(clkidx, sp);
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1114,10 +1120,16 @@ sandwich_samples(clock_idx_t clkidx, errinfo_t *ei)
</span>  * sample set, but we don't bother to check for that.
  *
  * A similar issue exists with approximate clocks, which stay at the same
<span style='display:block; white-space:pre;background:#ffe0e0;'>- * value for a long time and then jump.  While it might be possible to
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>- * come up with a more finely-tuned exception for those, for simplicity
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>- * we just give them a treatment similar to steerable clocks, except for
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>- * limiting it to the "late" case.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ * value for a long time and then jump significantly.  We do a few things
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ * to allow for this:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   1) We don't start checking values until the first step occurs.  This
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   allows capturing the delay offset from the update.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   2) Additionally, we use the one-step-earlier version of the reference
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   to compute the minimum, to allow for the earlier capture of the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   approximate clock.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   2) We keep the "lastmax" value unchnaged when the clock value is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   unchanged, providing extra tolerance for the step.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ * In addition to the above, the "late" case is considered retriable.
</span>  */
 static int
 compare_clocks(clock_idx_t clkidx, errinfo_t *ei, errinfo_t *eir, dstats_t *dp)
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1125,8 +1137,8 @@ compare_clocks(clock_idx_t clkidx, errinfo_t *ei, errinfo_t *eir, dstats_t *dp)
</span>   const ns_time_t *refbp = &refnsbuf[0];
   const ns_time_t *testbp = nsbufp[clock_types[clkidx]];
   const ns_time_t *refp = refbp, *testp = testbp;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  sns_time_t last, cur, tstcur = 0;
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-  int ret = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  sns_time_t prev, last, cur, tstlast, tstcur = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  int ret = 0, steps = 0, adjret = clock_okadj[clkidx] ? 1 : -1;
</span>   sns_time_t minref = 0, maxref = 0, difflim;
   sns_time_t lastmin = INT64_MIN, lastmax = INT64_MAX, curmin = 0, curmax = 0;
 
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1139,18 +1151,43 @@ compare_clocks(clock_idx_t clkidx, errinfo_t *ei, errinfo_t *eir, dstats_t *dp)
</span>   difflim = MAX(clock_res[clkidx], ei->nzmin)
             + MAX(clock_res[clock_idx_mach_absolute], eir->nzmin);
 
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  last = *refp++;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  tstlast = *testp; prev = last = *refp++;
</span>   while (testp < &testbp[NUM_DIFFS]) {
     tstcur = *testp++; cur = *refp++;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    minref = last - difflim; maxref = cur + difflim;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    minref = (clock_approx[clkidx] ? prev : last) - difflim;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    maxref = cur + difflim;
</span>     curmin = tstcur - maxref; curmax = tstcur - minref;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    if (curmax < lastmin || curmin > lastmax) {
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-      ei->errnum = curmax < lastmin ? -err_early : -err_late;
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-      ret = clock_okadj[clkidx]
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-            || (clock_approx[clkidx] && curmin > lastmax) ? 1 : -1;
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-      break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (!clock_approx[clkidx]) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      if (curmax < lastmin) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ei->errnum = -err_early;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ret = adjret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      if (curmin > lastmax) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ei->errnum = -err_late;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ret = adjret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      lastmax = curmax;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    } else {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      if (tstcur != tstlast || steps) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        if (curmax < lastmin) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+          ei->errnum = -err_early;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+          ret = -1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+          break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        if (curmin > lastmax) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+          ei->errnum = -err_late;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+          ret = 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+          break;
</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;'>+      if (tstcur != tstlast) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ++steps;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        lastmax = curmax;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      }
</span>     }
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    last = cur; lastmin = curmin; lastmax = curmax;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    tstlast = tstcur; prev = last; last = cur; lastmin = curmin;
</span>   }
 
   ei->first = testbp[0]; ei->last = testbp[NUM_DIFFS - 1];
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1231,7 +1268,7 @@ check_clock_sandwich(clock_idx_t clkidx,
</span>     if (ret) { if (ret < 0) break; continue; }
     ret = compare_clocks(clkidx, ei, eir, dp);
     if (ret <= 0) break;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  } while (!replay && ++tries < MAX_STEP_TRIES);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  } while (!replay && ++tries < MAX_RETRIES);
</span> 
   ei->retries = eir->retries = tries;
   return ret;
</pre><pre style='margin:0'>

</pre>