# Speeds from RAM alone: the data kit

This folder holds the records behind *Speeds from RAM alone*
(https://research.strata2signal.com/speeds-from-ram-alone/): what language models write at with no graphics card
in the path, measured on three machines under one registration frozen 2026-11-01T15:09:22Z, every card in each
machine hidden from the run and proven unused. Each machine has a folder of its own, named as the page names it:

- `laptop/`: the laptop with an Intel Core Ultra 9 290HX Plus and 64 GB of DDR5-5600, measured 2026-11-05,
  16:10:36Z to 16:36:34Z, `gemma4:26b` and `mistral-small3.2:24b` under Ollama 0.32.15;
- `two-channel-desktop/`: the desktop with an AMD Ryzen 7 3700X and 32 GB of DDR4, measured 2026-11-04,
  15:39:29Z to 16:16:21Z, the same two models under the same Ollama;
- `eight-channel-desktop/`: the desktop with an AMD EPYC 7532 and 128 GB of DDR4-3200 in eight channels, measured
  2026-11-03, 07:30:01Z to 07:59:09Z, Qwen3.8-Flash-Next IQ3_S under llama.cpp build 11514.

In each folder, three files, copied from the bench's own result folder and rewritten only by the named rules in
`provenance.json`:

- `summary.json`: the bench's own summary of the run, written by its reader from the run's rows and telemetry;
- `triad.json`: the STREAM triad's receipt;
- `RECEIPT.txt`: the one-line RAM-RECEIPT the run printed when it finished.

`index.json` lists every file but itself, `provenance.json` and the folder's index page, each with its size and
sha256.

## Where each figure on the page comes from

| On the page | File here | Fields |
|---|---|---|
| Best triad, worst of 9, triad threads | `<machine>/triad.json`, `<machine>/summary.json` | `receipt.TRIAD_BEST_GBs`, `receipt.TRIAD_WORST_GBs`, `receipt.threads`; `triad.best_gbs`, `triad.worst_gbs`, `triad.threads` |
| The rule: `gemma4:26b` at the default threads, k and its verdict | `laptop/summary.json`, `two-channel-desktop/summary.json` | `arms[0].decode_median`, `bandwidth_rule.k`, `bandwidth_rule.band`, `bandwidth_rule.verdict` |
| The laptop's and the two-channel desktop's tables: threads, writing, reading the prompt, first word | `laptop/summary.json`, `two-channel-desktop/summary.json` | per arm: `threads_seen`, `decode_median`, `prefill_median` (and `prefill_n`, the runs it counts), `first_word_median_ms` |
| CPU package while writing and energy a request (NOT WALL) | `laptop/summary.json`, `eight-channel-desktop/summary.json` | per arm: `decode_package_w_median`, `request_kj_median`; per run: `energy_decode`, `energy_prefill`, `energy_request` |
| Idle package (NOT WALL) | `laptop/summary.json`, `eight-channel-desktop/summary.json` | `idle_package.mean_w` |
| THROTTLED | `laptop/summary.json`, `two-channel-desktop/summary.json` | per arm: `throttled_runs`; per run: `throttled`; on the two-channel desktop also `throttle_rule` and `throttle_unread_runs` |
| The hottest sensor, the two-channel desktop's control temperature | every `summary.json` | per run: `cpu_temp_max_c`; on the two-channel desktop, `sensor_temp_max_c` |
| The eight-channel desktop's table: writing, share of the ceiling, reading the prompt, first word | `eight-channel-desktop/summary.json` | per arm (`R1-t8`, `R1-t32`, `R1-t16`, in the order they ran): `decode_median`, `ceiling_tok_s`, `share_of_ceiling`, `prefill_median`, `first_word_median_ms` |
| The first part read into memory before the first block (54.8 GB, 16.9 s) | `eight-channel-desktop/summary.json` | `preread.bytes`, `preread.seconds` |
| The two registered expectations | `eight-channel-desktop/summary.json` | `r1_tests` (`R1-a`, `R1-b`), `r1_pair` (the earlier page's two rows on this binary) |
| No card used | every `summary.json` | `no_card.legs`, `no_card.verdict`; on the eight-channel desktop, per run, `cards_util_max` (the cards' own work, as the window's sampler read it) |
| Other work on the machine (BOX SHARED), pages faulted back from disk | every `summary.json` | per run: `other_cpu_cores`, `box_shared`, `cold_pages`; per arm: `box_shared_runs`, `cold_page_runs` |
| The chart's two new bars | `laptop/summary.json`, `two-channel-desktop/summary.json` | `arms[0].decode_median` |

## How the figures were counted (the page's own rules)

- **Medians of three.** Each arm, one model at one thread setting, ran a warm-up and three scored runs; every
  printed figure is the median of the three (`arms[].runs[]` holds each run). The page prints rounded figures;
  the files keep the raw values.
- **Writing speed.** On the two Ollama machines, `decode_tok_s` is the engine's token count over its writing time
  and `decode_alt_tok_s` the same by the client's clock. On the eight-channel desktop, `decode_tok_s` is the
  client's clock, the tokens after the first over the time after the first, and `decode_alt_tok_s` the server's
  own figure. Prompt-reading speed is the engine's, from runs whose prompt reading passed its checks
  (`prefill_ok`); a refused rate would sit in `prefill_refused_tok_s` and is never quoted (none was refused).
- **The first word.** On the two Ollama machines, the client's clock less the model's load (`load_s`), because
  every scored run started from a fresh load; on the eight-channel desktop, whose model stayed loaded through each
  block, the time to the first token, the first request after each load included.
- **Energy.** From the processor package's own counter, never a meter at the wall: every watt and joule here is
  NOT WALL. A request's energy runs from sending it to its last token: on the laptop that includes the model's
  fresh load from disk; on the eight-channel desktop it does not. The two-channel desktop's counter could not be
  read (`rapl_source`), so its energy fields are null. An energy window whose ends overshot the counter's samples
  by up to two seconds is measured over the part the samples cover and marked `edge_clamped`.
- **THROTTLED.** A run during which the processor's throttle counter rose (the laptop) or its control temperature
  reached its limit (the two-channel desktop, `throttle_rule`), at any point from sending the request to its last
  token, the model's load and the prompt's reading included; a label, never a reason to drop the figure. The
  eight-channel desktop publishes no throttle counter, so the label does not read there. The page's split of the
  laptop's throttle counts and package temperatures into the prompt's reading and the writing was read from the
  one-second telemetry, which is not in this kit (below); the summaries carry each run's label and its hottest
  sensor over the whole request.
- **BOX SHARED.** A run during which other work on the machine averaged more than one core; none did.
- **No card.** Every check had to pass: the sandbox's own probe (`fence_probe`), no run voided (`no_void`), the
  host's card monitor outside the sandbox never listing a process of the run (`host_cards_never_ran_ours`, or
  `root_cards_never_ran_ours` where the window's own sampler read the cards), on the two Ollama machines zero
  bytes on any card after every load (`size_vram_0`, over `size_vram_reads` reads), and on the eight-channel
  desktop the writing speed under the ceiling (`under_ceiling`). The eight-channel desktop's start logs, which the
  page also cites (only processor buffers, no device found), are not in this kit.
- **The bandwidth rule.** For `gemma4:26b` at the engine's default threads, k is the writing speed over the
  machine's best triad; the rule holds if k lands between 0.20 and 0.28 (`bandwidth_rule.band`), else it reads
  above or below.

## What is not here, and why

- **The per-run rows** (`rows.jsonl`): they carry the engine's command lines with home and model paths, the shape
  of the request bodies and the pre-read's file path. Every run's figures the page prints are in the summaries.
- **The telemetry**: the one-second host telemetry and, on the eight-channel desktop, the window's own sampler,
  which names the live services' processes on the cards.
- **The registration's files**: the pin file (it carries paths and the frozen prompt's byte count and hash), the
  sandbox's probe and argument files, the status and unit logs, the laptop's restore log and timer markers, and
  the eight-channel desktop's window log folder (it names seats and ports). The registration and its two signed
  amendments are cited by date on the page.
- **The prompt**: its text is in no file here and is published nowhere.
- **Three things rewritten, by rule**: each triad receipt's `binary` field, the path the triad's program ran from,
  is withheld and reads `withheld-2026-11-06`; the laptop summary's `rapl_source` names its energy counter in words
  rather than by its local file; and the machines' private names, in the `box` and `run_id` fields and at the
  start of each RECEIPT line, are the names the page gives them. `provenance.json` counts every firing.

Every time in this folder is UTC; `t0` and `t1` are Unix seconds. Licence: CC BY 4.0; name the source and link to it.