agent/pitfalls.md

Pitfalls — each of these has actually cost real time

Measurement lies

• Timing the host, not the GPU. An eager reference measured 185 ms wall vs 2.06 ms GPU-busy. Use CUDA events around the region, and check the two agree.
• Timing under ncu. It serializes and replays; the number is meaningless.
• Warm cache. Re-running on the same buffer measures L2, not HBM. Use fresh inputs per rep.
• Autotune cache keyed on a stale shape. The first call compiles and tunes; time the steady state.
• Clock throttling. Long benchmarks drift. Lock clocks or take min-of-N, not mean.
• First-call outliers. cuBLAS/SDPA pick an algorithm per shape on first sight; warm up per shape.

Correctness traps

• A fast wrong kernel is the worst outcome. Correctness gate before optimization, always.
• Guessed tolerances. Measure E (independent correct implementation) and D (feature dropped); the gate goes between them. A gate that rejects a more precise kernel is a real and common bug.
• Top-k / argmax gates. Near-ties flip on ordinary noise; two correct implementations disagree.
• Integer outputs compared as floats. .float() is lossy above 2²⁴, so distinct large ids compare equal and a wrong kernel passes.
• The more precise implementation can be further from the reference. An fp64 RoPE differed 3.6e-4 from a reference that a merely-rearranged fp32 version matched to 1.6e-5.
• fp8 rounding is coarse. e4m3 eps is 0.125 — a 1% perturbation is below one ULP, so error is set by which elements flip a code, not by the perturbation size.
• tensor / python_float is a reciprocal-multiply and flips ~0.05% of fp8 codes. Use a 0-dim tensor.

Implementation traps

• Hardcoded SM count or a grid sized from one. Query multi_processor_count.
• Persistent kernel with a grid larger than fits. The spinning blocks deadlock. Check co-residency.
• Assuming a dimension is a multiple of the tile. Ragged shapes are graded deliberately.
• Register spills masquerading as a memory problem. Check LDL/STL in the SASS.
• Padding shared memory to avoid bank conflicts — breaks 128-bit alignment for 2-byte types. Swizzle instead.
• bf16 accumulation. Accumulate in fp32; a bf16 running sum drifts past tolerance on its own.

Reading a profile wrong

Counters are hints, not verdicts. A measured example from this machine: cuBLAS's own bf16 GEMM (nvjet_tst_256x128_64x4..., 4096³) profiles at SM 90.5%, DRAM 16.5%, occupancy 14.6%, 168 registers/thread, 136k shared-memory bank conflicts — and it is essentially the fastest thing that runs on the device. Three of those numbers look like defects.

• Low occupancy is not a bug. A GEMM wants big register-resident accumulator tiles; that costs registers, which caps occupancy by construction. Occupancy only matters when you are latency-bound and have nothing else hiding the latency. Check the SM/DRAM throughputs first: if one is already high, occupancy is not your problem.
• High register count is not automatically a spill. 168 regs/thread is a deliberate trade. Confirm a spill by looking for LDL/STL in the SASS (tools/dump_ir.sh sass), not by reading the count.
• Bank conflicts reported on a highly-tuned kernel are often on a path that is already overlapped. Fix them when a swizzle is missing, not because the counter is nonzero.

The order that works: establish which resource is saturated (SpeedOfLight), then look for a specific mechanism explaining the gap. Never chase a counter that merely looks unhealthy.

Process traps

• Abandoning a good optimization because it currently has a bug. The most expensive habit there is. Record why a variant was dropped: slower, or merely broken.
• Losing the last-known-good. Always keep a runnable fallback.
• Optimizing before profiling. And profiling with ncu before nsys has told you the time is in the kernel at all.
• Stopping because a percentage looks good. The leaderboard is uncapped and the roofline is an attribution formula, not a wall — a kernel that moves fewer bytes than counted can beat it.