@amritk/nish-x86_64-linux 0.32.0 → 0.34.0

package/std/net/http1-codec.ts

@@ -506,17 +506,19 @@ const http1StartRequest = (p: Http1Parser): void => {
 }
 
 /**
- * Whether any of the eight bytes of `x` is below 32 or is 127: a control
- * byte or DEL, which `http1TakeLine` stops at. Two of the bit tricks of
- * "Bit Twiddling Hacks" (S. E. Anderson, public domain): a byte below `n`
- * leaves its high bit set in `(x - n * ones) & ~x`, for `n` up to 128, and
- * `127` is the byte that is zero in `x ^ 127 * ones`. A byte from 128 up
- * has its high bit set in `x`, so `~x` clears it: obs-text never matches.
- * The answer is exact for the word, though not for which byte. Each
- * subtraction is masked to 64 bits because a `u64` is a BigInt under Node,
- * which does not wrap; natively the mask is a no-op.
+ * The bytes of `x` below 32 or equal to 127 — a control byte or DEL, which
+ * `http1TakeLine` stops at — as their high bits: zero when there is none,
+ * and else the lowest set bit is the first such byte's. Two of the bit
+ * tricks of "Bit Twiddling Hacks" (S. E. Anderson, public domain): a byte
+ * below `n` leaves its high bit set in `(x - n * ones) & ~x`, for `n` up to
+ * 128, and `127` is the byte that is zero in `x ^ 127 * ones`. A byte from
+ * 128 up has its high bit set in `x`, so `~x` clears it: obs-text never
+ * matches. A borrow only runs up from a byte that matched, so the bits above
+ * the first match may be false and the lowest is exact, in each mask and so
+ * in their union. Each subtraction is masked to 64 bits because a `u64` is a
+ * BigInt under Node, which does not wrap; natively the mask is a no-op.
  */
