@torrent-tv/proxy 2.96.14 → 2.97.1

package/services/storage/processor-report.js

@@ -0,0 +1,186 @@
+/**
+ * @file Where this machine's processor goes: the proxy's own threads and every
+ * encoder it runs (torrent-tv/meta#177).
+ *
+ * The encoders are priced in seconds of work per second of film, and the
+ * torrent per megabyte moved. What neither price carries was seen only from
+ * outside: at a cold start on the addon host (#166 run 12, 2026-10-10) the main
+ * thread ran at 83-108 % of a core for thirty seconds, measured by a shell loop
+ * reading `/proc`, while the proxy's own log said nothing for 10.7 s.
+ *
+ * Read once a second, said once a minute as each part's mean and highest
+ * second, and every second while a cold start is being profiled. The Node
+ * process is counted ONCE, as `process.cpuUsage()` reports it; the split into
+ * threads only says where that time went. Each ffmpeg is its own process and
+ * is added beside it. Linux only for the split and for ffmpeg; elsewhere the
+ * process figure alone is said.
+ */
+
+import { readFile, readdir } from "node:fs/promises";
+
+/** Clock ticks per second of `/proc/<pid>/stat`, as in `encode/host-load.js`. */
+const CLOCK_TICKS_PER_SECOND = 100;
+
+/**
+ * The CPU seconds and the name in one `/proc/.../stat` text.
+ *
+ * The name can hold spaces and brackets, so it is everything between the first
+ * `(` and the LAST `)`, and the fields are counted from there.
+ *
+ * @param {string} text
+ * @returns {{ name: string, seconds: number } | null}
+ */
+export function parseStat(text) {
+  const open = text.indexOf("(");
+  const close = text.lastIndexOf(")");
+  if (open < 0 || close < open) return null;
+  const after = text.slice(close + 2).trim().split(/\s+/);
+  // After the name and the state, utime is the 12th field and stime the 13th.
+  const utime = Number(after[11]);
+  const stime = Number(after[12]);
+  if (!Number.isFinite(utime) || !Number.isFinite(stime)) return null;
+  return { name: text.slice(open + 1, close), seconds: (utime + stime) / CLOCK_TICKS_PER_SECOND };
+}
+
+/**
+ * Which part of the proxy a thread belongs to: the main thread, the torrent
+ * thread (Node names a worker's thread `WorkerThread`), or the rest — V8's
+ * helpers, libuv's pool, the inspector — counted together.
+ *
+ * @param {number} tid
+ * @param {string} name
+ * @param {number} pid
+ * @returns {"main" | "worker" | "other"}
+ */
+export function partOfThread(tid, name, pid) {
+  if (tid === pid) return "main";
+  if (name === "WorkerThread") return "worker";
+  return "other";
+}
+
+/**
+ * CPU seconds of this process's threads, by part, or null where `/proc` cannot
+ * be read.
+ *
+ * @param {number} [pid]
+ * @returns {Promise<{ main: number, worker: number, other: number } | null>}
+ */
+export async function readThreadSeconds(pid = process.pid) {
+  let tids;
+  try {
+    tids = await readdir(`/proc/${pid}/task`);
+  } catch {
+    return null;
+  }
+  const parts = { main: 0, worker: 0, other: 0 };
+  await Promise.all(tids.map(async (entry) => {
+    const tid = Number(entry);
+    const stat = await readFile(`/proc/${pid}/task/${entry}/stat`, "utf8").then(parseStat, () => null);
+    if (stat) parts[partOfThread(tid, stat.name, pid)] += stat.seconds;
+  }));
+  return parts;
+}
+
+/**
+ * CPU seconds of each of these processes that can be read now.
+ *
+ * @param {number[]} pids
+ * @returns {Promise<Map<number, number>>}
+ */
+export async function readProcessesSeconds(pids) {
+  const seconds = new Map();
+  await Promise.all(pids.map(async (pid) => {
+    const stat = await readFile(`/proc/${pid}/stat`, "utf8").then(parseStat, () => null);
+    if (stat) seconds.set(pid, stat.seconds);
+  }));
+  return seconds;
+}
+
+/**
+ * Shares of one core between two readings, per part. A thread or a process
+ * present in only one of the two readings contributes nothing, so a process
+ * that came or went in between is not read as a jump.
+ *
+ * @param {{ at: number, process: number, threads: object | null, ffmpeg: Map<number, number> }} before
+ * @param {{ at: number, process: number, threads: object | null, ffmpeg: Map<number, number> }} after
+ * @returns {{ seconds: number, process: number, main: number | null, worker: number | null, other: number | null, ffmpeg: number | null } | null}
+ */
+export function sharesBetween(before, after) {
+  const seconds = (after.at - before.at) / 1000;
+  if (!(seconds > 0)) return null;
+  const share = (from, to) => (Number.isFinite(from) && Number.isFinite(to) ? Math.max(0, to - from) / seconds : null);
+  let ffmpeg = null;
+  for (const [pid, value] of after.ffmpeg) {
+    const earlier = before.ffmpeg.get(pid);
+    if (earlier !== undefined && value >= earlier) ffmpeg = (ffmpeg ?? 0) + (value - earlier) / seconds;
+  }
+  return {
+    seconds,
+    process: share(before.process, after.process),
+    main: share(before.threads?.main, after.threads?.main),
+    worker: share(before.threads?.worker, after.threads?.worker),
+    other: share(before.threads?.other, after.threads?.other),
+    ffmpeg
+  };
+}
+
+/**
+ * One line: per part, the mean over the interval and its highest second, as a
+ * percentage of one core.
+ *
+ * @param {object[]} seconds - Per-second shares from `sharesBetween`.
+ * @returns {string}
+ */
+export function describeShares(seconds) {
+  const parts = ["process", "main", "worker", "other", "ffmpeg"];
+  const said = parts.map((part) => {
+    const values = seconds.map((one) => one[part]).filter((value) => Number.isFinite(value));
+    if (values.length === 0) return `${part} n/a`;
+    const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+    return `${part} ${Math.round(mean * 100)}% (highest second ${Math.round(Math.max(...values) * 100)}%)`;
+  });
+  return `${said.join(", ")} of a core over ${seconds.length}s`;
+}
+
+/**
+ * Read every second, say once a minute, and every second while `detailed()`
+ * is true.
+ *
+ * @param {object} params
+ * @param {(line: string) => void} params.log
+ * @param {() => number[]} params.ffmpegPids - The encoders running now.
+ * @param {() => boolean} [params.detailed]
+ * @param {number} [params.everyMs]
+ * @param {number} [params.sayEveryMs]
+ * @returns {{ stop: () => void }}
+ */
+export function startProcessorReport({ log, ffmpegPids, detailed = () => false, everyMs = 1000, sayEveryMs = 60_000 }) {
+  let previous = null;
+  let series = [];
+  let since = Date.now();
+  let reading = false;
+  const tick = async () => {
+    if (reading) return;
+    reading = true;
+    try {
+      const usage = process.cpuUsage();
+      const [threads, ffmpeg] = await Promise.all([readThreadSeconds(), readProcessesSeconds(ffmpegPids())]);
+      const now = { at: Date.now(), process: (usage.user + usage.system) / 1e6, threads, ffmpeg };
+      const shares = previous ? sharesBetween(previous, now) : null;
+      previous = now;
+      if (!shares) return;
+      series.push(shares);
+      if (detailed()) log(`processor: ${describeShares([shares])}`);
+      if (now.at - since >= sayEveryMs) {
+        log(`processor: ${describeShares(series)}`);
+        series = [];
+        since = now.at;
+      }
+    } finally {
+      reading = false;
+    }
+  };
+  const timer = setInterval(() => { void tick(); }, everyMs);
+  if (typeof timer.unref === "function") timer.unref();
+  return { stop: () => clearInterval(timer) };
+}

