tools/mega_factory/CALIBRATION.md

Megakernel family — measured calibration

All numbers from a Llama-3.2-1B-shaped model (16 layers, d=2048, ffn=8192, 32 q / 8 kv heads, head_dim 64, vocab 128256, tied lm_head) on one H200, torch 2.11 / triton 3.6. Scripts: scratchpad/mk_calib{,2,3,4}.py.

1. Seeded random weights are numerically sound

1/sqrt(fan_in) scaled init. Activation RMS 1.13 (layer 0) -> 4.65 (layer 15), a 4.1x growth over 16 layers. Logits: mean -0.005, std 1.000, max|.| 4.13, all finite.

Naive randn (unscaled) is NOT usable — it diverges over depth and the logit comparison degenerates into comparing noise.

2/3. The kernel-count gate is sound

	kernel launches / step	dominant share
eager torch	628	0.184
CUDA-graphed torch	628	0.184
gate	<= 8	>= 0.90

CUDA Graphs do not reduce kernel count — a graph replays the same nodes, it only removes launch overhead. Eager and graphed both miss the gate by ~78x. This is what makes the gate enforceable without any source inspection: a submission either fused the model or it did not.

4. There is real headroom to win

	ms/step	tok/s	x floor
weight-bandwidth floor (2.47 GB @ 4.8 TB/s)	0.515	1942	1.0
eager wall (python-dispatch bound)	8.294	121	16.1
eager GPU busy	2.063	485	4.0
CUDA-graphed wall (the real bar)	2.119	472	4.1

Eager wall-clock is python-bound and is NOT a meaningful baseline — quote the graphed number. 4.1x of headroom between graphed torch and the bandwidth floor is what a megakernel competes for.

5. Correctness gate: logit relative error, NOT top-k agreement

Top-k agreement was the original proposal. It does not work: random weights give near-uniform logits, so top-1/top-2 are often near-tied and flip on any numerical noise.

variant	top1 agree	top10 overlap	relerr top10	relerr all
bf16 vs fp32	1.000	0.971	0.0042	0.0161
fp8 weights vs fp32 weights	0.833	0.767	0.0317	0.1369
fp8 weights vs same fp8 bytes	0.917	0.967	0.0038	0.0141
bf16 rerun (determinism floor)	1.000	—	—	0.0000

Depth sensitivity (bf16 vs fp32), relerr is stable while top-1 collapses:

layers	top1	relerr all
16	1.000	0.0161
32	1.000	0.0186
48	0.792	0.0209

Rule: gate on full-logit relative error, per-task tol set at ~2x the measured bf16 value. 16L -> 3e-2, 32L -> 3.5e-2, 48L -> 4e-2.

6. fp8 tasks must ship PRE-QUANTISED weights

Quantisation error is not the kernel's error. If the fixture is fp32 and the agent quantises, a correct fp8 megakernel disagrees with the reference on 17% of steps (relerr 0.137). Shipping the weights already in e4m3 + per-channel scales, and having the reference dequantise those same bytes, brings it to relerr 0.014 — as tight as bf16.

7. Harness validation — the gate matrix

Three probe submissions, run against the generated grader:

submission	gate 1 correct	gate 2 kernels/step	gate 3 dominant	reward
stub (NotImplementedError)	error	—	—	0
unfused reference	PASS (relerr 0.0)	FAIL (644)	FAIL (0.18)	0
one Triton kernel, wrong math	FAIL (relerr 1.40)	PASS (1.0)	PASS (1.0)	0

The gates are independent and only a submission that is both correct and fused can score. Note the usual lane check ("reference-as-submission must score > 0") does NOT apply to this family by design — the reference is not a megakernel, so it must score 0.

8. Allocator-induced noise floor (fp8 only)

Two independent but identical fp8 builds diverge by relerr ~1.4e-2 over 8 decode steps. Cause: dequantisation allocates ~2.5 GB of fresh tensors, the two builds land at different addresses, cuBLAS selects different GEMV algorithms, and the resulting 1-ULP difference compounds through the KV cache. bf16 and long-context (no dequant allocation) are bit-identical at 0.0.