-const http1WordHasControl = (x: u64): boolean => {
+const http1ControlBits = (x: u64): u64 => {
   const ones32: u64 = toU64(16843009)
   const ones: u64 = (ones32 << toU64(32)) | ones32
   const low32: u64 = 0xffffffff
@@ -525,7 +527,18 @@ const http1WordHasControl = (x: u64): boolean => {
   const below: u64 = (x - ones * toU64(32)) & all & ~x & high
   const y: u64 = x ^ (ones * toU64(127))
   const del: u64 = (y - ones) & all & ~y & high
-  return (below | del) !== toU64(0)
+  return below | del
+}
+
+/** Which byte of a word `bits`'s lowest set bit is in, 0 to 7; `bits` is not zero. */
+const http1FirstByte = (bits: u64): i32 => {
+  const mask32: u64 = 0xffffffff
+  const lo: u32 = toU32(bits & mask32)
+  if (lo !== toU32(0)) {
+    return (toI32(31) - toI32(Math.clz32(lo & (toU32(0) - lo)))) >> toI32(3)
+  }
+  const hi: u32 = toU32(bits >> toU64(32))
+  return toI32(4) + ((toI32(31) - toI32(Math.clz32(hi & (toU32(0) - hi)))) >> toI32(3))
 }
 
 /**
@@ -585,22 +598,39 @@ const http1TakeLine = (p: Http1Parser, limit: i32, overStatus: i32): i32 => {
   }
   while (i < stop) {
     // Most bytes are printable: sixteen at a time while a whole vector is,
-    // then one at a time, with no test in either loop but the bytes' and the
-    // bound's.
-    while (i >= 0 && i <= stop - 16 && i <= toI32(buf.length) - 16) {
+    // and the vector that is not answers where its first control byte is.
+    // The bytes after a control byte, and a tail shorter than a vector, go
+    // one at a time.
+    let found: boolean = false
+    while (!found && i >= 0 && i <= stop - 16 && i <= toI32(buf.length) - 16) {
       const v: u8x16 = loadU8x16(buf, i)
-      if (http1WordHasControl(http1Lanes(v, 0)) || http1WordHasControl(http1Lanes(v, 8))) {
-        break
+      const low: u64 = http1ControlBits(http1Lanes(v, 0))
+      if (low !== toU64(0)) {
+        i += http1FirstByte(low)
+        found = true
+      } else {
+        const high: u64 = http1ControlBits(http1Lanes(v, 8))
+        if (high !== toU64(0)) {
+          i += 8 + http1FirstByte(high)
+          found = true
+        } else {
+          i += 16
+        }
       }
-      i += 16
     }
-    while (i >= 0 && i < stop && i < toI32(buf.length) && buf[i] >= 32 && buf[i] !== 127) {
+    while (!found && i >= 0 && i < stop && i < toI32(buf.length) && buf[i] >= 32 && buf[i] !== 127) {
       i += 1
     }
     if (i < 0 || i >= stop || i >= toI32(buf.length)) {
       break
     }
-    const c: i32 = toI32(buf[i])
+    let c: i32 = toI32(buf[i])
+    if (c === 13 && i + 1 < stop && i + 1 < toI32(buf.length) && buf[i + 1] === 10) {
+      // CRLF, the end of almost every line: its LF is the next byte, so it
+      // is taken here rather than by another trip through the scan.
+      i += 1
+      c = 10
+    }
     if (c === 10) {
       if (i === p.start || buf[i - 1] !== 13) {
         return http1Fail(p, 400, "a line ended in a bare LF")
@@ -636,9 +666,11 @@ const http1TakeLine = (p: Http1Parser, limit: i32, overStatus: i32): i32 => {
  * `c - 64` and `c - 96` of each: `!` `#`-`'` `*` `+` `-` `.` and the digits
  * in the first (0x03ff6cfa); the upper-case letters, `^` and `_` in the
  * second (0xc7fffffe); `` ` ``, the lower-case letters, `|` and `~` in the
- * third (0x57ffffff). No byte below 33 or above 126 is a tchar. One shift
- * and mask replaces a chain of fourteen comparisons on the parser's hottest
- * path (`bench/techempower`).
+ * third (0x57ffffff). No byte below 33 or above 126 is a tchar.
+ * `http1IsTokenByte` reads them as two 64-bit masks, one for the bytes 0 to
+ * 63 and one for 64 to 127, so the test is a select and a shift with no
+ * branch on the byte: a name or method scan is the parser's hottest loop
+ * after the line scan (`bench/http1-parse`).
  */
 const HTTP1_TCHAR_32: i32 = 67071226
 const HTTP1_TCHAR_64: i32 = -939524098
@@ -646,16 +678,10 @@ const HTTP1_TCHAR_96: i32 = 1476395007
 
 /** Whether `c` is a tchar of RFC 9110 §5.6.2, the bytes a token is made of. */
 export const http1IsTokenByte = (c: i32): boolean => {
-  if (c < 32 || c > 127) {
-    return false
-  }
-  let mask: i32 = HTTP1_TCHAR_96
-  if (c < 64) {
-    mask = HTTP1_TCHAR_32
-  } else if (c < 96) {
-    mask = HTTP1_TCHAR_64
-  }
-  return ((mask >> (c & 31)) & 1) !== 0
+  const low: u64 = toU64(toU32(HTTP1_TCHAR_32)) << toU64(32)
+  const high: u64 = (toU64(toU32(HTTP1_TCHAR_96)) << toU64(32)) | toU64(toU32(HTTP1_TCHAR_64))
+  const word: u64 = c < 64 ? low : high
+  return c >= 0 && c < 128 && ((word >> toU64(c & 63)) & toU64(1)) !== toU64(0)
 }
 
 /** Whether `c` may appear in a field value (RFC 9110 §5.5): HTAB, SP, VCHAR or obs-text. */
@@ -978,9 +1004,30 @@ const http1FieldLine = (p: Http1Parser, keep: boolean): i32 => {
   if (a >= 0 && a < b && (buf[a] === 32 || buf[a] === 9)) {
     return http1Fail(p, 400, "a field line that starts with whitespace (obs-fold)")
   }
+  // A kept line is copied into the head first, and its name is read there,
+  // each upper-case letter lowered as the scan passes it: one walk over the
+  // name, not a check of `buf` and then a second walk of the copy. The copy
+  // of a line refused below is never read, since a refusal ends the parse.
+  let at: i32 = 0
   let i: i32 = a
-  while (i >= 0 && i < b && i < toI32(buf.length) && http1IsTokenByte(toI32(buf[i]))) {
-    i += 1
+  if (keep) {
+    at = http1HeadAppend(p, a, b)
+    const head: u8[] = p.head
+    let k: i32 = at
+    const stop: i32 = at + (b - a)
+    while (k >= 0 && k < stop && k < toI32(head.length)) {
+      const c: i32 = toI32(head[k])
+      if (!http1IsTokenByte(c)) {
+        break
+      }
+      head[k] = toU8(c >= 65 && c <= 90 ? c + 32 : c)
+      k += 1
+    }
+    i = a + (k - at)
+  } else {
+    while (i >= 0 && i < b && i < toI32(buf.length) && http1IsTokenByte(toI32(buf[i]))) {
+      i += 1
+    }
   }
   if (i === a || i >= b || buf[i] !== 58) {
     return http1Fail(p, 400, "a malformed field name")
@@ -1005,13 +1052,6 @@ const http1FieldLine = (p: Http1Parser, keep: boolean): i32 => {
     while (valueEnd > valueStart && valueEnd - 1 >= 0 && http1IsOws(toI32(buf[valueEnd - 1]))) {
       valueEnd -= 1
     }
-    const at: i32 = http1HeadAppend(p, a, b)
-    const head: u8[] = p.head
-    for (let k: i32 = at; k < at + (nameEnd - a) && k < toI32(head.length); k += 1) {
-      if (k >= 0 && head[k] >= 65 && head[k] <= 90) {
-        head[k] = head[k] + 32
-      }
-    }
     const base: i32 = 4 * p.headerCount
     http1SpanSet(p, base + 3, at + (valueEnd - a))
     // The last of the four is set first, so the array has room for them all.

package/std/net/http1-server.ts

@@ -525,28 +525,19 @@ export class Http1OutputPool {
  * `output[outputStart .. outputEnd)` for its carrier to send.
  */
 export class Http1Connection {
-  // References, then 64-bit fields, then 32-bit ones, then flags: the order
-  // the layout packs without padding.
-  config: Http1Config
-  /**
-   * The `Date` every final response carries. The connection makes its own;
-   * `Http1Server` and `Http1TlsServer` put theirs here, so that every slot of a
-   * pool shares one and the pool formats at most once a second. A program may
-   * put another, to share it or to pin its clock.
-   */
-  date: HttpDate
+  // What a request reads and writes comes first, so that `inputRoom`, `feed`,
+  // `next`, `respond`, `write`, `end`, `consume`, `release` and `park` touch
+  // the front of the object: the parser, the output and its pool, the clocks,
+  // the state and the flags. What a WebSocket, an error or a configured cap
+  // needs follows. Within each part the layout packs as widest first does:
+  // the narrow fields of the front end on a 4-byte boundary and the cold
+  // 32-bit fields bring the references behind them to an 8-byte one.
   /**
    * The request parser: its head (`methodIs`, `targetIs`, `header`, spans) is
    * the current request's from its `H1_REQUEST` until its response is done,
    * `H1_END` included, however much of a pipelined request is fed behind it.
    */
   parser: Http1Parser
-  /**
-   * The frame decoder: made when the slot first switches to WebSocket, so a
-   * slot that only ever speaks HTTP never holds its buffers, then kept for
-   * the slot's later peers.
-   */
-  ws: WsDecoder | null
   /**
    * Bytes to send are `output[outputStart .. outputEnd)`. Empty until the
    * connection first needs room to write: then its own buffer, made once, or
@@ -560,27 +551,17 @@ export class Http1Connection {
   /** Where the parser's input and head buffers go while the slot rests, with `Http1Config.idleInput`; null otherwise. */
   inputs: Http1OutputPool | null
   heads: Http1OutputPool | null
-  /** `H1_BODY`'s and `H1_WS_MESSAGE`'s bytes. */
-  data: u8[]
-  /** A ping's payload, kept until its pong fits: empty until the first ping. */
-  pong: u8[]
-  /** No fields, for the responses the connection writes itself: made once. */
-  noFields: u8[][]
+  /**
+   * The `Date` every final response carries. The connection makes its own;
+   * `Http1Server` and `Http1TlsServer` put theirs here, so that every slot of a
+   * pool shares one and the pool formats at most once a second. A program may
+   * put another, to share it or to pin its clock.
+   */
+  date: HttpDate
   /** When the carrier last moved a byte for the connection, in `monotonicNanos`. */
   lastActive: i64 = 0
   /** When the head being read began to arrive, in `monotonicNanos`; meaningful while `headTimed`. */
   headSince: i64 = 0
-  outputStart: i32 = 0
-  outputEnd: i32 = 0
-  dataStart: i32 = 0
-  dataLength: i32 = 0
-  /** `H1_WS_MESSAGE`'s opcode: text or binary. */
-  opcode: i32 = 0
-  /** `H1_ERROR`'s HTTP status or WebSocket close code, or `H1_WS_CLOSE`'s close code. */
-  status: i32 = 0
-  /** The most input the connection buffers, unread: the cap `inputRoom` holds it to. */
-  bufferLimit: i32 = 0
-  pongLength: i32 = 0
   state: i32 = 0
   response: i32 = 0
   /**
@@ -590,12 +571,23 @@ export class Http1Connection {
   responseFraming: i32 = 0
   /** A response with a length: the bytes it still owes. */
   responseLeft: i32 = 0
-  /** The response carries no body (HEAD, 204, 304): what is written is dropped. */
-  responseEmpty: boolean = false
+  outputStart: i32 = 0
+  outputEnd: i32 = 0
+  /**
+   * `output.length`, kept beside the offsets so that `acquire` and `release`
+   * learn whether the connection holds a buffer without reading an array:
+   * the empty one is out of cache by the time a resting connection's next
+   * request comes. Only the connection assigns `output`, and with it this.
+   */
+  outputCap: i32 = 0
+  /** The most input the connection buffers, unread: the cap `inputRoom` holds it to. */
+  bufferLimit: i32 = 0
   /** A request's head has been read and its exchange is not over. */
   requestOpen: boolean = false
   /** The request's body has been read to its end. */
   requestEnded: boolean = false
+  /** The response carries no body (HEAD, 204, 304): what is written is dropped. */
+  responseEmpty: boolean = false
   /** The connection closes once this exchange is over. */
   closeAfter: boolean = false
   /** The program accepted the request's WebSocket handshake. */
@@ -607,6 +599,13 @@ export class Http1Connection {
   inputEnded: boolean = false
   /** A head has begun to arrive and is not read whole yet: `headSince` is its deadline's start. */
   headTimed: boolean = false
+  dataStart: i32 = 0
+  dataLength: i32 = 0
+  /** `H1_WS_MESSAGE`'s opcode: text or binary. */
+  opcode: i32 = 0
+  /** `H1_ERROR`'s HTTP status or WebSocket close code, or `H1_WS_CLOSE`'s close code. */
+  status: i32 = 0
+  pongLength: i32 = 0
   /**
    * The TCP maximum segment size the program sets for this connection, for
    * `respondEncoded` under `HttpCompressor.segmentMode`; 0, the default,
@@ -616,6 +615,19 @@ export class Http1Connection {
   mss: i32 = 0
   /** The MSS `Http1Server.accept` read from this connection's socket (`netMss`), or 0 when it reports none. */
   socketMss: i32 = 0
+  config: Http1Config
+  /**
+   * The frame decoder: made when the slot first switches to WebSocket, so a
+   * slot that only ever speaks HTTP never holds its buffers, then kept for
+   * the slot's later peers.
+   */
+  ws: WsDecoder | null
+  /** `H1_BODY`'s and `H1_WS_MESSAGE`'s bytes. */
+  data: u8[]
+  /** A ping's payload, kept until its pong fits: empty until the first ping. */
+  pong: u8[]
+  /** No fields, for the responses the connection writes itself: made once. */
+  noFields: u8[][]
 
   /** A connection under `config`. A cap outside what the connection can work with panics. */
   constructor(config: Http1Config) {
@@ -759,10 +771,15 @@ export class Http1Connection {
     if (this.writeHeld || this.inputEnded || this.state === H1_S_CLOSING || this.state === H1_S_FAILED) {
       return 0
     }
-    const ws: WsDecoder | null = this.ws
-    const held: i32 =
-      this.state === H1_S_WEBSOCKET && ws !== null ? ws.end - ws.start : this.parser.buffered()
-    const room: i32 = this.inputLimit() - held
+    let room: i32 = 0
+    if (this.state === H1_S_WEBSOCKET) {
+      // Only a WebSocket reads the decoder and the configured message cap,
+      // so a request's check stays on the connection's front fields.
+      const ws: WsDecoder | null = this.ws
+      room = this.inputLimit() - (ws !== null ? ws.end - ws.start : this.parser.buffered())
+    } else {
+      room = this.bufferLimit - this.parser.buffered()
+    }
     return room > 0 ? room : 0
   }
 
@@ -809,11 +826,13 @@ export class Http1Connection {
    * the pool has no free buffer, or for a connection's own, once.
    */
   acquire(): void {
-    if (toI32(this.output.length) > 0) {
+    if (this.outputCap > 0) {
       return
     }
     const pool: Http1OutputPool | null = this.pool
-    this.output = pool !== null ? pool.take() : new Array<u8>(this.config.outputSize)
+    const output: u8[] = pool !== null ? pool.take() : new Array<u8>(this.config.outputSize)
+    this.output = output
+    this.outputCap = toI32(output.length)
     this.outputStart = 0
     this.outputEnd = 0
   }
@@ -825,16 +844,12 @@ export class Http1Connection {
    */
   release(): void {
     const pool: Http1OutputPool | null = this.pool
-    if (
-      pool === null ||
-      toI32(this.output.length) === 0 ||
-      this.outputEnd > this.outputStart ||
-      this.writeHeld
-    ) {
+    if (pool === null || this.outputCap === 0 || this.outputEnd > this.outputStart || this.writeHeld) {
       return
     }
     pool.give(this.output)
     this.output = this.noOutput
+    this.outputCap = 0
     this.outputStart = 0
     this.outputEnd = 0
   }