package/services/torrent/worker/client.js

@@ -475,12 +475,13 @@ export class TorrentWorkerClient {
    * @param {{ sourceKey: string, fileIndex: number, durationSeconds: number, zones: { from: number, to: number, priority: number }[] }} params
    * @returns {Promise<void>}
    */
-  async setPriorityMap({ sourceKey, fileIndex, zones, durationSeconds }) {
+  async setPriorityMap({ sourceKey, fileIndex, zones, durationSeconds, postedAt }) {
     return this.#caller.call(Command.PRIORITY_MAP, {
       sourceKey,
       fileIndex,
       zones,
-      durationSeconds
+      durationSeconds,
+      postedAt
     });
   }
 

package/services/torrent/worker/pool-adapter.js

@@ -164,11 +164,11 @@ export class WorkerTorrentPool {
    * @param {{ sourceKey: string, fileIndex: number, durationSeconds: number, zones: object[] }} params
    * @returns {Promise<void>}
    */
-  async setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones }) {
+  async setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones, postedAt }) {
     if (!sourceKey) {
       return;
     }
-    return this.#client.setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones });
+    return this.#client.setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones, postedAt });
   }
 
   /**

package/services/torrent/worker/worker.js

@@ -454,13 +454,17 @@ async function runCommand(command, params, id) {
     }
 
     case Command.PRIORITY_MAP: {
+      // When this handler began, on the clock the main thread posted by: the
+      // post to here holds the transfer and this thread's queue together
+      // (torrent-tv/meta#177).
+      const receivedAt = performance.timeOrigin + performance.now();
       // Source preparation owns adding the source. A delayed publication may
       // only update an existing source, never revive one after its viewer left.
       const zones = Array.isArray(params.zones) ? params.zones : [];
       // Nor may one for a file held whole, which has nothing left to fetch.
       const torrent = await knownTorrent(params.sourceKey);
       if (!torrent) {
-        return { appliedMs: null };
+        return { appliedMs: null, receivedAt, repliedAt: performance.timeOrigin + performance.now() };
       }
       // What applying a map costs this thread, told to whoever sent it: every
       // zone becomes a window of the register and the swarm is told again
@@ -469,7 +473,7 @@ async function runCommand(command, params, id) {
       ensureArrivalsWired(params.sourceKey, torrent);
       pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
       torrent.emit("priority-map-changed", params.fileIndex);
-      return { appliedMs: performance.now() - startedAt };
+      return { appliedMs: performance.now() - startedAt, receivedAt, repliedAt: performance.timeOrigin + performance.now() };
     }
 
     case Command.READ_RANGE: {

package/services/viewer/DownloadMaps.js

@@ -12,13 +12,21 @@ export class DownloadMaps {
   #nextEpoch = 0;
   #log;
   #now;
+  /**
+   * Milliseconds on the clock both threads read the same way, to the
+   * microsecond: what a publication's stages are measured with, the torrent
+   * thread's receipt included (torrent-tv/meta#177).
+   */
+  #clock;
 
