@amritk/nish-x86_64-linux 0.20.0 → 0.22.1

package/std/net/prefork.ts

@@ -84,6 +84,11 @@ export const PREFORK_STOPPED: i32 = -1
  * supervisor could not listen for SIGTERM and so starts none.
  */
 export const PREFORK_SPAWN_FAILED: i32 = -2
+/**
+ * What `preforkWith` answers in the supervisor when `restart` is off and every
+ * worker has exited.
+ */
+export const PREFORK_WORKERS_EXITED: i32 = -3
 
 /** The supervisor's numbers; every one is checked by `preforkWith`. */
 export class PreforkConfig {
@@ -99,6 +104,11 @@ export class PreforkConfig {
   quickExitMs: i32 = 1000
   /** How long the workers get to exit after SIGTERM before SIGKILL. */
   graceMs: i32 = 5000
+  /**
+   * Start a worker that exited again. Off, a worker that exits stays gone,
+   * and the supervisor returns once none is left.
+   */
+  restart: boolean = true
 }
 
 /** True when `s` is one or more ASCII digits and nothing else. */
@@ -177,6 +187,8 @@ class PreforkSlot {
   pid: i32 = 0
   /** The wait before the last restart, 0 after a worker that ran long. */
   delay: i32 = 0
+  /** The worker exited with `restart` off, and is never started again. */
+  gone: boolean = false
 }
 
 /** The supervisor's state while it runs. */
@@ -269,7 +281,9 @@ class PreforkSupervisor {
       const slot: PreforkSlot = this.slots[index]
       this.running = this.running - 1
       slot.pid = 0
-      if (!stopping) {
+      if (!this.config.restart) {
+        slot.gone = true
+      } else if (!stopping) {
         this.backoff(slot, preforkNowMs(), false)
       }
     }
@@ -285,7 +299,7 @@ class PreforkSupervisor {
     const now: i64 = preforkNowMs()
     for (let i: i32 = 0; i < toI32(this.slots.length); i++) {
       const slot: PreforkSlot = this.slots[i]
-      if (slot.pid === 0 && slot.at <= now && !this.start(i)) {
+      if (slot.pid === 0 && !slot.gone && slot.at <= now && !this.start(i)) {
         if (first) {
           return false
         }
@@ -355,7 +369,9 @@ const preforkInvalid = (config: PreforkConfig): string => {
 
 /**
  * In a worker, its index. In the supervisor, run the workers until SIGTERM or
- * SIGINT and answer `PREFORK_STOPPED`, or `PREFORK_SPAWN_FAILED` when a worker's
+ * SIGINT and answer `PREFORK_STOPPED`; with `restart` off, also until every
+ * worker has exited, answering `PREFORK_WORKERS_EXITED`; or
+ * `PREFORK_SPAWN_FAILED` when a worker's
  * first start failed (those already started are stopped first) or no signal
  * listener could be made (no worker is started). Panics on a config
  * `preforkInvalid` names a field of.
@@ -399,6 +415,10 @@ export const preforkWith = (args: string[], config: PreforkConfig): i32 => {
         running = false
       } else {
         supervisor.reap(false)
+        if (!config.restart && supervisor.running === 0) {
+          result = PREFORK_WORKERS_EXITED
+          running = false
+        }
         supervisor.restart(false)
       }
     }

package/std/net/quic-listener.ts

@@ -68,7 +68,7 @@
  * of in one burst that overruns a queue on the path.
  *
  *     let out: u8[] | null = quicListenerTakePaced(conn, now);
- *     while (out !== null) { … send it … ; out = quicListenerTakePaced(conn, now); }
+ *     while (out !== null) { … send it with conn.datagramEcn … ; out = quicListenerTakePaced(conn, now); }
  *     … and wake at the earlier of conn.deadline() and quicListenerPaceTime(conn, now)
  *
  * A carrier that sends whole flights with `quicListenerTakeFlight`, below,
@@ -90,9 +90,16 @@
  * side, `quicListenerReceiveSegments` hands a connection the datagrams of
  * one GRO receive, segment by segment, in place.
  *
+ * **ECN** (RFC 9000 §13.4). A carrier whose platform sends the ECN bits it
+ * is given sets the connection's `ecnMarking` and sends each datagram with
+ * the codepoint the connection marked it with: `conn.datagramEcn` after a
+ * `takeDatagramInto` or `quicListenerTakePaced`, `flight.ecn` for a flight.
+ * One send carries one codepoint, so a flight ends before a datagram the
+ * connection would mark otherwise. The listener's own answers go unmarked.
+ *
  *     const flight = new QuicFlight();
  *     const n: i32 = quicListenerTakeFlight(conn, now, buf, 0, toI32(buf.length), flight);
- *     if (n > 0) { udpSendTo(fd, buf, 0, n, peer, flight.count > 1 ? flight.segment : 0, 0); }
+ *     if (n > 0) { udpSendTo(fd, buf, 0, n, peer, flight.count > 1 ? flight.segment : 0, flight.ecn); }
  *
  * **Sans-IO and deterministic.** The caller gives the time, the client's
  * address and, once, `QUIC_LISTENER_ENTROPY_SIZE` random bytes: every
@@ -928,6 +935,8 @@ export class QuicFlight {
   count: i32 = 0
   /** Every datagram's size but the last's, which may be shorter: the `UDP_SEGMENT` to send with. */
   segment: i32 = 0
+  /** The ECN codepoint every datagram of the flight was marked with: the one to send with. */
+  ecn: i32 = 0
 }
 
 /**
@@ -941,8 +950,8 @@ export class QuicFlight {
  * `quicListenerTakePaced` does, so the flight is the pacer's whole credit
  * and no more. It stops at the first datagram shorter than
  * `QUIC_CONN_DATAGRAM_SIZE`, which can only be the last of a segmented send,
- * at `QUIC_LISTENER_FLIGHT_MAX` datagrams, and when `cap` has no room for
- * another.
+ * at `QUIC_LISTENER_FLIGHT_MAX` datagrams, when `cap` has no room for
+ * another, and before a datagram whose ECN codepoint would not be the first's.
  */
 export const quicListenerTakeFlight = (
   conn: QuicConnection,
@@ -954,6 +963,7 @@ export const quicListenerTakeFlight = (
 ): i32 => {
   flight.count = 0
   flight.segment = 0
+  flight.ecn = 0
   let length: i32 = 0
   if (conn.recovery.pacerDelay(now, quicListenerQuantum(conn)) > 0) {
     return length
@@ -963,6 +973,11 @@ export const quicListenerTakeFlight = (
     length + QUIC_CONN_DATAGRAM_SIZE <= cap &&
     conn.recovery.pacerDelay(now, QUIC_CONN_DATAGRAM_SIZE) <= 0
   ) {
+    // The codepoint `takeDatagramInto` would mark the next datagram with: one send carries one.
+    const next: i32 = conn.ecnMarking ? conn.recovery.ecnCodepoint() : 0
+    if (flight.count > 0 && next !== flight.ecn) {
+      return length
+    }
     const n: i32 = conn.takeDatagramInto(buf, at + length, now)
     if (n <= 0) {
       return length
@@ -970,6 +985,7 @@ export const quicListenerTakeFlight = (
     conn.recovery.onPaced(now, n)
     if (flight.count === 0) {
       flight.segment = n
+      flight.ecn = conn.datagramEcn
     }
     flight.count = flight.count + 1
     length = length + n

package/std/random.ts

@@ -5,7 +5,7 @@
  *     import { Rng } from "nish/random";
  *
  *     const r = new Rng(42);
- *     const die: i32 = 1 + (r.nextI32() >>> 1) % 6;
+ *     const die: i32 = r.nextInt(1, 6); // 1 to 6, each with equal chance
  *     const u: f64 = r.nextF64(); // in [0, 1)
  *
  * The state is one 32-bit integer. Each step adds the odd constant
@@ -24,8 +24,11 @@
  * two's-complement wrap natively and answer `(a + b) | 0` and `Math.imul(a, b)`
  * under Node (docs/LANGUAGE.md, "nish:unsafe"); every shift has a constant
  * count, and `^` and `>>> 16` answer the same 32 bits in JavaScript as in the
- * compiled program. `nextF64` builds its double from integers below 2^53, so
- * its products and sums are exact both ways. The program a test prints under
+ * compiled program. `nextInt` reads its span and its draws as unsigned
+ * counts with no `u32` (whose conversions saturate under Node): the sign bit
+ * flipped orders them under a signed compare, and the remainder is taken in
+ * pieces that stay below 2^31. `nextF64` builds its double from integers
+ * below 2^53, so its products and sums are exact both ways. The program a test prints under
  * Node is the one it prints compiled (docs/RUN_UNDER_NODE.md).
  *
  * It is not for cryptography: a key or a nonce comes from
@@ -37,7 +40,7 @@
  * would be a write their caller can see, and is refused as any such write is;
  * give each task its own, seeded from its index.
  */
-import { wrappingAdd, wrappingMul } from "nish:unsafe"
+import { wrappingAdd, wrappingMul, wrappingSub } from "nish:unsafe"
 
 /** 0x9E3779B9 as an `i32`: the Weyl increment, odd, so the walk visits every state. */
 const GOLDEN: i32 = -1640531527
@@ -54,6 +57,35 @@ const TWO_26: f64 = 67108864.0
 /** 2^53, which scales a 53-bit integer into [0, 1). */
 const TWO_53: f64 = 9007199254740992.0
 
+/** The sign bit: `x ^ SIGN` orders the bits of `x` as an unsigned count under a signed compare. */
+const SIGN: i32 = -2147483648
+
+/** 2^31 - 1, the `i32` just below 2^31, from which `remainder` finds 2^31 mod m. */
+const MAX: i32 = 2147483647
+
+/** Whether `a < b` when both are read as unsigned 32-bit counts. */
+const below = (a: i32, b: i32): boolean => (a ^ SIGN) < (b ^ SIGN)
+
+/**
+ * `a mod m` with both read as unsigned 32-bit counts and `m` not 0. A count
+ * of 2^31 or more is a negative `i32`, so it is taken apart into pieces a
+ * signed `%` answers the same in JavaScript, and every sum stays below 2^31.
+ */
+const remainder = (a: i32, m: i32): i32 => {
+  if (m < 0) {
+    // m is 2^31 or more, so a is less than 2m: at most one m comes off.
+    return below(a, m) ? a : wrappingSub(a, m)
+  }
+  if (a >= 0) {
+    return a % m
+  }
+  // a is 2^31 + low, so a mod m is low plus 2^31 mod m, added mod m.
+  const low: i32 = (a ^ SIGN) % m
+  const high: i32 = wrappingAdd(MAX % m, 1) % m
+  const room: i32 = wrappingSub(m, high)
+  return low >= room ? wrappingSub(low, room) : wrappingAdd(low, high)
+}
+
 /** MurmurHash3's `fmix32`: every bit of `h` into every bit of the answer, a bijection on 32 bits. */
 const mix = (h: i32): i32 => {
   let x: i32 = h
@@ -91,4 +123,34 @@ export class Rng {
     const lo: i32 = this.nextI32() >>> 6
     return (toF64(hi) * TWO_26 + toF64(lo)) / TWO_53
   }
+
+  /**
+   * An integer in [lo, hi], both ends included, each with equal chance;
+   * `nextInt(1, 6)` is a die. It panics when `lo` is greater than `hi`, and
+   * the whole `i32` range, `nextInt(-2147483648, 2147483647)`, is one
+   * `nextI32()`.
+   *
+   * There is no modulo bias: where the span `hi - lo + 1`, an unsigned count
+   * up to 2^32, does not divide 2^32 evenly, a draw among the lowest
+   * 2^32 mod span is refused and drawn again, and what is left holds every
+   * answer equally often. Fewer than half the draws are ever refused, so an
+   * answer takes one `nextI32()` step usually and fewer than two on average,
+   * and a sequence is still the seed's.
+   */
+  nextInt(lo: i32, hi: i32): i32 {
+    if (lo > hi) {
+      panic("Rng.nextInt: lo is greater than hi")
+    }
+    const span: i32 = wrappingAdd(wrappingSub(hi, lo), 1)
+    if (span === 0) {
+      return this.nextI32()
+    }
+    // 2^32 mod span, as (2^32 - span) mod span.
+    const refused: i32 = remainder(wrappingSub(0, span), span)
+    let draw: i32 = this.nextI32()
+    while (below(draw, refused)) {
+      draw = this.nextI32()
+    }
+    return wrappingAdd(lo, remainder(draw, span))
+  }
 }