Module Autotune

Output spatial symbol (a plain iterator of the output).

Kernel-window symbol (read by the kernel, not the output).

Padding offset on the input access (<= 0 for padded convs).

The reduction loop to split.

The accumulated node.

The reduction loop's extent.

The target's cell count — the site's whole output parallelism.

Estimated segment cost: the accumulation statement's trip count (the product of every enclosing loop extent) — the serial work a split could recover. The ranking key (gh-ocannl-541).

The gh-466 scatter form (Set_dynamic).

The gh-ocannl-537 enabling interchange: (outer, inner) Swaps applied in order before the Split_reduce, each hoisting an accumulation-cell loop outside sr_axis. Empty when the site is splittable as lowered.

The schedule came from the disk cache; no search ran. The census is then empty except for a declined baseline: the base compile precedes the lookup, so its rejection is real information about this process on this device even though nothing was searched.

Including the serial baseline where it was dispatched — on GPU backends it is not (gh-ocannl-532), and neither is any other candidate that binds no hardware dimension. So this count is not comparable across a CPU and a GPU backend: every serial-form candidate the CPU backends legitimately time is refused on GPU, and the refusals are counted in declines under Not_dispatched_key instead (gh-ocannl-543).

Candidates rejected by op preconditions, hardware limits, or backend compilation — the serial baseline included (gh-ocannl-533) — plus detected seed sites declined before proposal (split-reduce sites evicted by max_split_reduce_sites, gh-ocannl-541) and candidates refused as unparallelized on a GPU backend (gh-ocannl-532), which the decline census records so a previously-proposed site — or a candidate space the backend's execution model empties — never stops being proposed silently.

true when the call terminated on a fatal failure instead of completing. tune reports exactly once per call, on every path that does any work (gh-ocannl-550) — argument validation is the exception, and deliberately so: an incompatible timing_ctx is a precondition violation detected before anything happens, not an outcome of a search, and reporting it would attribute a phase to a call that never reached one. The failures that precede the search proper — a base compile that fails before the base lowering is captured, a fatal baseline link, a fatal cache replay, a baseline timing failure — and the untuned fallback compiles of a search-less call (search=false) report with every counter at the value it had reached and the failure in terminal_failure, so a caller attributing arms by arrival order (the positional ?report of Train.tune_placements) still gets a slot for the search that died.

The serial baseline's own compile was rejected with a typed cause and the search ran on the scheduled candidates alone (gh-ocannl-533): baseline_ms is then infinity and the rejection is in declines like any candidate's. The HIP scratch validator declining the unscheduled serial form of a large softmax/cross-entropy head at Backend_link is the case this exists for — before it was contained, that one rejection ended the search.

Candidate rejections aggregated by stable cause key. Their counts sum to candidates_failed. Cache-entry replay failures are excluded.

The fatal failure that stopped a partial search; None on completed reports. phase is the one the failure carries — where the search actually died (at link, at launch, at sync), not where the report was assembled.

Beam-expansion rounds actually executed (0 = seeds only).

Whole-routine matmul-sketch instantiations seeded (0 when no matmul micro-kernel was detected or no tile sizes divide the extents), after the model pre-filter when one is active (keep_fraction < 1). Deterministic given the computation, backend, and configuration.

Of sketch_candidates, the fused-epilogue twins (gh-ocannl-486): seeded when the site's output feeds an eligible elementwise tail (Schedule.can_fuse_epilogue) — each sketch is then proposed both unfused and with Schedule.Fuse_epilogue appended, so the tuner measures the one-kernel fused form against the fissioned two-kernel form.

Per-fission-segment sketch candidates seeded (0 when the computation does not fission, or no segment contains a compatible matmul site). Deterministic given the computation and backend.

Of the seeded per-fission-segment sketch candidates, those that compiled and were actually timed (not rejected by op preconditions or hardware limits, not deduplicated by digest).

Split-reduce seeds (gh-ocannl-484 task 3): one candidate per split_reduce_sites site within the max_split_reduce_sites cap and eligible num_blocks value — the two-pass deterministic split reduction applied whole-routine before fission, each resulting segment getting the default preset. Deterministic given the computation and backend; 0 when no reduction-dominated site is detected. Sites the cap evicts appear in declines under Seed_evicted_key "split_reduce".

Of the split-reduce candidates (the per-site singles and the recombined multi-site composite), those that compiled and were actually timed.

Candidates whose label promises a tensorized (Schedule.Tensorize) pipeline that the search put through candidate compile: whole-routine and per-fission-segment sketch seeds, the cross-segment recombination composite, and beam-expansion candidates. Counted at the same point as mma_timed, so the two always describe the same population.

