@amritk/nish-x86_64-linux 0.17.0 → 0.20.0

package/runtime/runtime-simd.c

@@ -0,0 +1,203 @@
+/* Nish runtime, the vector half: byte searches that read sixteen or thirty-two
+ * bytes at a time (WP38 S1, docs/wp38-simd.md §3.1).
+ *
+ * A translation unit of its own for the reason runtime-host.c is one: each file
+ * carries its own measured `.text*` ceiling in tests/runtime-budgets.js, and
+ * runtime.c had no room left when this arrived. Section GC means a program that
+ * never calls a kernel links none of this file, and scripts/build.sh pairs it
+ * with runtime.c like the other halves, so a link line still names one runtime.
+ *
+ * Every kernel has up to three paths. The scalar one runs anywhere. The base
+ * one uses the vectors every machine of the target has -- SSE2 on x86-64, NEON
+ * on AArch64, simd128 on wasm only when built with `-msimd128`, which is not
+ * the default (wp38 §5) -- so it needs no question asked of the CPU. The AVX2
+ * one is compiled for that extension alone with `target("avx2")`, so the binary
+ * stays a baseline binary and only a machine that has it ever runs it.
+ *
+ * Which path runs is decided on a kernel's first call, never at program start.
+ * The kernel is called through a pointer that starts at its resolver; the
+ * resolver asks the CPU, stores the path it picked and calls it, and every
+ * later call goes straight to the stored path. `NISH_SIMD` pins the choice:
+ * `scalar` and `base` name their paths, and `avx2`, any other value, or no
+ * value at all mean the best this machine has. A machine without AVX2 that is
+ * asked for it gets the base path, because running it would fault. The
+ * instruction gate sets `NISH_SIMD=base` (bench/run.mjs) so that a count does
+ * not depend on the host it was measured on.
+ */
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "nish.h"
+
+#if defined(__x86_64__) || defined(__i386__)
+#if defined(__SSE2__)
+#include <cpuid.h>
+#include <immintrin.h>
+#define NISH_SIMD_SSE2 1
+#endif
+#elif defined(__ARM_NEON)
+#include <arm_neon.h>
+#define NISH_SIMD_NEON 1
+#elif defined(__wasm_simd128__)
+#include <wasm_simd128.h>
+#define NISH_SIMD_WASM 1
+#endif
+
+/* One path of `nish_str_index_of_any`: the contract in nish.h. */
+typedef int64_t (*nish_any_path)(const nish_str *s, const nish_str *set, int64_t from);
+
+/* The scalar path, and the tail of the vector ones. A 256-bit membership
+   table answers each byte with one load and one shift whatever the size of
+   the set, so this path is also total: an empty set finds nothing and a set
+   longer than sixteen bytes is answered correctly, which is why the vector
+   paths hand any set outside 1..16 bytes to it rather than overrun their
+   sixteen splatted registers. */
+static int64_t nish_any_scalar(const nish_str *s, const nish_str *set, int64_t from) {
+  uint32_t in[8] = {0};
+  for (uint64_t k = 0; k < set->len; k++) {
+    uint8_t b = (uint8_t)set->data[k];
+    in[b >> 5] |= 1u << (b & 31);
+  }
+  for (uint64_t i = (uint64_t)from; i < s->len; i++) {
+    uint8_t b = (uint8_t)s->data[i];
+    if (in[b >> 5] >> (b & 31) & 1) return (int64_t)i;
+  }
+  return -1;
+}
+
+/* The vector paths compare each block against every byte of the set and OR
+   the answers, rather than classify each byte by its two nibbles through a
+   shuffle table as simdjson does. The shuffle is `pshufb`, which is SSSE3 and
+   not in the x86-64 baseline, and a two-table classify is only exact for a
+   set whose bytes fit eight nibble classes; an arbitrary set of sixteen bytes
+   does not. A compare per set byte is exact for every set, and the sets this
+   was built for -- a quote and a backslash, JSON's six structural bytes -- are
+   small enough that the compares cost less than the shuffles would. */
+#if defined(NISH_SIMD_SSE2)
+static int64_t nish_any_base(const nish_str *s, const nish_str *set, int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  __m128i want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = _mm_set1_epi8(set->data[j]);
+  for (; i + 16 <= n; i += 16) {
+    __m128i v = _mm_loadu_si128((const __m128i *)(s->data + i));
+    __m128i hit = _mm_cmpeq_epi8(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = _mm_or_si128(hit, _mm_cmpeq_epi8(v, want[j]));
+    unsigned m = (unsigned)_mm_movemask_epi8(hit);
+    if (m) return (int64_t)(i + (uint64_t)__builtin_ctz(m));
+  }
+  return nish_any_scalar(s, set, (int64_t)i);
+}
+
+/* Thirty-two bytes a block, then the base path for what is left: a tail of
+   up to thirty-one bytes is at most one sixteen-byte block and a scalar run. */
+__attribute__((target("avx2"))) static int64_t nish_any_avx2(const nish_str *s, const nish_str *set,
+                                                             int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  __m256i want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = _mm256_set1_epi8(set->data[j]);
+  for (; i + 32 <= n; i += 32) {
+    __m256i v = _mm256_loadu_si256((const __m256i *)(s->data + i));
+    __m256i hit = _mm256_cmpeq_epi8(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = _mm256_or_si256(hit, _mm256_cmpeq_epi8(v, want[j]));
+    unsigned m = (unsigned)_mm256_movemask_epi8(hit);
+    if (m) return (int64_t)(i + (uint64_t)__builtin_ctz(m));
+  }
+  return nish_any_base(s, set, (int64_t)i);
+}
+#elif defined(NISH_SIMD_NEON)
+static int64_t nish_any_base(const nish_str *s, const nish_str *set, int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  uint8x16_t want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = vdupq_n_u8((uint8_t)set->data[j]);
+  for (; i + 16 <= n; i += 16) {
+    uint8x16_t v = vld1q_u8((const uint8_t *)s->data + i);
+    uint8x16_t hit = vceqq_u8(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = vorrq_u8(hit, vceqq_u8(v, want[j]));
+    /* NEON has no movemask. Shifting each 16-bit pair of answers right by four
+       and narrowing keeps four bits of every byte's answer, in order, in one
+       64-bit lane, so the first hit is the lowest set bit over four. The
+       idea is Danila Kutenin's ("Porting x86 vector bitmask optimizations to
+       Arm NEON", Arm Community blog, 2022). */
+    uint64_t m = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(hit), 4)), 0);
+    if (m) return (int64_t)(i + ((uint64_t)__builtin_ctzll(m) >> 2));
+  }
+  return nish_any_scalar(s, set, (int64_t)i);
+}
+#elif defined(NISH_SIMD_WASM)
+static int64_t nish_any_base(const nish_str *s, const nish_str *set, int64_t from) {
+  uint64_t k = set->len, n = s->len, i = (uint64_t)from;
+  if (k - 1 >= 16) return nish_any_scalar(s, set, from);
+  v128_t want[16];
+  for (uint64_t j = 0; j < k; j++) want[j] = wasm_i8x16_splat(set->data[j]);
+  for (; i + 16 <= n; i += 16) {
+    v128_t v = wasm_v128_load(s->data + i);
+    v128_t hit = wasm_i8x16_eq(v, want[0]);
+    for (uint64_t j = 1; j < k; j++) hit = wasm_v128_or(hit, wasm_i8x16_eq(v, want[j]));
+    uint32_t m = wasm_i8x16_bitmask(hit);
+    if (m) return (int64_t)(i + (uint64_t)__builtin_ctz(m));
+  }
+  return nish_any_scalar(s, set, (int64_t)i);
+}
+#else
+/* A target with no vectors in its baseline: wasm without `-msimd128`, the
+   default there, among them. Its base path is the scalar one. */
+#define nish_any_base nish_any_scalar
+#endif
+
+#if defined(NISH_SIMD_SSE2)
+/* Whether this machine runs AVX2 code: the CPU has the extension (leaf 7,
+   EBX bit 5) and the operating system saves the 256-bit registers across a
+   context switch (OSXSAVE, then XCR0's SSE and AVX bits): the procedure the
+   Intel SDM gives for detecting AVX2, and the three facts
+   `__builtin_cpu_supports("avx2")` reads. That builtin is not used,
+   because its answer lives in libgcc's `__cpu_model`, and the object that
+   defines it carries a constructor that fills it in at start-up: once a link
+   names it, every program pays, a kernel called or not. Measured on
+   `examples/hello.ts` at `--profile speed`, that object took the binary from
+   4,712 bytes to 10,000 and the run 374 instructions longer. `cpuid.h` is inline
+   assembly and nothing else, so here the question is asked on the first call
+   and never before it. */
+static int nish_cpu_has_avx2(void) {
+  unsigned a, b, c, d;
+  if (!__get_cpuid(1, &a, &b, &c, &d) || !(c & bit_OSXSAVE) || !(c & bit_AVX)) return 0;
+  unsigned lo, hi;
+  __asm__("xgetbv" : "=a"(lo), "=d"(hi) : "c"(0));
+  if ((lo & 6) != 6) return 0;
+  return __get_cpuid_count(7, 0, &a, &b, &c, &d) && (b & bit_AVX2);
+}
+#endif
+
+/* Which path `NISH_SIMD` and this machine pick. AVX2 is asked of the CPU only
+   when the answer could matter, so a pinned `scalar` or `base` never reads
+   the CPU's feature bits at all. */
+static nish_any_path nish_any_choose(void) {
+  const char *pin = getenv("NISH_SIMD");
+  if (pin != NULL && strcmp(pin, "scalar") == 0) return nish_any_scalar;
+  if (pin != NULL && strcmp(pin, "base") == 0) return nish_any_base;
+#if defined(NISH_SIMD_SSE2)
+  if (nish_cpu_has_avx2()) return nish_any_avx2;
+#endif
+  return nish_any_base;
+}
+
+static int64_t nish_any_resolve(const nish_str *s, const nish_str *set, int64_t from);
+
+/* The path every call goes through, the resolver until the first call has
+   run. The loads and the store are relaxed atomics, which are plain moves on
+   every target, because under `--threads` two workers may make the first call
+   at once; both pick the same path, so whichever store lands is the answer. */
+static nish_any_path nish_any = nish_any_resolve;
+
+static int64_t nish_any_resolve(const nish_str *s, const nish_str *set, int64_t from) {
+  nish_any_path path = nish_any_choose();
+  __atomic_store_n(&nish_any, path, __ATOMIC_RELAXED);
+  return path(s, set, from);
+}
+
+int64_t nish_str_index_of_any(const nish_str *s, const nish_str *set, int64_t from) {
+  return __atomic_load_n(&nish_any, __ATOMIC_RELAXED)(s, set, from);
+}

