@torrent-tv/proxy 2.98.15 → 2.98.17

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -1319,8 +1319,13 @@ export class EncodeRuns {
   /**
    * How long this run took to open its original input, for sizing the next
    * stretch: from its spawn to the name of its first closed piece, less what
-   * encoding that piece costs at the run's speed — its own where it measured
-   * one, else the output's. Nothing is noted where either is unknown.
+   * encoding that piece costs at a measured speed — the run's own where it
+   * closed two pieces, else the output's newest reading, which is taken
+   * between two closed pieces of a run too. Never a predicted speed: the
+   * output's starting figure, scaled by a machine share that missed short
+   * runs, read 0.08x on Home Assistant and recorded opens of 0.00 s (r41,
+   * torrent-tv/meta#178). Nothing is noted where no speed was measured or the
+   * rest is negative, and the open estimated before stands.
    *
    * @param {object} session
    * @param {import("./EncodeRun.js").EncodeRun} run
@@ -1330,14 +1335,21 @@ export class EncodeRuns {
   #noteOpen(session, run, ended) {
     const grid = session.timeline?.published ?? session.timeline?.boundaries;
     const pieceSeconds = Number(grid?.[run.from + 1]) - Number(grid?.[run.from]);
-    const speed = run.speedX > 0 ? run.speedX : this.#host.encodeOrchestrator.speedOn?.(session.outputKey) ?? 0;
+    const speed = run.speedX > 0 ? run.speedX : this.#speedReadings.windowOf(session).at(-1)?.speed ?? 0;
     // FFmpeg's reads may have waited for the stretch being copied; that wait
     // is the copy's, and the stretch is sized from the open (`run-open.js`).
     const open = runOpenOf({
       firstNamedMs: ended.firstNamedMs, firstNamedWallMs: ended.firstNamedWallMs, startedAt: run.startedAt,
       waitedBefore: run.originalInput?.waitedBefore, pieceSeconds, speed
     });
-    if (!open) return;
+    if (!open) {
+      if (Number.isFinite(ended.firstNamedMs) && pieceSeconds > 0) {
+        this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: open not measured ` +
+          `(first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film, ` +
+          `${speed > 0 ? `at a measured ${speed.toFixed(2)}x the piece takes longer than that` : "no speed measured between two closed pieces"})`);
+      }
+      return;
+    }
     const { openSeconds, waitedMs } = open;
     this.#host.encodeOrchestrator.noteOpen?.(session.outputKey ?? "", openSeconds);
     this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: opened in ` +

package/services/encode/host-load.js

@@ -92,6 +92,34 @@ export async function readProcessCpuSeconds(pid) {
   }
 }
 
+/**
+ * The CPU time every child of this process that has ended has used, from the
+ * `cutime` and `cstime` of `/proc/self/stat`: the kernel adds a child's time
+ * there when the child is waited for, which Node does as soon as it exits.
+ *
+ * What a process that started and ended between two readings of its own pid
+ * cost, which no reading of that pid can say: on Home Assistant a run of one
+ * piece started and ended between two readings 5 s apart, used 6.65 s of CPU,
+ * and both readings said `ffmpeg=0%` (r41, torrent-tv/meta#178).
+ *
+ * @returns {Promise<number | null>} Seconds of CPU, or null where there is no `/proc`.
+ */
+export async function readEndedChildrenCpuSeconds() {
+  try {
+    const text = await readFile("/proc/self/stat", "utf8");
+    const afterComm = text.slice(text.lastIndexOf(")") + 2).trim().split(/\s+/);
+    // After the comm and state fields, cutime is index 13 and cstime index 14.
+    const cutime = Number(afterComm[13]);
+    const cstime = Number(afterComm[14]);
+    if (!Number.isFinite(cutime) || !Number.isFinite(cstime)) {
+      return null;
+    }
+    return (cutime + cstime) / CLOCK_TICKS_PER_SECOND;
+  } catch {
+    return null; // not Linux, or /proc is not mounted
+  }
+}
+
 /**
  * Is this still the machine the benchmarks were taken on: its clock and its
  * temperature.

package/services/encode/quality/HostLoad.js

@@ -11,6 +11,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 { encoderCpuBetween } from "./encoder-cpu.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "../torrent-cost.js";
 import { medianOf, movedBeyondScatter, READINGS_KEPT, scatterOf } from "../learned-median.js";
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode-run-state.js";
@@ -532,17 +533,23 @@ export class HostLoad {
    * the only thing that would have taken the next reading.
    */
   async #learnIdleAvailability(watched, suspended) {
-    const system = (await this.#host.readSystemCpu?.()) ?? null;
-    const sample = { takenAt: Date.now(), system, proxyCpuSeconds: this.#host.readProxyCpuSeconds() };
+    const [system, endedChildren] = await Promise.all([
+      this.#host.readSystemCpu?.() ?? null,
+      this.#host.readEndedChildrenCpuSeconds?.() ?? null
+    ]);
+    const sample = { takenAt: Date.now(), system, endedChildren, byPid: new Map(), proxyCpuSeconds: this.#host.readProxyCpuSeconds() };
     const previous = this.#idleAvailabilitySample;
     this.#idleAvailabilitySample = sample;
     if (previous === null) {
       this.hostAvailability = availableShareFrom({});
       return;
     }
+    // Nothing runs at either reading, and a run may still have run between
+    // them: what it used is in the ended-children time (`encoder-cpu.js`).
+    const encoders = encoderCpuBetween(previous, sample);
     const share = this.#host.shareOfMachine(
       { takenAt: previous.takenAt, processCpuSeconds: 0, system: previous.system },
-      { takenAt: sample.takenAt, processCpuSeconds: 0, system: sample.system }
+      { takenAt: sample.takenAt, processCpuSeconds: encoders?.seconds ?? 0, system: sample.system }
     );
     const proxyShare = this.#setAvailability(share, previous, sample);
     // Said while something is watched, so what is free while every encoder
@@ -559,7 +566,7 @@ export class HostLoad {
    * and the processor share divide; `free` is what nothing used over the
    * interval. Unknown stays `n/a`, never zero.
    */
-  async #sayMachine(share, proxyShare, running, suspended) {
+  async #sayMachine(share, proxyShare, running, suspended, incomplete = false) {
     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
@@ -574,7 +581,8 @@ export class HostLoad {
     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(
-      `host-load: ffmpeg=${asPercent(share.processShare)} proxy=${asPercent(proxyShare)} ` +
+      `host-load: ffmpeg=${incomplete ? `at least ${asPercent(share.processShare)} (a run was not read; availability kept)` : asPercent(share.processShare)} ` +
+      `proxy=${asPercent(proxyShare)} ` +
       `system=${asPercent(share.systemShare)} ` +
       `iowait=${asPercent(share.iowaitShare)} cpu=${machine.megahertz === null ? "n/a" : `${machine.megahertz}MHz`} ` +
       `temp=${machine.celsius === null ? "n/a" : `${machine.celsius}C`} ` +
@@ -646,22 +654,28 @@ export class HostLoad {
     // alone would print something like `ffmpeg=-598%`. Only pids present in
     // BOTH readings are counted, so a process that came or went contributes
     // nothing rather than a lie.
-    const pids = encoding.flatMap((session) => this.#host.liveRunsOf(session).map((run) => run.process?.pid ?? null)).filter((pid) => pid !== null);
-    const [system, ...cpuReadings] = await Promise.all([
+    const runs = encoding.flatMap((session) => this.#host.liveRunsOf(session)).filter((run) => Number.isInteger(run.process?.pid));
+    const [system, endedChildren, ...cpuReadings] = await Promise.all([
       this.#host.readSystemCpu(),
-      ...pids.map((pid) => this.#host.readProcessCpuSeconds(pid))
+      this.#host.readEndedChildrenCpuSeconds?.() ?? null,
+      ...runs.map((run) => this.#host.readProcessCpuSeconds(run.process.pid))
     ]);
     /** @type {Map<number, number>} */
     const byPid = new Map();
-    pids.forEach((pid, index) => {
+    /** @type {Map<number, number>} */
+    const startedAt = new Map();
+    runs.forEach((run, index) => {
       const seconds = cpuReadings[index];
       if (seconds !== null) {
-        byPid.set(pid, seconds);
+        byPid.set(run.process.pid, seconds);
+        startedAt.set(run.process.pid, run.startedAt);
       }
     });
     const sample = {
       takenAt: Date.now(),
       byPid,
+      startedAt,
+      endedChildren,
       system,
       // The proxy's own CPU, across every thread: the torrent, the hashing, the
       // piece store and the delivery. None of it is in the encode budget, and
@@ -674,20 +688,14 @@ export class HostLoad {
     if (previous === null) {
       return false; // the first reading is only something to compare against
     }
-    // Summed over the pids both readings hold, so nothing is measured against a
-    // process that was not there before. Unknown stays unknown: on a host with
-    // no `/proc` there are no readings at all, and the share is null rather
-    // than a confident zero.
-    let encoderDelta = null;
-    for (const [pid, seconds] of sample.byPid) {
-      const before = previous.byPid?.get(pid);
-      if (before !== undefined && seconds >= before) {
-        encoderDelta = (encoderDelta ?? 0) + (seconds - before);
-      }
-    }
+    // Every process counted once, including runs that started or ended between
+    // the readings (`encoder-cpu.js`). Unknown stays unknown: on a host with no
+    // `/proc` there are no readings at all, and the share is null rather than a
+    // confident zero.
+    const encoders = encoderCpuBetween(previous, sample);
     const share = this.#host.shareOfMachine(
-      { takenAt: previous.takenAt, processCpuSeconds: encoderDelta === null ? null : 0, system: previous.system },
-      { takenAt: sample.takenAt, processCpuSeconds: encoderDelta, system: sample.system }
+      { takenAt: previous.takenAt, processCpuSeconds: encoders === null ? null : 0, system: previous.system },
+      { takenAt: sample.takenAt, processCpuSeconds: encoders?.seconds ?? null, system: sample.system }
     );
     if (share === null) {
       this.hostAvailability = availableShareFrom({});
@@ -701,6 +709,12 @@ export class HostLoad {
     // they stopped).
     const suspended = encoding.filter((session) => this.#host.runStateOf(session) === ENCODE_RUN_STATE.SUSPENDED).length;
     const running = encoding.length - suspended;
+    if (encoders && !encoders.complete) {
+      // A lower bound of our own load is not a reading of what other work left
+      // us: the last availability stands, and the line says so.
+      await this.#sayMachine(share, null, running, suspended, true);
+      return false;
+    }
     // Kept for the quality offer, which predicts from a benchmark taken on a
     // QUIET host: the same reading that is printed here says how much of the
     // machine a new encoder could actually have. Only what nobody has been

package/services/encode/quality/encoder-cpu.js

@@ -0,0 +1,66 @@
+/**
+ * @file The CPU this proxy's FFmpeg processes used between two readings of the
+ * machine (torrent-tv/meta#178).
+ *
+ * A process's own counter says what it used since it started, and is gone once
+ * it has ended. Counting only processes present in both readings left out every
+ * run that started or ended between them: on Home Assistant a run of one piece
+ * started and ended between two readings 5 s apart, used 6.65 s of CPU, and
+ * both readings said `ffmpeg=0%` (r41). The availability left to encoders is
+ * the machine's load less theirs, so an encoder left out made the machine look
+ * busier with other work than it was.
+ *
+ * So three parts, each counted once:
+ *  1. a process in both readings: what its counter moved;
+ *  2. a process started after the first reading: its whole counter;
+ *  3. a process that ended between them: what the kernel added to this
+ *     process's ended-children time (`cutime + cstime`), less what the first
+ *     reading already counted of it.
+ * A part that cannot be told — a process that was there but unread, an
+ * ended-children time that went back, no such time at all while a process
+ * ended — makes the answer incomplete: a lower bound, never a measured zero.
+ */
+
+/**
+ * @typedef {object} EncoderReading
+ * @property {number} takenAt - Wall clock, ms.
+ * @property {Map<number, number>} byPid - CPU seconds of each live FFmpeg process read.
+ * @property {Map<number, number>} [startedAt] - When each of them was spawned, wall clock ms.
+ * @property {number | null} endedChildren - This process's ended-children CPU seconds.
+ */
+
+/**
+ * @param {EncoderReading} previous
+ * @param {EncoderReading} sample
+ * @returns {{ seconds: number, complete: boolean } | null} Null when nothing at all was read.
+ */
+export function encoderCpuBetween(previous, sample) {
+  const endedKnown = Number.isFinite(previous.endedChildren) && Number.isFinite(sample.endedChildren);
+  if (sample.byPid.size === 0 && previous.byPid.size === 0 && !endedKnown) return null;
+  let seconds = 0, complete = true;
+  for (const [pid, now] of sample.byPid) {
+    const before = previous.byPid.get(pid);
+    if (before !== undefined) {
+      if (now >= before) seconds += now - before;
+      else complete = false;
+    } else if (sample.startedAt?.get(pid) > previous.takenAt) {
+      seconds += now;
+    } else {
+      complete = false;
+    }
+  }
+  let countedOfEnded = 0, ended = 0;
+  for (const [pid, before] of previous.byPid) {
+    if (sample.byPid.has(pid)) continue;
+    countedOfEnded += before;
+    ended += 1;
+  }
+  if (endedKnown) {
+    const rest = sample.endedChildren - previous.endedChildren - countedOfEnded;
+    if (rest >= 0) seconds += rest;
+    else complete = false;
+  } else if (ended > 0) {
+    complete = false;
+  }
+  return { seconds, complete };
+}

package/services/encode/run-open.js

@@ -8,6 +8,14 @@
  * wall clock, so they are taken up to the wall-clock moment the first piece
  * was named — the run's start plus its time to that name, not that time alone,
  * which as a moment lay before every wait and counted none of them.
+ *
+ * THE SPEED IS A MEASURED ONE, between two closed pieces, and a negative rest
+ * is no open at all: on Home Assistant runs of one piece took 6.0-7.5 s to it
+ * for 4 s of film, were priced at a speed of 0.08x that no run had measured,
+ * and recorded opens of 0.00 s; the next inputs were sized from them to one
+ * piece, and the runs stayed one piece each (r41, torrent-tv/meta#178). A rest
+ * below zero says the speed does not describe that piece, and nothing is
+ * recorded: the open estimated before stands.
  */
 
 /**
@@ -18,12 +26,14 @@
  * @param {((until: number) => number) | null | undefined} params.waitedBefore - The input's wall-clock waits for its copy before `until`, ms.
  * @param {number} params.pieceSeconds - The first piece's film.
  * @param {number} params.speed - Film seconds per second; 0 when not known.
- * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is unknown.
+ * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is
+ *   unknown, or where the piece's encoding at that speed exceeds the time to it.
  */
 export function runOpenOf({ firstNamedMs, firstNamedWallMs, startedAt, waitedBefore, pieceSeconds, speed }) {
   if (!Number.isFinite(firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return null;
   const waitedMs = Number.isFinite(firstNamedWallMs) && startedAt > 0 && typeof waitedBefore === "function"
     ? waitedBefore(startedAt + firstNamedWallMs)
     : 0;
-  return { waitedMs, openSeconds: Math.max(0, (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed) };
+  const openSeconds = (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed;
+  return openSeconds >= 0 ? { waitedMs, openSeconds } : null;
 }

package/services/server/wire-outputs.js

@@ -11,7 +11,7 @@
 import { logger } from "../../utils/logger.js";
 import { KeyframeTables } from "../media/KeyframeTables.js";
 import { waits } from "./WaitLedger.js";
-import { readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
+import { readEndedChildrenCpuSeconds, readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
 import { PriorityOrchestrator } from "../viewer/PriorityOrchestrator.js";
 import { urgentOutputsReady } from "../viewer/urgent-output-ready.js";
@@ -290,6 +290,7 @@ export function wireOutputs({
   // What the torrent and the proxy itself spend on this host, and how fast each watched torrent moves.
   parts.hostLoad = new HostLoad({
     readMetadataActivity,
+    readEndedChildrenCpuSeconds,
     readMachineState,
     readProcessCpuSeconds,
     readProxyCpuSeconds,