@torrent-tv/proxy 2.101.2 → 2.101.3

package/bin/cli.js

@@ -90,7 +90,6 @@ 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(
@@ -400,7 +399,6 @@ 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.101.2",
+  "version": "2.101.3",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/server.js

@@ -88,6 +88,7 @@ import { takeTurns } from "./utils/take-turns.js";
 import { completedFilesRoot } from "./services/storage/files/CompletedFiles.js";
 import { startupCpuProfile } from "./services/storage/cpu-profile.js";
 import { startProcessorReport } from "./services/storage/processor-report.js";
+import { processorBound } from "./services/storage/machine-processor.js";
 
 const require = createRequire(import.meta.url);
 const { version } = require("./package.json");
@@ -134,9 +135,6 @@ 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,
@@ -234,6 +232,10 @@ export async function startProxyServer({
   let videoEncoder = transcodeAudio
     ? await detectVideoEncoder({ ffmpegBin, logger })
     : null;
+  // The cores this process may use (a container's quota or CPU set): the
+  // readings below divide out a share of those, the unit every later share of
+  // the machine is in (torrent-tv/meta#180, phase 3).
+  const processorCores = processorBound().cores;
   // WHAT THIS HOST DOES, measured before any viewer exists. Every one of these
   // was gated on the chosen encoder being SOFTWARE, and two of the three are
   // not about the encoder at all: a host with a GPU decodes in software just
@@ -246,7 +248,7 @@ export async function startProxyServer({
   // (the rungs are timed on raw frames), but the order keeps the two figures
   // side by side in the log.
   const decodeCostModel = transcodeAudio
-    ? await benchmarkDecodeCost({ ffmpegBin, logger })
+    ? await benchmarkDecodeCost({ ffmpegBin, logger, processorCores })
     : null;
   // What a second job costs on this host. Measured because the budget adds
   // independent prices and this host says two jobs that each fit alone do not
@@ -267,16 +269,16 @@ export async function startProxyServer({
   // the processor and the threads, the device and its driver — which is what
   // decides whether anything kept from an earlier run still applies.
   const fingerprint = videoEncoder
-    ? await readHostFingerprint({ ffmpegBin, encoder: videoEncoder })
+    ? await readHostFingerprint({ ffmpegBin, encoder: videoEncoder, processorCores })
     : null;
   /** @type {Record<string, object[]>} */
   const calibratedModes = {};
   if (videoEncoder) {
     calibratedModes[videoEncoder.kind] =
-      (await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger })).modes;
+      (await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger, processorCores })).modes;
     if (videoEncoder.kind !== "software") {
       calibratedModes.software =
-        (await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger })).modes;
+        (await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger, processorCores })).modes;
       // A device that passed detection's own test and then none of whose modes
       // passed the product's is not used: detection encodes a synthetic pattern
       // with arguments of its own, and it is the product's arguments a viewer
@@ -857,7 +859,6 @@ export async function startProxyServer({
   let sourcePreparation;
   const outputParts = wireOutputs({
     pinnedPreset,
-    inputStretchBytes,
     indexMemory,
     serviceShare,
     readMetadataActivity: () => containerOrchestrator.activity(),

package/services/encode/EncodeInputs.js

@@ -62,20 +62,10 @@ 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 = () => {}, stretchBytes = null }) {
+    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {} }) {
     this.#stretchCopied = stretchCopied;
-    this.#fixedStretchBytes = Number.isSafeInteger(stretchBytes) && stretchBytes > 0 ? stretchBytes : null;
     this.#openOf = openOf;
     this.#resolve = resolve;
     this.#read = readRanges;
@@ -354,10 +344,6 @@ export class EncodeInputs {
   #sizingFor(output) {
     const rate = middleOf(this.#copyRates);
     const open = this.#openOf(output);
-    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 };
   }
@@ -621,7 +607,7 @@ export class EncodeInputs {
     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,
+        targetBytes: target, minimumBytes: minimum, inputBytes: result.bytes,
         copyBytesPerMs: sizing?.copyBytesPerMs ?? null, openSeconds: sizing?.openSeconds ?? null,
         openMeasured: sizing?.openMeasured ?? null, reservations, probes
       })}`);

package/services/encode/available-share.js

@@ -41,6 +41,19 @@
  * `share`, what other processes leave, stays for the download's share of the
  * proxy's processor (`processor-share.js`), which divides the proxy's room
  * between its own download and its encoders and must not lose that room twice.
+ *
+ * THE WHOLE MACHINE IS WHAT THIS PROCESS MAY USE (torrent-tv/meta#180, phase
+ * 3). `/proc/stat` and `os.cpus()` describe the host; a container's CPU quota
+ * (`cpu.max`, Docker `--cpus`) or a CPU set (`--cpuset-cpus`) gives the proxy
+ * fewer cores than that. Where such a bound is smaller than the host, both
+ * shares are fractions of the bound instead: the encoders get what the host's
+ * other work leaves, but never more than the bound less the proxy's own draw.
+ * Measured as fractions of the host, a 1.5-core quota on an 8-core host read
+ * a busy neighbour as lost room the quota never had, and the proxy's own draw
+ * as an eighth of what it takes from the quota. The startup measurements are
+ * divided by the same fraction (`host-load.js` `freeShareDuring`), so a cost
+ * filed from either stays in one unit. Without a bound smaller than the host,
+ * nothing changes.
  */
 
 /**
@@ -52,10 +65,17 @@
  * @param {number | null} reading.encoderShare - Our own ffmpeg processes.
  * @param {number | null} reading.proxyShare - The proxy process itself, every
  *   thread of it.
- * @returns {{ share: number, forEncoders: number, unattributed: number, known: boolean }}
+ * @param {number | null} [reading.hostCores] - The cores the three shares
+ *   above are fractions of.
+ * @param {number | null} [reading.boundCores] - The cores this process may use
+ *   (`storage/machine-processor.js` `processorBound`); counts only when
+ *   smaller than `hostCores`.
+ * @returns {{ share: number, forEncoders: number, unattributed: number, known: boolean, boundCores?: number }}
  *   `share` is what other processes leave; `forEncoders` what they and the
- *   proxy leave. `known` is false when the host does not report its own load —
- *   then both are 1 and the caller must say it is uncorrected rather than pretend.
+ *   proxy leave; both of `boundCores` where it is given, else of the whole
+ *   host. `unattributed` stays a fraction of the host. `known` is false when
+ *   the host does not report its own load — then both are 1 and the caller
+ *   must say it is uncorrected rather than pretend.
  */
 export function availableShareFrom(reading = {}) {
   const systemBusy = finite(reading.systemBusy);
@@ -65,11 +85,26 @@ export function availableShareFrom(reading = {}) {
     return { share: 1, forEncoders: 1, unattributed: 0, known: false };
   }
   const encoders = finite(reading.encoderShare) ?? 0;
-  const ours = encoders + (finite(reading.proxyShare) ?? 0);
+  const proxy = finite(reading.proxyShare) ?? 0;
+  const ours = encoders + proxy;
   // Rounding, and the two readings being taken microseconds apart, can put our
   // own share fractionally above the system total. Below zero is not a
   // measurement of anything.
   const unattributed = clamp(systemBusy - ours, 0, 1);
+  const hostCores = finite(reading.hostCores);
+  const boundCores = finite(reading.boundCores);
+  if (hostCores !== null && boundCores !== null && boundCores > 0 && boundCores < hostCores) {
+    // In cores: the host's other work takes from the host, the proxy's own
+    // draw from the bound as well.
+    const leftOnHost = hostCores - clamp(systemBusy - encoders, 0, 1) * hostCores;
+    return {
+      share: clamp(Math.min(boundCores, hostCores - unattributed * hostCores) / boundCores, 0, 1),
+      forEncoders: clamp(Math.min(boundCores - proxy * hostCores, leftOnHost) / boundCores, 0, 1),
+      unattributed,
+      known: true,
+      boundCores
+    };
+  }
   return { share: clamp(1 - unattributed, 0, 1), forEncoders: clamp(1 - (systemBusy - encoders), 0, 1),
     unattributed, known: true };
 }

package/services/encode/calibration.js

@@ -185,6 +185,8 @@ async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, rung, segm
  * @param {{ info: (m: string) => void, warn: (m: string) => void }} [params.logger]
  * @param {number} [params.segmentDurationSec]
  * @param {Array<{ width: number, height: number }>} [params.frames]
+ * @param {number | null} [params.processorCores] - The cores this process may
+ *   use, which the readings' share of the machine is of (`measureEncodeSlope`).
  * @param {object} [params.measure] - Replaces the three readings, for a check
  *   that must not run ffmpeg: `check`, `rawFrames`, `speed`. `speed` answers a
  *   number, or `{ speed, freeShare }` as `measureEncodeSlope` does.
@@ -196,12 +198,13 @@ export async function calibrateEncoder({
   logger,
   segmentDurationSec = 4,
   frames = CALIBRATION_FRAMES,
+  processorCores = null,
   measure = null
 }) {
   const log = logger ?? { info: () => {}, warn: () => {} };
   const check = measure?.check ?? checkModeProducesCorrectSegments;
   const rawFrames = measure?.rawFrames ?? ((frame) => decodeToRawFrames(ffmpegBin, log, frame));
-  const speed = measure?.speed ?? ((rung, rawPath, frame) => measureEncodeSlope(ffmpegBin, encoder, rung, rawPath, frame));
+  const speed = measure?.speed ?? ((rung, rawPath, frame) => measureEncodeSlope(ffmpegBin, encoder, rung, rawPath, frame, processorCores));
   const release = measure?.release ?? ((rawPath) => {
     try {
       rmSync(path.dirname(rawPath), { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });

package/services/encode/fingerprint.js

@@ -22,7 +22,10 @@
  * 2. the libx264 build — the version string x264 writes into every stream it
  *    produces (`x264 - core N rNNNN hash`), read from one encoded frame;
  * 3. the processor model and the thread count the encoder is given
- *    (`CPU_THREADS`, which is the core count);
+ *    (`CPU_THREADS`, which is the core count), and the cores this process may
+ *    use where a container's CPU quota or CPU set makes them fewer: a speed
+ *    filed as a share of those cores (`available-share.js`) does not hold
+ *    under another quota (torrent-tv/meta#180);
  * 4. for a device-backed encoder, the device model and its driver: NVIDIA's
  *    own tool where it exists, and otherwise what the kernel publishes under
  *    `/sys` for the render node or the video device.
@@ -116,7 +119,9 @@ export function configurationKeyOf(fingerprint, encoder) {
       ...common,
       `x264=${fingerprint?.x264 ?? UNKNOWN}`,
       `cpu=${fingerprint?.cpu ?? UNKNOWN}`,
-      `threads=${fingerprint?.threads ?? UNKNOWN}`
+      `threads=${fingerprint?.threads ?? UNKNOWN}`,
+      // Only where it binds, so a host without a quota keeps its key.
+      ...(Number.isFinite(fingerprint?.boundCores) ? [`bound=${fingerprint.boundCores}`] : [])
     ].join(";");
   }
   const device = fingerprint?.devices?.[encoder?.kind] ?? null;
@@ -137,6 +142,8 @@ export function configurationKeyOf(fingerprint, encoder) {
  * @property {string} x264
  * @property {string} cpu
  * @property {number} threads
+ * @property {number | null} [boundCores] - The cores this process may use,
+ *   where fewer than the host's; absent or null otherwise.
  * @property {Record<string, DeviceFingerprint>} devices - By encoder kind.
  */
 
@@ -288,10 +295,10 @@ async function nvidiaDevice() {
  * Read this host's fingerprint. Always resolves: an unreadable part is
  * `unknown`, never a refusal to start.
  *
- * @param {{ ffmpegBin: string, encoder?: { kind: string, device: string | null } | null }} params
+ * @param {{ ffmpegBin: string, encoder?: { kind: string, device: string | null } | null, processorCores?: number | null }} params
  * @returns {Promise<HostFingerprint>}
  */
-export async function readHostFingerprint({ ffmpegBin, encoder = null }) {
+export async function readHostFingerprint({ ffmpegBin, encoder = null, processorCores = null }) {
   const versionText = await capture(ffmpegBin, ["-hide_banner", "-version"], 5000);
   // `-hide_banner` does not hide the version line itself: it is the answer.
   const ffmpeg = parseFfmpegVersion(versionText ? versionText.toString("utf8") : "");
@@ -317,6 +324,7 @@ export async function readHostFingerprint({ ffmpegBin, encoder = null }) {
     x264,
     cpu: os.cpus()[0]?.model?.trim() || UNKNOWN,
     threads: CPU_THREADS,
+    boundCores: Number.isFinite(processorCores) && processorCores < os.cpus().length ? processorCores : null,
     devices
   };
 }

package/services/encode/host-load.js

@@ -189,14 +189,14 @@ export function shareOfMachine(before, after, cores = os.cpus().length) {
  * One reading of everything above, to be compared against the next.
  *
  * @param {number | null} pid - The encoder's process, when one is running.
- * @returns {Promise<{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }>}
+ * @returns {Promise<{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null, proxyCpuSeconds: number }>}
  */
 export async function sampleHost(pid) {
   const [processCpuSeconds, system] = await Promise.all([
     pid === null ? Promise.resolve(null) : readProcessCpuSeconds(pid),
     readSystemCpu()
   ]);
-  return { takenAt: Date.now(), processCpuSeconds, system };
+  return { takenAt: Date.now(), processCpuSeconds, system, proxyCpuSeconds: readProxyCpuSeconds() };
 }
 
 /**
@@ -215,12 +215,22 @@ export async function sampleHost(pid) {
  * Null when the host does not report its load (no `/proc`), or a reading was
  * refused; the measurement is then used as it was read, and says so.
  *
- * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null } | null} before
- * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null } | null} after
+ * Where this process may use fewer cores than the host has (a container's CPU
+ * quota or CPU set, `boundCores`), the share is of those cores, as the share a
+ * running encoder is filed with (`available-share.js`): what the host's other
+ * work leaves, but never more than the bound less this process's own draw.
+ * Otherwise the measurement, which ran inside the bound, was divided by a
+ * share of the whole host, and a busy neighbour made it read faster than the
+ * bound allows (torrent-tv/meta#180, phase 3).
+ *
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null, proxyCpuSeconds?: number | null } | null} before
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null, proxyCpuSeconds?: number | null } | null} after
  * @param {number} [cores]
+ * @param {number | null} [boundCores] - The cores this process may use; counts
+ *   only when fewer than `cores`.
  * @returns {number | null} Between 0 and 1.
  */
-export function freeShareDuring(before, after, cores = os.cpus().length) {
+export function freeShareDuring(before, after, cores = os.cpus().length, boundCores = null) {
   if (!before || !after) {
     return null;
   }
@@ -229,10 +239,28 @@ export function freeShareDuring(before, after, cores = os.cpus().length) {
     return null;
   }
   const others = Math.min(1, Math.max(0, shares.systemShare - shares.processShare));
-  const free = 1 - others;
+  const free = Number.isFinite(boundCores) && boundCores > 0 && boundCores < cores
+    ? Math.min(1, (cores - others * cores) / boundCores, (boundCores - proxyCoresBetween(before, after)) / boundCores)
+    : 1 - others;
   return free > 0 ? free : null;
 }
 
+/**
+ * The cores this process drew between two readings; 0 where either has no
+ * reading of it.
+ *
+ * @param {{ takenAt: number, proxyCpuSeconds?: number | null }} before
+ * @param {{ takenAt: number, proxyCpuSeconds?: number | null }} after
+ * @returns {number}
+ */
+function proxyCoresBetween(before, after) {
+  const elapsedSec = (after.takenAt - before.takenAt) / 1000;
+  if (!(elapsedSec > 0) || !Number.isFinite(before.proxyCpuSeconds) || !Number.isFinite(after.proxyCpuSeconds)) {
+    return 0;
+  }
+  return Math.max(0, (after.proxyCpuSeconds - before.proxyCpuSeconds) / elapsedSec);
+}
+
 /**
  * How much CPU THIS process has used, across every thread it owns.
  *

package/services/encode/hwaccel.js

@@ -679,13 +679,13 @@ export async function benchmarkContention({ ffmpegBin, logger, clipsDir = CALIBR
   return penalties;
 }
 
-export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR }) {
+export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR, processorCores = null }) {
   const log = logger ?? { info: () => {}, warn: () => {} };
   const startedAllAt = Date.now();
   /** @type {Record<string, { pixelTerm: number, bitrateTerm: number, constantTerm: number }>} */
   const families = {};
   for (const [family, clips] of Object.entries(CALIBRATION_SETS)) {
-    const fitted = await fitOneFamily({ ffmpegBin, log, clipsDir, family, clips });
+    const fitted = await fitOneFamily({ ffmpegBin, log, clipsDir, family, clips, processorCores });
     if (fitted) {
       families[family] = fitted;
     }
@@ -721,10 +721,10 @@ export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBR
 /**
  * Fit one codec family's decode cost from its own clips.
  *
- * @param {{ ffmpegBin: string, log: { info: Function, warn: Function }, clipsDir: string, family: string, clips: string[] }} params
+ * @param {{ ffmpegBin: string, log: { info: Function, warn: Function }, clipsDir: string, family: string, clips: string[], processorCores?: number | null }} params
  * @returns {Promise<{ pixelTerm: number, bitrateTerm: number, constantTerm: number } | null>}
  */
-async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips }) {
+async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips, processorCores = null }) {
   const startedAllAt = Date.now();
   /** @type {Array<{ megapixelsPerSecond: number, megabitsPerSecond: number, costSecondsPerSecond: number }>} */
   const samples = [];
@@ -745,7 +745,7 @@ async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips }) {
   }
   for (const [index, clip] of clips.entries()) {
     const stream = streams[index];
-    const measured = stream ? await decodePipedStream(ffmpegBin, stream, log) : null;
+    const measured = stream ? await decodePipedStream(ffmpegBin, stream, log, processorCores) : null;
     if (!measured?.speed) {
       log.warn(
         `hwaccel: decode benchmark "${clip}" said nothing; ${family} not measured` +
@@ -998,9 +998,11 @@ function runCapturingStderr(ffmpegBin, args, timeoutMs) {
  *
  * @param {string} ffmpegBin
  * @param {{ bytes: Buffer, demuxer: string, megapixelsPerSecond: number, megabitsPerSecond: number, fps: number }} stream
+ * @param {{ info: Function, warn: Function }} [log]
+ * @param {number | null} [processorCores] - The cores this process may use, for `freeShareDuring`.
  * @returns {Promise<{ speed: number, windowSec: number, megapixelsPerSecond: number, megabitsPerSecond: number } | null>}
  */
-function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () => {} }) {
+function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () => {} }, processorCores = null) {
   return new Promise((resolve) => {
     const args = [
       "-hide_banner", "-loglevel", "error", "-nostats",
@@ -1047,7 +1049,7 @@ function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () =
       const hostAfter = hostBefore !== null && child?.pid && child.exitCode === null
         ? await sampleHost(child.pid).catch(() => null)
         : null;
-      const freeShare = freeShareDuring(hostBefore === null ? null : await hostBefore, hostAfter);
+      const freeShare = freeShareDuring(hostBefore === null ? null : await hostBefore, hostAfter, undefined, processorCores);
       try {
         child?.stdin?.destroy();
       } catch {
@@ -1418,9 +1420,13 @@ export function slopeOf(samples, minimumWindowSec = ENCODE_BENCHMARK_WINDOW_SEC)
  * A hardware encoder is limited by its device and not by the cores, so its
  * reading is kept as read.
  *
+ * `processorCores` is the cores this process may use (a container's quota or
+ * CPU set); the share divided out is of those where they are fewer than the
+ * host's (`freeShareDuring`, torrent-tv/meta#180).
+ *
  * @returns {Promise<{ speed: number, measuredSpeed: number, freeShare: number | null } | null>}
  */
-export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, frame = { width: BENCHMARK_REF_W, height: BENCHMARK_REF_H }) {
+export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, frame = { width: BENCHMARK_REF_W, height: BENCHMARK_REF_H }, processorCores = null) {
   const cpuBound = encoder?.kind === "software";
   return new Promise((resolve) => {
     const args = [
@@ -1470,7 +1476,7 @@ export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, fram
           resolve(null);
           return;
         }
-        const freeShare = freeShareDuring(before, after);
+        const freeShare = freeShareDuring(before, after, undefined, processorCores);
         resolve({ speed: freeShare === null ? value : value / freeShare, measuredSpeed: value, freeShare });
       });
     };

package/services/encode/quality/HostLoad.js

@@ -593,6 +593,7 @@ export class HostLoad {
       // What the offer will multiply a prediction by, in the same line as the
       // readings it comes from.
       ` available=${asPercent(this.hostAvailability.share)} for-encoders=${asPercent(this.hostAvailability.forEncoders)}` +
+      (Number.isFinite(this.hostAvailability.boundCores) ? ` of ${this.hostAvailability.boundCores.toFixed(2)} cores` : "") +
       ` free=${asPercent(free)}` + processor + late
     );
   }
@@ -664,7 +665,7 @@ export class HostLoad {
   /**
    * @param {{ elapsedSec: number, processShare: number | null, systemShare: number | null, rejected?: string[] } | null} share
    * @param {{ proxyCpuSeconds: number | null }} previous
-   * @param {{ proxyCpuSeconds: number | null }} sample
+   * @param {{ proxyCpuSeconds: number | null, processor?: { bound?: { cores: number } | null } | null }} sample
    * @returns {number | null} The proxy's own share of the machine, for the log.
    */
   #setAvailability(share, previous, sample) {
@@ -682,10 +683,14 @@ export class HostLoad {
     const proxyShare = Number.isFinite(previous.proxyCpuSeconds)
       ? (sample.proxyCpuSeconds - previous.proxyCpuSeconds) / (share.elapsedSec * cores)
       : null;
+    // Of the cores this process may use where that is fewer than the host's
+    // (torrent-tv/meta#180, phase 3).
     this.hostAvailability = availableShareFrom({
       systemBusy: share.systemShare,
       encoderShare: share.processShare,
-      proxyShare
+      proxyShare,
+      hostCores: cores,
+      boundCores: sample.processor?.bound?.cores ?? null
     });
     return proxyShare;
   }

package/services/server/wire-outputs.js

@@ -197,9 +197,6 @@ 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.
@@ -1117,7 +1114,6 @@ 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
@@ -1141,9 +1137,6 @@ 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,