Improve quality of our ANSI C clock() function

It now works most excellently across all supported operating
sytsems (earlier it didn't work on NT and XNU). Demo code is
available in examples/clock.c and this change also adds some
of the newer ANSI C time functions like timespec_get(), plus
timespec_getres() which hasn't even come out yet as it's C23

Author: jart

examples/clock.c

@@ -0,0 +1,41 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/struct/timespec.h"
+#include "libc/stdio/stdio.h"
+#include "libc/time/time.h"
+
+/**
+ * @fileoverview clock() function demo
+ */
+
+int main(int argc, char *argv[]) {
+  unsigned long i;
+  volatile unsigned long x;
+  struct timespec now, start, next, interval;
+  printf("hammering the cpu...\n");
+  next = start = _timespec_mono();
+  interval = _timespec_frommillis(500);
+  next = _timespec_add(next, interval);
+  for (;;) {
+    for (i = 0;; ++i) {
+      x *= 7;
+      if (!(i % 256)) {
+        now = _timespec_mono();
+        if (_timespec_gte(now, next)) {
+          break;
+        }
+      }
+    }
+    next = _timespec_add(next, interval);
+    printf("consumed %10g seconds monotonic time and %10g seconds cpu time\n",
+           _timespec_tonanos(_timespec_sub(now, start)) / 1000000000.,
+           (double)clock() / CLOCKS_PER_SEC);
+  }
+}

examples/hostname.c

@@ -8,14 +8,14 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/calls/calls.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/log/check.h"
-#include "libc/stdio/stdio.h"
 
 int main(int argc, char *argv[]) {
   char name[254];
-  CHECK_NE(-1, gethostname(name, sizeof(name)));
-  printf("gethostname() → %`'s\n", name);
-  CHECK_NE(-1, getdomainname(name, sizeof(name)));
-  printf("getdomainname() → %`'s\n", name);
+  gethostname(name, sizeof(name));
+  kprintf("gethostname() → %#s\n", name);
+  getdomainname(name, sizeof(name));
+  kprintf("getdomainname() → %#s\n", name);
   return 0;
 }

libc/bits/atomic.h

@@ -0,0 +1,29 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+
+/**
+ * Converts timespec interval from nanoseconds.
+ */
+struct timespec _timespec_fromnanos(int64_t x) {
+  struct timespec ts;
+  ts.tv_sec = x / 1000000000;
+  ts.tv_nsec = x % 1000000000;
+  return ts;
+}

libc/calls/_timespec_fromnanos.c

@@ -184,9 +184,11 @@ o//libc/calls/statfs2cosmo.o: private			\
 
 # we always want -O2 because:
 #   division is expensive if not optimized
+o/$(MODE)/libc/calls/clock.o				\
 o/$(MODE)/libc/calls/_timespec_tomillis.o		\
 o/$(MODE)/libc/calls/_timespec_tomicros.o		\
 o/$(MODE)/libc/calls/_timespec_totimeval.o		\
+o/$(MODE)/libc/calls/_timespec_fromnanos.o		\
 o/$(MODE)/libc/calls/_timespec_frommillis.o		\
 o/$(MODE)/libc/calls/_timespec_frommicros.o: private	\
 		OVERRIDE_CFLAGS +=			\

libc/calls/addtimeval.c renamed to libc/calls/_timeval_add.c

@@ -16,36 +16,51 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/rusage.h"
 #include "libc/calls/struct/timespec.h"
-#include "libc/dce.h"
-#include "libc/fmt/conv.h"
-#include "libc/nt/accounting.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/synchronization.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/errno.h"
 #include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/rusage.h"
 #include "libc/time/time.h"
 
 /**
- * Returns how much CPU program has consumed on time-sharing system.
+ * Returns sum of CPU time consumed by current process since birth.
  *
- * @return value that can be divided by CLOCKS_PER_SEC, or -1 w/ errno
- * @see clock_gettime()
+ * This function provides a basic idea of how computationally expensive
+ * your program is, in terms of both the userspace and kernel processor
+ * resources it's hitherto consumed. Here's an example of how you might
+ * display this information:
+ *
+ *     printf("consumed %g seconds of cpu time\n",
+ *            (double)clock() / CLOCKS_PER_SEC);
+ *
+ * This function offers at best microsecond accuracy on all supported
+ * platforms. Please note the reported values might be a bit chunkier
+ * depending on the kernel scheduler sampling interval see `CLK_TCK`.
+ *
+ * @return units of CPU time consumed, where each unit's time length
+ *     should be `1./CLOCKS_PER_SEC` seconds; Cosmopolitan currently
+ *     returns the unit count in microseconds, i.e. `CLOCKS_PER_SEC`
+ *     is hard-coded as 1000000. On failure this returns -1 / errno.
+ * @raise ENOSYS should be returned currently if run on Bare Metal
+ * @see clock_gettime() which polyfills this on Linux and BSDs
+ * @see getrusage() which polyfills this on XNU and NT
  */
 int64_t clock(void) {
+  int e;
+  struct rusage ru;
   struct timespec ts;
-  struct NtFileTime creation_time, exit_time, kernel_time, user_time;
-  int64_t proc, total;
-  // polyfill on Windows where CLOCK_PROCESS_CPUTIME_ID may be not available
-  if (IsWindows() && CLOCK_PROCESS_CPUTIME_ID == -1) {
-    proc = GetCurrentProcess();
-    if (!GetProcessTimes(proc, &creation_time, &exit_time, &kernel_time,
-                         &user_time))
+  e = errno;
+  if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == -1) {
+    errno = e;
+    if (getrusage(RUSAGE_SELF, &ru) != -1) {
+      ts = _timeval_totimespec(_timeval_add(ru.ru_utime, ru.ru_stime));
+    } else {
       return -1;
-    total = ReadFileTime(kernel_time) + ReadFileTime(user_time);
-    ts = WindowsDurationToTimeSpec(total);
-  } else if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == -1) {
-    return -1;
+    }
   }
-  return ts.tv_sec * CLOCKS_PER_SEC +
-         ts.tv_nsec / (1000000000 / CLOCKS_PER_SEC);
+  // convert nanoseconds to microseconds w/ ceil rounding
+  // this would need roughly ~7,019,309 years to overflow
+  return ts.tv_sec * 1000000 + (ts.tv_nsec + 999) / 1000;
 }

