@torrent-tv/proxy 2.89.3 → 2.89.4

package/services/encode/EncodeOrchestrator.js

@@ -84,9 +84,6 @@ export class EncodeOrchestrator {
   /** Consecutive fast failures at one position, per output. @type {Map<string, { at: number, count: number }>} */
   #failedStarts = new Map();
 
-  /** The fastest speed measured on one output, kept across restarts. @type {Map<string, number>} */
-  #lastSpeed = new Map();
-
   /** How runs have ended, by cause. @type {Map<string, number>} */
   #endings = new Map();
 
@@ -567,27 +564,6 @@ export class EncodeOrchestrator {
     }
   }
 
-  /**
-   * @param {string} address
-   * @param {object} run
-   * @param {number} speedX
-   */
-  noteSpeed(address, wanted, speedX) {
-    for (const run of this.runsOn(address)) {
-      if (run === wanted) {
-        run.noteSpeed(speedX);
-      }
-    }
-    // HOW FAST THIS MACHINE ENCODES THIS OUTPUT is a property of the machine and
-    // the material, not of one process. Read off `run.speedX` alone it was lost
-    // at every restart: a moved encoder is a new object that has measured
-    // nothing, so the plan fell back to "nothing is known" and stopped comparing
-    // arrivals at all — which is every decision in this layer.
-    if (speedX > 0 && speedX > (this.#lastSpeed.get(address) ?? 0)) {
-      this.#lastSpeed.set(address, speedX);
-    }
-  }
-
   /**
    * Decide and act, for every output anybody wants anything of and every output
    * that still has an encoder on it.
@@ -680,14 +656,7 @@ export class EncodeOrchestrator {
     // the answer the plan had given.
     const costs = this.#costs.seconds();
     const refetchSecPerFilmSecond = this.refetchSecPerFilmSecond(address);
-    // The best figure this host has: what a run here is doing now, what one was
-    // last measured doing, or what the startup benchmark predicted. The first
-    // two are this output's own; the third exists before either.
-    const speedX = Math.max(
-      live.reduce((best, run) => Math.max(best, run.speedX || 0), 0),
-      this.#lastSpeed.get(address) ?? 0,
-      this.startingSpeedFor(address) || 0
-    );
+    const speedX = this.#speedOn(address, live);
     const actions = planEncoders({
       coverage,
       windows,
@@ -853,14 +822,6 @@ export class EncodeOrchestrator {
       this.logger.warn(`encode: no encoder could be made for #${from}..#${to} of ${address}`);
       return;
     }
-    // What this machine has been measured to do on this output, carried over.
-    // A restart does not make the machine slower, and without this every moved
-    // encoder began as one whose speed nothing had measured — which the plan
-    // reads as "no arrival can be computed" and answers by comparing nothing.
-    const known = this.#lastSpeed.get(address) ?? 0;
-    if (known > 0) {
-      run.noteSpeed(known);
-    }
     const onThisOutput = this.#runs.get(address) ?? [];
     onThisOutput.push(run);
     this.#runs.set(address, onThisOutput);
@@ -876,6 +837,28 @@ export class EncodeOrchestrator {
     this.coverageOf(address).claim(run, from, endOfRun({ from, to }));
   }
 
+  /**
+   * The best figure this host has for one encoder on this output: the
+   * processing speed a run here has measured (`EncodeRun.speedX`), or what this
+   * output was last measured doing and the startup measurements predict
+   * (`startingSpeedFor`), which exists before any run has closed two pieces and
+   * after a restart. The run owns its speed; nothing here keeps a copy.
+   *
+   * It is the MACHINE's speed: input waits for the swarm are not in it. What
+   * the swarm delivers is the separate supply term
+   * (`refetchSecPerFilmSecond`).
+   *
+   * @param {string} address
+   * @param {{ speedX: number }[]} live
+   * @returns {number}
+   */
+  #speedOn(address, live) {
+    return Math.max(
+      live.reduce((best, run) => Math.max(best, run.speedX || 0), 0),
+      this.startingSpeedFor(address) || 0
+    );
+  }
+
   /**
    * How many encoders may run on this output, from every limit at once.
    *
@@ -894,15 +877,7 @@ export class EncodeOrchestrator {
    */
   #affordableOn(address, live) {
     const byProcessor = Math.max(0, this.maxRunsFor(address));
