<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/9edd87b8b55f78e1e1136e0a49f4b7fbde79ef59">https://github.com/macports/macports-legacy-support/commit/9edd87b8b55f78e1e1136e0a49f4b7fbde79ef59</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit 9edd87b8b55f78e1e1136e0a49f4b7fbde79ef59
</span>Author: Fred Wright <fw@fwright.net>
AuthorDate: Sat Feb 22 15:53:41 2025 -0800

<span style='display:block; white-space:pre;color:#404040;'>    libtest_settime: Include CLOCK_MONOTONIC in monotonicity check.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    This adds CLOCK_MONOTONIC to the existing monotonicity check for
</span><span style='display:block; white-space:pre;color:#404040;'>    CLOCK_MONOTONIC_RAW.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Also switches to clock_gettime_nsec_np() for reading times.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Also fixes minor inconsistency in clock warmup.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Also expands monotonicity error messages.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Also now reports priority.
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Also fixes a couple of typos.
</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 on 10.12+.
</span><span style='display:block; white-space:pre;color:#404040;'>    Demonstrates failure of old legacy-support CLOCK_MONOTONIC
</span><span style='display:block; white-space:pre;color:#404040;'>    implementation on <10.12, but otherwise passes.
</span>---
 manual_tests/libtest_settime.c | 59 +++++++++++++++++++++++++++---------------
 1 file changed, 38 insertions(+), 21 deletions(-)

<span style='display:block; white-space:pre;color:#808080;'>diff --git a/manual_tests/libtest_settime.c b/manual_tests/libtest_settime.c
</span><span style='display:block; white-space:pre;color:#808080;'>index e340a6f..27728ed 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/manual_tests/libtest_settime.c
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/manual_tests/libtest_settime.c
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -24,10 +24,10 @@
</span>  *  NTP threshold for making step adjustments.
  *   2) We attempt to almost immediately undo the adjustment.
  *   3) The adjustment is first forward and then backward, so if the test
<span style='display:block; white-space:pre;background:#ffe0e0;'>- *  dies in midstream, we're left with the less troublesome forard step.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *  dies in midstream, we're left with the less troublesome forward step.
</span>  *   4) We set our priority to the maximum, and launch as many threads
  *  as there are CPUs, to mostly lock out other programs (briefly).
<span style='display:block; white-space:pre;background:#ffe0e0;'>- *   5) We begin with 100ms sleep, to start with a fresh quantum and
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ *   5) We begin with 500ms sleep, to start with a fresh quantum and
</span>  *  minimize the chance of a reschedule in midstream.
  */
 
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -61,22 +61,19 @@ typedef long long nstime_t;
</span> 
 typedef struct info_s {
   nstime_t init_raw;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  nstime_t init_mono;
</span>   nstime_t init_real;
   nstime_t first_set;
   nstime_t first_real;
   nstime_t middle_raw;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  nstime_t middle_mono;
</span>   nstime_t middle_real;
   nstime_t second_set;
   nstime_t second_real;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  nstime_t final_mono;
</span>   nstime_t final_raw;
 } info_t;
 
<span style='display:block; white-space:pre;background:#ffe0e0;'>-static nstime_t
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-timespec2ns(const struct timespec *ts)
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-{
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-  return ts->tv_sec * BILLION + ts->tv_nsec;
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-}
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-
</span> static struct timespec
 ns2timespec(nstime_t nsec)
 {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -90,11 +87,8 @@ ns2timespec(nstime_t nsec)
</span> static int
 clock_getns(clockid_t clock_id, nstime_t *nsp)
 {
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  struct timespec ts;
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-  if (clock_gettime(clock_id, &ts) < 0) return errno;
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-  *nsp = timespec2ns(&ts);
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-  return 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  *nsp = clock_gettime_nsec_np(clock_id);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return *nsp ? 0 : errno;
</span> }
 
 static int
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -110,12 +104,13 @@ static int
</span> do_test(info_t *tp)
 {
   int err, tverr;
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  nstime_t delta;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  nstime_t delta, scratch;
</span>   struct timeval orig_tv;
 
   /* First warm up the clocks */
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  (void) clock_getns(CLOCK_MONOTONIC_RAW, &tp->init_raw);
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-  (void) clock_getns(CLOCK_REALTIME, &tp->init_raw);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) clock_getns(CLOCK_MONOTONIC_RAW, &scratch);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) clock_getns(CLOCK_MONOTONIC, &scratch);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  (void) clock_getns(CLOCK_REALTIME, &scratch);
</span> 
   /* Get us a fresh quantum */
   (void) usleep(SLEEP_MS * 1000);
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -123,8 +118,9 @@ do_test(info_t *tp)
</span>   /* Save original gettimeofday() time */
   tverr = gettimeofday(&orig_tv, NULL);
 
