diff --git a/js/justfile b/js/justfile index b09aea9e954..d71a6cdf9da 100644 --- a/js/justfile +++ b/js/justfile @@ -71,6 +71,11 @@ catalog-bench: bun install --frozen-lockfile bun publish/bench/catalog.ts +# Sweep QMux record decoding over record size x frames per record. +qmux-record-bench: + bun install --frozen-lockfile + bun qmux/bench/record.ts + # Sweep CMAF fragment decode over mdat bytes x declared sample count, including a hostile count. cmaf-bench: bun install --frozen-lockfile diff --git a/js/qmux/bench/record.ts b/js/qmux/bench/record.ts new file mode 100644 index 00000000000..46c893d384b --- /dev/null +++ b/js/qmux/bench/record.ts @@ -0,0 +1,51 @@ +/** + * Sweep QMux record decoding over record size x frames per record. Each frame is a STREAM frame + * whose payload fills its share of the record, an empty STREAM frame, or a MAX_DATA control frame. + * Decoding must cost what the record holds, so time per record stays flat as frames multiply. + */ + +import * as Frame from "../src/frame.ts"; +import * as Stream from "../src/stream.ts"; +import { VarInt } from "../src/varint.ts"; + +const runs = 200; +const id = new Stream.Id(VarInt.from(4n)); + +/** `count` frames that `make` builds, concatenated into one record body. */ +function record(count: number, make: () => Frame.Any): Uint8Array { + const parts = Array.from({ length: count }, () => Frame.encode(make(), "qmux-01")); + const out = new Uint8Array(parts.reduce((sum, part) => sum + part.byteLength, 0)); + let offset = 0; + for (const part of parts) { + out.set(part, offset); + offset += part.byteLength; + } + return out; +} + +function time(body: Uint8Array, count: number): number { + const start = performance.now(); + for (let run = 0; run < runs; run++) { + const frames = Frame.decodeRecord(body); + if (frames.length !== count) throw new Error(`decoded ${frames.length} of ${count} frames`); + } + return ((performance.now() - start) * 1000) / runs; +} + +console.log("record_bytes,kind,frames,us_per_record"); +for (const size of [1_024, 16_380]) { + for (const count of [1, 16, 256]) { + // Four bytes of STREAM header (type, id, two-byte length) per frame. + const payload = new Uint8Array(Math.max(0, Math.floor(size / count) - 4)); + const body = record(count, () => ({ type: "stream", id, data: payload, fin: false })); + console.log(`${body.byteLength},stream,${count},${time(body, count).toFixed(1)}`); + } + for (const [kind, make] of [ + ["empty", (): Frame.Any => ({ type: "stream", id, data: new Uint8Array(0), fin: false })], + ["max_data", (): Frame.Any => ({ type: "max_data", max: 1n << 20n })], + ] as const) { + const one = Frame.encode(make(), "qmux-01").byteLength; + const count = Math.floor(size / one); + console.log(`${size},${kind},${count},${time(record(count, make), count).toFixed(1)}`); + } +} diff --git a/js/qmux/src/frame.test.ts b/js/qmux/src/frame.test.ts index 8a2f8445462..2f5e06c69d1 100644 --- a/js/qmux/src/frame.test.ts +++ b/js/qmux/src/frame.test.ts @@ -382,3 +382,57 @@ describe("maxStreamPayload", () => { // stream ID come out of the budget. }); }); + +describe("record decoding cost", () => { + /** The bytes `Uint8Array.prototype.slice` copies while `run` runs. */ + function copied(run: () => void): number { + const slice = Uint8Array.prototype.slice; + let bytes = 0; + Uint8Array.prototype.slice = function (this: Uint8Array, ...args: [number?, number?]) { + const out = slice.apply(this, args); + bytes += out.byteLength; + return out; + } as typeof slice; + try { + run(); + } finally { + Uint8Array.prototype.slice = slice; + } + return bytes; + } + + /** A record of `count` copies of one encoded frame. */ + function record(frame: Frame.Any, count: number): Uint8Array { + const one = Frame.encode(frame, "qmux-01"); + const out = new Uint8Array(one.byteLength * count); + for (let i = 0; i < count; i++) out.set(one, i * one.byteLength); + return out; + } + + const id = new Stream.Id(VarInt.from(4n)); + + test("decoding copies each payload once, however many frames follow it", () => { + // The largest default record of empty STREAM frames: each frame's remainder used to be + // copied, about 45 MB for this one record. + const empty = record({ type: "stream", id, data: new Uint8Array(0), fin: false }, 5_460); + let frames: Frame.Any[] = []; + expect(copied(() => (frames = Frame.decodeRecord(empty)))).toBe(0); + expect(frames.length).toBe(5_460); + + const payloads = record({ type: "stream", id, data: new Uint8Array(32).fill(7), fin: false }, 400); + expect(copied(() => Frame.decodeRecord(payloads))).toBe(400 * 32); + }); + + test("a retained payload does not alias its record", () => { + const body = record({ type: "stream", id, data: new Uint8Array([1]), fin: false }, 2); + const [first] = Frame.decodeRecord(body); + if (first.type !== "stream") throw new Error("expected a stream frame"); + expect(first.data.buffer).not.toBe(body.buffer); + expect(first.data.buffer.byteLength).toBe(1); + }); + + test("a truncated length is still refused", () => { + const one = Frame.encode({ type: "stream", id, data: new Uint8Array(8), fin: false }, "qmux-01"); + expect(() => Frame.decodeRecord(one.subarray(0, one.byteLength - 1))).toThrow("frame truncated"); + }); +}); diff --git a/js/qmux/src/frame.ts b/js/qmux/src/frame.ts index ad45ef6a339..12ab8c0bd47 100644 --- a/js/qmux/src/frame.ts +++ b/js/qmux/src/frame.ts @@ -530,8 +530,8 @@ function decodeTransportParams(buffer: Uint8Array): TransportParams { throw new Error("transport parameter truncated"); } - const paramData = buffer.slice(0, len); - buffer = buffer.slice(len); + let paramData: Uint8Array; + [paramData, buffer] = take(buffer, len); // A repeated recognized parameter is a protocol error (mirrors Rust's // DuplicateParam). Unknown IDs fall through and may repeat. @@ -619,17 +619,29 @@ export function decode(buffer: Uint8Array, _version: WireFormat): Any | null { return decodeQMux(buffer); } -/** Slice `len` bytes off the front of `buffer`, rejecting truncated input. +/** Split `len` bytes off the front of `buffer`, rejecting truncated input. * - * `Uint8Array.slice` clamps to the buffer end and silently returns short data, + * `Uint8Array.subarray` clamps to the buffer end and silently returns short data, * which is the wrong behavior for parsing length-prefixed wire formats. Use * `take` at every site that reads a varint-declared payload length. + * + * Both halves are views of `buffer`, so splitting a record frame by frame copies + * nothing. A payload that outlives the record is copied by {@link own}. */ function take(buffer: Uint8Array, len: number): [Uint8Array, Uint8Array] { if (buffer.byteLength < len) { throw new Error(`frame truncated: need ${len} bytes, have ${buffer.byteLength}`); } - return [buffer.slice(0, len), buffer.slice(len)]; + return [buffer.subarray(0, len), buffer.subarray(len)]; +} + +/** A copy of a payload the session retains past the record it arrived in. + * + * A view would keep the whole record alive behind it, so a tiny frame could pin + * a record many times its size against credit that counts only the frame. + */ +function own(payload: Uint8Array): Uint8Array { + return payload.slice(); } /** Decode all frames from a QMux Record payload (draft-01). @@ -650,197 +662,7 @@ export function decodeRecord(buffer: Uint8Array): Any[] { } function decodeQMux(buffer: Uint8Array): Any | null { - let v: VarInt; - - [v, buffer] = VarInt.decode(buffer); - const frameType = v.value; - - // PADDING - if (frameType === 0x00n) { - return null; - } - - // STREAM frames: 0x08-0x0f - if (frameType >= 0x08n && frameType <= 0x0fn) { - const hasOff = (frameType & 0x04n) !== 0n; - const hasLen = (frameType & 0x02n) !== 0n; - const hasFin = (frameType & 0x01n) !== 0n; - - [v, buffer] = VarInt.decode(buffer); - const id = new Stream.Id(v); - - let offset: bigint | undefined; - if (hasOff) { - [v, buffer] = VarInt.decode(buffer); - offset = v.value; - } - - let data: Uint8Array; - if (hasLen) { - [v, buffer] = VarInt.decode(buffer); - const len = Number(v.value); - [data, buffer] = take(buffer, len); - } else { - data = buffer; - } - - return { type: "stream", id, offset, data, fin: hasFin }; - } - - // RESET_STREAM - if (frameType === 0x04n) { - [v, buffer] = VarInt.decode(buffer); - const id = new Stream.Id(v); - - [v, buffer] = VarInt.decode(buffer); - const code = v; - - [v, buffer] = VarInt.decode(buffer); - const finalSize = v.value; - - return { type: "reset_stream", id, code, finalSize }; - } - - // RESET_STREAM_AT (draft-02): a reset that still delivers its first - // reliable_size bytes. reliable_size > final_size is a FRAME_ENCODING_ERROR. - if (frameType === RESET_STREAM_AT) { - [v, buffer] = VarInt.decode(buffer); - const id = new Stream.Id(v); - [v, buffer] = VarInt.decode(buffer); - const code = v; - [v, buffer] = VarInt.decode(buffer); - const finalSize = v.value; - [v, buffer] = VarInt.decode(buffer); - const reliableSize = v.value; - if (reliableSize > finalSize) { - throw new Error("RESET_STREAM_AT reliable_size exceeds final_size"); - } - return { type: "reset_stream", id, code, finalSize, reliableSize }; - } - - // STOP_SENDING - if (frameType === 0x05n) { - [v, buffer] = VarInt.decode(buffer); - const id = new Stream.Id(v); - - [v, buffer] = VarInt.decode(buffer); - const code = v; - - return { type: "stop_sending", id, code }; - } - - // CONNECTION_CLOSE / APPLICATION_CLOSE - if (frameType === 0x1cn || frameType === 0x1dn) { - [v, buffer] = VarInt.decode(buffer); - const code = v; - - // The Frame Type field is present only for CONNECTION_CLOSE (0x1c); - // APPLICATION_CLOSE (0x1d) omits it (RFC 9000 §19.19). - if (frameType === 0x1cn) { - [v, buffer] = VarInt.decode(buffer); - } - - // reason_length + reason - [v, buffer] = VarInt.decode(buffer); - const reasonLen = Number(v.value); - let reasonBytes: Uint8Array; - [reasonBytes, buffer] = take(buffer, reasonLen); - const reason = new TextDecoder().decode(reasonBytes); - - return frameType === 0x1dn - ? { type: "application_close", code, reason } - : { type: "connection_close", code, reason }; - } - - // MAX_DATA - if (frameType === 0x10n) { - [v, buffer] = VarInt.decode(buffer); - return { type: "max_data", max: v.value }; - } - - // MAX_STREAM_DATA - if (frameType === 0x11n) { - [v, buffer] = VarInt.decode(buffer); - const id = new Stream.Id(v); - [v, buffer] = VarInt.decode(buffer); - return { type: "max_stream_data", id, max: v.value }; - } - - // MAX_STREAMS (bidi) - if (frameType === 0x12n) { - [v, buffer] = VarInt.decode(buffer); - return { type: "max_streams_bidi", max: v.value }; - } - - // MAX_STREAMS (uni) - if (frameType === 0x13n) { - [v, buffer] = VarInt.decode(buffer); - return { type: "max_streams_uni", max: v.value }; - } - - // DATA_BLOCKED - if (frameType === 0x14n) { - [v, buffer] = VarInt.decode(buffer); - return { type: "data_blocked", limit: v.value }; - } - - // STREAM_DATA_BLOCKED - if (frameType === 0x15n) { - [v, buffer] = VarInt.decode(buffer); - const id = new Stream.Id(v); - [v, buffer] = VarInt.decode(buffer); - return { type: "stream_data_blocked", id, limit: v.value }; - } - - // STREAMS_BLOCKED (bidi) - if (frameType === 0x16n) { - [v, buffer] = VarInt.decode(buffer); - return { type: "streams_blocked_bidi", limit: v.value }; - } - - // STREAMS_BLOCKED (uni) - if (frameType === 0x17n) { - [v, buffer] = VarInt.decode(buffer); - return { type: "streams_blocked_uni", limit: v.value }; - } - - // QX_TRANSPORT_PARAMETERS - if (frameType === 0x3f5153300d0a0d0an) { - [v, buffer] = VarInt.decode(buffer); - const len = Number(v.value); - let payload: Uint8Array; - [payload, buffer] = take(buffer, len); - const params = decodeTransportParams(payload); - return { type: "transport_parameters", params }; - } - - // QX_PING request - if (frameType === QX_PING_REQUEST) { - [v, buffer] = VarInt.decode(buffer); - return { type: "ping_request", sequence: v.value }; - } - - // QX_PING response - if (frameType === QX_PING_RESPONSE) { - [v, buffer] = VarInt.decode(buffer); - return { type: "ping_response", sequence: v.value }; - } - - // DATAGRAM without length — payload runs to the end of the record - if (frameType === 0x30n) { - return { type: "datagram", data: buffer, lengthPrefixed: false }; - } - - // DATAGRAM with length - if (frameType === 0x31n) { - [v, buffer] = VarInt.decode(buffer); - const len = Number(v.value); - let data: Uint8Array; - [data, buffer] = take(buffer, len); - return { type: "datagram", data, lengthPrefixed: true }; - } - - throw new Error(`Invalid QMux frame type: 0x${frameType.toString(16)}`); + return decodeQMuxOne(buffer)?.[0] ?? null; } /** Decode a single QMux frame, returning the frame and remaining buffer. @@ -876,14 +698,12 @@ function decodeQMuxOne(buffer: Uint8Array): [Any | null, Uint8Array] | null { let data: Uint8Array; if (hasLen) { [v, buffer] = VarInt.decode(buffer); - const len = Number(v.value); - [data, buffer] = take(buffer, len); + [data, buffer] = take(buffer, Number(v.value)); } else { - data = buffer; - buffer = buffer.slice(buffer.byteLength); + [data, buffer] = take(buffer, buffer.byteLength); } - return [{ type: "stream", id, offset, data, fin: hasFin }, buffer]; + return [{ type: "stream", id, offset, data: own(data), fin: hasFin }, buffer]; } // RESET_STREAM @@ -897,7 +717,8 @@ function decodeQMuxOne(buffer: Uint8Array): [Any | null, Uint8Array] | null { return [{ type: "reset_stream", id, code, finalSize }, buffer]; } - // RESET_STREAM_AT (draft-02); see the single-frame decoder for the semantics. + // RESET_STREAM_AT (draft-02): a reset that still delivers its first + // reliable_size bytes. reliable_size > final_size is a FRAME_ENCODING_ERROR. if (frameType === RESET_STREAM_AT) { [v, buffer] = VarInt.decode(buffer); const id = new Stream.Id(v); @@ -1018,17 +839,16 @@ function decodeQMuxOne(buffer: Uint8Array): [Any | null, Uint8Array] | null { // DATAGRAM without length — payload runs to the end of the record if (frameType === 0x30n) { - const data = buffer; - return [{ type: "datagram", data, lengthPrefixed: false }, buffer.slice(buffer.byteLength)]; + const [data, rest] = take(buffer, buffer.byteLength); + return [{ type: "datagram", data: own(data), lengthPrefixed: false }, rest]; } // DATAGRAM with length if (frameType === 0x31n) { [v, buffer] = VarInt.decode(buffer); - const len = Number(v.value); let data: Uint8Array; - [data, buffer] = take(buffer, len); - return [{ type: "datagram", data, lengthPrefixed: true }, buffer]; + [data, buffer] = take(buffer, Number(v.value)); + return [{ type: "datagram", data: own(data), lengthPrefixed: true }, buffer]; } throw new Error(`Invalid QMux frame type: 0x${frameType.toString(16)}`); diff --git a/quest/m1/release-audit/README.md b/quest/m1/release-audit/README.md index c82fdc9b53d..482dfacb529 100644 --- a/quest/m1/release-audit/README.md +++ b/quest/m1/release-audit/README.md @@ -95,7 +95,6 @@ child records whether its behavior is new on main or inherited from release. - [Review HLS admission](/quest/m1/release-audit/hls-admission.md) - resolve the security-sensitive resource-boundary review before the cut - [Bound decoded datagram retention](/quest/m1/release-audit/datagram-memory.md) - shared ownership accounts for retained plain and compressed payloads across tracks - [Decode order](/quest/m1/ts-reliability/decode-order.md) - the exporters' decode clock holds at most the declared reorder depth, so flat timestamps cannot bypass MKV/TS backpressure or cause quadratic draining -- [Parse QMux records without copying suffixes](/quest/m1/release-audit/qmux-copy.md) - many small frames do not cause quadratic copying - [Release AUTH wake listeners](/quest/m1/release-audit/auth-listeners.md) - session churn does not retain one terminal promise reaction per change - [Finish bitrate recovery](/quest/m1/release-audit/rate-recovery.md) - a quiet bandwidth grant no longer strands moq-video, moq-ffi, and moq-c encoders partway up the ramp - [Retire expiry metadata](/quest/m1/release-audit/expiry-index.md) - empty deadline entries do not accumulate with historical read budgets diff --git a/quest/m1/release-audit/qmux-copy.md b/quest/m1/release-audit/qmux-copy.md deleted file mode 100644 index e5c9db99f01..00000000000 --- a/quest/m1/release-audit/qmux-copy.md +++ /dev/null @@ -1,30 +0,0 @@ -# [M] Parse QMux records without copying each remaining suffix - -## Goal - -QMux record decoding does work proportional to bytes and frames rather than -repeatedly copying the entire unparsed suffix. Retaining a small frame must -also not unnecessarily pin a large record allocation. - -## Plan - -P2 performance/resource issue at main 6369eca. -`js/qmux/src/frame.ts::take` clones both the requested payload and remaining -buffer. `decodeRecord` repeats this for each frame, even empty STREAM frames. -A legal 16,380-byte record containing 5,460 empty STREAM frames caused -44,709,210 copied bytes before dispatch, measured by instrumenting -`Uint8Array.slice` around the real decoder. Smaller records of 1,023 and -4,095 bytes copied 173,910 and 2,792,790 bytes. The largest took about 10.9ms -on the audit host; deterministic copied-byte growth is the evidence, not -that machine's timing. Empty frames on an existing stream need no data credit. - -The in-tree implementation is new since release. Release used the external -`@moq/qmux` package, whose old source was not compared, so this is not a -demonstrated main-only regression. - -Use a cursor/view for parsing and make payload ownership explicit at the -retention boundary. Check every frame variant using the shared helper. -Benchmark record size and frame count independently, including empty/control -frames, truncated lengths, and retained tiny payloads. The current consumers -are QMux WebSocket fallback receive loops. No public API or wire change is -expected. diff --git a/sh/gh/nightly.sh b/sh/gh/nightly.sh index 76d4251ffb6..9850b042645 100755 --- a/sh/gh/nightly.sh +++ b/sh/gh/nightly.sh @@ -134,6 +134,7 @@ case "$1" in javascript "$benchmark" just js bench "$benchmark" done javascript catalog just js catalog-bench + javascript qmux-record just js qmux-record-bench javascript cmaf just js cmaf-bench javascript arrivals just js arrivals-bench javascript p2p just js p2p-bench