libc/calls/calls.mk

@@ -25,8 +25,6 @@
 #include "libc/sysv/errfuns.h"
 #include "libc/time/time.h"
 
-int sys_clock_getres(int, struct timespec *) hidden;
-
 static int sys_clock_getres_poly(int clock, struct timespec *ts, int64_t real) {
   if (clock == CLOCK_REALTIME) {
     ts->tv_sec = 0;
@@ -65,6 +63,7 @@ int clock_getres(int clock, struct timespec *ts) {
   } else {
     rc = sys_clock_getres(clock, ts);
   }
-  STRACE("clock_getres(%d, [%s]) → %d% m", clock, DescribeTimespec(rc, ts), rc);
+  STRACE("clock_getres(%s, [%s]) → %d% m", DescribeClockName(clock),
+         DescribeTimespec(rc, ts), rc);
   return rc;
 }

libc/calls/clock.c

@@ -16,38 +16,33 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/clock_gettime.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/intrin/pthread.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/time/clockstonanos.internal.h"
 
 static struct {
   pthread_once_t once;
-  uint64_t base;
-  struct timespec mono;
+  struct timespec base_wall;
+  uint64_t base_tick;
 } g_mono;
 
 static void sys_clock_gettime_mono_init(void) {
-  clock_gettime(CLOCK_REALTIME, &g_mono.mono);
-  g_mono.base = rdtsc();
-  g_mono.once = true;
+  g_mono.base_wall = _timespec_real();
+  g_mono.base_tick = rdtsc();
 }
 
-int sys_clock_gettime_mono(struct timespec *ts) {
-  // this routine stops being monotonic after 194 years of uptime
+int sys_clock_gettime_mono(struct timespec *time) {
   uint64_t nanos;
+  uint64_t cycles;
   struct timespec res;
   if (X86_HAVE(INVTSC)) {
     pthread_once(&g_mono.once, sys_clock_gettime_mono_init);
-    nanos = ClocksToNanos(rdtsc(), g_mono.base);
-    res = g_mono.mono;
-    res.tv_sec += nanos / 1000000000;
-    res.tv_nsec += nanos % 1000000000;
-    *ts = res;
+    cycles = rdtsc() - g_mono.base_tick;
+    nanos = cycles / 3;
+    *time = _timespec_add(g_mono.base_wall, _timespec_fromnanos(nanos));
     return 0;
   } else {
     return einval();

libc/calls/clock_getres.c

@@ -66,8 +66,8 @@ int clock_gettime(int clock, struct timespec *ts) {
   }
 #if SYSDEBUG
   if (!__time_critical) {
-    STRACE("clock_gettime(%d, [%s]) → %d% m", clock, DescribeTimespec(rc, ts),
-           rc);
+    STRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
+           DescribeTimespec(rc, ts), rc);
   }
 #endif
   return rc;