package/runtime/runtime-wasm.c

@@ -115,6 +115,17 @@ void nish_array_grow(nish_array *a, uint64_t elem_size) {
   a->cap = cap;
 }
 
+/* ---- Math.min and Math.max of a float: llvm.minnum / llvm.maxnum, which wasm32
+ * has no instruction for. Its `f64.min` answers NaN when either operand is NaN,
+ * and minnum answers the other operand, so the backend lowers minnum to a libm
+ * call, and these are that libm. They answer what minnum answers natively: a
+ * NaN operand is dropped, and two NaNs give NaN (tests/cases/math_minmax_float,
+ * held to these by tests/run.js). Between `0` and `-0` minnum may answer either. */
+double fmin(double a, double b) { return a != a ? b : b != b ? a : a < b ? a : b; }
+double fmax(double a, double b) { return a != a ? b : b != b ? a : a > b ? a : b; }
+float fminf(float a, float b) { return a != a ? b : b != b ? a : a < b ? a : b; }
+float fmaxf(float a, float b) { return a != a ? b : b != b ? a : a > b ? a : b; }
+
 /* ---- Panics: `unreachable`, which the host sees as a RuntimeError */
 void nish_panic_index(uint64_t idx, uint64_t len) { (void)idx; (void)len; __builtin_trap(); }
 void nish_panic_slice(int64_t s, int64_t e, int64_t len) { (void)s; (void)e; (void)len; __builtin_trap(); }
