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.

libc/intrin/maps.h

@@ -53,6 +53,7 @@ void *__maps_pickaddr(size_t);
 void __maps_add(struct Map *);
 void __maps_free(struct Map *);
 void __maps_insert(struct Map *);
+bool __maps_track(char *, size_t);
 struct Map *__maps_alloc(void);
 struct Map *__maps_floor(const char *);
 void __maps_stack(char *, int, int, size_t, int, intptr_t);

libc/intrin/mmap.c

@@ -305,6 +305,28 @@ void __maps_insert(struct Map *map) {
   __maps_check();
 }
 
+static void __maps_track_insert(struct Map *map, char *addr, size_t size,
+                                uintptr_t map_handle) {
+  map->addr = addr;
+  map->size = size;
+  map->prot = PROT_READ | PROT_WRITE;
+  map->flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NOFORK;
+  map->hand = map_handle;
+  __maps_lock();
+  __maps_insert(map);
+  __maps_unlock();
+}
+
+bool __maps_track(char *addr, size_t size) {
+  struct Map *map;
+  do {
+    if (!(map = __maps_alloc()))
+      return false;
+  } while (map == MAPS_RETRY);
+  __maps_track_insert(map, addr, size, -1);
+  return true;
+}
+
 struct Map *__maps_alloc(void) {
   struct Map *map;
   uintptr_t tip = atomic_load_explicit(&__maps.freed, memory_order_relaxed);
@@ -321,14 +343,7 @@ struct Map *__maps_alloc(void) {
   if (sys.addr == MAP_FAILED)
     return 0;
   map = sys.addr;
-  map->addr = sys.addr;
-  map->size = gransz;
-  map->prot = PROT_READ | PROT_WRITE;
-  map->flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NOFORK;
-  map->hand = sys.maphandle;
-  __maps_lock();
-  __maps_insert(map);
-  __maps_unlock();
+  __maps_track_insert(map, sys.addr, gransz, sys.maphandle);
   for (int i = 1; i < gransz / sizeof(struct Map); ++i)
     __maps_free(map + i);
   return MAPS_RETRY;

libc/intrin/pthread_mutex_lock.c

@@ -57,12 +57,12 @@ static void pthread_mutex_lock_drepper(atomic_int *futex, char pshare) {
   LOCKTRACE("acquiring pthread_mutex_lock_drepper(%t)...", futex);
   if (word == 1)
     word = atomic_exchange_explicit(futex, 2, memory_order_acquire);
+  BLOCK_CANCELATION;
   while (word > 0) {
-    BLOCK_CANCELATION;
-    _weaken(nsync_futex_wait_)(futex, 2, pshare, 0);
-    ALLOW_CANCELATION;
+    _weaken(nsync_futex_wait_)(futex, 2, pshare, 0, 0);
     word = atomic_exchange_explicit(futex, 2, memory_order_acquire);
   }
+  ALLOW_CANCELATION;
 }
 
 static errno_t pthread_mutex_lock_recursive(pthread_mutex_t *mutex,

libc/intrin/sys_umtx_timedwait_uint.c

@@ -23,7 +23,7 @@
 int sys_umtx_timedwait_uint_cp(atomic_int *, int, int, size_t,
                                struct _umtx_time *) asm("sys_futex_cp");
 
-int sys_umtx_timedwait_uint(atomic_int *p, int expect, bool pshare,
+int sys_umtx_timedwait_uint(atomic_int *p, int expect, bool pshare, int clock,
                             const struct timespec *abstime) {
   int op;
   size_t size;
@@ -32,7 +32,7 @@ int sys_umtx_timedwait_uint(atomic_int *p, int expect, bool pshare,
     tm_p = 0;
     size = 0;
   } else {
-    timo._clockid = CLOCK_REALTIME;
+    timo._clockid = clock;
     timo._flags = UMTX_ABSTIME;
     timo._timeout = *abstime;
     tm_p = &timo;