@torrent-tv/proxy 2.101.0 → 2.101.2

package/package.json

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

package/server.js

@@ -1151,10 +1151,13 @@ export async function startProxyServer({
   });
   startProcessorReport({
     log: (line) => logger.info(line),
-    ffmpegPids: () => [...outputParts.outputs.values()]
-      .flatMap((output) => outputParts.encodeRuns.liveRunsOf(output))
-      .map((run) => run.process?.pid)
-      .filter((pid) => Number.isInteger(pid)),
+    ffmpegRuns: () => [...outputParts.outputs.values()]
+      .flatMap((output) => outputParts.encodeRuns.liveRunsOf(output).map((run) => ({
+        pid: run.process?.pid,
+        label: `${output.outputKey} #${run.from}..#${run.to}`,
+        film: Number(run.progress?.processedSeconds) - Number(run.progress?.startPositionSeconds ?? 0)
+      })))
+      .filter((run) => Number.isInteger(run.pid)),
     detailed: () => startupProfile.active()
   });
   // What the last life of this process left on the disk. The kernel kills this

package/services/encode/ProcessorBudget.js

@@ -0,0 +1,104 @@
+/**
+ * @file The one owner of what this machine's processor gives the encoders
+ * (torrent-tv/meta#180, phase 2: one owner, results unchanged).
+ *
+ * Before it, the same two readings reached the processor's decisions by six
+ * routes: the share of the machine other work leaves (`HostLoad`'s latest
+ * reading) was read separately by the admission, the quality offer, the cost
+ * model and the download share, and the contention penalties measured at
+ * startup were handed separately to the cost model, the runs and the plan. A
+ * reading that changes, or a new one (the processor's bound and measured free
+ * amount, `storage/machine-processor.js`), would have had to be threaded to
+ * each of them again. Now each asks this object, and the arithmetic stays in
+ * the two files that define it (`available-share.js`, `contention.js`).
+ *
+ * It lives in the encoding component because every question it answers is the
+ * encoders', and that component may import nothing outside itself; it is
+ * assembled beside the machine budget in `server/wire-outputs.js`. Its unit is
+ * today's: shares of the whole machine and seconds of the whole machine per
+ * second of film. Nothing here changes an answer.
+ */
+
+import { correctForAvailability, leftForEncoders } from "./available-share.js";
+import { contentionPenalty } from "./contention.js";
+
+export class ProcessorBudget {
+  /** @type {() => ({ share: number, forEncoders?: number, known: boolean } | null | undefined)} */
+  #reading;
+
+  /** @type {import("./contention.js").ContentionPenalties | null} */
+  #penalties;
+
+  /**
+   * @param {object} params
+   * @param {() => ({ share: number, forEncoders?: number, known: boolean } | null | undefined)} params.reading -
+   *   The latest share of the machine other work leaves, as `HostLoad` keeps it.
+   * @param {import("./contention.js").ContentionPenalties | null} [params.penalties] -
+   *   How much slower one job runs beside others, measured at startup.
+   */
+  constructor({ reading, penalties = null }) {
+    if (typeof reading !== "function") {
+      throw new TypeError("ProcessorBudget requires reading");
+    }
+    this.#reading = reading;
+    this.#penalties = penalties instanceof Map ? penalties : null;
+  }
+
+  /**
+   * The latest share of the machine other work leaves, or null before the
+   * first reading.
+   *
+   * @returns {{ share: number, forEncoders?: number, known: boolean } | null}
+   */
+  availability() {
+    return this.#reading() ?? null;
+  }
+
+  /**
+   * The share of the machine an encoder gets now; 1 where the host does not
+   * report its load.
+   *
+   * @returns {number}
+   */
+  left() {
+    return leftForEncoders(this.availability());
+  }
+
+  /**
+   * A speed measured alone on a quiet machine, as it would run now.
+   *
+   * @param {number} aloneSpeed
+   * @returns {number}
+   */
+  speedOf(aloneSpeed) {
+    return correctForAvailability(aloneSpeed, this.availability());
+  }
+
+  /**
+   * The measured penalties, as the plan and the runs read them.
+   *
+   * @returns {import("./contention.js").ContentionPenalties | null}
+   */
+  get penalties() {
+    return this.#penalties;
+  }
+
+  /**
+   * Replace the penalties, as a new measurement of them does.
+   *
+   * @param {import("./contention.js").ContentionPenalties | null} penalties
+   */
+  set penalties(penalties) {
+    this.#penalties = penalties instanceof Map ? penalties : null;
+  }
+
+  /**
+   * How much slower one job runs with `others` beside it.
+   *
+   * @param {number} others
+   * @returns {{ penalty: number, measured: boolean, from: number }}
+   */
+  penaltyFor(others) {
+    return contentionPenalty(others, this.#penalties);
+  }
+}

package/services/encode/quality/HostLoad.js

@@ -16,6 +16,7 @@ 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";
 import { SourceFiles } from "../../media/SourceFile.js";
+import { costKindForSession } from "./EncodeCost.js";
 
 /**
  * What the torrent thread says of itself over one interval: how late its event
@@ -537,7 +538,8 @@ export class HostLoad {
       this.#host.readSystemCpu?.() ?? null,
       this.#host.readEndedChildrenCpuSeconds?.() ?? null
     ]);
-    const sample = { takenAt: Date.now(), system, endedChildren, byPid: new Map(), proxyCpuSeconds: this.#host.readProxyCpuSeconds() };
+    const sample = { takenAt: Date.now(), system, endedChildren, byPid: new Map(), proxyCpuSeconds: this.#host.readProxyCpuSeconds(),
+      processor: this.#host.sampleProcessor?.() ?? null };
     const previous = this.#idleAvailabilitySample;
     this.#idleAvailabilitySample = sample;
     if (previous === null) {
@@ -556,7 +558,7 @@ export class HostLoad {
     // stands is seen beside what it is free for (torrent-tv/meta#178); a proxy
     // nobody watches stays quiet.
     if (share !== null && watched) {
-      await this.#sayMachine(share, proxyShare, 0, suspended);
+      await this.#sayMachine(share, proxyShare, 0, suspended, false, this.#processorLine(previous, sample, share, proxyShare));
     }
   }
 
@@ -566,7 +568,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, incomplete = false) {
+  async #sayMachine(share, proxyShare, running, suspended, incomplete = false, processor = "") {
     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
@@ -591,10 +593,74 @@ 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)}` +
-      ` free=${asPercent(free)}` + late
+      ` free=${asPercent(free)}` + processor + late
     );
   }
 
+  /**
+   * The processor's upper bound and its measured free amount over the same
+   * interval, for the machine's line (torrent-tv/meta#180, phase 1). Read
+   * beside today's figures and used by no decision; empty where the host does
+   * not take these readings.
+   *
+   * @param {{ processor?: object | null }} previous
+   * @param {{ processor?: object | null }} sample
+   * @param {{ processShare: number | null, systemShare: number | null }} share
+   * @param {number | null} proxyShare
+   * @returns {string}
+   */
+  #processorLine(previous, sample, share, proxyShare) {
+    if (typeof this.#host.processorBetween !== "function" || typeof this.#host.describeProcessor !== "function") {
+      return "";
+    }
+    const ourShare = Number.isFinite(proxyShare) && Number.isFinite(share.processShare) ? proxyShare + share.processShare : null;
+    return this.#host.describeProcessor(this.#host.processorBetween(previous.processor, sample.processor, {
+      systemShare: share.systemShare,
+      ourShare,
+      hostCores: Math.max(1, os.cpus().length)
+    }));
+  }
+
+  /**
+   * What each run's FFmpeg spent per second of film over the interval between
+   * two readings, with the runs beside it (torrent-tv/meta#180, phase 1).
+   *
+   * In CPU seconds per second of film (`k`), which is not the unit of
+   * `EncodeCost` (seconds of the whole machine per second of film, from
+   * speed): a run that uses all it is given has `cost = k / cores`. A `k` read
+   * beside other runs already carries their contention, so it is said with
+   * them; a run is alone only when no other run was alive at either reading.
+   * Only runs read at both ends that made film in between are said. For the
+   * log only.
+   *
+   * @param {{ takenAt: number, byPid: Map<number, number>, runs?: Map<number, { film: number | null, label: string, kind: string }> }} previous
+   * @param {{ takenAt: number, byPid: Map<number, number>, runs?: Map<number, { film: number | null, label: string, kind: string }> }} sample
+   */
+  #sayRunCosts(previous, sample) {
+    if (!previous.runs || !sample.runs) return;
+    const elapsedSec = (sample.takenAt - previous.takenAt) / 1000;
+    if (!(elapsedSec > 0)) return;
+    const alive = new Map([...previous.runs, ...sample.runs]);
+    const said = [];
+    for (const [pid, run] of sample.runs) {
+      const before = previous.runs.get(pid);
+      const cpuNow = sample.byPid.get(pid);
+      const cpuBefore = previous.byPid.get(pid);
+      if (!before || !Number.isFinite(cpuNow) || !Number.isFinite(cpuBefore) || cpuNow < cpuBefore) continue;
+      if (!Number.isFinite(run.film) || !Number.isFinite(before.film)) continue;
+      const film = run.film - before.film;
+      if (!(film > 0)) continue;
+      const cpu = cpuNow - cpuBefore;
+      const beside = [...alive].filter(([other]) => other !== pid).map(([, other]) => other.kind);
+      said.push(`${run.label} ${run.kind} k=${(cpu / film).toFixed(3)} CPU-s per film-s ` +
+        `(${cpu.toFixed(2)} CPU-s, ${film.toFixed(2)} film-s, speed ${(film / elapsedSec).toFixed(2)}x, ` +
+        `${(cpu / elapsedSec).toFixed(2)} cores), beside ${beside.length}` + (beside.length > 0 ? ` [${beside.join(", ")}]` : ""));
+    }
+    if (said.length > 0) {
+      logger.info(`processor: run cost over ${elapsedSec.toFixed(1)}s: ${said.join("; ")}`);
+    }
+  }
+
   /**
    * @param {{ elapsedSec: number, processShare: number | null, systemShare: number | null, rejected?: string[] } | null} share
    * @param {{ proxyCpuSeconds: number | null }} previous
@@ -658,9 +724,17 @@ export class HostLoad {
     // that ends meanwhile drops its process, and read after the await it threw
     // `Cannot read properties of null (reading 'pid')`, seven times in one
     // field session, each losing that reading (r64, torrent-tv/meta#178).
-    const runs = encoding.flatMap((session) => this.#host.liveRunsOf(session))
+    // With the film each has made and what it is, for its cost over the
+    // interval (torrent-tv/meta#180).
+    const runs = encoding.flatMap((session) => this.#host.liveRunsOf(session)
       .filter((run) => Number.isInteger(run.process?.pid))
-      .map((run) => ({ pid: run.process.pid, startedAt: run.startedAt }));
+      .map((run) => ({
+        pid: run.process.pid,
+        startedAt: run.startedAt,
+        film: filmMadeBy(run),
+        label: `${session.outputKey ?? session.id} #${run.from}..#${run.to}`,
+        kind: costKindForSession(session)
+      })));
     const [system, endedChildren, ...cpuReadings] = await Promise.all([
       this.#host.readSystemCpu(),
       this.#host.readEndedChildrenCpuSeconds?.() ?? null,
@@ -670,12 +744,15 @@ export class HostLoad {
     const byPid = new Map();
     /** @type {Map<number, number>} */
     const startedAt = new Map();