@@ -122,7 +133,9 @@ void nish_panic_div(_Bool by_zero) { (void)by_zero; __builtin_trap(); }
 void nish_panic_overflow(uint32_t op) { (void)op; __builtin_trap(); }
 void nish_exit(int32_t code) { (void)code; __builtin_trap(); }
 /* A panic's message (`panic`, `expect`, a failed range entry) has no stderr to
- * go to here; the `nish_exit` that follows it is the trap. An exported function
- * with a ranged parameter checks it on entry (WP31 §9), so this is what lets
- * such a module link; the loader throws a RangeError before the call reaches it. */
+ * go to here, so `nish_panic` is the trap. An exported function with a ranged
+ * parameter checks it on entry (WP31 §9), so this is what lets such a module
+ * link; the loader throws a RangeError before the call reaches it. */
+void nish_panic(const void *s) { (void)s; __builtin_trap(); }
+/* Output has nowhere to go either. */
 void nish_write(const void *s, int32_t fd, _Bool newline) { (void)s; (void)fd; (void)newline; }

package/runtime/runtime.c

@@ -18,6 +18,7 @@
  * both use `-flto`, and the cold paths that lost the inlining are cold.
  */
 #define _POSIX_C_SOURCE 200809L
+#include <errno.h>
 #include <inttypes.h>
 #include <math.h>
 #include <stddef.h>
