<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>