Improve performance of printf functions

libc/calls/internal.h

@@ -228,6 +228,7 @@ int gethostname_bsd(char *, size_t) hidden;
 int gethostname_nt(char *, size_t) hidden;
 size_t __iovec_size(const struct iovec *, size_t) hidden;
 void __rusage2linux(struct rusage *) hidden;
+ssize_t WritevUninterruptible(int, struct iovec *, int);
 
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § syscalls » windows nt » veneers                           ─╬─│┼

libc/calls/now.c

@@ -70,10 +70,6 @@ long double ConvertTicksToNanos(uint64_t ticks) {
   return ticks * g_now.cpn; /* pico scale */
 }
 
-static long double ConvertTicksToSeconds(uint64_t ticks) {
-  return 1 / 1e9 * ConvertTicksToNanos(ticks);
-}
-
 long double nowl_sys(void) {
   return dtime(CLOCK_REALTIME);
 }
@@ -82,5 +78,5 @@ long double nowl_art(void) {
   uint64_t ticks;
   if (!g_now.once) RefreshTime();
   ticks = unsignedsubtract(rdtsc(), g_now.k0);
-  return g_now.r0 + ConvertTicksToSeconds(ticks);
+  return g_now.r0 + (1 / 1e9L * (ticks * g_now.cpn));
 }

libc/calls/vdprintf.c

@@ -22,43 +22,55 @@
 #include "libc/limits.h"
 #include "libc/macros.internal.h"
 #include "libc/nt/files.h"
+#include "libc/sock/sock.h"
+#include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
 struct VdprintfState {
-  int n;
-  int fd;
-  unsigned char buf[1024];
+  int n, t, fd;
+  char b[1024];
 };
 
-static int vdprintf_flush(struct VdprintfState *df, int n) {
-  int i, rc;
-  for (i = 0; i < n; i += rc) {
-    if ((rc = write(df->fd, df->buf + i, n - i)) == -1) {
-      return -1;
+static int vdprintf_putc(const char *s, struct VdprintfState *t, size_t n) {
+  struct iovec iov[2];
+  if (n) {
+    if (t->n + n < sizeof(t->b)) {
+      memcpy(t->b + t->n, s, n);
+      t->n += n;
+    } else {
+      iov[0].iov_base = t->b;
+      iov[0].iov_len = t->n;
+      iov[1].iov_base = s;
+      iov[1].iov_len = n;
+      if (WritevUninterruptible(t->fd, iov, 2) == -1) {
+        return -1;
+      }
+      t->t += t->n;
+      t->n = 0;
     }
   }
   return 0;
 }
 
-static int vdprintf_putc(int c, struct VdprintfState *df) {
-  df->buf[df->n++ & (ARRAYLEN(df->buf) - 1)] = c & 0xff;
-  if ((df->n & (ARRAYLEN(df->buf) - 1))) {
-    return 0;
-  } else {
-    return vdprintf_flush(df, ARRAYLEN(df->buf));
-  }
-}
-
 /**
  * Formats string directly to system i/o device.
  * @asyncsignalsafe
  * @vforksafe
  */
 int(vdprintf)(int fd, const char *fmt, va_list va) {
-  struct VdprintfState df;
-  df.n = 0;
-  df.fd = fd;
-  if (__fmt(vdprintf_putc, &df, fmt, va) == -1) return -1;
-  if (vdprintf_flush(&df, df.n & (ARRAYLEN(df.buf) - 1)) == -1) return -1;
-  return df.n;
+  struct iovec iov[1];
+  struct VdprintfState t;
+  t.n = 0;
+  t.t = 0;
+  t.fd = fd;
+  if (__fmt(vdprintf_putc, &t, fmt, va) == -1) return -1;
+  if (t.n) {
+    iov[0].iov_base = t.b;
+    iov[0].iov_len = t.n;
+    if (WritevUninterruptible(t.fd, iov, 1) == -1) {
+      return -1;
+    }
+    t.t += t.n;
+  }
+  return t.t;
 }

libc/calls/writevuninterruptible.c

@@ -0,0 +1,45 @@
+/*-*- 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 2021 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/internal.h"
+#include "libc/errno.h"
+#include "libc/sock/sock.h"
+
+ssize_t WritevUninterruptible(int fd, struct iovec *iov, int iovlen) {
+  ssize_t rc;
+  size_t wrote;
+  do {
+    if ((rc = writev(fd, iov, iovlen)) != -1) {
+      wrote = rc;
+      do {
+        if (wrote >= iov->iov_len) {
+          wrote -= iov->iov_len;
+          ++iov;
+          --iovlen;
+        } else {
+          iov->iov_base = (char *)iov->iov_base + wrote;
+          iov->iov_len -= wrote;
+          wrote = 0;
+        }
+      } while (wrote);
+    } else if (errno != EINTR) {
+      return -1;
+    }
+  } while (iovlen);
+  return 0;
+}