@@ -69,6 +70,11 @@ int __main_argc_argv(int argc, char **argv) { return nish_c_main(argc, argv); }
    allocates from compiled code. The asserts below are the contract, checked
    wherever this file is compiled. */
 typedef struct nish_chunk { struct nish_chunk *next; uint64_t cap; } nish_chunk;
+/* runtime-cross.c walks the chunks through a copy of this definition, which
+   asserts the same three facts. */
+_Static_assert(sizeof(nish_chunk) == 16, "runtime-cross.c's nish_xchunk: { next, cap }, the bytes after it");
+_Static_assert(offsetof(nish_chunk, next) == 0, "runtime-cross.c's nish_xchunk: next first");
+_Static_assert(offsetof(nish_chunk, cap) == 8, "runtime-cross.c's nish_xchunk: cap second");
 struct nish_arena { char *buf; uint64_t off; uint64_t cap; nish_chunk *chunks; };
 /* One per thread under -DNISH_THREADS, one per process otherwise; the layout is
    the same either way, which is why nothing else in this file has to know. */
@@ -79,12 +85,45 @@ _Static_assert(offsetof(struct nish_arena, off) == 8, "the inlined allocator bum
 _Static_assert(offsetof(struct nish_arena, cap) == 16, "the inlined allocator reads field 2");
 _Static_assert(offsetof(struct nish_arena, chunks) == 24, "arena layout is ABI");
 
-/* `fputs` rather than one `write`: libc's own loop finishes a short write,
-   which a bare `write` would cut off (docs/security/runtime.md, RT-11), and
-   stderr is unbuffered, so the message leaves before `_exit`. A C host that
-   gives stderr a buffer of its own would lose it here. */
+/* ---- Panics: the first one wins.
+
+   Every way a program fails -- a failed check, `panic`, out of memory -- calls
+   `nish_panic_claim` before it prints. Two tasks of a scope, or two workers of
+   a parallel map, can fail at once, and without the claim both messages would
+   reach stderr interleaved and both threads would race to the exit. The first
+   to claim prints its whole message and exits; any later one parks until
+   that exit ends the process, so exactly one message is printed and the exit
+   code is the first panic's. How each path exits is unchanged by the claim:
+   `panic`, `expect` and a failed range entry (`nish_panic`) call `exit(1)`, as
+   they did through `nish_exit`, so atexit handlers run and stdio is flushed;
+   a failed check and out of memory call `_exit(1)`, as they always have. Only
+   one thread can reach either exit, because the claim comes first. Only a
+   threads build (`-DNISH_THREADS`) can have two threads panic, so only it
+   pays for the claim; everywhere else it is an empty inline function. Under wasi with threads, the trap is the
+   defensive answer: no host there gives a parked thread a way to wait. */
+#ifdef NISH_THREADS
+static int nish_panicked;
+void nish_panic_claim(void) {
+  if (__atomic_exchange_n(&nish_panicked, 1, __ATOMIC_ACQ_REL)) {
+#if defined(__wasi__)
+    __builtin_trap();
+#else
+    for (;;) pause();
+#endif
+  }
+}
+#else
+static inline void nish_panic_claim(void) {}
+#endif
+
+/* The message goes out through `nish_write_all`, below, which finishes a
+   short write and retries one a signal interrupts (docs/security/runtime.md,
+   RT-11); it is unbuffered, so the message leaves before `_exit`. It used
+   `fputs`, whose libc loop finishes a short write but gives up on `EINTR`. */
+static void nish_write_all(int fd, const char *p, uint64_t n);
 static NISH_COLD void nish_die(const char *msg) {
-  fputs(msg, stderr);
+  nish_panic_claim();
+  nish_write_all(2, msg, strlen(msg));
   _exit(1);
 }
 /* A function rather than a macro around `nish_die`: seven call sites each
@@ -251,19 +290,29 @@ _Bool nish_str_at(const nish_str *s, int64_t at, const nish_str *sub) {
    exactly such a header from `examples/strings.ts`, and the interop tests
    caught runtime.c picking it up and inheriting `nish.h` through it. A C host
    would hit the same. A fifth of the time is not worth making the runtime
-   sensitive to its includer's `-I` paths. */
-int64_t nish_str_index_of(const nish_str *s, const nish_str *sub) {
-  if (sub->len == 0) return 0;
-  if (sub->len > s->len) return -1;
-  const char *p = s->data, *end = s->data + s->len - sub->len + 1;
-  while (p < end) {
-    const char *c = memchr(p, sub->data[0], (size_t)(end - p));
-    if (!c) return -1;
-    if (memcmp(c + 1, sub->data + 1, sub->len - 1) == 0) return (int64_t)(c - s->data);
-    p = c + 1;
+   sensitive to its includer's `-I` paths.
+
+   `s.indexOf(sub, from)` is the same search from byte `from`, and
+   `s.indexOf(sub)` is it from 0: one loop, not two. The compiler clamps `from`
+   into [0, s.length] first, as JavaScript does, with `llvm.smin`/`smax` where
+   LLVM can fold them, so the clamp costs this file nothing; an empty needle
+   answers that clamped `from`. The clamp is a precondition: a caller that
+   skips it never reads outside the string, but gets -1 for a non-empty needle
+   (a negative `from` reads as one past the end) and `from` itself, unchanged,
+   for an empty one. */
+int64_t nish_str_index_of_from(const nish_str *s, const nish_str *sub, int64_t from) {
+  uint64_t at = (uint64_t)from;
+  if (sub->len == 0) return from;
+  while (at <= s->len && sub->len <= s->len - at) {
+    const char *c = memchr(s->data + at, sub->data[0], s->len - at - sub->len + 1);
+    if (!c) break;
+    at = (uint64_t)(c - s->data);
+    if (memcmp(c + 1, sub->data + 1, sub->len - 1) == 0) return (int64_t)at;
+    at++;
   }
   return -1;
 }
+int64_t nish_str_index_of(const nish_str *s, const nish_str *sub) { return nish_str_index_of_from(s, sub, 0); }
 
 /* `console.log` / `console.error` / `write` / `writeError` and the message of
    `panic`: fd 1 or 2, with or without the trailing newline.
@@ -273,19 +322,34 @@ int64_t nish_str_index_of(const nish_str *s, const nish_str *sub) {
    does the same. So the bytes are written until all of them are out, or until
    a write fails (docs/security/runtime.md, RT-11). A failure still ends the
    output, `EAGAIN` on a non-blocking stdout included, since spinning on it
-   would burn a core. `EINTR` is not retried here: it needs a handler
-   installed without `SA_RESTART`, and the only one this runtime installs
-   (runtime-host.c) has it, so an interrupted write either restarts in the
-   kernel or comes back short. The newline needs no loop: one byte is never
-   written in part. */
-void nish_write(const nish_str *s, int32_t fd, _Bool newline) {
+   would burn a core. `EINTR` is retried, the newline's included: the only
+   handler this runtime installs (runtime-host.c) has `SA_RESTART`, but a C
+   host may install one without it. `panic`'s message, `expect`'s, and the
+   arithmetic and out-of-memory panics (`nish_die`) are written here. The
+   index and slice panics and the file and entropy failures use `dprintf`, and
+   runtime-parallel.c's out of memory one `write`: neither retries `EINTR`. */
+static void nish_write_all(int fd, const char *p, uint64_t n) {
   uint64_t done = 0;
   ssize_t k;
-  while (done < s->len && (k = write(fd, s->data + done, s->len - done)) > 0) done += k;
-  if (newline) (void)!write(fd, "\n", 1);
+  while (done < n) {
+    k = write(fd, p + done, n - done);
+    if (k > 0) done += k;
+    else if (k == 0 || errno != EINTR) break;
+  }
+}
+void nish_write(const nish_str *s, int32_t fd, _Bool newline) {
+  nish_write_all(fd, s->data, s->len);
+  if (newline) nish_write_all(fd, "\n", 1);
 }
 /* console.log(s) */
 void nish_print(const nish_str *s) { nish_write(s, 1, 1); }
+/* `panic(message)`, `r.expect(message)` and a failed range entry: the message
+   and a newline on stderr, then `exit(1)`, the first panic only. */
+__attribute__((noreturn)) void nish_panic(const nish_str *s) {
+  nish_panic_claim();
+  nish_write(s, 2, 1);
+  exit(1);
+}
 
 /* Decimal digits of `u`, with a '-' in front when `neg`. 20 digits is the
    widest a uint64_t can be, plus the sign. */
@@ -1235,6 +1299,7 @@ __attribute__((noinline)) void nish_wipe(nish_array *bytes) {
 }
 
 void nish_panic_index(uint64_t idx, uint64_t len) {
+  nish_panic_claim();
   dprintf(2, "index out of range: %" PRIu64 " >= %" PRIu64 "\n", idx, len);
   _exit(1);
 }
@@ -1248,6 +1313,7 @@ void nish_panic_index(uint64_t idx, uint64_t len) {
    a reader who wrote `s.slice(i - 1)` wants to be told `-1` rather than
    18446744073709551615. The length cannot be negative either way. */
 void nish_panic_slice(int64_t start, int64_t end, int64_t len) {
+  nish_panic_claim();
   dprintf(2, "slice out of range: [%" PRId64 ", %" PRId64 ") of length %" PRId64 "\n", start, end, len);
   _exit(1);
 }

package/runtime/shim.mjs

@@ -22,7 +22,8 @@
  *     `indexOf` answers with one. `slice` cuts on byte offsets too and panics
  *     on a range the string does not contain, where JavaScript would clamp and
  *     read a negative offset from the end. `String.fromCharCode` builds a
- *     one-byte string from the low 8 bits.
+ *     one-byte string from the low 8 bits, and `String.fromBytes` one such
+ *     string per byte of its range.
  *   - `a[i]` is bounds-checked: out of range prints
  *     `index out of range: <i> >= <len>` to stderr and exits 1, and so is
  *     `a.pop()` on an empty array, which has no `undefined` to return.
@@ -347,6 +348,20 @@ export function fromCharCode(code) {
   return Buffer.from([toIndex(code) & 0xff]).toString("latin1");
 }
 
+/**
+ * `String.fromBytes(bytes, start, end)`: the bytes of `[start, end)`, one
+ * code unit each as `fromCharCode` builds them, checked as `s.slice`'s range
+ * is and failing with its panic.
+ */
+export function fromBytes(bytes, start, end) {
+  const from = toIndex(start);
+  const to = toIndex(end);
+  if (!(from >= 0 && from <= to && to <= bytes.length)) panicSlice(from, to, bytes.length);
+  const out = Buffer.allocUnsafe(to - from);
+  for (let i = from; i < to; i++) out[i - from] = bytes[i];
+  return out.toString("latin1");
+}
+
 /** `console.log(x)`: `String(x)` (no `n` suffix for i64) plus a newline, written synchronously. */
 export function log(x) {
   fs.writeSync(1, `${String(x)}\n`);
@@ -726,6 +741,61 @@ export function spawnSyncTo(argv, out, err) {
   return spawnImpl(argv, out, err);
 }
 
+/**
+ * `spawn(argv)` and `waitPid(pid, flags)` (WP34 N12) have no faithful reading
+ * under Node, for `signalFd`'s reason: Node reaps its children itself, on the
+ * event loop, and hands their status to an `exit` listener, so no synchronous
+ * function here can wait for one, and a child Node started is never there for
+ * a wait-less poll to find. Each throws, naming itself.
+ */
+function noProcessReading(name) {
+  throw new Error(
+    `\`${name}\` has no synchronous reading under Node: a child is reaped by the event loop, which a synchronous wait never returns to (docs/wp33-round-trip.md)`
+  );
+}
+
+export function spawn() {
+  return noProcessReading("spawn");
+}
+
+export function waitPid() {
+  return noProcessReading("waitPid");
+}
+
+/**
+ * `kill(pid, sig)`: 0, or a negative errno, as `runtime-os.c`'s `nish_kill`
+ * answers. Only 0, 2, 9 and 15 are sent and a pid of 0 or below is refused,
+ * both -22, before Node is asked; Node's error then names its errno, which
+ * `os.constants.errno` turns back into the number (-3 for no such process).
+ */
+export function kill(pid, sig) {
+  if (pid <= 0 || !(sig === 0 || sig === 2 || sig === 9 || sig === 15)) return -22;
+  try {
+    process.kill(pid, sig);
+    return 0;
+  } catch (e) {
+    return -(os.constants.errno[e.code] ?? 22);
+  }
+}
+
+/**
+ * `availableParallelism()`: Node's own count, which reads the affinity mask as
+ * the native one does, lowered by a positive `NISH_NUM_THREADS` the way the
+ * native count is. The native count also reads a cgroup v2 CPU quota, which
+ * Node does not, so inside a container with a quota the two may differ; both
+ * are at least 1.
+ */
+export function availableParallelism() {
+  const n = os.availableParallelism();
+  const want = /^[0-9]+$/.test(process.env.NISH_NUM_THREADS ?? "") ? Number(process.env.NISH_NUM_THREADS) : 0;
+  return want > 0 && want < n ? want : n;
+}
+
+/** `totalMemory()`: `os.totalmem()`, as a BigInt because an `i64` is held as one here. */
+export function totalMemory() {
+  return BigInt(os.totalmem());
+}
+
 /**
  * `monotonicNanos()`: `process.hrtime.bigint()`, a monotonic clock in
  * nanoseconds (`CLOCK_MONOTONIC` on every platform that has it, which is the