SlotsPage

tcmts.studio.SlotsPage · #xadidacs · term · runs on the server

uses node:fs

The machine's slots, which every tcm on it shares (withSlot): what one holds keeps about a core busy (a suite, test definitions, checking, an app build). Each slot and what holds it; the runs holding them, each with what it is, whose codebase (this one, or another) and branch, its process, how many slots and since when; the line waiting for one, in turn; how many were held and waited for over the last half hour, as the studio saw them; and why there are as many as there are (the machine's cores and memory, or TCM_SLOTS). Made again every few seconds while shown.

import { shownUptime, slotBudget, slotsNow, slotWork } from "#codebase/tcmts/cli/running";
import { shareNow } from "#codebase/tcmts/share";
import { BranchLink, Live, slotSamples, StudioFrame, studioShare } from "#codebase/tcmts/studio";
import fs from "node:fs";
import path from "node:path";

export async function SlotsPage() {
  studioShare();
  const s = shareNow();
  if (!s.signedIn) return <StudioFrame tab="slots" title="Sign in">{null}</StudioFrame>;
  const now = Date.now();
  const root = s.cb.lay.root;
  const real = (() => {
    try {
      return fs.realpathSync(root);
    } catch {
      return root;
    }
  })();
  const slots = slotsNow();
  const budget = slotBudget();
  const ours = (r?: string) => !!r && (r === root || r === real);
  const whose = (r?: string) =>
    !r ? "" : ours(r) ? "this codebase" : `…/${path.basename(r) === "codebase" ? path.basename(path.dirname(r)) : path.basename(r)}`;
  const said = (kind: string) =>
    ({ "tcm test": "suites", "test definitions": "test definitions", "app build": "an app build", verify: "a verify" })[kind] ?? kind;
  const COLOURS = ["var(--acc)", "var(--srv)", "var(--brw)", "var(--any)", "var(--warn)", "var(--ok)"];
  const runs = [...Map.groupBy(slots.held, (h) => `${h.pid} ${h.what}`).values()].map((hs, i) => ({
    ...slotWork(hs[0]!.what),
    what: hs[0]!.what,
    pid: hs[0]!.pid,
    count: hs.length,
    since: Math.min(...hs.map((h) => h.since)),
    colour: COLOURS[i % COLOURS.length]!,
    tokens: new Set(hs.map((h) => h.token)),
    details: hs.flatMap((h) => (h.detail ? [h.detail] : [])),
  }));
  // (a suite by its last two parts: e2e.studio.testStudio as studio.testStudio)
  const short = (d: string) => d.split(".").slice(-2).join(".");
  const colourOf = (token: string) => runs.find((r) => r.tokens.has(token))?.colour;
  const wanted = slots.waiting.reduce((n, w) => n + (w.want ?? 1), 0);
  const longest = slots.waiting.length ? Math.max(...slots.waiting.map((w) => now - w.since)) : 0;
  const mine = slots.held.filter((h) => ours(slotWork(h.what).root)).length;
  const branchLink = (r: { root?: string; branch?: string }) =>
    r.branch ? (
      ours(r.root) && s.cb.store.hasBranch(r.branch) ? (
        <BranchLink branch={r.branch} />
      ) : (
        <span className="mono">{r.branch}</span>
      )
    ) : null;
  // the last half hour, as bars of a minute each: the most held, and the most waited for, in it
  const minutes = Array.from({ length: 30 }, (_, i) => {
    const from = now - (30 - i) * 60_000;
    const in_ = slotSamples.filter((x) => x.at >= from && x.at < from + 60_000);
    return in_.length
      ? {
          size: Math.max(...in_.map((x) => x.size)),
          mine: Math.max(...in_.map((x) => (x.byRoot[root] ?? 0) + (real !== root ? (x.byRoot[real] ?? 0) : 0))),
          held: Math.max(...in_.map((x) => x.held)),
          waiting: Math.max(...in_.map((x) => x.waiting)),
        }
      : undefined;
  });
  const top = Math.max(budget.size, ...minutes.map((m) => (m ? m.held + m.waiting : 0)));
  const watched = slotSamples[0]?.at;
  const gb = (b: number) => `${Math.round(b / 2 ** 30)} GB`;
  return (
    <StudioFrame tab="slots" title="Slots">
      <Live />
      <div className="pagehead">
        <h2 className="title">Slots</h2>
        <span className="muted">the work every tcm on this machine runs at once, together</span>
      </div>
      <div className="box">
        <div className="boxbody">
          <div className="stats">
            <div className="stat"><b>{slots.held.length} of {slots.size}</b>in use</div>
            <div className="stat"><b className={slots.waiting.length ? "warn" : ""}>{slots.waiting.length}</b>waiting{wanted > slots.waiting.length ? `, for ${wanted} slots` : ""}</div>
            <div className="stat"><b>{longest ? shownUptime(longest) : "—"}</b>the longest wait</div>
            <div className="stat"><b>{mine}</b>held for this codebase</div>
          </div>
        </div>
        <div className="slotbar" role="img" aria-label={`${slots.held.length} of ${slots.size} slots held`}>
          {Array.from({ length: slots.size }, (_, i) => {
            const h = slots.held[i];
            if (!h) return <span key={i} title="free" />;
            const w = slotWork(h.what);
            return (
              <span
                key={i}
                style={{ background: colourOf(h.token) }}
                title={`${h.detail ? `${short(h.detail)}: ` : ""}${said(w.kind)} of ${whose(w.root)}${w.branch ? ` on ${w.branch}` : ""}, ${shownUptime(now - h.since)}`}
              />
            );
          })}
        </div>
      </div>

      <div className="cols-2" style={{ display: "grid", gap: 24 }}>
        <div>
          <div className="box">
            <div className="boxhead">
              <b>Held by</b>
              <span className="count">{runs.length}</span>
              <span className="muted">each run, and the slots it holds</span>
            </div>
            {runs.length ? (
              runs.map((r) => (
                <div className="lrow" key={`${r.pid} ${r.what}`} title={r.what}>
                  <div>
                    <span className="swatch" style={{ background: r.colour }} /> <b>{said(r.kind)}</b>{" "}
                    <span className="muted">of {whose(r.root)}</span> {branchLink(r)}
                    <div className="muted" style={{ fontSize: 12.5, marginTop: 2 }}>
                      process {r.pid} · since {shownUptime(now - r.since)} ago
                    </div>
                    {r.details.length > 0 && (
                      <div className="muted mono" style={{ fontSize: 12, marginTop: 2 }}>
                        running {r.details.map(short).join(", ")}
                      </div>
                    )}
                  </div>
                  <span>{r.count} slot{r.count > 1 ? "s" : ""}</span>
                </div>
              ))
            ) : (
              <div className="empty">Nothing holds a slot: no tcm is testing, checking or building.</div>
            )}
          </div>
          <div className="box">
            <div className="boxhead">
              <b>Waiting</b>
              <span className="count">{slots.waiting.length}</span>
              <span className="muted">served first come, first served</span>
            </div>
            {slots.waiting.length ? (
              slots.waiting.map((w, i) => {
                const x = slotWork(w.what);
                return (
                  <div className="lrow" key={w.token} title={w.what}>
                    <div>
                      <span className="muted">{i + 1}.</span> <b>{said(x.kind)}</b> <span className="muted">of {whose(x.root)}</span> {branchLink(x)}
                      <div className="muted" style={{ fontSize: 12.5, marginTop: 2 }}>
                        process {w.pid} · waiting {shownUptime(now - w.since)}
                      </div>
                    </div>
                    <span>wants {w.want ?? 1}</span>
                  </div>
                );
              })
            ) : (
              <div className="empty">No one is waiting.</div>
            )}
          </div>
          <div className="box">
            <div className="boxhead">
              <b>The last half hour</b>
              <span className="muted">
                {watched ? `the most held and waited for, minute by minute, as the studio saw them since ${new Date(watched).toTimeString().slice(0, 5)}` : "as the studio sees them, from now on"}
              </span>
            </div>
            <div className="boxbody">
              <svg className="slotchart" viewBox="0 0 300 80" preserveAspectRatio="none" role="img" aria-label="slots held and waited for, each minute of the last half hour">
                <line x1="0" x2="300" y1={80 - (budget.size / top) * 76} y2={80 - (budget.size / top) * 76} className="cap" />
                {minutes.map((m, i) => {
                  if (!m) return null;
                  const h = (n: number) => (n / top) * 76;
                  const x = i * 10 + 1;
                  return (
                    <g key={i}>
                      <rect x={x} width={8} y={80 - h(m.mine)} height={h(m.mine)} className="mine" />
                      <rect x={x} width={8} y={80 - h(m.held)} height={h(m.held - m.mine)} className="others" />
                      <rect x={x} width={8} y={80 - h(m.held + m.waiting)} height={h(m.waiting)} className="waiting" />
                    </g>
                  );
                })}
              </svg>
              <div className="legend" style={{ marginTop: 8 }}>
                <span className="li"><span className="swatch" style={{ background: "var(--acc)" }} />this codebase's</span>
                <span className="li"><span className="swatch" style={{ background: "var(--dim)" }} />others'</span>
                <span className="li"><span className="swatch" style={{ background: "var(--warn)" }} />waiting</span>
                <span className="li muted">the line: {budget.size} slots</span>
              </div>
            </div>
          </div>
        </div>
        <aside className="side">
          <div className="sect">
            <h4>Why {budget.size}</h4>
            {budget.env ? (
              <p className="muted" style={{ marginTop: 0 }}>
                <code>{budget.env}={budget.size}</code> says so, for the tcm the studio runs with. Without it this machine would have{" "}
                {Math.max(2, Math.min(budget.byCores, budget.byMemory))}.
              </p>
            ) : (
              <p className="muted" style={{ marginTop: 0 }}>
                A slot for each performance core and one for every three efficiency cores, with 2 GB of memory each; never fewer than 2. <code>TCM_SLOTS</code> sets another number.
              </p>
            )}
            <dl className="kv">
              <dt>Cores</dt>
              <dd>{budget.cpus}{budget.performance !== budget.cpus ? `, ${budget.performance} of them performance cores` : ""}</dd>
              <dt>By cores</dt>
              <dd>{budget.byCores}</dd>
              <dt>Memory</dt>
              <dd>{gb(budget.memory)}</dd>
              <dt>By memory</dt>
              <dd>{budget.byMemory}</dd>
            </dl>
          </div>
          <div className="sect">
            <h4>What takes one</h4>
            <div className="muted">
              Each suite <code>tcm test</code> runs, test definitions (a slot per Vitest project), checking, an app build,
              and each part of a verify. Work inside a slot (a suite's own tcm) takes no more.
            </div>
          </div>
        </aside>
      </div>
    </StudioFrame>
  );
}

uses

used by