-    // The best figure this host has: what a run here is doing now, what one was
-    // last measured doing, or what the startup benchmark predicted. The first
-    // two are this output's own; the third exists before either, so the budget
-    // is never asked to price encoders at a speed of zero.
-    const fastest = Math.max(
-      live.reduce((best, run) => Math.max(best, run.speedX || 0), 0),
-      this.#lastSpeed.get(address) ?? 0,
-      this.startingSpeedFor(address) || 0
-    );
+    const fastest = this.#speedOn(address, live);
     const budget = affordableRuns({
       byProcessor,
       speedX: fastest,

package/services/encode/EncodePlan.js

@@ -65,9 +65,11 @@
  * @property {number} from - The first number it was given.
  * @property {number} to - The last number it was given, inclusive.
  * @property {number} head - The next number it will produce. Its position.
- * @property {number} speedX - Measured encode speed against realtime, from
- *   ffmpeg's own progress. Zero or less means nothing has measured it yet, and
- *   then no comparison involving its speed can be made.
+ * @property {number} speedX - The run's processing speed against realtime:
+ *   film made between closed pieces over its own working time
+ *   (`EncodeRun.speedX`), with input waits and stops taken out. Zero or less
+ *   means nothing has measured it yet, and then no comparison involving its
+ *   speed can be made.
  */
 
 /**

package/services/encode/EncodeRun.js

@@ -39,6 +39,8 @@
 
 import { ENCODE_RUN_EVENT, ENCODE_RUN_STATE, INITIAL_RUN_STATE, nextState } from "./encode-run-state.js";
 import { classifyEncodeExit, ENCODE_EXIT } from "./encode-exit.js";
+import { speedFromWork } from "./encoder-readings.js";
+import { RunClock } from "./RunClock.js";
 import { RunProgress } from "./RunProgress.js";
 
 /** Microseconds in a second, as ffmpeg's `out_time_ms` counts them. */
@@ -150,8 +152,14 @@ export class EncodeRun {
    */
   #firstOutputAt = 0;
 
-  /** @type {number} */
-  #speedX = 0;
+  /** The film made and the run's own working time, as of the last progress report. */
+  #workSample = null;
+
+  /** The work sample taken when this run last measured its speed. */
+  #pieceSample = null;
+
+  /** @type {{ speed: number, at: number } | null} */
+  #speedReading = null;
 
   /** @type {boolean} */
   #stopping = false;
@@ -186,6 +194,9 @@ export class EncodeRun {
    * @param {{ info: (line: string) => void, warn: (line: string) => void, error?: (line: string) => void }} params.logger
    * @param {() => number} [params.now]
    * @param {(ended: RunEnded) => void} [params.onEnded]
+   * @param {(reading: { speed: number, at: number }) => void} [params.onSpeedMeasured] -
+   *   Told each time this run has measured its processing speed, once per
+   *   reading.
    * @param {(name: string) => string | null} [params.onClosed] - Called with the
    *   WORKING name of every piece the encoder has finished writing, as the
    *   encoder itself names it on its own channel, and answers with the name that
@@ -222,6 +233,7 @@ export class EncodeRun {
     logger,
     now,
     onEnded,
+    onSpeedMeasured,
     onClosed,
     onProgress,
     lastSegmentIndex,
@@ -242,8 +254,11 @@ export class EncodeRun {
     this.logger = logger;
     this.now = typeof now === "function" ? now : Date.now;
     this.progress = new RunProgress({ startSeconds, totalSeconds, now: this.now });
+    /** Where this run's time went: its own work, or waiting, or stopped. */
+    this.clock = new RunClock({ now: this.now });
     this.onEnded = typeof onEnded === "function" ? onEnded : () => {};
     this.onProgress = typeof onProgress === "function" ? onProgress : () => {};
+    this.onSpeedMeasured = typeof onSpeedMeasured === "function" ? onSpeedMeasured : () => {};
     // Told the NAME of every piece the encoder has closed. The name is the
     // proof it is whole; nothing else here can prove that.
     this.onClosed = typeof onClosed === "function" ? onClosed : (name) => name;
@@ -264,9 +279,25 @@ export class EncodeRun {
     return this.#state;
   }
 
-  /** @returns {number} */
+  /**
+   * This run's processing speed: film made over its own working time between
+   * two closed pieces, with the time its input waited and the time it was
+   * stopped taken out (`RunClock`). Zero until two pieces have closed.
+   *
+   * @returns {number}
+   */
   get speedX() {
-    return this.#speedX;
+    return this.#speedReading?.speed ?? 0;
+  }
+
+  /**
+   * The same speed with the moment it was measured, or null before a second
+   * piece has closed.
+   *
+   * @returns {{ speed: number, at: number } | null}
+   */
+  get speedReading() {
+    return this.#speedReading === null ? null : { ...this.#speedReading };
   }
 
   /** @returns {number} When it was spawned, or 0 before that. */
@@ -355,6 +386,16 @@ export class EncodeRun {
     return this.#stopping && !this.#ended;
   }
 
+  /** An input read of this run starts waiting for bytes; see {@link RunClock}. */
+  inputWaitBegins() {
+    this.clock.inputWaitBegins();
+  }
+
+  /** An input read of this run has its bytes. */
+  inputWaitEnds() {
+    this.clock.inputWaitEnds();
+  }
+
   /** @returns {boolean} Whether it is stopped where it stands, producing nothing. */
   get isSuspended() {
     return this.#state === ENCODE_RUN_STATE.SUSPENDED;
@@ -460,19 +501,24 @@ export class EncodeRun {
       if (key === "out_time_ms") {
         const numeric = Number(value);
         if (Number.isFinite(numeric) && numeric >= 0) {
-          this.#reportProgress({ processedSeconds: numeric / MICROSECONDS_PER_SECOND, speed: null });
+          this.#reportProgress({ processedSeconds: numeric / MICROSECONDS_PER_SECOND });
         }
       } else if (key === "out_time") {
-        this.#reportProgress({ processedSeconds: null, speed: null, outTime: value });
-      } else if (key === "speed") {
-        this.noteSpeed(Number.parseFloat(value));
-        this.#reportProgress({ processedSeconds: null, speed: value });
+        this.#reportProgress({ processedSeconds: null, outTime: value });
       }
     }
   }
 
   #reportProgress(report) {
     this.progress.note(report);
+    if (Number.isFinite(report.processedSeconds) || typeof report.outTime === "string") {
+      const at = this.now();
+      this.#workSample = {
+        at,
+        producedSeconds: Math.max(0, this.progress.processedSeconds - this.progress.startPositionSeconds),
+        workingMs: this.clock.workingMs(at)
+      };
+    }
     this.onProgress(this.progress.snapshot());
   }
 
@@ -493,11 +539,6 @@ export class EncodeRun {
     }
   }
 
-  /**
-   * What ffmpeg says about its own speed.
-   *
-   * @param {number} speedX - Times realtime.
-   */
   /**
    * Names of finished pieces, as the encoder writes them.
    *
@@ -524,6 +565,7 @@ export class EncodeRun {
   }
 
   #publishClosed(name) {
+      this.#measureSpeed();
       // ITS SERVED NAME, which is what whoever owns the disk gives it in answer.
       // ffmpeg writes a piece under a working name and reports that; the piece
       // becomes servable by being renamed, and everything below works in the
@@ -548,9 +590,28 @@ export class EncodeRun {
       return true;
   }
 
-  noteSpeed(speedX) {
-    if (Number.isFinite(speedX) && speedX > 0) {
-      this.#speedX = speedX;
+  /**
+   * A closed piece is the moment this run's speed is read: what it made since
+   * the last reading, over its own working time. Measured from the first
+   * closed piece rather than from the spawn, so the process start and the wait
+   * for its first input bytes, which are charged once as startup, are not
+   * counted as processing. A stretch with no progress keeps the earlier sample,
+   * and the next reading spans both.
+   */
+  #measureSpeed() {
+    const sample = this.#workSample;
+    if (sample === null) {
+      return;
+    }
+    if (this.#pieceSample === null) {
+      this.#pieceSample = sample;
+      return;
+    }
+    const speed = speedFromWork(this.#pieceSample, sample);
+    if (speed !== null) {
+      this.#speedReading = { speed, at: sample.at };
+      this.#pieceSample = sample;
+      this.onSpeedMeasured(this.speedReading);
     }
   }
 
@@ -611,6 +672,7 @@ export class EncodeRun {
       return false;
     }
     this.#transition(ENCODE_RUN_EVENT.SUSPEND_ORDERED);
+    this.clock.stopped();
     this.logger.info(`encode-run #${this.from}..#${this.to} suspended — ${reason}`);
     return true;
   }
@@ -656,6 +718,7 @@ export class EncodeRun {
       continued = false;
     }
     this.#transition(ENCODE_RUN_EVENT.RESUMED);
+    this.clock.continued();
     return continued;
   }