@torrent-tv/proxy 2.98.10 → 2.98.12

package/package.json

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

package/services/encode/EncodeInputs.js

@@ -28,6 +28,8 @@ export class EncodeInputs {
   /** Whether an output's last resolved input was its original file. @type {WeakMap<object, boolean>} */
   #original = new WeakMap();
   #revision = 0;
+  /** Output → how long its last input took to be ready, ms. @type {WeakMap<object, number>} */
+  #preparedIn = new WeakMap();
   #memoryRevision = 0;
   #held = 0;
   #allowed = 0;
@@ -270,6 +272,18 @@ export class EncodeInputs {
    * @param {{ sourceKey: string, ranges: Array<{ fileIndex: number, start: number, end: number }> } | null} [arrived] -
    *   The bytes that arrived, inclusive, when the event names them.
    */
+  /**
+   * How long this output's last input took from being asked for to being
+   * ready, in milliseconds, or null before one was: the time a run gives the
+   * input after it to be prepared in (`EncodeRuns`).
+   *
+   * @param {object} output
+   * @returns {number | null}
+   */
+  preparationMsOf(output) {
+    return this.#preparedIn.get(output) ?? null;
+  }
+
   bytesChanged(arrived = null) {
     this.#revision++;
     for (const request of this.#requests.values()) {
@@ -376,6 +390,7 @@ export class EncodeInputs {
       // is commanded over its prefix.
       if (result.kind === "result" && result.to > request.to) result.to = Math.max(request.from, request.to);
       request.result = result;
+      if (result.kind === "result") this.#preparedIn.set(request.output, this.#now() - request.timing.askedAt);
       this.#note(request, result.kind === "result" ? `ready #${result.from}..#${result.to}, ${result.bytes ?? "?"} bytes` +
         (Number.isFinite(result.copyMs) ? (result.deferredBytes > 0
           ? `, opening part copied in ${result.copyMs}ms, ${result.deferredBytes} bytes of the stretch copied while the run opens`

package/services/encode/EncodePlan.js

@@ -362,6 +362,26 @@ export function planEncoders({
   const decided = new Map();
   const room = Math.max(0, maxRuns - live.length);
   const refetchPerSegment = segmentSeconds * refetchSecPerFilmSecond;
+  // WHAT "NEVER" IS, ONE FIGURE FOR EVERY ARRANGEMENT THIS PASS COMPARES: later
+  // than any encoder here can reach the last wanted number — the film's length,
+  // a start and a stop, the whole wanted stretch at the slowest rate any
+  // arrangement can run at, and every piece fetched again. Capped at the film's
+  // length instead, a slow encoder's arrival scored as never; and worked out
+  // from each arrangement's own encoders, the arrangement without an encoder
+  // had a smaller never than the one with it. Either way an encoder making the
+  // film behind the viewer at 0.57x scored no better than none, and the plan
+  // stopped it before its first piece, then started it again when the speed
+  // read 1.9x — thirteen times in three minutes on Home Assistant, each start
+  // copying 108-122 MB of input (r37, torrent-tv/meta#178).
+  const neverSec = (() => {
+    const first = Math.min(...wanted.map((span) => span.from));
+    const last = Math.max(...wanted.map((span) => span.to));
+    const film = (last + 1) * segmentSeconds;
+    const slowest = rate / contentionPenaltyFor(Math.max(maxRuns, live.length));
+    if (!(slowest > 0) || !Number.isFinite(film)) return film;
+    return film + firstByteWaitSec + killCostSec + (last - first + 2) / slowest +
+      (last - first + 1) * refetchPerSegment + segmentSeconds;
+  })();
 
   let arrangements = [{ fill: [], used: new Set(), fresh: 0 }];
   for (let index = 0; index < positions.length; index += 1) {
@@ -441,7 +461,7 @@ export function planEncoders({
           : (piece) => finishesItsPieceIn(run, piece)
       });
     }
-    const scored = latenessOf(priced(encoders), coverage, wanted, untilNeeded, rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds);
+    const scored = latenessOf(priced(encoders), coverage, wanted, untilNeeded, rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds, neverSec);
     if (bestScore === null || cheaperThan(scored, bestScore)) {
       bestScore = scored;
       best = arrangement;
@@ -492,7 +512,7 @@ export function planEncoders({
   const scoreOf = (override) => {
     const encoders = encodersOf(override);
     return latenessOf(encoders, coverage, wanted, untilNeeded,
-      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds);
+      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds, neverSec);
   };
   for (const run of live) {
     if (placement.has(run)) {
@@ -519,7 +539,7 @@ export function planEncoders({
     const kept = encodersOf(new Map());
     const without = encodersOf(new Map([[run, null]]));
     const scoreOf_ = (encoders) => latenessOf(encoders, coverage, wanted, untilNeeded,
-      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds);
+      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds, neverSec);
     return cheaperThan(scoreOf_(kept), scoreOf_(without));
   };
 
@@ -586,7 +606,7 @@ export function planEncoders({
         continue;
       }
       const without = latenessOf(encodersOf(new Map([[run, null]])), coverage, wanted, untilNeeded,
-        rate / contentionPenaltyFor(Math.max(0, live.length - 2)), refetchPerSegment, segmentSeconds);
+        rate / contentionPenaltyFor(Math.max(0, live.length - 2)), refetchPerSegment, segmentSeconds, neverSec);
       if (cheapestScore === null || cheaperThan(without, cheapestScore)) {
         cheapestScore = without;
         cheapest = run;
@@ -751,13 +771,14 @@ function ranksOf(wanted, first, last) {
   return rankAt;
 }
 
-function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPerSegment, segmentSeconds) {
+function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPerSegment, segmentSeconds, neverSec = null) {
   const first = Math.min(...wanted.map((span) => span.from));
   const last = Math.max(...wanted.map((span) => span.to));
-  // What a number nobody reaches at all counts as. The film's own length is the
-  // honest bound — nothing can be later than never — and a finite figure is what
-  // lets two hopeless arrangements still be told apart by the rest of the sum.
-  const never = (last + 1) * segmentSeconds;
+  // What a number nobody reaches at all counts as: one figure for every
+  // arrangement the plan compares, later than any arrival (`neverSec` in
+  // `planEncoders`), and finite, so two hopeless arrangements are still told
+  // apart by the rest of the sum. Without it, the film's own length.
+  const never = Number.isFinite(neverSec) ? neverSec : (last + 1) * segmentSeconds;
 
   // WHICH SIDE OF THE VIEWERS a piece is on. The map states it; nothing here
   // works it out from positions, and nothing here knows where a viewer stands.
@@ -876,7 +897,7 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
     // gives. It is a definition rather than a guard: it also makes the score
     // total on a host whose startup measured nothing at all, where every arrival
     // is beyond reckoning and every arrangement is therefore equally hopeless.
-    const when = byWhom === null ? never : Math.min(soonest, never);
+    const when = byWhom === null || !Number.isFinite(soonest) ? never : soonest;
     const rank = rankAt(index);
     doneAt.set(rank, Math.max(doneAt.get(rank) ?? 0, when));
     const deadline = untilNeeded(index);

package/services/encode/EncodeRuns.js

@@ -12,6 +12,7 @@ import { spawn } from "node:child_process";
 import { contentionPenalty } from "./contention.js";
 import { LOOKAHEAD_PAUSE_SECONDS } from "./CushionReport.js";
 import { SpeedReadings } from "./SpeedReadings.js";
+import { nextInputAtFirstPiece } from "./next-input.js";
 import { ENCODE_RUN_STATE, liveRunsOf, runStateOf, wireState } from "./encode-run-state.js";
 import { ENCODE_EXIT } from "./encode-exit.js";
 import { EncodeRun, endOfRun } from "./EncodeRun.js";
@@ -1096,6 +1097,8 @@ export class EncodeRuns {
     // killed mid-piece leaving a partial file — is not a correctness problem
     // either, because the store serves a segment only once its closure is
     // proven, and it is cleared up when the run ends.
+    // Told when this run closes its first piece; see the next stretch below.
+    let atFirstPiece = null;
     const run = new EncodeRun({
       address: session.outputKey ?? session.id,
       encoder: this.#host.videoEncoder,
@@ -1129,7 +1132,12 @@ export class EncodeRuns {
       onProgress: (report) => this.#noteRunProgress(session, run, report),
       // A closed piece moves this encoder forward, perhaps out of the band that
       // led; who has the processor is decided again at once.
-      onProduced: () => this.#host.encodeOrchestrator?.shareTheMachine?.(),
+      onProduced: () => {
+        this.#host.encodeOrchestrator?.shareTheMachine?.();
+        const told = atFirstPiece;
+        atFirstPiece = null;
+        told?.();
+      },
       indexOfName: (name) => session.segmentFormat.segmentIndexFromName(
         session.segmentFormat.servedNameOf?.(name) ?? name),
       // Why this encoder exists, recorded with its argument list. It used to be
@@ -1231,12 +1239,24 @@ export class EncodeRuns {
       // It waits for this run's own stretch to be copied: that copy goes on
       // while the run opens and FFmpeg's reads wait for it, and a second copy
       // beside it on the same thread would slow it (torrent-tv/meta#178).
+      //
+      // And for this run's first piece when the rest of the run leaves the
+      // time to prepare it in (`next-input.js`).
       if (inputEnd < mayReach) {
         const askNext = () => {
           if (this.isLive(session) && run.isAlive) this.#host.encodeInputs?.take(session, inputEnd + 1, mayReach);
         };
-        if (admittedInput.whole) void admittedInput.whole.then(whole => { if (whole) askNext(); });
-        else askNext();
+        const preparedInMs = this.#host.encodeInputs?.preparationMsOf?.(session) ?? null;
+        const speed = Number(this.#host.encodeCost?.speedForOutput?.(session.outputKey));
+        const timeline = session.timeline;
+        const restSeconds = Number(timeline?.publishedStartOf?.(inputEnd + 1)) - Number(timeline?.publishedStartOf?.(safeIndex + 1));
+        const atOnce = !nextInputAtFirstPiece({ preparedInMs, speed, restSeconds });
+        let copied = false, produced = atOnce;
+        const askWhenBoth = () => { if (copied && produced) askNext(); };
+        if (!atOnce) atFirstPiece = () => { produced = true; askWhenBoth(); };
+        const whenCopied = () => { copied = true; askWhenBoth(); };
+        if (admittedInput.whole) void admittedInput.whole.then(whole => { if (whole) whenCopied(); });
+        else whenCopied();
       }
     } else if (admittedInput) {
       run.admittedInputKeys = new Map([[safeIndex, inputKey]]);

package/services/encode/next-input.js

@@ -0,0 +1,26 @@
+/**
+ * @file When a run asks for the input of the run after it (torrent-tv/meta#178).
+ *
+ * Asked as soon as the run's own stretch was copied, the next input was copied
+ * while the run opened: a background run on Home Assistant started with its
+ * 108.7 MB, the next 115.6 MB were copied at once, the proxy took 1.5-2 cores,
+ * and the share left to encoders fell from 65 % to 10-16 % before either had
+ * a piece (r37). Asked at the run's first piece, it still has the rest of the
+ * run to be ready in — unless preparing an input of this output was measured
+ * to take longer than that rest at this output's speed, or the run is one
+ * piece, whose first piece is its last.
+ */
+
+/**
+ * Whether the next input waits for this run's first piece.
+ *
+ * @param {object} params
+ * @param {number | null} params.preparedInMs - How long this output's last input took from being asked for to being ready.
+ * @param {number} params.speed - This output's processing speed, film seconds per second; 0 when not known.
+ * @param {number} params.restSeconds - The film this run makes after its first piece.
+ * @returns {boolean}
+ */
+export function nextInputAtFirstPiece({ preparedInMs, speed, restSeconds }) {
+  if (!Number.isFinite(preparedInMs) || !(speed > 0) || !(restSeconds > 0)) return false;
+  return preparedInMs < restSeconds / speed * 1000;
+}