+    /** @type {Map<number, { film: number | null, label: string, kind: string }>} */
+    const runsByPid = new Map();
     runs.forEach((run, index) => {
       const seconds = cpuReadings[index];
       if (seconds !== null) {
         byPid.set(run.pid, seconds);
         startedAt.set(run.pid, run.startedAt);
       }
+      runsByPid.set(run.pid, { film: run.film, label: run.label, kind: run.kind });
     });
     const sample = {
       takenAt: Date.now(),
@@ -687,7 +764,9 @@ export class HostLoad {
       // piece store and the delivery. None of it is in the encode budget, and
       // on the addon host it is most of what the machine does while encoders
       // are suspended.
-      proxyCpuSeconds: this.#host.readProxyCpuSeconds()
+      proxyCpuSeconds: this.#host.readProxyCpuSeconds(),
+      runs: runsByPid,
+      processor: this.#host.sampleProcessor?.() ?? null
     };
     const previous = this.#hostLoadSample;
     this.#hostLoadSample = sample;
@@ -699,6 +778,7 @@ export class HostLoad {
     // `/proc` there are no readings at all, and the share is null rather than a
     // confident zero.
     const encoders = encoderCpuBetween(previous, sample);
+    this.#sayRunCosts(previous, sample);
     const share = this.#host.shareOfMachine(
       { takenAt: previous.takenAt, processCpuSeconds: encoders === null ? null : 0, system: previous.system },
       { takenAt: sample.takenAt, processCpuSeconds: encoders?.seconds ?? null, system: sample.system }
@@ -718,7 +798,7 @@ export class HostLoad {
     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);
+      await this.#sayMachine(share, null, running, suspended, true, this.#processorLine(previous, sample, share, null));
       return false;
     }
     // Kept for the quality offer, which predicts from a benchmark taken on a
@@ -726,7 +806,7 @@ export class HostLoad {
     // machine a new encoder could actually have. Only what nobody has been
     // charged for is subtracted — see `encode/available-share.js`.
     const proxyShare = this.#setAvailability(share, previous, sample);
-    await this.#sayMachine(share, proxyShare, running, suspended);
+    await this.#sayMachine(share, proxyShare, running, suspended, false, this.#processorLine(previous, sample, share, proxyShare));
     return false;
   }
 
@@ -756,3 +836,15 @@ export class HostLoad {
       : 0;
   }
 }
