@torrent-tv/proxy 2.97.12 → 2.97.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.97.12",
+  "version": "2.97.13",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/server.js

@@ -716,10 +716,7 @@ export async function startProxyServer({
         if (original) {
           const ranges = await containerOrchestrator.inspect(params, "source-ranges");
           if (ranges.kind !== "result") return ranges;
-          // The torrent's piece is the unit its stretch is copied in, so a copy
-          // nobody needs any more stops at the next piece (`OriginalInput.js`).
           sources.push({ sourceKey: params.sourceKey, fileIndex, timeShiftSeconds,
-            pieceLength: torrentPool.knownTorrent(params.sourceKey)?.pieceLength ?? null,
             input: { ...ranges.value, original: true, selections: wanted.map(track => ({ track,
               index: track.declaredIndex ?? choices.find(choice => choice.type === track.type)?.index ?? 0 })) } });
           continue;

package/services/encode/EncodeInputs.js

@@ -208,7 +208,7 @@ export class EncodeInputs {
       this.#requests.delete(key);
       this.#wanted.delete(key);
       // A copy already answered may still be copying its stretch; released,
-      // it stops at the next piece.
+      // the stretch is dropped when its read returns.
       request.result?.release?.();
     }
     this.#retryMemory();

package/services/encode/OriginalInput.js

@@ -61,29 +61,17 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
     let released = false;
     let failed = false;
     retained = true;
-    // A stretch is copied one piece of the torrent at a time, so a release
-    // stops it at the next piece: the thread it is copied on serves every other
-    // read too, and a copy nobody will use went on to its end (torrent-tv/meta#178).
-    const copyLater = async job => {
-      const { source } = job.entry;
-      const [first, last] = source.input.ranges[job.position];
-      const unit = Number(source.pieceLength) > 0 ? Number(source.pieceLength) : last - first + 1;
-      const target = Buffer.allocUnsafeSlow(last - first + 1);
-      try {
-        for (let at = first; at <= last; at += unit) {
-          if (released) return false;
-          const buffers = await read(source, [[at, Math.min(last, at + unit - 1)]]);
-          if (buffers === null) { failed = true; return false; }
-          buffers[0].copy(target, at - first);
-        }
-      } catch {
-        failed = true;
-        return false;
-      }
+    // ONE READ FOR THE STRETCH. Copied a torrent piece per read (2.97.12), a
+    // stretch took 33.1 s for 83.9 MB on the field's AVI against 126.5 MB in
+    // 16.3 s as one read beside another copy (torrent-tv/meta#178): each read
+    // waits its turn on two busy threads, and the stretch paid that once per
+    // piece. A release therefore discards the stretch when its read returns.
+    const copyLater = job => read(job.entry.source, [job.entry.source.input.ranges[job.position]]).then(buffers => {
+      if (buffers === null) { failed = true; return false; }
       if (released) return false;
-      job.entry.buffers[job.position] = target;
+      job.entry.buffers[job.position] = buffers[0];
       return true;
-    };
+    }, () => { failed = true; return false; });
     // The stretches, one source after another: they share one reader, and the
     // first source's stretch is the one FFmpeg reaches first.
     const whole = (async () => {

package/services/encode/quality/HostLoad.js

@@ -8,6 +8,7 @@
  */
 
 import os from "node:os";
+import { monitorEventLoopDelay } from "node:perf_hooks";
 import { logger } from "../../../utils/logger.js";
 import { availableShareFrom } from "../available-share.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "../torrent-cost.js";
@@ -15,6 +16,24 @@ import { medianOf, movedBeyondScatter, READINGS_KEPT, scatterOf } from "../learn
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode-run-state.js";
 import { SourceFiles } from "../../media/SourceFile.js";
 
+/**
+ * What the torrent thread says of itself over one interval: how late its event
+ * loop ran, and how long reads for readers took inside it, from a command's
+ * arrival to its answer (torrent-tv/meta#178). Empty where it says nothing.
+ *
+ * @param {{ readerMs: number | null, readerReads: number | null, loopP99Ms: number | null, loopMaxMs: number | null }} now
+ * @param {{ readerMs: number | null, readerReads: number | null }} previous
+ * @returns {string}
+ */
+function threadSays(now, previous) {
+  const loop = Number.isFinite(now.loopP99Ms) && Number.isFinite(now.loopMaxMs)
+    ? `; its loop late p99=${Math.round(now.loopP99Ms)}ms max=${Math.round(now.loopMaxMs)}ms` : "";
+  const reads = Number.isFinite(now.readerReads) && Number.isFinite(previous.readerReads) && now.readerReads > previous.readerReads
+    && Number.isFinite(now.readerMs) && Number.isFinite(previous.readerMs)
+    ? `; ${now.readerReads - previous.readerReads} read(s) for readers took ${Math.round(now.readerMs - previous.readerMs)}ms in it` : "";
+  return loop + reads;
+}
+
 export class HostLoad {
   /** What this reads and asks of the rest of the proxy, and nothing else. @type {object} */
   #host;
@@ -35,6 +54,8 @@ export class HostLoad {
 
   /** The previous reading of the torrent thread's processor and the bytes downloaded. */
   #torrentSample = null;
+  /** This thread's event-loop lateness, begun at the first machine reading. */
+  #mainLoop = null;
 
   /** A reading of the torrent thread is under way; it asks the worker, which may not answer. */
   #readingTorrent = false;
@@ -186,6 +207,10 @@ export class HostLoad {
         uploaded: totals?.uploaded ?? null,
         served: totals?.served ?? null,
         threadCpuSeconds: totals?.threadCpuSeconds ?? null,
+        readerMs: totals?.readerMs ?? null,
+        readerReads: totals?.readerReads ?? null,
+        loopP99Ms: totals?.loopP99Ms ?? null,
+        loopMaxMs: totals?.loopMaxMs ?? null,
         metadata: this.#host.readMetadataActivity?.()
       };
       this.#learnThreadCost(now);
@@ -241,7 +266,7 @@ export class HostLoad {
         `torrent: downloaded ${(megabytes / elapsedSec).toFixed(2)} MB/s, sent to peers ${rateOf("uploaded")}, ` +
         `handed to readers ${rateOf("served")} over ${elapsedSec.toFixed(1)}s, ` +
         `limit ${Number.isFinite(limit) ? `${(limit / 1e6).toFixed(2)} MB/s` : "none"}; ` +
-        `its thread drew ${Math.round(cpuSeconds / elapsedSec * 100)}% of the machine`
+        `its thread drew ${Math.round(cpuSeconds / elapsedSec * 100)}% of the machine` + threadSays(now, previous)
       );
     }
     if (megabytes === 0) {
@@ -456,7 +481,8 @@ export class HostLoad {
     try {
       const totals = await this.#host.getTorrentTotals();
       const read = (key) => { const value = Number(totals?.[key]); return Number.isFinite(value) ? value : null; };
-      return { downloaded: read("downloaded"), uploaded: read("uploaded"), served: read("served"), threadCpuSeconds: read("threadCpuSeconds") };
+      return { downloaded: read("downloaded"), uploaded: read("uploaded"), served: read("served"), threadCpuSeconds: read("threadCpuSeconds"),
+        readerMs: read("readerMs"), readerReads: read("readerReads"), loopP99Ms: read("loopP99Ms"), loopMaxMs: read("loopMaxMs") };
     } catch {
       return null; // the pool is busy or gone; a reading missed is not a fault
     }
@@ -525,6 +551,16 @@ export class HostLoad {
    */
   async #sayMachine(share, proxyShare, running, suspended) {
     const machine = await this.#host.readMachineState();
+    // HOW LATE THIS THREAD'S LOOP RAN over the interval: every answer to FFmpeg
+    // and every hand-over of a copy waits for it (torrent-tv/meta#178). Begun at
+    // the first reading, so a check that never reads the machine starts no timer.
+    if (!this.#mainLoop) {
+      this.#mainLoop = monitorEventLoopDelay({ resolution: 20 });
+      this.#mainLoop.enable();
+    }
+    const late = this.#mainLoop.count > 0
+      ? ` loop p99=${Math.round(this.#mainLoop.percentile(99) / 1e6)}ms max=${Math.round(this.#mainLoop.max / 1e6)}ms` : "";
+    this.#mainLoop.reset();
     const asPercent = (value) => (value === null || value === undefined ? "n/a" : `${Math.round(value * 100)}%`);
     const free = Number.isFinite(share.systemShare) ? Math.max(0, 1 - share.systemShare) : null;
     logger.info(
@@ -536,7 +572,7 @@ export class HostLoad {
       ` over=${share.elapsedSec.toFixed(1)}s` +
       // What the offer will multiply a prediction by, in the same line as the
       // readings it comes from.
-      ` available=${asPercent(this.hostAvailability.share)} free=${asPercent(free)}`
+      ` available=${asPercent(this.hostAvailability.share)} free=${asPercent(free)}` + late
     );
   }
 

package/services/torrent/worker/held-bytes.js

@@ -167,7 +167,7 @@ export async function readHeldBytes(torrent, fileIndex, start, end, logger = nul
 const missingSaid = new WeakMap();
 
 /** Acquire every input piece before copying any of the segment's ranges. */
-export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logger = null) {
+export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logger = null, onRead = null) {
   const file = torrent?.files?.[fileIndex];
   const pieceLength = Number(torrent?.pieceLength);
   const store = pieceStoreOf(torrent);
@@ -223,6 +223,7 @@ export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logge
         });
       });
       if (!buffer || buffer.length !== length) return null;
+      onRead?.(length);
       for (const { rangeIndex, absoluteStart, absoluteEnd } of span.ranges) {
         const from = Math.max(absoluteStart, pieceStart);
         const to = Math.min(absoluteEnd, pieceStart + pieceLength - 1);

package/services/torrent/worker/worker.js

@@ -23,6 +23,7 @@
 import { isUsableTorrentHandle, requireCurrentTorrent } from "./handle-state.js";
 import "./install-webrtc-shim.js";
 import { parentPort, workerData } from "node:worker_threads";
+import { monitorEventLoopDelay, performance } from "node:perf_hooks";
 import { Readable } from "node:stream";
 import { heldFileBytes } from "./held-file-bytes.js";
 import { createSendStream } from "./channel.js";
@@ -108,6 +109,18 @@ const openReads = new Map();
  */
 let servedBytes = 0;
 
+/**
+ * How long reads for readers took inside this thread, from the command's
+ * arrival to its answer, and how many there were; and how late this thread's
+ * event loop ran. A copy for an encoder took 16.3 s for 126.5 MB as one read
+ * and 33.1 s for 83.9 MB as one read per piece on the field's AVI, and nothing
+ * said whether the time was spent here or on the way (torrent-tv/meta#178).
+ */
+let readerMs = 0;
+let readerReads = 0;
+const loopDelay = monitorEventLoopDelay({ resolution: 20 });
+loopDelay.enable();
+
 /**
  * Shorthand for this file. The same path as `logger.info` anywhere else in the
  * thread — kept only because it reads better at the hundred call sites here.
@@ -432,7 +445,12 @@ async function runCommand(command, params, id) {
       // bytes, so the price of a downloaded byte is taken over one interval
       // whether or not anything encodes (torrent-tv/meta#178).
       const usage = process.threadCpuUsage();
-      return { downloaded, uploaded, served: servedBytes, threadCpuSeconds: (usage.user + usage.system) / 1e6 };
+      // The loop's lateness over the interval since the last reading, in ms.
+      const loopP99Ms = loopDelay.count > 0 ? loopDelay.percentile(99) / 1e6 : null;
+      const loopMaxMs = loopDelay.count > 0 ? loopDelay.max / 1e6 : null;
+      loopDelay.reset();
+      return { downloaded, uploaded, served: servedBytes, threadCpuSeconds: (usage.user + usage.system) / 1e6,
+        readerMs, readerReads, loopP99Ms, loopMaxMs };
     }
 
 
@@ -528,8 +546,11 @@ async function runCommand(command, params, id) {
     case Command.READ_HELD: {
       const known = resolvedTorrents.get(params.sourceKey);
       const torrent = isUsableTorrentHandle(known) ? known : null;
+      const startedAt = performance.now();
       const bytes = await readWhileInUse(openReads, id, torrent, params.fileIndex,
         () => readHeldBytes(torrent, params.fileIndex, params.start, params.end, logger));
+      readerMs += performance.now() - startedAt;
+      readerReads += 1;
       servedBytes += bytes?.length ?? 0;
       return { bytes };
     }
@@ -537,9 +558,13 @@ async function runCommand(command, params, id) {
     case Command.READ_HELD_RANGES: {
       const known = resolvedTorrents.get(params.sourceKey);
       const torrent = isUsableTorrentHandle(known) ? known : null;
+      const startedAt = performance.now();
+      // Counted as each piece is read, so a long copy lands in the intervals
+      // it was made in rather than in the one it ended in.
       const buffers = await readWhileInUse(openReads, id, torrent, params.fileIndex,
-        () => readHeldRanges(torrent, params.fileIndex, params.ranges, params.maxBytes, logger));
-      for (const buffer of buffers ?? []) servedBytes += buffer?.length ?? 0;
+        () => readHeldRanges(torrent, params.fileIndex, params.ranges, params.maxBytes, logger, (length) => { servedBytes += length; }));
+      readerMs += performance.now() - startedAt;
+      readerReads += 1;
       return { buffers };
     }