-  constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now }) {
+  constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now,
+    clock = () => performance.timeOrigin + performance.now() }) {
     if (typeof publish !== "function") throw new TypeError("Download map publication is required.");
     this.#publish = publish;
     this.#resolvePlayback = resolvePlayback;
     this.#log = typeof log === "function" ? log : null;
     this.#now = now;
+    this.#clock = clock;
   }
 
   async playback({ sourceKey, fileIndex, durationSeconds, zones }) {
@@ -200,6 +208,7 @@ export class DownloadMaps {
   }
 
   #emit(file) {
+    const builtFrom = this.#clock();
     const zones = [...file.zones, ...file.nativeZones];
     for (const { ranges, requestId, priority, urgent, deadlineAt, order } of file.metadata.values()) {
       for (const [byteStart, byteEnd] of ranges) {
@@ -217,16 +226,32 @@ export class DownloadMaps {
     // orders nothing differently, so the deadlines' order is compared and not
     // their values.
     const shape = shapeOf(publication);
+    // WHAT A PUBLICATION COSTS, stage by stage (torrent-tv/meta#177): building
+    // and comparing it here, every time something is stated, sent or not;
+    // waiting behind the previous one; the synchronous post, which drops the
+    // zones repeated for the torrent and copies the rest for the other thread;
+    // from the post to the torrent thread's
+    // handler, which holds the transfer and that thread's queue together; and
+    // applying it there. A cold minute of #166 run 12 built 10 408 maps and
+    // sent 439, and nothing said what that cost.
+    const builtMs = this.#clock() - builtFrom;
     if (file.shape && sameShape(file.shape, shape)) {
-      this.#statsOf(file).unchanged += 1;
+      const stats = this.#statsOf(file);
+      stats.unchanged += 1;
+      stats.unsentBuildMs += builtMs;
       this.#report(file);
       return Promise.resolve();
     }
     file.shape = shape;
+    const askedAt = this.#clock();
     const pending = file.pending.then(() => {
       if (this.#files.get(`${file.sourceKey}:${file.fileIndex}`) !== file) return undefined;
       const sentAt = this.#now();
-      return Promise.resolve(this.#publish(publication)).then(reply => {
+      const postedAt = this.#clock();
+      const sent = this.#publish({ ...publication, postedAt });
+      const postMs = this.#clock() - postedAt;
+      return Promise.resolve(sent).then(reply => {
+        const answeredAt = this.#clock();
         // A torrent not yet in the thread applies nothing, so this map was not
         // delivered and the next one, however alike, has to be.
         if (reply?.appliedMs === null && file.shape === shape) file.shape = null;
@@ -235,6 +260,11 @@ export class DownloadMaps {
         stats.sent += 1;
         stats.zones.push(zones.length);
         stats.deliveredMs.push(this.#now() - sentAt);
+        stats.sentBuildMs.push(builtMs);
+        stats.waitedMs.push(postedAt - askedAt);
+        stats.postMs.push(postMs);
+        if (Number.isFinite(reply?.receivedAt)) stats.toHandlerMs.push(Math.max(0, reply.receivedAt - postedAt - postMs));
+        if (Number.isFinite(reply?.repliedAt)) stats.replyMs.push(Math.max(0, answeredAt - reply.repliedAt));
         if (Number.isFinite(reply?.appliedMs)) stats.appliedMs.push(reply.appliedMs);
         this.#report(file);
         return reply;
@@ -249,7 +279,7 @@ export class DownloadMaps {
   }
 
   #statsOf(file) {
-    file.stats ??= { since: this.#now(), sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [] };
+    file.stats ??= emptyStats(this.#now());
     return file.stats;
   }
 
@@ -264,11 +294,28 @@ export class DownloadMaps {
       `zones median ${middle(stats.zones)} max ${largest(stats.zones)}; ` +
       `delivered median ${middle(stats.deliveredMs)}ms max ${largest(stats.deliveredMs)}ms (${total(stats.deliveredMs)}ms in all), ` +
       `applied in the torrent thread median ${middle(stats.appliedMs)}ms max ${largest(stats.appliedMs)}ms ` +
-      `(${total(stats.appliedMs)}ms in all)`);
-    file.stats = { since: now, sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [] };
+      `(${total(stats.appliedMs)}ms in all); ` +
+      `stages of a sent map — built ${stage(stats.sentBuildMs)}, waited behind the previous ${stage(stats.waitedMs)}, ` +
+      `posted ${stage(stats.postMs)}, post to the torrent thread's handler ${stage(stats.toHandlerMs)}, ` +
+      `reply back ${stage(stats.replyMs)}; maps built and not sent took ${total([stats.unsentBuildMs])}ms here`);
+    file.stats = emptyStats(now);
   }
 }
 
+/** @param {number} since */
+function emptyStats(since) {
+  return { since, sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [],
+    sentBuildMs: [], waitedMs: [], postMs: [], toHandlerMs: [], replyMs: [], unsentBuildMs: 0 };
+}
+
+/** One stage's median, largest and sum, in milliseconds with tenths. @param {number[]} values */
+function stage(values) {
+  if (values.length === 0) return "n/a";
+  const sorted = [...values].sort((left, right) => left - right);
+  const sum = values.reduce((total, value) => total + value, 0);
+  return `median ${sorted[Math.floor(sorted.length / 2)].toFixed(1)}ms max ${sorted.at(-1).toFixed(1)}ms sum ${Math.round(sum)}ms`;
+}
+
 /** How many numbers describe one zone's part in what the torrent does. */
 const ZONE_FIELDS = 7;