+
+/**
+ * The film a run has made since it started, from its progress, or null before
+ * it has said any.
+ *
+ * @param {{ progress?: { processedSeconds?: number, startPositionSeconds?: number } }} run
+ * @returns {number | null}
+ */
+function filmMadeBy(run) {
+  const made = Number(run.progress?.processedSeconds) - Number(run.progress?.startPositionSeconds ?? 0);
+  return Number.isFinite(made) && made >= 0 ? made : null;
+}

package/services/server/ViewerRequests.js

@@ -658,6 +658,7 @@ export class ViewerRequests {
           fileLength: stats?.fileLength,
           pieceLength: stats?.pieceLength,
           downloadRateReadings: this.#sourceRateReadings(measurement, output.file.sourceKey, stats, now),
+          downloadRateSummaries: this.#sourceRateSummaries(measurement, output.file.sourceKey),
           downloadForecast,
         });
       }
@@ -774,11 +775,14 @@ export class ViewerRequests {
         bufferLimitSeconds: input.bufferLimitSeconds,
         lookaheadSeconds: input.lookaheadSeconds,
         link: input.linkReadings,
-        sources: input.sources.map(({ id, complete, residence, downloadForecast, downloadRateReadings }) => ({
+        sources: input.sources.map(({ id, complete, residence, downloadForecast, downloadRateReadings,
+          downloadRateSummaries }) => ({
           id, complete, residenceRanges: residence?.length ?? 0,
           forecastAt: downloadForecast?.measuredAt ?? null, plannedPieces: downloadForecast?.ranges.length ?? 0,
           unknownPieces: downloadForecast?.ranges.filter(range => range.availableAt === null).length ?? 0,
-          downloadRateBytesPerSecond: downloadRateReadings?.lastValue ?? null
+          // The rate the forecast reads, and both summaries it was chosen from.
+          downloadRateBytesPerSecond: this.#host.playbackReadiness.forecastRate(downloadRateReadings, now, 0, "time"),
+          downloadRateSummaries
         })),
         tracks: tracks.map(({ id, processedSeconds, readings, segments, readySegmentIndices }) => ({
           id, processedSeconds, readings, segments: segments.length, prepared: readySegmentIndices.length
@@ -818,7 +822,7 @@ export class ViewerRequests {
     const rates = (forecast.operations ?? []).map(operation =>
       `${operation.track} ${operation.operation} ${Number.isFinite(operation.speed) ? operation.speed.toFixed(2) : "?"}x`);
     const downloads = (input.sources ?? []).map(source => {
-      const rate = source.downloadRateReadings?.lastValue;
+      const rate = this.#host.playbackReadiness.forecastRate(source.downloadRateReadings, now, 0, "time");
       return `${Number.isFinite(rate) ? (rate / 1_048_576).toFixed(2) : "?"} MB/s`;
     });
     logger.info(`playback held ${session.id} consumer=${consumerId}: delay ${seconds(delay)}s by ` +
@@ -949,7 +953,14 @@ export class ViewerRequests {
     }
     // Totals that went back belong to a torrent added again: read on from them.
     if (limit) source.limit = limit;
-    return sourceService(source.free.snapshot(), source.delivered.snapshot());
+    return sourceService(source.free.snapshot(), source.delivered.snapshot(),
+      (summary) => this.#host.playbackReadiness.forecastRate(summary, now, 0, "time"));
+  }
+
+  /** Both summaries a source's service was chosen from, for the forecast's log line. */
+  #sourceRateSummaries(state, id) {
+    const source = state.sources.get(id);
+    return source ? { free: source.free.snapshot(), delivered: source.delivered.snapshot() } : null;
   }
 }
 
@@ -962,12 +973,19 @@ export class ViewerRequests {
  * downloaded 5-18 MB/s, answered "service not advancing", and held the viewer
  * (r54, torrent-tv/meta#178). What the swarm did carry, it can carry.
  *
+ * The two are compared by the rate the forecast reads from them, bytes over
+ * the span measured. Compared by their last readings, a summary whose last
+ * reading was 10.7 MB/s and whose span read 0 B/s won over 3.4-16.7 MB/s
+ * carried, and the forecast held the viewer with no delay to state (r74,
+ * torrent-tv/meta#185).
+ *
  * @param {object | null} free - A rate summary (`RateTrend.snapshot`).
  * @param {object | null} delivered
+ * @param {(summary: object) => number | null} rateOf - The rate the forecast reads from a summary.
  * @returns {object | null}
  */
-export function sourceService(free, delivered) {
+export function sourceService(free, delivered, rateOf) {
   if (!free) return delivered;
   if (!delivered) return free;
-  return delivered.lastValue > free.lastValue ? delivered : free;
+  return (rateOf(delivered) ?? 0) > (rateOf(free) ?? 0) ? delivered : free;
 }

package/services/server/wire-outputs.js

@@ -101,6 +101,8 @@ import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObserva
 import { configurationKeyOf } from "../encode/fingerprint.js";
 import { qualityStateOf } from "../encode/quality/OutputQualityState.js";
 import { downloadShare } from "../storage/processor-share.js";
+import { describeProcessor, processorBetween, sampleProcessor } from "../storage/machine-processor.js";
+import { ProcessorBudget } from "../encode/ProcessorBudget.js";
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode/encode-run-state.js";
 import { secondsUntilClosed } from "../encode/piece-close-time.js";
 
@@ -303,6 +305,11 @@ export function wireOutputs({
     readProxyCpuSeconds,
     readSystemCpu,
     shareOfMachine,
+    // The processor's upper bound and measured free amount, said beside the
+    // machine's line and used by no decision yet (torrent-tv/meta#180).
+    sampleProcessor: () => sampleProcessor(),
+    processorBetween,
+    describeProcessor,
     liveRunsOf: (...args) => parts.encodeRuns.liveRunsOf(...args),
     runStateOf: (...args) => parts.encodeRuns.runStateOf(...args),
     get getSourceStats() { return parts.getSourceStats; },
@@ -344,7 +351,7 @@ export function wireOutputs({
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
     servesAudioSeparately: (...args) => parts.renditions.servesAudioSeparately(...args),
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
-    get contentionPenalties() { return parts.contentionPenalties; },
+    get contentionPenalties() { return parts.processor?.penalties ?? null; },
     get encodeCost() { return parts.encodeCost; },
     get encodeOrchestrator() { return parts.encodeOrchestrator; },
     get ffmpegBin() { return parts.ffmpegBin; },
@@ -730,7 +737,7 @@ export function wireOutputs({
       files.set(key, file);
     }
     const watched = [...files.values()].filter((file) => Number.isFinite(file.bytesPerFilmSecond) && file.bytesPerFilmSecond > 0);
-    const share = downloadShare({ availableShare: parts.hostLoad.hostAvailability?.share ?? 1,
+    const share = downloadShare({ availableShare: parts.processor?.availability()?.share ?? 1,
       baseDraw: parts.hostLoad.baseDraw, costPerMegabyte: parts.hostLoad.observedTorrentCostPerMegabyte, files: watched });
     // Kept beside the readings it is judged against: what the torrents moved
     // over each interval is said next to the limit in force (meta#178).
@@ -738,7 +745,17 @@ export function wireOutputs({
     void Promise.resolve(parts.setDownloadRate(share.bytesPerSecond, `film speed ${share.filmSpeed.toFixed(2)}x ` +
       `over ${watched.length} file(s), ${Math.round(share.capacity * 100)}% of the machine for the proxy`)).catch(() => {});
   };
-  parts.contentionPenalties = contentionPenalties instanceof Map ? contentionPenalties : null;
+  // The one owner of what the processor gives the encoders: the share of the
+  // machine other work leaves and the measured contention penalties, read by
+  // every place that decides on the processor (torrent-tv/meta#180).
+  parts.processor = new ProcessorBudget({ reading: () => parts.hostLoad.hostAvailability, penalties: contentionPenalties });
+  // Kept as the name the penalties were always set and read by, now the budget's.
+  Object.defineProperty(parts, "contentionPenalties", {
+    get: () => parts.processor.penalties,
+    set: (penalties) => { parts.processor.penalties = penalties; },
+    enumerable: true,
+    configurable: true
+  });
   // Seconds of film per second when the picture is COPIED, measured at
   // startup. Nothing else prices that branch: the other benchmarks measure
   // encoding and decoding, and a copy does neither.
@@ -907,11 +924,11 @@ export function wireOutputs({
     host: () => ({
       benchmark: parts.softwarePresetBenchmark,
       decodeModel: parts.decodeCostModel,
-      contentionPenalties: parts.contentionPenalties,
+      contentionPenalties: parts.processor.penalties,
       copySpeedX: parts.copySpeedX,
       audioCalibration,
       audioDescriptionOf,
-      availability: parts.hostLoad.hostAvailability,
+      availability: parts.processor.availability() ?? undefined,
       // WHICH encoder this host settled on. Only the software ladder is
       // benchmarked, so a reading taken off a hardware encoder cannot be
       // split into its decode and encode halves and is not filed as one.
@@ -951,7 +968,7 @@ export function wireOutputs({
     encodeCost: parts.encodeCost,
     occupiedCostSec: (fileKey) => parts.admission?.occupiedCost({ exceptFileKey: fileKey }).costSec ?? 0,
     occupancyKnownFor: (fileKey) => (parts.admission?.occupiedCost({ exceptFileKey: fileKey }).unpriced ?? 0) === 0,
-    availability: () => parts.hostLoad.hostAvailability ?? null,
+    availability: () => parts.processor.availability(),
     outputs: parts.outputs,
     stateFor: (session) => parts.encodeRuns.runStateOf(session),
     // WHICH HEIGHTS A LIVE VIEWER HAS ON SCREEN, as numbers. Who is watching
@@ -1045,7 +1062,7 @@ export function wireOutputs({
     finished: (address) => parts.outputs.outputsOn(address).some((session) => finishedOutput(session)),
     loadOf: (address) => parts.encodeCost.loadOfOutput(address),
     loadForCandidate: (spec, file) => parts.encodeCost.loadForCandidate(spec, file),
-    availability: () => parts.hostLoad.hostAvailability ?? null
+    availability: () => parts.processor.availability()
   });
   parts.encodeOrchestrator = new EncodeOrchestrator({
     inputDemandChanged: (address, windows) => {
@@ -1061,7 +1078,7 @@ export function wireOutputs({
     maxRunsFor: (address) => parts.encodeRuns.maxRunsForOutput(address),
     makeRun: ({ address, from, to, because }) => parts.encodeRuns.makeRunAt(address, from, to, because),
     segmentSeconds: parts.segmentDurationSec,
-    contentionPenalties: parts.contentionPenalties,
+    contentionPenalties: parts.processor.penalties,
     startingSpeedFor: (address) => parts.encodeCost.speedForOutput(address),
     segmentCoverage,
     // HOW IT ASKS TO DECIDE AGAIN. A plan that refuses to place anything

package/services/storage/machine-memory.js

@@ -163,7 +163,7 @@ function hostAvailable(readFile) {
 function containerRoom(readFile, hostTotal) {
   let membership;
   try {
-    membership = ownCgroup(readFile("/proc/self/cgroup"));
+    membership = cgroupOf(readFile("/proc/self/cgroup"), "memory");
   } catch {
     return null; // silent-ok: not Linux, or /proc is not readable.
   }
@@ -187,18 +187,19 @@ function containerRoom(readFile, hostTotal) {
 }
 
 /**
- * Which cgroup this process is in, for the memory controller.
+ * Which cgroup this process is in, for one controller (`memory`, `cpu`).
  *
- * A host in hybrid mode lists both versions; the memory controller is then on
- * version 1, named in the line that lists it.
+ * A host in hybrid mode lists both versions; a controller mounted on version 1
+ * is named in the line that lists it, and only then is version 2 the answer.
  *
  * @param {string} text - `/proc/self/cgroup`.
+ * @param {string} controller
  * @returns {{ version: 1 | 2, path: string } | null}
  */
-function ownCgroup(text) {
+export function cgroupOf(text, controller) {
   for (const line of text.split("\n")) {
     const match = /^\d+:([^:]*):(.*)$/.exec(line);
-    if (match && match[1].split(",").includes("memory")) {
+    if (match && match[1].split(",").includes(controller)) {
       return { version: 1, path: match[2] };
     }
   }
@@ -219,7 +220,7 @@ function ownCgroup(text) {
  * @param {string} path
  * @returns {string[]}
  */
-function levelsOf(mount, path) {
+export function levelsOf(mount, path) {
   const parts = path.split("/").filter(Boolean);
   if (parts.includes("..")) {
     return [];