Tolerances are therefore set per task, at ~2x the combined expected error:

task	noise floor	expected impl error	combined	tol
bf16	0.000	0.016	0.016	3e-2
long-context	0.000	0.016	0.016	3e-2
fp8	0.014	0.016	0.021	4e-2

9. Measured rooflines

task	weights	KV	floor	eager us/step	x floor
bf16	2.47 GB	0.07 GB	529 us	8418	15.9
fp8	1.24 GB	0.07 GB	272 us	7859	28.9
long-context	2.47 GB	1.07 GB	739 us	8684	11.8

(eager is python-dispatch bound; the honest bar is CUDA-graphed torch at ~4x the floor.)

10. Solvability proof (private — not shipped to agents)

A compliant megakernel was written to confirm the three gates are simultaneously satisfiable: ONE persistent Triton kernel, grid of 64 co-resident blocks, all 16 layers + attention + the tied 128k LM head inside it, cross-layer dependencies as grid-wide atomic barriers (5 barriers/layer).

pilot	reward	correct	k/step	dominant
bf16	334.98 tok/s	1.0	3.0	0.9993
fp8	335.17 tok/s	1.0	3.0	0.999
long-context 32k	81.15 tok/s	1.0	3.0	0.999

(3 launches, not 1, because bar.zero_() and the token copy_() are each a kernel. Both trivial, so the dominant share stays at 0.999.)

Two things this proved that guesswork would not have:

1. A Triton grid-wide barrier works (verified standalone first, then in situ) — so Triton is a viable path, not just CUDA. Requires a co-resident grid or the spinning blocks deadlock.
2. The tolerance was mis-set. The proof kernel keeps the residual stream in fp32; the reference keeps it in bf16 (what production serving stacks do). Both are legitimate and they differ by 0.031, which FAILED the original 3e-2 gate. A tolerance that rejects the more precise implementation is simply wrong, so all three pilots moved to 5e-2 and the precision policy now states explicitly that either residual dtype passes.

Note the proof kernel (335 tok/s) does NOT beat CUDA-graphed torch (472 tok/s) — it round-trips every intermediate through HBM scratch. Graphed torch scores 0 (fails gate 2), so 335 is a valid leaderboard entry, but it shows the headroom is real and unclaimed: the floor is 1942 tok/s.

11. The bf16 output floor — corrected formula (measured)

A tempting but WRONG rule: "a bf16 output implies a relative-error floor of eps_bf16/(2*sqrt(3)) = 2.3e-3, so any tolerance under that rejects correct kernels." That figure is the error between a bf16 value and an exact one. It is NOT the floor between two implementations that both round to bf16.

Measured (scratchpad/floor.py): two implementations that both accumulate in fp32 and round once at the end disagree only on elements straddling a rounding boundary, giving

    relerr  ~=  sqrt(delta * ulp_bf16)

where delta is their fp32-level disagreement:

fp32-level delta	resulting bf16-output disagreement
1e-7	2.3e-5
1e-5	2.1e-4
1e-3	2.1e-3

Reaching 2.3e-3 requires delta ~ 1e-3 — i.e. doing the arithmetic itself in bf16, which the specs already forbid. So a bf16 output does not imply a 2.3e-3 floor; measured floors for fp32-accumulating kernels are 2e-5 to 1e-4, and tolerances of 1e-4..5e-4 on bf16 outputs can be perfectly correct.

Nine tasks were audited against the wrong rule; eight were false alarms and two were bit-exact (gradient-accumulation-fused, dist-tp-embedding-allreduce) — for those a very tight gate is a correct exactness check, not a sub-floor mistake.

The hunt still paid: quantized-optimizer-state had a 1.01x margin (correct Triton kernel 4.93e-4 vs a 5e-4 gate) — the same defect class as megakernel-mamba-hybrid. Raised to 2e-3.

Known weakness, not yet fixed

