fpga-archive-reports-arch · EAGLE4 FPGA archive
Draft-ahead (card drafts tree t+1 while the H200 verifies tree t): measured hit rates, what is exact, and the price of the inexact variant (2026-11-17)
Program 1: ONE drafter on the talon2 V80s (4 ATT + 2 MLPV), single stream, H200 verifies. Llama-3.2-3B bitnet_721 and Qwen3.8-27B GPTQ-2 W2A16.
Motto: a wall is a measured constraint to engineer around, toward the fastest flashable PDI. User directive: "make the drafter faster".
Fable design agent for box1-two-v2. Read-only study + stdlib replay. No build, flash, card access, GPU run, kill, move or removal. talon2: one read-only tar of serve logs, nothing run.
Rescoped mid-task by box1-two-v2: (1) verify that EXACT draft-ahead has hit rate 0; (2) the drafter-own-hidden variant is an ACCURACY TRADE (user ruling): quantify it, do not design toward shipping it; (3) use the window-2 / window-3 Qwen silicon logs; (4) list the exact overlap that remains.
Tags: [M] measured (file cited), [D] arithmetic on [M], [P] projection or assumption.
Short paths: R/ = this directory, E/ = R/draft_ahead_20261117/, Q/ = reports/results/QWEN_GPTQ2_20261116/, S/ = scripts/4c1/, B/ = scripts/qwen27b_open_release_20261102/c4q5120/.
0. Answer first
- Exact draft-ahead has hit rate 0 by construction, on both models. Confirmed in code [M]. The next tree's root row is
embed[bonus token] | fc(target hidden of the last accepted node), and every KV row of an accepted token is built from the target's hidden of that token. All of these are outputs of the verify that draft-ahead wants to overlap. Citations in section 1. box1-qwen-junior's finding (Q/D7_HOSTGAP_20261117.md:278-296) is correct, and the same holds for Llama. - The "hit rates" below are therefore hit rates of the INEXACT variant only (root = the drafter's own leaf state; output tokens stay exact because the target still verifies, but trees and accept change). That variant is an accuracy trade and a user ruling. Nothing here is designed toward shipping it; sections 3-4 are its price list.
- Measured hit rates [M].
drafter, set, config full path accepted (upper bound of any single-path guess) h1: on the best leaf and next token = drafter top-1 h2: accepted path is a prefix of the best path h3: 2 leaves x top-1 / x top-2 Qwen GPTQ-2 silicon, humaneval-80, d7 W2 (1,994 rounds) 85.96 % (1,714) about 82-84 % [D] (leaf top-1 not observable; x 0.975-0.987 level-1 rate) not observable (log holds level 1 only) not observable Qwen silicon, mt_bench:4, d7 W2 (275 rounds) 2.9 % (8) <= 2.9 % – – Qwen silicon, he4 + mt4 mix, d7 (363 rounds) 22.0 % (80) <= 22 % – – Qwen silicon, humaneval:4, d5 / d2 89.5 % / 98.6 % – – – Llama GPU fp16 drafter, humaneval 20 x 512, D = 7 (863 trees) 41.6 % 26.0 % (224) 57.2 % 32.6 % / 35.5 % same, D = 11 23.5 % 15.3 % (132) 50.3 % 18.8 % / 20.2 % - The ARCH_RETHINK fit for Qwen humaneval (0.86 full depth, hit 0.84) is now a measurement: 0.8596.
- h2 buys nothing: when the accept stops inside the tree, the bonus token is by construction not a drafted child, so no resident node can be the next root.
- A Qwen humaneval-80 silicon serve DOES exist (talon2
runs/qgwin_20261117w3c01/serve/*he80full*, copied toE/evidence/). The Llama 2-bit card drafter and Llama humaneval-80 still have no per-step log.
- Price of the inexact variant on Qwen humaneval-80 (replay of the 2,074 logged silicon rounds, section 3) [D on M, continuation accept is P].
continuation accept assumption tokens per verify wall tok/s (measured base 140.15; replay base 140.7) gain upper bound: a continuation tree accepts what the logged fresh tree accepted 7.42 (unchanged) 200.6 +42.6 % hazard saturates at the level-7 value (what Llama's measured deep levels do) 7.07 (−4.7 %) 187.4 +33 % hazard keeps its measured linear growth with depth 6.31 (−15 %) 160-164 +14 to +16 % twice that slope 6.10 (−18 %) 155-157 +10 to +11 % - GPU-only on the same 80 prompts is 326.83 tok/s [M]. Even the upper bound does not reach GPU-only (200.6 / 326.8 = 0.61). The ARCH_RETHINK "36.5 → 25 ms" was on the he4 + mt4 round; on humaneval-80 the decode round is 49.5 ms [M] and falls to 33.5 ms at best.
- Accept of a continuation tree is NOT-MEASURED for Qwen. Llama's measured analogue: a continuation collects 4.79 drafted tokens against 5.47 for a fresh tree at the same kind of position (−12 %), with a per-level hazard that is flat from level 3 to level 15 (section 2.2).
- Llama: unchanged verdict, marginal. Hit 15.3 % at d11.
R/ARCH_RETHINK_7CARD_20261117.md:192-198: +3.3 % at zero miss cost, break-even at 0.3 ms miss cost. It is the same accuracy trade. - Exact overlap that remains is small: about 1.5-2 ms of a 49.5 ms Qwen round (<= 4 %) and nothing new on Llama (section 5). The exact route to the same window is a faster verify-to-tree path: the in-RPC KV rows cost 1.27 ms each [D on M] and are 9.6 ms of a steady humaneval round plus 17.4 s of 102.7 s (16.9 %) as prompt rows; c5 KV_MROW addresses exactly that.
- One exact, config-only alternative has about the same modelled gain as the pessimistic draft-ahead rows: a deeper plain tree. With the measured hazards extended linearly, d11 gives about +11 % and d15 about +16 % decode tok/s on humaneval [P], no RTL, same exactness regime as every depth sweep. It needs goldens at md 11 / 15 and a window. It and draft-ahead rest on the same unknown, the Qwen hazard at levels 8-15.
- Cheapest measurement that decides both (no card): one
CARD=mock(or GPU-only with a per-round trace) humaneval run at depth 15 on a free H200;E/qwen_hit_rates.pythen prints the level 1-15 hazards. Recipe in section 6. Not run here: the box1 H200 belongs to the demo and talon2 is junior's.
1. Why the exact variant cannot hit [M, code]
| input of tree t+1 | Qwen GPTQ-2 path | Llama 7-card path | a verify-t output? |
|---|---|---|---|
| root token | B/c4q5120_bridge.py:797-799 r = ext.last[0], tok = ext.tokens[r] (extend buffers written by the verify's accept); first round :808 b.spec_info.bonus_tokens[0] |
S/c4_cardproc.py:668 drv.root_image(ids[n - 1], …), ids = the verify-extend gather's input ids |
yes |
| root feature h_fc | B/c4q5120_bridge.py:803-805 _c4q_orig_ptf(inner, ext.input_hidden[r:r+1]) = fc(target aux hidden, 15,360) |
S/c4_cardproc.py:654,668 entry = pm.get(S-1), entry[1] = the captured target 3H row; scripts/fpga_tree_marshaller.py:1414-1428 |
yes |
| KV rows of accepted tokens | B/c4q5120_bridge.py:23-24 and :1047,1059: row j = `embed[tok_j] |
fc(aux row j)` sent as KV-only rows | S/c4_cardproc.py:659-663 ses.add_rows(ps, k, v) + ses.sync: K/V of the GPU drafter's extend on target features, imported by KV_LOAD |
| ctx_len, md | host arithmetic | host arithmetic | known once the accept length is known |
- md5:
c4q5120_bridge.pyd169011d,c4_cardproc.pya6c31890,c4_kvi.pyde1c40b5. - What is already overlapped exactly: Llama launches the next tree at the verify-extend gather (
S/c4_cardproc.py:615, record run 3,200 / 3,200 early launches, 0 misses,reports/results/VERIFY_OVERLAP_SPECULATIVE_TREE_20261110.md:99); Qwen writes the previous root's row in the idle window (PREROOT, 1.26 ms,Q/D7_HOSTGAP_20261117.md:101). - So "predict the accepted endpoint" is not enough. Even a perfect guess of the endpoint lacks the target's hidden state there. Any tree drafted before the verify returns is rooted on something else.
2. Measured hit rates
2.1 Qwen GPTQ-2, silicon [M]
Source: STATS["trees_log"] of the serve bridge (B/c4q5120_bridge.py:1125-1126: request, ctx, root token, md, W, level-1 children) joined with the per-request output_ids. Advance per round = difference of consecutive root positions (accepted drafted tokens + bonus). Analyser E/qwen_hit_rates.py (md5 9ed11e89), output E/qwen_hit_rates.out. Asserted per round: root token == output_ids[ctx − prompt_tokens].
| run (ATT + MLPV) | set | rounds (non-final) | advance histogram | full path | mean advance | level-1 accepted; by rank 0 |
|---|---|---|---|---|---|---|
…w3c1g_he80full_20261117_154118 (0x13A9 + 0x13E5), d7 W2 V20 K_C 64 |
humaneval 80 x 256 | 1,994 | 1:24 2:30 3:35 4:44 5:44 6:48 7:55 8:1714 | 0.8596 | 7.5075 | 98.80 %; 98.73 % of those |
…w3c1b_full_20261117_152512 (same images) |
humaneval:4 | 88 | 8:72 | 0.818 | 7.35 | 98.9 %; 98.9 % |
| same | mt_bench:4 | 275 | 1:64 2:69 3:52 4:33 5:21 6:22 7:6 8:8 | 0.029 | 3.03 | 76.7 %; 85.3 % |
window 2 arm d Q/d7_hostgap_evidence/silicon_w2/…w2d_fullki… (0x139C + 0x139D) |
he4 / mt4 | 88 / 276 | (8:72) / (8:7) | 0.818 / 0.025 | 7.35 / 3.02 | – |
…w3c1d_full5… d5 |
he4 / mt4 | 114 / 274 | – | 0.895 / 0.131 | 5.71 / 3.00 | – |
…hgd2_best… d2 |
he4 / mt4 | 219 / 361 | – | 0.986 / 0.540 | 2.97 / 2.33 | – |
- Evidence md5: he80full jsonl effb947a, stats ce4f729d, client.log 40448024; w3c1b jsonl 30afd4f3, stats 71a6a910. Copied from talon2
/home/carrick/eagle4_talon2_4c1/runs/qgwin_20261117w3c01/serve/(read-only tar, 35 jsonl + 31 stats kept at/mnt/data/eagle4_scratch/draft_ahead_20261117/talon2_ro/). - Junior's "21.7 % full depth" (
Q/D7_HOSTGAP_20261117.md:183) is the he4 + mt4 mix: 79 / 364. Split by task it is 81.8 % on humaneval and 2.5 % on mt_bench. - Per-level stop hazard on humaneval-80 (stop at level l given level l reached): 1.20, 1.52, 1.80, 2.31, 2.36, 2.64, 3.11 % for levels 1-7 [D]. It rises about 0.30 points per level (fit 0.92 % + 0.304 % x level). That rise is the only Qwen evidence on how a drafter-rooted continuation ages.
- Full-path rounds cluster: runs of consecutive full-path rounds have mean length 7.9, up to 31.
- Limits, stated plainly: the log holds level-1 children only, so (h1) "bonus = drafter top-1 below the leaf", (h2) and (h3) are not observable for Qwen; one mt_bench round shows advance 1 with the next token among the level-1 children (a stop-token case, 1 of 275). No per-step log exists for Qwen at depth > 7.
2.2 Llama [M, GPU fp16 drafter traces of 10-20; 2-bit card drafter: no per-step log]
Traces /mnt/data/eagle4_scratch/4c1_spec_20261020/e1_traces/d3trace_he_d15_20261020_214838.jsonl (863 trees) and d3trace_he_d7_20261020_215113.jsonl (1,099). Analyser E/llama_hit_rates.py (md5 c77f8504, reuses S/d3_trace/analyze_overlap.py e35292a5), output E/llama_hit_rates.out.
| D = 7 | D = 11 | |
|---|---|---|
| h1 (best leaf accepted and next token = drafter top-1) | 26.0 % (224 / 863) | 15.3 % (132 / 863) |
| h2 (accepted path, k >= 1, is a prefix of the best path) | 57.2 % | 50.3 % |
| h3, 2 leaves x top-1 (2 parallel continuations) | 32.6 % | 18.8 % |
| h3, 2 leaves x top-2 (4 continuations) | 35.5 % | 20.2 % |
- Continuation accept, measured: after an h1 hit at D = 7 the continuation (levels 9-15 of the same beam, rooted on the drafter's own state) collects 4.79 drafted tokens (48 % reach the 7-level cap). A FRESH d7 tree on the step after a full-accept step collects 5.47 (native d7 trace, n 491). The continuation is worth 12 % less per verify.
- Hazard by level, d15 beam: 5.5, 6.9, 13.0, 14.2, 15.2, 14.6, 12.7 % for levels 1-7 and 14.8, 12.1, 12.3, 14.0, 14.3, 8.6, 13.2, 12.3 % for levels 8-15. It is flat from level 3 on. A target-rooted tree is better only in its first two levels; drafting on the drafter's own state does not keep degrading.
3. The inexact variant as a decision input (Qwen)
3.1 What it is, stated once (not a shipping design)
While verify t runs, the cards (a) body-pass the best leaf of tree t, (b) take its top-1 child as the root, (c) draft a d-level tree below it on the K/V the tree's own path left in the lane-chain slots. If verify t accepts the whole best path and its bonus token equals that root, tree t+1 is already there and goes straight to verify t+1; the exact KV rows of round t are ingested lazily in the next window. Otherwise the result is dropped and today's serial round runs. It is the same computation as a 2x deeper tree whose beam collapses to its best node at the split, verified in two halves.
- Output tokens: exact in every case (greedy target verify decides them).
- Trees and accept: different from today's whenever a continuation is used. This is the accuracy trade.
3.2 Round costs used [M / D], all on the humaneval-80 silicon run
| constant | value | derivation |
|---|---|---|
| decode per round, silicon | 49.50 ms | sum(wall − ttft) / 2,074 rounds, he80full.jsonl |
| decode per round, GPU-only | 20.11 ms | …w3c1h_he80gpu….jsonl (95491610), 2,081 rounds; wall 326.83 tok/s |
| TREE (card tree + IPC) | 9.32 ms | …hgt_tim….stats.json (f94e06ae): srv.tree_ms mean 8.73 over 363 rounds + (RPC − busy) median 0.60 |
| KVROW (one in-RPC KV-only row) | 1.275 ms | (t_card 53.35 s − 2,074 x TREE) / 26,685 in-RPC rows; the timing arm fits 1.20 ms |
| ROWB (bridge row build) | 0.158 ms / row | t_row 4.87 s / rows |
| REST (verify + scheduler + inject) | 21.43 ms | (decode − t_card − t_row) / rounds |
| prompt rows | 17.4 s of 102.7 s decode (16.9 %) | 13,630 rows x KVROW; mean prompt 171 tokens |
| CONT_X (continuation tree / plain tree) | 14 / 13 | one extra body pass for the leaf [P] |
- The replay's baseline reproduces the measured decode time to −0.42 % and the wall tok/s as 140.7 against 140.15.
- Window fit: deferred rows 8 x 1.275 + continuation tree 10.04 = 20.2 ms against REST 21.43 ms. It fits with 1.2 ms to spare, so the replay's miss wait is 0.0 ms in every arm. A hit round costs max(REST, window work).
3.3 Replay mock
E/draft_ahead_mock.py (stdlib; header documents policy and every assumption). It replays the logged rounds of each request on their real token stream and re-chunks them under the policy.
- Token check: in every arm and seed the concatenation of accepted chunks equals the logged
output_ids(chunks==output True). Exactness of the output is structural; the mock proves the bookkeeping only. - Continuation accept is the unknown. Four scenarios:
opt(= the logged fresh tree's advance at that position; the replay stays on the logged round grid, so this arm is pure [D on M]),flat,lin,lin2(extra per-level stops from the hazard models of section 2.1 [P]). A continuation that stops early is followed by a serial fresh round up to the logged grid point (conservative). - Chain cap C = how many continuation rounds may follow each other before a serial re-root.
- Outputs:
E/mock_he80.out,E/mock_mix_w3c1b.out,E/predictions.out. Re-run:cd E && python3 draft_ahead_mock.py evidence/qgserve_silicon_d7w2v20kc64_w3c1g_he80full_20261117_154118.jsonl.
humaneval-80, 20 seeds, wall tok/s (base 140.7):
| scenario | C = 1 | C = 2 | C = 4 | no cap | hit per opportunity (no cap) | tokens per verify (no cap) |
|---|---|---|---|---|---|---|
| opt | 167.8 (+19.2 %) | 179.2 (+27.4 %) | 188.9 (+34.3 %) | 200.6 (+42.6 %) | 0.839 | 7.42 |
| flat | 164.3 (+16.7 %) | 173.4 (+23.3 %) | 180.7 (+28.5 %) | 187.4 (+33.2 %) | 0.740 | 7.07 |
| lin | 160.3 (+13.9 %) | 163.7 (+16.3 %) | 163.2 (+16.0 %) | 162.5 (+15.5 %) | 0.548 | 6.31 |
| lin2 | 156.6 (+11.3 %) | 157.0 (+11.6 %) | 155.4 (+10.4 %) | 155.2 (+10.3 %) | 0.491 | 6.10 |
tok/s against hit rate (scenario opt, a logged full-path round hits with probability p): hit per round 0 → 140.7; 0.17 → 149.8; 0.35 → 160.5; 0.52 → 172.3; 0.69 → 186.2; 0.86 → 202.7. About +0.5 % tok/s per point of hit rate.
he4 + mt4 mix (w3c1b, base 107.7): opt +5.1 % (C = 1) to +8.6 % (no cap), hit per opportunity 0.12-0.18. The hazard scenarios are not meaningful on a two-task mix and are not quoted. mt_bench alone is at most 2.9 % hits: no gain.
3.4 Miss cost and the abort path [M code, U silicon]
- With the measured costs the window work ends before the verify returns, so a miss costs no wait and no abort on Qwen d7. Abort matters only if the continuation is deeper than the window.
- A safe mid-tree stop exists in RTL but not as a host abort.
loop_seq_d2.sv(207c9b66,verilog/forks/mlpv_cardstop_w8_20261113/tb/world/mlpv_cs1ad1/loop_seq_d2.sv): TREE_STOP ends a tree at a level boundary (:22-23"stop -> W 0x174 = 1 + STOP msg", HEAD retires every issued level-(L+1) item,:13); the host can force it throughTS_VERDICT [1] stop(:68, taken at:315) only when the card has raisedts_req(:566-571). - CARDSTOP_V is not an abort. It moves the TREE_STOP mass verdict onto the card for W != 2 (
:96-103,S/c4_cardstop.py:2-13), which removes the host's chance to answer. ARM_DRAIN_V is not an abort either: it drains outstanding AXI-lite master transactions before a re-ARM (:105-108,:308-309,:379). It is the piece that makes a re-arm after a stop safe (the re-arm race, memoryproject_loopseq_rearm_race_and_d7_20261113). - The MLPV has a host STOP bit (
S/c4_regmap.py:768TREE_CTL 0x174 [0]) that no kit path uses mid-tree. A host-initiated abort is NOT-MEASURED on any image. - KV state on a miss, today's mechanism: tree rows live in lane-chain slots above
ctx_len(S/c4_kvcommit.py:10-11, slot = ctx_hw + j x max_depth + l) and are never attended by the next tree; discarding a speculation is free and the next tree is byte-identical to a never-speculated run (measured on Llama 4C1, 0x12B1 + 0x128B,reports/results/FOURCARD_DESIGN_20261016/SPEC_DRAFT_KV_LATCH_20261020.md:60-74). Persistent rows are written only by host KV-only rows (Qwen) or KV_LOAD / COMMIT_PATH (Llama). Not re-measured on the Qwen 40 x 128 ATT images.
3.5 What the variant would need (spec level only, in case the user rules for it)
- Loop sequencer: a CONTINUE arm rooted at a resident node (leaf body pass, then the tree below its top-1 child, K/V read from the lane-chain path slots). No array change.
- MLPV: export of the leaf's top-1 token before the continuation (the host needs it to test the hit).
- Host: queue of one pending tree; hit test = advance == md + 1 and bonus == exported token; lazy exact row ingest ordered before the next continuation; goldens for the continuation tree from a bit-true model (it is a deterministic function of the same inputs as today's tree t).
- A host abort only if depth is pushed past the verify window.
First gate, before any RTL: the level 8-15 hazard measurement of section 6. Kill line from ARCH_RETHINK (
R/ARCH_RETHINK_7CARD_20261117.md:214): humaneval hit rate below 0.4; measured 0.86, so the gate that remains is the continuation accept.
4. Llama
- Root and rows are verify outputs (section 1), so exact = 0 hits.
- Inexact variant, measured inputs: h1 26.0 % at d7, 15.3 % at d11; continuation worth 4.79 against 5.47 drafted tokens.
- Gain:
reports/results/VERIFY_OVERLAP_SPECULATIVE_TREE_20261110.md:120-128models d11 at +2.5 to +5.3 % (extrapolated tail);R/ARCH_RETHINK_7CARD_20261117.md:192-198gives +3.3 % at zero miss cost on the 961.43 record and break-even at a 0.3 ms miss cost. No new Llama number is claimed here. - The verify is 3.45 ms and a d11 tree 2.0-2.6 ms, so the window is tight and a miss can cost real wait, unlike Qwen.
5. Exact overlap that remains (same trees, same accept)
| item | status | ceiling per Qwen d7 round | source |
|---|---|---|---|
| PREROOT: previous root's row written in the idle window | on | 1.26 ms (taken) | Q/D7_HOSTGAP_20261117.md:101 |
| EARLY (extend rows sent at prelaunch) | built, default off | 0.30-0.40 ms | same :33 |
| ROWVEC / TREEPIN / PREPOISON | built | 0.40-0.57 / <= 0.60 / about 0.1 ms | same :31-34 |
| cfg + loop-register pre-write in the idle window | not built | <= 0.2 ms | same :287 |
| pre-quantised embedding half of every row (static Q4.12 table instead of gather + q16 per round) | not built | <= about 1.0 ms: (t_row 2.35 − t_fc 0.32) x the emb share; overlaps ROWVEC | [D] he80 stats |
| prefetch of top-k bonus candidates | no ceiling | 0 | on a mid-tree stop the bonus is by construction not a drafted child; on a full path it is a child of the never-forwarded leaf |
| KV rows of predicted tokens during verify | impossible exactly | 0 | row = f(target hidden) |
| batch-2 ping-pong | preserved lever | aggregate only, not single stream | policy |
- Sum of what is still open and exact on the host: about 1.5-2 ms of 49.5 ms. Llama: the early launch and VERIFY_PRE (0.506 ms / step) are already in the record.
- The exact way to shrink the same gap is the row and tree time itself. On humaneval-80 the card RPC is 25.7 ms per round [M]: about 9.3 ms tree, 8.3 ms steady rows, 8.4 ms amortised prompt rows [D]. c5 KV_MROW (one sweep for N rows,
Q/DESIGN_C5_MULTIROW_KV_20261117.md) attacks 16.7 of those 25.7 ms; no draft-ahead variant touches the prompt rows.
6. One measurement decides the continuation accept and the plain-depth alternative
- Needed: Qwen GPTQ-2 advance histogram at depth 15, humaneval. It gives the hazard at levels 8-15 directly.
- Predictions to test (
E/predictions.out) [P]: mean tokens per verify of a plain W2 tree at d7 / d11 / d15 = 7.51 / 10.69 / 13.49 (flat), 7.51 / 10.64 / 13.25 (lin), 7.51 / 10.60 / 13.00 (lin2). The means are close; the histogram separates them (level-15 hazard 3.1 % / 5.5 % / 7.9 %). - Recipe for box1-qwen-junior (their kit, their window; nothing modified here): the window-3 launcher
Q/qgwin_20261116/w3/serveW3_remote.shwithCM=mock QS=15 QV=36 TK=humaneval:80(mock = CPU bit-true card model + real target, writestrees_log), thenpython3 E/qwen_hit_rates.py <arm>.jsonl. If the mock is too slow at d15,CM=none QS=15plusQS=11gives the two means only. About 5 minutes of H200 each.QV=36is my guess for the verify-token budget at d15 (20 at d7, 16 at d5); junior should set it. - Plain depth as the exact alternative [P]: steady round = REST + rows + tree with tree linear in depth. d7 187 → d11 213 → d15 224 tok/s steady; with prompt rows 149 → 167 (+11 %) → 174 (+16 %) decode tok/s. Needs goldens at md 11 / 15 (golden cover today: 2, 3, 5, 7) and the ctx window check.
7. NOT-MEASURED
- Accept of a continuation tree on Qwen; any Qwen per-step log beyond depth 7; (h1) leaf top-1, (h2), (h3) for Qwen.
- Llama hit rates on the 2-bit card drafter and on humaneval-80 x 256.
- A host-initiated mid-tree abort on any image; lane-chain discard and COMMIT_PATH on the Qwen ATT images.
- Tree time against depth on Qwen silicon beyond d7 (linear is assumed in section 6).
8. Files
E/qwen_hit_rates.py 9ed11e89, E/llama_hit_rates.py c77f8504, E/draft_ahead_mock.py (md5 in E/MD5SUMS.txt), outputs E/*.out, E/mock_constants.json, evidence copies E/evidence/ (md5 in E/MD5SUMS.txt).