@torrent-tv/proxy 2.100.14 → 2.101.0

package/bin/cli.js

@@ -90,6 +90,7 @@ program
   .option("--no-port-mapping", "Disable automatic UPnP/NAT-PMP port mapping")
   .option("--delivery-sink", "Serve /api/delivery-sink, a torrent-free byte stream for delivery testing")
   .option("--pin-preset <name>", "Encode every software picture at this libx264 preset only, for runs that must be compared at one quality (off by default)")
+  .option("--input-stretch-bytes <bytes>", "Size every original-input stretch to this many bytes instead of copy rate times open, for runs that compare input sizes; memory, downloaded bytes and the plan still bound it (off by default)")
   .option("--heap-snapshots", "Write a heap snapshot of a thread whose memory reaches a new high-water; each one stops that thread while it is written (off by default)")
   .option("--profile-start <seconds>", "Profile the CPU of the main thread and the torrent thread for this many seconds from the first source opened, written beside the state (off by default)")
   .option(
@@ -399,6 +400,7 @@ try {
     profileStartSeconds: Number(options.profileStart) || 0,
     heapSnapshots: options.heapSnapshots === true,
     pinnedPreset: typeof options.pinPreset === "string" && options.pinPreset.trim() ? options.pinPreset.trim() : null,
+    inputStretchBytes: Number(options.inputStretchBytes) > 0 ? Math.floor(Number(options.inputStretchBytes)) : null,
     // Late-bound the same way `webRtcManager` is below: the torrent pool is
     // built inside `startProxyServer`, before `dataChannelHandler` — the
     // thing that actually owns a channel to push down — exists.

package/package.json

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

package/server.js

@@ -134,6 +134,9 @@ export async function startProxyServer({
   // The one software preset every picture is encoded at, for runs compared at
   // one quality; null leaves the choice to the machine.
   pinnedPreset = null,
+  // The size every original-input stretch is given in place of copy rate
+  // times open, for runs that compare input sizes; null keeps the rule.
+  inputStretchBytes = null,
   // What viewers' connections carry beyond the film, per byte of film; the
   // transport counts it and is built after this server, so it is late-bound.
   serviceShare = () => null,
@@ -854,6 +857,7 @@ export async function startProxyServer({
   let sourcePreparation;
   const outputParts = wireOutputs({
     pinnedPreset,
+    inputStretchBytes,
     indexMemory,
     serviceShare,
     readMetadataActivity: () => containerOrchestrator.activity(),

package/services/encode/EncodeInputs.js

@@ -62,10 +62,20 @@ export class EncodeInputs {
    * @type {(output: object, from: number, to: number, input: object) => void}
    */
   #stretchCopied;
+  /**
+   * A stretch size the operator named for comparison runs
+   * (`--input-stretch-bytes`), in place of copy rate times open; null keeps
+   * the measured rule. Only the target changes: memory, downloaded bytes and
+   * the plan's bound still end a stretch (torrent-tv/meta#182).
+   *
+   * @type {number | null}
+   */
+  #fixedStretchBytes;
 
   constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
-    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {} }) {
+    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {}, stretchBytes = null }) {
     this.#stretchCopied = stretchCopied;
+    this.#fixedStretchBytes = Number.isSafeInteger(stretchBytes) && stretchBytes > 0 ? stretchBytes : null;
     this.#openOf = openOf;
     this.#resolve = resolve;
     this.#read = readRanges;
@@ -337,9 +347,19 @@ export class EncodeInputs {
    * @returns {{ bytes: number, openMeasured: boolean } | null}
    */
   stretchFor(output) {
+    const sizing = this.#sizingFor(output);
+    return sizing ? { bytes: sizing.bytes, openMeasured: sizing.openMeasured } : null;
+  }
+
+  #sizingFor(output) {
     const rate = middleOf(this.#copyRates);
     const open = this.#openOf(output);
-    return rate === null || !open ? null : { bytes: Math.floor(rate * open.seconds * 1000), openMeasured: open.measured };
+    if (this.#fixedStretchBytes !== null) {
+      return { bytes: this.#fixedStretchBytes, openMeasured: true, openSeconds: open?.seconds ?? null,
+        copyBytesPerMs: rate, fixed: true };
+    }
+    return rate === null || !open ? null : { bytes: Math.floor(rate * open.seconds * 1000),
+      openMeasured: open.measured, openSeconds: open.seconds, copyBytesPerMs: rate };
   }
 
   /**
@@ -493,6 +513,9 @@ export class EncodeInputs {
    */
   async #admitStretch(request, firstSources) {
     const { output, from } = request;
+    // Record existing decisions only: diagnostics must not resolve another
+    // interval or ask storage for an additional availability reading.
+    const probes = [], reservations = [];
     let minimum = originalInputBytes(firstSources);
     const stretches = new Map([[from, { sources: firstSources, bytes: minimum }]]);
     const held = new Map();
@@ -508,7 +531,11 @@ export class EncodeInputs {
     };
     const fits = async (end, maxBytes) => {
       const stretch = await at(end);
-      return Boolean(stretch) && stretch.bytes <= maxBytes && await this.#present(stretch.sources, held, request.timing);
+      const withinLimit = Boolean(stretch) && stretch.bytes <= maxBytes;
+      const result = !stretch ? "unresolved" : !withinLimit ? "size"
+        : await this.#present(stretch.sources, held, request.timing) ? "fits" : "missing-bytes";
+      probes.push({ end, limitBytes: maxBytes, bytes: stretch?.bytes ?? null, result });
+      return result === "fits";
     };
     // Grows by doubling and then halves back: a handful of resolutions find
     // the end whether it is a piece away or the rest of the film.
@@ -535,10 +562,11 @@ export class EncodeInputs {
       }
       return good;
     };
-    const sizing = this.stretchFor(output);
+    const sizing = this.#sizingFor(output);
     const target = sizing?.bytes ?? null;
     if (sizing && !sizing.openMeasured) request.timing.openApproximate = true;
     let end = target === null || this.#heldRanges === null ? floor : await longest(target);
+    const targetEnd = end;
     if (this.#requests.get(request.key) !== request) return undefined;
     this.#wanted.set(request.key, { wanted: stretches.get(end).bytes, required: minimum });
     await this.#spent(request.timing, "budgetMs", () => this.#revise());
@@ -576,7 +604,13 @@ export class EncodeInputs {
       if (this.#requests.get(request.key) !== request) return undefined;
       this.#wanted.set(request.key, { wanted: chosen.bytes, required: chosen.bytes });
       result = await admitOriginalInput({ sources: chosen.sources, readRanges: this.#read, now: this.#now,
-        reserve: async bytes => this.#hold(request, bytes) });
+        reserve: async bytes => {
+          const reservation = { bytes, allowed: this.#allowed, held: this.#held, capacity,
+            room: roomNow(), end };
+          const release = this.#hold(request, bytes);
+          reservations.push({ ...reservation, admitted: typeof release === "function" });
+          return release;
+        } });
       // Another output's copy can take the room this one was sized for while
       // it was being chosen. A shorter stretch is tried at once rather than
       // waiting for a memory change that may never come.
@@ -585,6 +619,12 @@ export class EncodeInputs {
     }
     if (result.kind === "needs-memory") this.#wanted.set(request.key, { wanted: minimum, required: minimum });
     if (result.kind === "result") {
+      this.#log(`encode input selection of ${addressOf(output)}: ${JSON.stringify({
+        from, requestedTo: request.to, serves, floor, targetEnd, chosenEnd: end,
+        targetBytes: target, targetFixed: sizing?.fixed === true, minimumBytes: minimum, inputBytes: result.bytes,
+        copyBytesPerMs: sizing?.copyBytesPerMs ?? null, openSeconds: sizing?.openSeconds ?? null,
+        openMeasured: sizing?.openMeasured ?? null, reservations, probes
+      })}`);
       Object.assign(result, { from, to: end });
       // The stretch is copied after the answer, while the run opens; the rate
       // is the whole copy's, learned once it is done.

package/services/server/wire-outputs.js

@@ -195,6 +195,9 @@ export function wireOutputs({
     // A software preset every picture is encoded at, for runs compared at one
     // quality (`--pin-preset`); null leaves the choice to the machine.
     pinnedPreset = null,
+    // A size every original-input stretch is given in place of copy rate
+    // times open (`--input-stretch-bytes`); null keeps the rule.
+    inputStretchBytes = null,
     // What every encoder this host may use was qualified and measured to do at
     // startup, by kind (`encode/calibration.js`). Takes the place of the one
     // array above, which a test may still hand in on its own.
@@ -1097,6 +1100,7 @@ export function wireOutputs({
     readRanges: readEncodeRanges,
     heldRanges: readEncodeHeldRanges,
     stretchCopied,
+    stretchBytes: inputStretchBytes,
     reviseBudget: () => parts.machineBudget.revise("memory", "admitted encode inputs"),
     capacity: () => parts.machineBudget.capacityOf("memory"),
     // How long this output's input takes to open, from the one owner of start
@@ -1120,6 +1124,9 @@ export function wireOutputs({
       parts.serving.invalidateWaits(output);
     }
   }) : null);
+  if (parts.encodeInputs && inputStretchBytes) {
+    logger.info(`encode input: every original-input stretch sized to ${inputStretchBytes} bytes (--input-stretch-bytes)`);
+  }
   // One owner of the disk, and the list of what takes it lives with the owner.
   parts.machineBudget = wireMachineBudget({
     segmentStore: parts.segmentStore,