quantized-optimizer-state's discrimination is only 4.3x (target is >=10x), and the cause is the FIXTURE, not the tolerance: when an element's v_code is 0 and its gradient is ~0, v_new underflows, the AdamW denominator collapses to eps=1e-8, and that element's update becomes ~1e4x typical. The top 8 elements then carry 11-50% of the whole tensor's energy, so the relative-Frobenius gate is effectively reading a handful of hypersensitive values and E swings 10x between seeds. The proper fix is to clamp v_absmax away from zero in the input generator.

12. Quantisation fixtures: constrain the input span, and make SCALES exactly representable

Quantisation tasks have a failure mode the rest of the lane does not: the measured error depends on the input span, so a tolerance measured on a few seeds can be a lottery.

The rule that matters: per-TENSOR scales must be exactly representable

A scale drawn from a continuous distribution is not representable in bf16/fp16, so a kernel that carries it in anything narrower than fp32 incurs a rounding error. Whether that error is visible depends entirely on the scale's GRANULARITY:

• per-tensor (a scalar) -- the rounding error multiplies the WHOLE output coherently, so it shows up at full magnitude and is pure seed lottery.
• per-row / per-block -- independent rounding errors average out over the reduction, so the aggregate effect is small.

Measured on nvfp4-dequant-gemm, whose global_scale was an arbitrary fp32 scalar in [0.02, 0.06]:

fixture	E over 80 seeds	spread	headroom at worst seed (tol 5e-3)
(0.02 + 0.04*rand()).float()	1.3e-05 .. 2.9e-03	221x	1.73x
.to(torch.bfloat16).float()	0.0 .. 0.0	1x	deterministic

Note the tail kept GROWING with more seeds (max 2.4e-3 at 20 seeds, 2.9e-3 at 80): measuring a tolerance on a handful of seeds understates it. And the grader validates the last TIMED rep on seeds 10000+i, which are different from the correctness seeds 100+i -- so an unstable E can pass correctness and fail the timed check.

Scales are METADATA. These tasks grade the dequant-GEMM, not the rounding of one scalar. Round per-tensor scales onto the bf16 grid at generation so bf16, fp16 and fp32 all agree exactly. By contrast int8-w8a8-gemm's per-row a_scale/b_scale measured only a 1.29x spread and were deliberately LEFT alone -- rounding them would misrepresent real int8 dequant, which is fp32.

The other two span effects, measured and found mild here

• Energy concentration. Relative Frobenius error is dominated by the largest output elements -- which in a quantised kernel are exactly the ones that SET absmax and are best represented, so the metric under-weights the small elements quantisation damages most. Measured across the family the top 0.1% of elements carry 1-11% of the energy, which is not pathological. It DOES become pathological when a fixture admits denormal/underflow outliers: see section 11, where 8 elements carried 86% of the energy.
• Block dynamic range. absmax/rms over 128-element blocks measured 2.4-5.1 across the family; a gaussian block of that size expects ~3.2, so no task is currently outlier-dominated. If a task ever wants to model real activation outliers (AWQ/SmoothQuant), inject them at a FIXED count and magnitude rather than relying on the tail of randn, so the fixture is reproducible.

Span audit of the 23 remaining precision findings

_factory/span_check.py was run over all 23. No new span defects were found — nvfp4's per-tensor scale remains the only one.

outcome	n	detail
bit-exact, span irrelevant	9	E = 0.0 across 60 seeds (permutation/gather/layout/integer tasks)
audited, healthy	4	seed ratio 1.0-1.1x; energy_top0.1% 1.3-15.7%; absmax/rms 5.2-6.8
generic bf16 twin not meaningful	6	fp8/packed inputs, where a blanket bf16 round-trip is near-identity
separate harness	3	megakernel family: weights are seeded random and quantised fixtures are pre-quantised by rule (section 6)
legacy grader layout	1	muon-newton-schulz keeps no embedded reference

Reference thresholds observed across the lane, for calibrating future audits: energy_top0.1% runs 1-16% (>30% means the gate is reading a handful of elements — see section 11's 86% underflow case), and absmax/rms over 128-blocks runs 2.4-6.8 against ~3.2 for a gaussian.

The 6 not covered by the generic twin all had their tolerances measured by purpose-built independent implementations during the precision pass, which is the stronger check; the span twin would only have added seed-stability evidence.