<span style='display:block; white-space:pre;background:#ffe0e0;'>-  /* Get both real and raw times */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  /* Get both real and raw times, plus monotonic */
</span>   if (clock_getns(CLOCK_MONOTONIC_RAW, &tp->init_raw)) return errno;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (clock_getns(CLOCK_MONOTONIC, &tp->init_mono)) return errno;
</span>   if (clock_getns(CLOCK_REALTIME, &tp->init_real)) return errno;
 
   /* Adjust clock forward */
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -137,6 +133,7 @@ do_test(info_t *tp)
</span>     /* Capture times from the middle */
     if ((err = clock_getns(CLOCK_REALTIME, &tp->first_real))) break;
     if ((err = clock_getns(CLOCK_MONOTONIC_RAW, &tp->middle_raw))) break;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+    if ((err = clock_getns(CLOCK_MONOTONIC, &tp->middle_mono))) break;
</span>     if ((err = clock_getns(CLOCK_REALTIME, &tp->middle_real))) break;
 
     /* Adjust clock backward, can't fix it if it doesn't work */
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -154,6 +151,7 @@ do_test(info_t *tp)
</span> 
   /* Otherwise, finish up with a couple more captures */
   if (clock_getns(CLOCK_REALTIME, &tp->second_real)) return errno;
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (clock_getns(CLOCK_MONOTONIC, &tp->final_mono)) return errno;
</span>   if (clock_getns(CLOCK_MONOTONIC_RAW, &tp->final_raw)) return errno;
 
   /* Just to be safe, restore the time via settimeofday() */
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -177,13 +175,16 @@ do_test(info_t *tp)
</span> static void
 print_times(info_t *tp) {
   PRINT_TIME(tp, init_raw);
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  PRINT_TIME(tp, init_mono);
</span>   PRINT_TIME(tp, init_real);
   PRINT_TIME(tp, first_set);
   PRINT_TIME(tp, first_real);
   PRINT_TIME(tp, middle_raw);
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  PRINT_TIME(tp, middle_mono);
</span>   PRINT_TIME(tp, middle_real);
   PRINT_TIME(tp, second_set);
   PRINT_TIME(tp, second_real);
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  PRINT_TIME(tp, final_mono);
</span>   PRINT_TIME(tp, final_raw);
 }
 
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -258,6 +259,8 @@ main(int argc, char *argv[])
</span>   if (setpriority(PRIO_PROCESS, 0, TARGET_PRIO) < 0) {
     perror("Unable to set priority");
     fprintf(stderr, "Continuing anyway (will probably fail)\n");
<span style='display:block; white-space:pre;background:#e0ffe0;'>+  } else {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("Priority set to %d\n", TARGET_PRIO);
</span>   }
 
   /* Try to lock out everyone else while we screw with the clock */
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -292,13 +295,27 @@ main(int argc, char *argv[])
</span> 
   /* First check raw monotonicity (very unlikely wrong) */
   if (dur1 < 0) {
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    printf("Middle raw %lld < init raw %lld\n",
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-           info.middle_raw, info.init_raw);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("Middle raw %lld < init raw %lld, diff = %lld\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           info.middle_raw, info.init_raw, dur1);
</span>     err = 1;
   }
   if (dur2 < 0) {
<span style='display:block; white-space:pre;background:#ffe0e0;'>-    printf("Final raw %lld < middle raw %lld\n",
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-           info.final_raw, info.middle_raw);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("Final raw %lld < middle raw %lld, diff = %lld\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           info.final_raw, info.middle_raw, dur2);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    err = 1;
</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;'>+  /* Also check non-raw monotonicity */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (info.middle_mono < info.init_mono) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("Middle mono %lld < init mono %lld, diff = %lld\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           info.middle_mono, info.init_mono,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           info.middle_mono - info.init_mono);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    err = 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  if (info.final_mono < info.middle_mono) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    printf("Final mono %lld < middle mono %lld, diff = %lld\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           info.final_mono, info.middle_mono,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           info.final_mono - info.middle_mono);
</span>     err = 1;
   }
 
</pre><pre style='margin:0'>

</pre>