Of mma_candidates, those that compiled and were actually timed (dedup'd duplicates excluded — an identical candidate was already timed). mma_candidates > 0 with mma_timed = 0 means the search never measured a tensorized pipeline at all, the state gh-ocannl-521 recorded for every GPU backend: candidates are cheap to enumerate and were being rejected in bulk at candidate compile.

Sketch candidates the analytic cost model scored during the seed pre-filter (gh-ocannl-491); 0 when the pre-filter is off (keep_fraction >= 1) or nothing was scoreable (e.g. no envelope constants).

Of model_scored, the candidates dropped before compilation and timing. Candidates without model coverage are never counted here — they are always kept.

The winning candidate compiles as multiple fissioned kernels; false when nothing was timed.

The unscheduled serial baseline's measured time, or infinity when it was not dispatched: on a GPU backend an unparallelized candidate is never run (gh-ocannl-532 — the whole routine in one work-item, unbounded in cost and uninterruptible), so it has no measurement and cannot win. Also infinity when baseline_declined.

The untuned default pipeline's measured time (gh-ocannl-552): the config_thresholds fissioned-preset seed reproduces Ir.Schedule.maybe_default_schedules exactly, so this is the schedule the user gets without tuning — the reference baseline_ms cannot provide on GPU backends, where it is infinity. Attributed by digest, so it is present even when the seed deduplicated against an identical earlier candidate (the timed serial baseline included, on CPU backends whose config thresholds leave the code unparallelized). On a completed search with default_ms = Some d, best_ms <= d by construction — the seed is in the pool — and the margin between them is the value tuning added (the question gh-ocannl-491 asks). The attribution honors the scheduling gates: with automatic scheduling inactive (Ir.Schedule.automatic_schedule_active) the untuned default is the unscheduled serial form and this field reports the baseline's measurement (so None on GPU, where that form is never dispatched); with config schedule_fission=false no candidate reproduces the whole-routine config-thresholds default and this is None. Also None when the seed failed to compile, was refused as unparallelized on GPU (gh-ocannl-532), or on a cache hit whose entry predates this field or was written under a config that shaped a different default pipeline (Ir.Schedule.default_schedule_fingerprint mismatch).

The winner's measured time, or infinity when nothing was timed at all — every candidate failed and the baseline was not dispatched (or was declined). In that case no cache entry is stored and the returned routine is the untuned default compile, not the serial baseline.

The crowned candidate's spec label — the same string the autotune_log lines carry (e.g. "F_sketch[mma-gpu 16x32x32 ep]"). "baseline" when no candidate beat the serial baseline, "" when nothing was timed. Which candidate won is otherwise recoverable only by matching best_ms against the log's per-candidate times (gh-ocannl-546).

The crowned schedule contains a Schedule.Tensorize — read off best_schedule, so this is what the winner is, not what its label promised. This is the fact a caller needs to state that a search's shipping artifact uses tensor cores; per-search mma_timed answers only whether one was measured.

Tile_mma statements the crowned candidate emitted, and of those, how many rendered as the lane-0 scalar fallback (best_mma_scalar_fallbacks). The pair keeps the reporting contract's distinction (gh-ocannl-545): best_tensorized with best_mma_scalar_fallbacks > 0 is a schedule that carries a Tensorize and executes scalar code, and best_tensorized with best_mma_statements = 0 is one that emitted no tensorized statement at all. A genuinely tensorized artifact is best_tensorized with best_mma_statements > 0 and best_mma_scalar_fallbacks = 0.

The best timed tensorized candidate's time, infinity when none was timed (gh-ocannl-546). Against best_ms this is the margin by which tensorization won or lost this search, which is the difference between "the tensorized pipeline is uncompetitive here" and "it lost inside measurement noise"; best_tensorized implies the two are equal.

Its population is structural — timed candidates whose schedule contains a Schedule.Tensorize — and therefore differs from mma_timed's label-promised one, in both directions. A beam move can append a Tensorize to a saved or preset incumbent, producing a candidate that is tensorized while its label promises nothing (so it counts here and not in mma_timed); conversely a labeled candidate whose applied schedule carries no Tensorize counts in mma_timed and not here. Same choice as best_tensorized, for the same reason: what shipped is a property of the schedule.

infinity on a cache hit even when the replayed winner tensorizes: this process timed nothing, and best_ms there is the searching process's measurement.

The winner's schedule; for a fissioned winner, the concatenation of the per-segment schedules (informational). Empty when nothing was timed.

"default", or the winning candidate's spec label (matching the autotune_log labels).

The winner's roofline lower bound in ms — a ranking score, not a runtime prediction; None when selection did not run.

Model evaluations that produced a score (the default pipeline included; the fissioned flow also scores per segment).

Model evaluations without coverage, excluded from the ranking.

Candidates excluded from the ranking because their scheduled form fails Ir.Low_level.validate_parallel: the model cannot see that a schedule will not compile, and rates the tensorized families best, so on a backend where those are unbuildable it used to crown one and then degrade to the default (gh-ocannl-522).