Introduce pthread_condattr_setclock()

This is one of the few POSIX APIs that was missing. It lets you choose a
monotonic clock for your condition variables. This might improve perf on
some platforms. It might also grant more flexibility with NTP configs. I
know Qt is one project that believes it needs this. To introduce this, I
needed to change some the *NSYNC APIs, to support passing a clock param.
There's also new benchmarks, demonstrating Cosmopolitan's supremacy over
many libc implementations when it comes to mutex performance. Cygwin has
an alarmingly bad pthread_mutex_t implementation. It is so bad that they
would have been significantly better off if they'd used naive spinlocks.

third_party/nsync/mem/nsync_counter.c

@@ -25,6 +25,7 @@
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/races.internal.h"
 #include "third_party/nsync/wait_s.internal.h"
+#include "libc/sysv/consts/clock.h"
 #include "third_party/nsync/waiter.h"
 __static_yoink("nsync_notice");
 
@@ -100,7 +101,7 @@ uint32_t nsync_counter_wait (nsync_counter c, nsync_time abs_deadline) {
 	uint32_t result = 0;
 	waitable.v = c;
 	waitable.funcs = &nsync_counter_waitable_funcs;
-	if (nsync_wait_n (NULL, NULL, NULL, abs_deadline, 1, &pwaitable) != 0) {
+	if (nsync_wait_n (NULL, NULL, NULL, CLOCK_REALTIME, abs_deadline, 1, &pwaitable) != 0) {
 		IGNORE_RACES_START ();
 		result = ATM_LOAD_ACQ (&c->value);
 		IGNORE_RACES_END ();

third_party/nsync/mem/nsync_cv.c

@@ -175,6 +175,7 @@ struct nsync_cv_wait_with_deadline_s {
 	void *pmu;
 	void (*lock) (void *);
 	nsync_mu *cv_mu;
+	int clock;
 	nsync_time abs_deadline;
 	nsync_note cancel_note;
 	waiter *w;
@@ -187,7 +188,7 @@ static int nsync_cv_wait_with_deadline_impl_ (struct nsync_cv_wait_with_deadline
 	IGNORE_RACES_START ();
 	while (ATM_LOAD_ACQ (&c->w->nw.waiting) != 0) { /* acquire load */
 		if (c->sem_outcome == 0) {
-			c->sem_outcome = nsync_sem_wait_with_cancel_ (c->w, c->abs_deadline, c->cancel_note);
+			c->sem_outcome = nsync_sem_wait_with_cancel_ (c->w, c->clock, c->abs_deadline, c->cancel_note);
 		}
 		if (c->sem_outcome != 0 && ATM_LOAD (&c->w->nw.waiting) != 0) {
 			/* A timeout or cancellation occurred, and no wakeup.
@@ -278,13 +279,14 @@ static void nsync_cv_wait_with_deadline_unwind_ (void *arg) {
    programmes. */
 int nsync_cv_wait_with_deadline_generic (nsync_cv *pcv, void *pmu,
 					 void (*lock) (void *), void (*unlock) (void *),
-					 nsync_time abs_deadline,
+					 int clock, nsync_time abs_deadline,
 					 nsync_note cancel_note) {
 	int outcome;
 	struct nsync_cv_wait_with_deadline_s c;
 	IGNORE_RACES_START ();
 
 	c.w = nsync_waiter_new_ ();
+	c.clock = clock;
 	c.abs_deadline = abs_deadline;
 	c.cancel_note = cancel_note;
 	c.cv_mu = NULL;
@@ -470,10 +472,10 @@ void nsync_cv_broadcast (nsync_cv *pcv) {
 
 /* Wait with deadline, using an nsync_mu. */
 errno_t nsync_cv_wait_with_deadline (nsync_cv *pcv, nsync_mu *pmu,
-				     nsync_time abs_deadline,
+				     int clock, nsync_time abs_deadline,
 				     nsync_note cancel_note) {
 	return (nsync_cv_wait_with_deadline_generic (pcv, pmu, &void_mu_lock,
-						     &void_mu_unlock,
+						     &void_mu_unlock, clock,
 						     abs_deadline, cancel_note));
 }
 
@@ -486,7 +488,7 @@ errno_t nsync_cv_wait_with_deadline (nsync_cv *pcv, nsync_mu *pmu,
    ECANCELED may be returned if calling POSIX thread is cancelled only when
    the PTHREAD_CANCEL_MASKED mode is in play. */
 errno_t nsync_cv_wait (nsync_cv *pcv, nsync_mu *pmu) {
-	return nsync_cv_wait_with_deadline (pcv, pmu, nsync_time_no_deadline, NULL);
+	return nsync_cv_wait_with_deadline (pcv, pmu, 0, nsync_time_no_deadline, NULL);
 }
 
 static nsync_time cv_ready_time (void *v, struct nsync_waiter_s *nw) {

third_party/nsync/mem/nsync_mu_wait.c

@@ -141,7 +141,7 @@ int nsync_mu_wait_with_deadline (nsync_mu *mu,
 				 int (*condition) (const void *condition_arg),
 				 const void *condition_arg,
 				 int (*condition_arg_eq) (const void *a, const void *b),
-				 nsync_time abs_deadline, nsync_note cancel_note) {
+				 int clock, nsync_time abs_deadline, nsync_note cancel_note) {
 	lock_type *l_type;
 	int first_wait;
 	int condition_is_true;
@@ -231,7 +231,7 @@ int nsync_mu_wait_with_deadline (nsync_mu *mu,
 		have_lock = 0;
 		while (ATM_LOAD_ACQ (&w->nw.waiting) != 0) { /* acquire load */
 			if (sem_outcome == 0) {
-				sem_outcome = nsync_sem_wait_with_cancel_ (w, abs_deadline,
+				sem_outcome = nsync_sem_wait_with_cancel_ (w, clock, abs_deadline,
 									   cancel_note);
 				if (sem_outcome != 0 && ATM_LOAD (&w->nw.waiting) != 0) {
 					/* A timeout or cancellation occurred, and no wakeup.
@@ -280,7 +280,7 @@ void nsync_mu_wait (nsync_mu *mu, int (*condition) (const void *condition_arg),
                     const void *condition_arg,
 		    int (*condition_arg_eq) (const void *a, const void *b)) {
 	if (nsync_mu_wait_with_deadline (mu, condition, condition_arg, condition_arg_eq,
-					 nsync_time_no_deadline, NULL) != 0) {
+					 0, nsync_time_no_deadline, NULL) != 0) {
 		nsync_panic_ ("nsync_mu_wait woke but condition not true\n");
 	}
 }

third_party/nsync/mem/nsync_note.c

@@ -24,6 +24,7 @@
 #include "third_party/nsync/mu_wait.h"
 #include "third_party/nsync/races.internal.h"
 #include "third_party/nsync/wait_s.internal.h"
+#include "libc/sysv/consts/clock.h"
 #include "third_party/nsync/waiter.h"
 __static_yoink("nsync_notice");
 
@@ -247,7 +248,7 @@ int nsync_note_wait (nsync_note n, nsync_time abs_deadline) {
 	struct nsync_waitable_s *pwaitable = &waitable;
 	waitable.v = n;
 	waitable.funcs = &nsync_note_waitable_funcs;
-	return (nsync_wait_n (NULL, NULL, NULL, abs_deadline, 1, &pwaitable) == 0);
+	return (nsync_wait_n (NULL, NULL, NULL, CLOCK_REALTIME, abs_deadline, 1, &pwaitable) == 0);
 }
 
 nsync_time nsync_note_expiry (nsync_note n) {

third_party/nsync/mem/nsync_once.c

@@ -22,6 +22,7 @@
 #include "third_party/nsync/once.h"
 #include "third_party/nsync/races.internal.h"
 #include "libc/thread/thread.h"
+#include "libc/sysv/consts/clock.h"
 #include "third_party/nsync/wait_s.internal.h"
 __static_yoink("nsync_notice");
 
@@ -91,7 +92,7 @@ static void nsync_run_once_impl (nsync_once *once, struct once_sync_s *s,
 					attempts += 10;
 				}
 				deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (attempts));
-				nsync_cv_wait_with_deadline (&s->once_cv, &s->once_mu, deadline, NULL);
+				nsync_cv_wait_with_deadline (&s->once_cv, &s->once_mu, CLOCK_REALTIME, deadline, NULL);
 			} else {
 				attempts = pthread_delay_np (once, attempts);
 			}

third_party/nsync/mem/nsync_sem_wait.c

@@ -29,11 +29,11 @@ __static_yoink("nsync_notice");
      w->sem is non-zero----decrement it and return 0.
      abs_deadline expires---return ETIMEDOUT.
      cancel_note is non-NULL and *cancel_note becomes notified---return ECANCELED. */
-int nsync_sem_wait_with_cancel_ (waiter *w, nsync_time abs_deadline,
+int nsync_sem_wait_with_cancel_ (waiter *w, int clock, nsync_time abs_deadline,
 			         nsync_note cancel_note) {
 	int sem_outcome;
 	if (cancel_note == NULL) {
-		sem_outcome = nsync_mu_semaphore_p_with_deadline (&w->sem, abs_deadline);
+		sem_outcome = nsync_mu_semaphore_p_with_deadline (&w->sem, clock, abs_deadline);
 	} else {
 		nsync_time cancel_time;
 		cancel_time = nsync_note_notified_deadline_ (cancel_note);
@@ -58,7 +58,7 @@ int nsync_sem_wait_with_cancel_ (waiter *w, nsync_time abs_deadline,
 				}
 				nsync_mu_unlock (&cancel_note->note_mu);
 				sem_outcome = nsync_mu_semaphore_p_with_deadline (&w->sem,
-					local_abs_deadline);
+					clock, local_abs_deadline);
 				if (sem_outcome == ETIMEDOUT && !deadline_is_nearer) {
 					sem_outcome = ECANCELED;
 					nsync_note_notify (cancel_note);

third_party/nsync/mem/nsync_wait.c

@@ -28,7 +28,7 @@
 __static_yoink("nsync_notice");
 
 int nsync_wait_n (void *mu, void (*lock) (void *), void (*unlock) (void *),
-		  nsync_time abs_deadline,
+		  int clock, nsync_time abs_deadline,
 		  int count, struct nsync_waitable_s *waitable[]) {
 	int ready;
 	IGNORE_RACES_START ();
@@ -77,7 +77,7 @@ int nsync_wait_n (void *mu, void (*lock) (void *), void (*unlock) (void *),
 				}
 			} while (nsync_time_cmp (min_ntime, nsync_time_zero) > 0 &&
 				 nsync_mu_semaphore_p_with_deadline (&w->sem,
-					min_ntime) == 0);
+					clock, min_ntime) == 0);
 		}
 
 		/* An attempt was made above to enqueue waitable[0..i-1].