Module Autotune

Parameters of one matmul-sketch seed candidate; see Sketch_families.sketch_params for field documentation. Exposed for tests (the seeding pre-filter of gh-ocannl-479 and the mixed grid-outermost shape of gh-ocannl-473 are asserted on directly).

The short tag of a candidate's post-schedule digest (the ~digest on_candidate_measured receives; a fissioned candidate's is its segments' digests joined by '+') that the autotune_log lines print and that a beam-round candidate's label names its parent by (F_saved[N segs from <tag>]+seg<i>:<move>, gh-ocannl-1230).

How a sketch's parameters print inside its candidate label (W_sketch[...], and each entry of F_sketch[...]) in the autotune_log lines and report.best_label: every field renders, so two seeds that differ in any one field — a swizzled, pipelined or register-tile twin of one geometry — never share a label (gh-ocannl-1230). Contains no ',', the separator of a composite's entries.

Which segments of a recorded fission segmentation a per-segment sketch is for (gh-ocannl-1243): each one's first unit (Ir.Schedule.segmentation's units) and their common structural pre-schedule digest. The digest leaves placements out, so it cannot name a segment on its own: segments of one structure share a key only when their placement-aware digests agree too.

The label of a per-segment sketch candidate (F_sketch[...]) over its (segment key, params) entries: each entry is sketch_params_label followed by " @" and a tag of its segment key — a tag of the digest, then ":u" and the keyed segments' first units joined by "+u" — so one-entry candidates of two segments that admit the same parameters print apart, structurally identical segments included. Entries are separated by ',' in key order; fine marks the finer segmentation. A staffed candidate (gh-ocannl-1138) appends " | staff " and its ?staff entries rendered alike, so the part before it is the candidate's focus and reads as the bare single's whole label does.

The default preset a segment gets in the tuner's fission pipelines (gh-ocannl-1483): Ir.Schedule.default_gpu on a GPU backend, Ir.Schedule.default_cpu on a CPU one, nothing otherwise. `Search is the search's aggressive min_parallel:1 thresholds — what tune's candidates, their per-segment seeding, and the threshold of model_default's per-segment substitution use (gh-ocannl-1512); `Config the configured ones — with no block_size the untuned default pipeline's own presets, and what that substitution ships on the segments it leaves unsketched.

The fission pipeline the tuner's call sites segment and compile under (gh-ocannl-1483): Ir.Schedule.fission_segmented in place on the argument (its placements receive the promotions), with the untuned default pipeline's placements (promote_locals on GPU), its schedule-aware merge probes (Ir.Schedule.fission_keep_mapping) and its zero policy (Ir.Schedule.zero_expansion on GPU, none otherwise). A fissioned candidate compiles through it, a per-segment sketch candidate with its recorded segmentation as replay.

The segmentation the per-segment sketch candidates are enumerated (tune, arity_cuts for its finer pass), modeled (model_default) and explained (model_explain) under, all at `Search presets (gh-ocannl-1483, gh-ocannl-1512): the configured thresholds leave a below-threshold nest unannotated, and fission coalesces adjacent unannotated segments back into one kernel, so at `Config a small routine's sites are never cut apart. tuner_fission with the zero fold (fold_zeros, gh-ocannl-1175) and segment_preset's presets, derived on a hermetic copy of the argument, so its placements are left as they were. The tuples' segments carry the copy's placements, promotions included. A test that needs the tuner's per-segment view derives it here rather than restating these settings. Raises Ir.Schedule_outcome.Cause_at as Ir.Schedule.fission_segmented does.

A keyed segment of the search's segmentation, its pre-schedule slice, and the seeds it admits.

The seeds tune proposes for a base lowering before its model pre-filter (gh-ocannl-1490): sketch_seed_params then coalesced_seed_params, on the whole routine and on each keyed segment of sketch_segmentation at `Search presets. tune enumerates through this, so a driver taking the seeding census, or executing the seeds one by one, sees what a search seeds without running one. census is called on every lowering seeded, tagged as the autotune_log_seeding stream tags it (default: that stream, a no-op unless the key is on).

The replay a per-segment sketch candidate compiles under (tuner_fission's replay): the segmentation, with each segment a key names by position — and whose structural digest is the key's — scheduled by sketch, every other one left to its preset.

A recognized matmul accumulation site; see the implementation's field docs. Exposed for tests (gh-ocannl-683 asserts on the contraction nest directly).

Recognize a matmul accumulation nest: a perfectly nested all-serial accumulation whose contraction loops are the innermost suffix absent from the accumulator's index map, every other loop owning a distinct accumulator axis, with the 2-D tile roles assigned per classify_matmul's operand rules and everything else batch. Reads off the extracted access relations like detect_conv, with the same legality_crosscheck soak. Exposed for tests.

The matmul site every seeding and schedule-construction entry point uses (gh-ocannl-1183): the site, the enabling-interchange prefix every schedule built from it carries, and the code it was detected on. The prefix is empty, and the code the argument, for a site detect_matmul finds; otherwise it is an adjacent-Swap chain, each Op_legal, sinking the contraction loops of the first accumulation-of-a-product statement below its write loops (the backward contractions backprop lowers with the contraction loops outermost or interleaved), and the code is the interchanged one. None when the plain matcher fails and detect_conv succeeds: the conv family keeps its segments. Exposed for tests.

The interchange seeded_default gives a segment it does not seed (gh-ocannl-1348): for each perfectly nested serial accumulation whose reduction loops (those absent from the accumulator's index map) enclose a write loop, the adjacent-Swap chain of detect_matmul_canonical's contraction sink, taking the reduction loops below the write loops in their original relative order, so the default preset maps the write loops and code generation keeps the accumulator in a register instead of reading and writing device memory every step. Statement by statement, each chain kept only when every Swap is Op_legal after the chains kept before it. A statement qualifies only when every write loop owns an accumulator axis as a plain iterator (so the interchange keeps each cell's summation order: values are unchanged bitwise) and its storage precision is its own accumulator precision under accum_prec -- or, with admit_narrow (default false; seeded_default's seed_narrow, gh-ocannl-1405), also where accum_prec widens it: the summation order is still kept, but the cell then rounds to its storage once rather than after every step. Empty where nothing qualifies. Exposed for tests.

A recognized convolution accumulation site (gh-ocannl-493); see the implementation's field docs. Exposed for tests.

Recognize a convolution accumulation nest: the output written at plain distinct iterators, one operand carrying affine components that mix an output symbol with a kernel-window symbol (the projections carry the strides, dilations, and padding offsets), the other operand reading the kernel window, exactly one out-channel and one reduction-channel symbol, with the out-channel at the output's last axis and a conv axis at its second-to-last (the implicit-GEMM row). Reads off the extracted access relations (Ir.Low_level.affine_accesses — the gh-494 artifact the op-legality oracle also consumes); under config legality_crosscheck the retained procedural matcher runs alongside and any divergence raises. Exposed for tests.

Boundary (gh-ocannl-912): rank-generic — any number of batch axes and of spatial axes (1-D, 2-D, 3-D) beyond the row become outer loops — but it refuses every SINGLETON axis, because lowering drops extent-1 loops and indexes the axis at a literal Fixed_idx: a batch of one or an output spatial extent of one (the output is no longer written at plain iterators), a single input channel or a k-by-1 window (the kernel is no longer read at plain iterators; with one input channel no reduction-channel loop remains for Tensorize (row, oc, ic)). A channel row of several axes is refused too (exactly one reduction channel). An all-singleton window (1x1, any stride) is a plain GEMM: detect_matmul owns it. Refused sites get no matmul or conv sketch seeds (the preset and split-reduce candidates are unaffected); test/operations/conv_detection_boundary is the witness.

The launch geometry a GPU matmul seed will have, predicted from the parameters alone (gh-ocannl-709) — the grid's row-block .y extent and folded batch .z product, and the workgroup's register-split extents — so seeding can consult the same Ir.Schedule.launch_geometry_excess the pre-driver gate does and never propose a candidate the device would refuse. Ir.Schedule.unknown_launch_geometry for parameters that name no block geometry (every CPU pipeline: the C backends render annotated loops serially). Exposed for tests, which cross-check the prediction against an applied schedule's Ir.Low_level.launch_dims — a prediction that drifted from what the builders emit would withhold legal candidates.

The launch geometry a GPU convolution seed will have (gh-ocannl-739): the site's outer output loops followed by the blocked flavor's row-block loop in grid nest order, and the tensorization lane as the sole workgroup loop. This lets convolution seeding consult Ir.Schedule.launch_geometry_excess before compiling a candidate. The prediction is a lower bound on the applied schedule's geometry; tests derive a real conv site through Ir.Schedule.fission_scheduled and cross-check every GPU seed against Ir.Low_level.launch_dims. Ir.Schedule.unknown_launch_geometry for CPU parameters.

The (operand, operand, accumulator) format triples a site with these storage precisions resolves to, in preference order — the key the typed seeds look up in mma_format_tiles and mma_staged_layouts. Single-precision operands read as tf32 first only under Ir.Numerics.t.tf32_matmuls. Exposed for tests, which derive the storage precisions of an advertised triple from it rather than restating the format table.

The advertised intrinsic tile a site with these storage precisions seeds in this emission scope under the current policy, None where the descriptor withholds it (no advertised format triple, or a wide-accumulator lifetime the scope lists exclude). Exposed for tests: it is the descriptor's verdict as seeding reads it, which cuda_mma_cutoffs compares against the arm resolver's floors at every cutoff (gh-ocannl-1214).

The matmul-sketch seeds proposed for the given lowering: parameterized instantiations of the composed pipelines with dividing tile sizes, pre-filtered against rules that statically imply a declined rendering (gh-ocannl-479) — on GPU backends: the (operand, operand, accumulator) format tile advertised by limits.mma.mma_format_tiles, including policy-enabled TF32 and excluding combinations the backend supports at one accumulator width but not the other (gh-ocannl-545: CUDA's bf16 has no wmma accumulator of its own); on the C backends: operand-precision uniformity (f32/f64), the fused accumulation form, micro-kernel column extent at least one vector of lanes (limits.simd_vector), and transposed-B storage for shapes that read B in place. Builder preconditions the schedule builders settle identically for every tile completion — the zero-expansion row-axis rule, and the GPU sketches' companion-coverage rule per fusion flavor — also pre-filter here, as the family tree's construction-time refutations (gh-ocannl-577): a seed list never proposes a candidate that statically must fail its build. For the matmul family this list is Ir.Schedule_space.leaves of sketch_family_tree — the matmul family's tree where a matmul site is detected, else the convolution family's (gh-ocannl-697) — epilogue twins included. capabilities is the compiling context's Context.codegen_capabilities: the workgroup-memory refutations charge the staged tiles by it as the gate does (Schedule.kernel_workgroup_bytes: allocation rounding, tile-MMA scratch, gh-ocannl-1255); the default charges exact tile sizes, a weaker floor. Exposed for tests.

See Sketch_families.coalesce_prefix (gh-ocannl-1165, gh-ocannl-1279). Exposed for tests.

The coalesced tuner branch (gh-ocannl-1165, gh-ocannl-1279), which tune seeds beside sketch_seed_params's candidates, whole-routine and per fission segment: see Sketch_families.coalesced_seed_params. Its winners persist as ordinary saved schedules whose leading Ir.Schedule.Coalesce ops name their loops structurally.

Why the backend and the configuration withhold the tensorized family from a matmul site with these operand and destination storage precisions, before any geometry or site structure is consulted — None when they do not (gh-ocannl-1115). matmul_sketch_tree refutes its tensorized branch with exactly this witness. On GPU: routine logging, an mma lane wider than the workgroup, no advertised format tile; on CPU, the register tiling's shape-independent rules: a usable vector file, two lanes at the compute precision, uniform vector-capable compute precisions, a register file holding a four-row tile (Ir.Register_tile.rn_cap), routine logging. Exposed so a test claims a tensorized seed's PRESENCE exactly where the seeder's own capability judgment admits it, never gating on the seed list under test.

The matmul sketch family as a refinement tree (gh-ocannl-514 phase 1): decision levels — epilogue fusion, pipeline, packing shape, geometry, twins — whose lazily-refined choices depend on earlier commitments, and whose Ir.Schedule_space.leaves are exactly the family's sketch_seed_params, in enumeration order. None when no matmul site is detected. The root level is the Fuse_epilogue flavor (gh-ocannl-613): unfused first, then fused — refuted with the fusion recognizer's reason (Schedule.fuse_epilogue_witness) when the site's output feeds no fusable tail — so the twins enumerate after every unfused leaf and each flavor's construction-time verdicts are its own (gh-ocannl-577: companion coverage can pass fused where it fails unfused). Statically-decidable builder preconditions refute at the pipeline level — above the geometry menus and the tile lattice, so a family whose every completion must fail its candidate build never expands (gh-ocannl-577). The conv family is its own tree under the same root, conv_sketch_tree (gh-ocannl-697). Exposed for tests and as the phase-4 search driver's entry into the family space.

The convolution sketch family as a refinement tree (gh-ocannl-697): see Sketch_families.conv_sketch_tree. None when no conv site is detected. Exposed for tests.

The combined view (gh-ocannl-1488): a family = matmul | conv root above the tree of whichever family claims the lowering (matmul_sketch_tree where a matmul site is detected, else conv_sketch_tree), unforced below that family's root; None when neither does. Each family is judged on the site's own shape, so the family choice is a decision with a witness: the other child is refuted with no_matmul_site_witness or no_conv_site_witness, or with matmul_precedence_witness should both detectors claim the site. sketch_seed_params is its leaves, and model_family_search walks it.

The combined view's refutation of the matmul family on a lowering with no matmul site.

The combined view's refutation of the conv family on a lowering with no conv site.

The combined view's refutation of the conv family on a site both detectors claim: matmul keeps its precedence, so a lowering seeds one family.

sketch_seed_params beside the judgment its seeds came from.

One padded role: the site's extent along it and the block it pads to.

The roles a seed pads, judged on the site of the family that seeded it by the very predicates the seeding charges the masked accumulator tile's workgroup memory by; the census's pad lines print them. None for a seed they do not judge: a CPU or scalar seed, or a coalesced layout's.

Config autotune_log_seeding, read once per process.

The census of one lowering on stderr, tagged where; a no-op unless log_seeding_enabled.

The exclusion witness marking the tile-size lattice branches beyond the curated geometry menus (gh-ocannl-514 phase 5): binary interval refinements over the staged tile sizes — every intrinsic-tile multiple of the row block crossed with every staged depth block — whose boxes carry corner-judged verdicts (a workgroup-memory floor at the most favorable corner refutes the whole box pre-expansion). Ir.Schedule_space.leaves never enumerates an excluded branch, so the tuner's seed lists are unchanged by the lattice's existence.

The pad-waste threshold of the matmul family's geometry menus (gh-ocannl-740), as this process resolves config autotune_pad_waste_max (at least 1; a malformed or NaN value raises Utils.Invalid_config_value, gh-ocannl-1332). A geometry's pad-waste ratio is its padded work over the site's: the product, over the axes it pads to its block sizes, of padded over real extent. A geometry whose ratio is at least this many times that of the least-padded geometry its own menu proposes is Ir.Schedule_space.child.Excluded with a witness naming both ratios: valid, never proposed by default, re-proposed exactly by Ir.Schedule_space.lift_excluded. The least-padded geometry is never excluded, and legality refutations take precedence. Judged in the GPU blocktile menu, the GPU tensorized curated menu and the CPU packed menu of each packing shape, and in the conv family's CPU shape menu and GPU row-geometry menus (gh-ocannl-1393), where nothing is excluded at the default threshold: a row block needs two or more blocks, so its waste stays under 2x, and the GPU channel pads are site-wide, so they cancel. Exposed so a test judges the tree against the threshold the tree was built with.

Lift every pad_waste_max exclusion in the family tree (gh-ocannl-740), as lift_geometry_lattice lifts the lattice: laziness preserved, the lifted geometries still subject to legality, other policies' exclusions kept. Its Ir.Schedule_space.leaves are what the menus may propose with the pad-waste economy off.

Lift every CPU-companion exclusion (gh-ocannl-1609) — the flavors whose site binds a hardware dimension beside a materialized companion, valid on the C backends' fork-join model and excluded as search economy — as lift_pad_waste lifts pad waste: laziness preserved, lifted branches still subject to legality, other policies' exclusions kept. Matmul and conv trees alike.

Lift every geometry-lattice exclusion — the branches whose decision is Family_decision.Geometry Lattice, identified by that datum rather than by the exclusion's prose witness — preserving the laziness of everything else; lifted branches remain subject to legality (the box refutations), and other exclusions stay excluded. model_default's family search applies this under config model_default_geometry_lattice. Exposed for tests.

Whether the CPU packed composition keeps its row-block loop outermost — above the reduction-block loops instead of sunk under them: the hoisted-only Grid shape and the two per-chunk packing shapes. The loop order cpu_mma_pack_sketch_schedule builds, and what the certain-traffic floor reads off a path's packing shape (gh-ocannl-1676).

Why Schedule.Fuse_epilogue refuses the fused twin of every completion of the CPU packed geometry and packing shape p carries (gh-ocannl-1612), or None where it may admit one. Only the shapes that sink the row-block loop under the reduction-block loops are concerned (not cpu_pack_grid_outermost): there the micro-kernel writes the accumulator once per reduction block, so a repeating reduction-block loop, a k-block Partition whose segments share an enclosing loop that runs twice, or a row-block edge split off beside a k Partition leaves no exactly-once store-back. None off the CPU packed matmul sketches. The family tree refutes the fused flavor's geometries with it. Exposed for tests, which check it two-sided against the applied fused schedules.

Whether every application of the matmul tensorized sketch p to opt has Schedule.contract_tensorized_accumulator mint the fresh bm x bn accumulator fragment, at the output's storage precision, that sketch_path_traffic_floor prices (gh-ocannl-1676, gh-ocannl-1706). Certain where a reduction-block loop of two or more iterations encloses the micro-kernel without indexing the accumulator — an outer contraction loop (m_ko) on every tensorized form; the k-block loop of a staged GPU geometry; on the CPU packed composition, either one only under the grid-outermost loop order (cpu_pack_grid_outermost) — and wherever pad masks on the row or column force the contraction (a staged geometry whose row or column block does not divide its extent, every operand staged). The same predicates the builders' loop order and staging read. false off the uncoalesced matmul tensorized sketches. Exposed for tests, which check it against the applied schedules.

The certain-traffic increment (bytes) of a family-tree decision path (gh-ocannl-514 phase 5): traffic every completion below the path moves beyond the schedule-invariant Ir.Cost_model.completion_floor, read off the path's committed staging decisions as data (Family_decision, gh-ocannl-591; the decision also says which pipeline minted it, so the caller's backend kind is not needed alongside the path) — a committed staged geometry contributes its operand tiles' distinct-cell footprints exactly as Ir.Cost_model.analyze charges them on every leaf (in-kernel GPU stages read and write; CPU packed panels only under in-kernel serial packing — a hoisted panel replaces the original operand's reads rather than adding traffic), and a lattice box contributes its most favorable (smallest-tiles) corner priced at the same per-format intrinsic tile the lattice is built from, so the increment is monotone in refinement. On a conv lowering (no matmul site, a detect_conv one — the family that claims it, gh-ocannl-1489) a committed row geometry (conv-shape on the CPU leg, conv-rows on the GPU leg) contributes both staged operand tiles, written and read, at the tiles' own precisions (the CPU packing precision where it widens; GPU reduction and column extents padded to the selected format's intrinsic tile), one copy whatever the pipelined depth; every prefix above the row geometry prices 0. Both families add Tensorize's accumulator fragment, written and read at the output's storage width, where every completion below the path contracts the accumulator (gh-ocannl-1601): a conv row geometry whose window has a loop of two or more iterations (rows x out-channels), a staged GPU mma geometry whose reduction runs in two or more blocks (bm x bn; a lattice box only once its largest bk leaves two blocks), and wherever matmul_fragment_certain says every completion contracts: an outer contraction loop of two or more iterations, the grid-outermost CPU packed shapes' repeated reduction blocks, pad masks on a staged row or column, the CPU whole-triple row block under an outer contraction loop (gh-ocannl-1676, gh-ocannl-1706). 0 when neither family has a site or nothing is certain. Composed with the floor's legs, this is what makes the family bound non-uniform across the tree — the schedule-invariant floor differentiates only placements (phase 3), the increments differentiate the sketch-geometry subtrees. Detection runs once at partial application; the returned closure is cheap per path. Exposed for tests.

The composed pipeline a seed parameterizes, built against the given lowering (the site is re-detected). Refuses typed when no site is detected or the parameters do not fit the segment (Sketch_families.sketch_schedule: Ir.Schedule_outcome.Cause_at (Transform, _)); any other exception escaping the builder is a builder bug, fatal under strict_failure_classification (gh-ocannl-1390). accum_prec is the rendering backend's accumulator resolution ((Context.codegen_capabilities ctx).accum_prec): the scalar pipelines' Privatize mints its tile at it (Ir.Schedule.privatize, gh-ocannl-1116). Exposed for tests (the pad-composition seeding of gh-ocannl-485 is executed directly).

Test seam: see Sketch_families.with_sketch_builder_fault (gh-ocannl-1390).

The privatized preset extension used by the fissioned candidates: appends a Schedule.privatize ~accum_prec ~target ~over for every materialized read-modify-write accumulator detected in the schedule's application to the segment — over being the outermost enclosing Serial loop whose symbol the access vector does not mention and whose subtree contains no hardware-typed loop. Each proposal is validated by try-applying the grown schedule against a hermetic copy of the segment (proposals violating the op's preconditions are dropped), so the result always applies cleanly where the input schedule does. Exposed for tests.

A extend_with_privatize proposal the op refused.

extend_with_privatize beside the proposals it dropped, in detection order. Where a search's privatized presets drop proposals, they reach its report as privatize_drops (gh-ocannl-1438); this is where a census of Privatize's refusals on segments no search compiles reads them (gh-ocannl-1395: test/operations/privatize_census). Empty when the input schedule itself does not apply.

A reduction-dominated accumulation site eligible for Ir.Schedule.Split_reduce seeding (gh-ocannl-484 task 3); see the implementation's field docs. Exposed for tests.

The label of a split-reduce candidate (F_split[...]) over its (site, num_blocks) entries, in the autotune_log lines and report.best_label: each entry renders every field of its site — the target by debug name and, where that differs, its id (name#id), the split axis, red, out, cost, the block count, dyn, the interchange chain pair by pair (swap:o/i+o/i) and the coalesced reduction pair (coalesce:o*i) and the cell loops the block loop is hoisted above (hoist:c+c) — so two sites that differ in any one field never share a label (gh-ocannl-1230). Entries are separated by ',', which no entry contains.

gh-ocannl-1414: the loops outer and inner merged by a Ir.Schedule.Coalesce, as the merged loop's fresh symbol and the coalesced code (built on a hermetic copy), or None where the op declines: the pair is not a perfect nest of two Serial loops, or some access does not read it as two adjacent plain iterators over unpadded axes. split_reduce_sites prepares a two-loop reduction band with it, and a site it prepares records the pair in sr_coalesce, so the candidate's prelude replays the same op (under the same merged symbol) before the split. Exposed so that a caller preparing its own reduction pair, such as a contraction over two axes, reaches the split through the same preparation.

The split-reduce seeding sites of the given lowering: rmw accumulations (and gh-466 Set_dynamic scatters) whose target has at most a few thousand cells while a serial reduction loop of substantial extent feeds it — little output parallelism, lots of splittable reduction work. Per site the largest-extent enclosing serial loop that passes the hermetic Ir.Schedule.op_legality probe of the corresponding Split_reduce is chosen (the op's own recognizer decides the pinning discipline), so every returned site is seedable as proposed.

Every detected site is returned, ranked by descending estimated segment cost (sr_cost, the accumulation's trip count) — gh-ocannl-541: the earlier sr_red / sr_out integer-division ratio zeroed every large-output site, and the in-detection cap then silently excluded (and, once gh-537 made more sites reachable, evicted) exactly the sites carrying the most serial work. The candidate-volume cap now lives in tune (max_split_reduce_sites / config autotune_split_reduce_max_sites), which records evicted sites in the decline census.

A candidate rejected only because the accumulation cell's loops sit inside the reduction loop — how OCANNL lowers conv bias/weight gradients, where nothing else in the schedule space reaches the dominant segment — is re-probed after the enabling loop interchange (Ir.Schedule.split_reduce_hoist names the loops, each Swap confirmed Op_legal on the code it acts on); the chain is recorded in sr_swaps and replayed by the candidate's prelude.

A site no single loop splits — a small-batch parameter gradient for b, s, o: g[o] += dy[b,s,o] with b too short to split and s enclosed by b, which pins no component of the cell — is re-probed with its two outermost reduction loops merged (gh-ocannl-1414): the cell loops below the outer one are hoisted as above, the pair is merged by coalesce_reduction_pair, and the split is probed on the merged loop, whose extent is sr_red. A site one loop already splits keeps that split. static_indices only reaches the interchange and coalescing probes' Sched.apply. Exposed for tests.

Whether two split_reduce_sites enumerations' sites are one site (gh-ocannl-1697): the same target, and the same split loop -- or, for a coalesced site, whose merged loop each enumeration mints afresh, the same pair of loops merged.

The whole-routine prelude splitting each (site, num_blocks): per site its interchange (sr_swaps), its coalescing (sr_coalesce, minting the merged loop under the symbol sr_axis names, as detection probed it), the Ir.Schedule.Split_reduce, then the Swaps hoisting the split's block loop above the cell loops sr_block_hoist names (gh-ocannl-1412). The schedule the search's F_split candidates and the untuned split (seeded_split_sites) both apply. Exposed for tests.

gh-ocannl-685: spend a cap round-robin across named categories instead of as a prefix over their concatenation, returning the survivors (in the original category order, so an under-cap input comes back unchanged) and the per-category drop counts. One proposal per category per round, a category that runs out stops taking turns: every non-empty category is represented before any gets a second, and unused share spills to the others without imposing a ranking. Used for menu's per-unit action cap, whose list is a category-ordered concatenation and NOT ranked -- a plain prefix there starved every category after the first outright. Exposed for tests.

The beam-round action menu over one unit's transformed code — registry must resolve its loop binders, including symbols minted by the schedule applied so far (the search harness builds it with Ir.Schedule_cache.to_saved over that schedule): dividing serial Splits, Swaps of perfect serial pairs, Unrolls, Retype-Vectorized on innermost loops, and Tensorize role permutations, each proposal vetted by Ir.Schedule.op_legality (proven-illegal ones are pruned before they cost a candidate compile; Op_unknown proceeds to compile-and-time). The loop enumeration descends into accumulation-minted Local_scope bodies and treats binder-sharing mint copies as one decision (gh-ocannl-666). It descends virtualization's inlined computations too, but a loop reached through one draws the Retype-Vectorized proposal ALONE (Ir.Low_level.scope_mint, gh-ocannl-687): that is the one category with a renderer built for the shape (an inlined reduction's Set_local accumulation is what C_syntax.try_vectorize_reduce recognizes, and the enclosing loop -- whose body holds a Local_scope -- cannot be explicitly vectorized at all), while Splits, Swaps and Unrolls there are up to eight descriptors per loop that nothing proposed before gh-666 and that displace proposals for the main nest.

The per-unit action cap is shared across the categories by share_cap rather than spent in category order (gh-ocannl-685). admits filters proposals BEFORE that cap, so the budget is shared over moves the caller can use rather than over moves it is about to discard -- the beam passes its GPU dispatchability rule here, since an incumbent binding no hardware dimension can only be expanded through a move that binds one. It may record its refusals. Exposed for tests.

Aggregate of candidate declines sharing one stable key. Details retain at most the first three distinct diagnostics and are never part of the key.

Why a search was abandoned by its caller's ?abandon rule (gh-ocannl-1110).

The shared admission gate for the consumers that RANK: candidate selection, the calibration rows, the roofline consistency check, cache attribution. Returns a positive finite ms only for an uncontended result; a refused or degenerate result is None. Deliberately NOT the gate for queued_batch_depth, which chooses a scale rather than consuming a measurement (gh-ocannl-888).

The admission verdict of one timing window, naming the cause of a refusal (gh-ocannl-1517): Admitted exactly when admitted_timing_ms is Some. A refusal names the first cause that holds of unbatched (unbatched), an unreadable reading (a minimum that is not finite and positive: a clock that resolved nothing) and contended (contended). The reading precedes contention because a non-positive minimum is also the dispersion check's floor, against which every positive sample reads as a stall: such a window is usually contended as well, and named so it put a clock that resolved nothing down to a loaded host. What the search counts per cause in report, what its NOT TIMED log lines name, and the admission of each timing_call all come from here -- the last applied to the PHYSICAL reading, as calibration took it, before the test scopes and on_candidate_measured act on admission (see with_contended_test_windows).

The settle's spelling in the benchmarks' timing trace and result line: isolated, single_estimate, singles_reach_target, singles_far_over_target, prior_depth, measured_batch, affine_projection, wall_scaled, cap_measured, cap_unresolved, budget_exhausted.

Likewise: admitted, refused_unbatched, refused_contended, refused_unreadable.

One unit of a beam entry in a beam-expansion round (gh-ocannl-1360): what the round's expansion rule (config autotune_round_expansion) did with it.

One beam entry as a round found it.

One beam-expansion round (gh-ocannl-1360): the per-entry, per-unit move counts the round's autotune_log line round N: ... summarizes, recorded before the round attempts any of them. A test reads them to choose a beam entry with the moves it needs instead of discovering their absence by failing a claim.

"not run", "kept", "swapped" or "inconclusive".

One beam-finals contender (gh-ocannl-1635), in finals_contenders' order.

The beam finals' contenders (gh-ocannl-1635) among pool, each entry paired with its search reading in ms: the entries with a finite reading within margin (a fraction) of the fastest, by reading with ties in pool order, at most width of them; empty when fewer than two qualify or margin <= 0. Every candidate of a search is timed in a window of its own, and a window's reading carries the window's offset (drift, or contention that only slows it), so ranking by those readings crowns the luckiest window as often as the fastest schedule -- the winner's curse Bench_select fixed for projection_shape_bench (gh-ocannl-1531). tune passes as pool every entry it ranked as an incumbent -- the final beam, then the beams accepted rounds replaced and the round a rejected round discarded -- with margin config autotune_finals_margin (default 0.1) and width its beam_width; it re-times the contenders in finals_order and crowns by finals_crown. The composite playoff decides its near ties the same way (gh-ocannl-1665): its pool is the incumbent composite and one alternate, in that order, at width 2, so an alternate replaces the incumbent by winning a finals of the two when both qualify, and by reading faster otherwise (fiss_sketch_playoff_finals). So do the staffed sweeps' joins (gh-ocannl-1698): the pool is the incumbent and the key's fastest single (staffed_finals).

The width is the beam's so that every entry outside the finals that the beam ranked read no faster than every contender: each such entry was evicted from a beam (or a round's accumulator) by beam_width faster ones, all in the pool. So a report's best_ms -- the crown's SEARCH reading -- exceeds such an entry's reading only when the entry was a contender that the finals ranked behind the crown (finals_outranked). A beam of one holds no finals. The composite playoff's windows are such entries, ranked by their search readings like any candidate's: its swaps choose which composites are built and timed next, never the crown, so the same holds for a fissioned crown, and a playoff swap needs no record of its own (gh-ocannl-1725). A staffed join likewise chooses only the staff the later keys' singles are timed with (gh-ocannl-1698).

The finals' windows, in order: the contenders, then the same in reverse, so each is timed twice and a drift across the finals reaches every contender alike. Every window is a compile of its own, the adjacent pair in the middle included, so each starts from the state a search candidate's window starts from.

The finals' crown from each contender's admitted finals readings: a contender's finals reading is the least of its readings, and the crown is the contender with the least, ties to the earlier, beside that reading; None when some contender has no reading -- it cannot be compared in the shared round, so the search keeps its own head.

A ranked candidate whose schedule asks for a Grid loop (schedule_asks_grid) while its routine rendered at least one outermost Grid loop serially on a pool-backed backend (grid_rendered_serially), gh-ocannl-1702.

Whether a candidate's schedule places a loop on the Grid axis: a Split with a Grid side or a Retype to Grid (gh-ocannl-1702). Read off the schedule, not the label, for the reason report.best_tensorized is: a beam move can append such a placement to a plainly-labeled incumbent, and every packed Grid sketch states its row-block loop this way. A Grid loop the default pipeline placed is not one the schedule asked for.

Whether a routine's Grid census records a serial outermost Grid loop on a pool-backed backend: pool holds and serial > 0 (gh-ocannl-1702). On a backend with no CPU pool a Grid loop is a hardware grid and the census is empty, so this is false there.

The refused windows a report puts down to host contention alone (gh-ocannl-1517): timings_contended minus its timings_unbatched and timings_unreadable subsets, so the three causes timing_admission names partition the report's refusals. A skip or a retry excused by a loaded host reads this, not timings_contended, which a degenerate clock reading also grows.

The fraction (0.01) by which a beam round's best reading must undercut the incumbent's for the round to be adopted. A round that improves by less is timed and discarded with the incumbent still crowned, so an entry of that round can read below best_ms by less than this fraction (gh-ocannl-716): the band, beside finals_outranked, in which another entry's search reading may sit below the crown's.

Whether the beam finals crowned the report's winner over a contender that read search_ms in the search (gh-ocannl-1635): finals_outcome is Finals_swapped, the fastest admitted finals reading belongs to a contender whose search reading is best_ms -- the reported winner's, so a report whose finals crowned another entry explains nothing (gh-ocannl-1741) -- and a contender of that search reading has an admitted finals reading no faster than the crown's. Outside a rejected round's min_progress band, the one way best_ms, the crown's search reading, can exceed the search reading of another entry the beam ranked -- the untuned default's default_ms among them (finals_contenders) -- and by up to the finals' margin, config autotune_finals_margin: a claim that another entry's reading undercuts best_ms only inside the round band reads || finals_outranked r ~search_ms (gh-ocannl-1716).

The report of a tune call that never searched (config autotune_search=false, gh-ocannl-559, and no cache entry to replay): outcome = Search_disabled, every counter zero, every time infinity, best_label empty, best_tensorization = None and source_digest = "". The caller gets the untuned default compile. Also the base the pre-search failure reports are built on, with outcome replaced and whatever census the call had reached filled in.

timing is the objective the call resolved, which is all that distinguishes one of these from another: it names what the (absent) times would have been measured under, and keeps report.timing a plain field rather than an option every consumer of a real report would have to unwrap. A caller synthesizing a report — a test building a search outcome to feed family_profit_of_reports, say — passes whichever objective its scenario is about.

Whether the progress lines are on in this domain: the ?progress of the innermost enclosing tune or Train.tune_placements call that passed one, else config autotune_progress.

Whether the autotune: diagnostics (and the untuned-default control they gate) are on in this domain: the ?log of the innermost enclosing tune or Train.tune_placements call that passed one, else config autotune_log at true. Its crown level leaves this off: that level prints only each call's autotune-crown: line (crown_fields), which a ?log override turns on (true) or off (false) together with the rest.

with_streams ?log ?progress f runs f with log_enabled and progress_enabled overridden by whichever of the two is given, in the calling domain only, restoring the enclosing settings on return or exception. It is how tune and Train.tune_placements scope their arguments; an omitted argument leaves the enclosing setting in place.

Writes one progress line (prefix and wall_s added) when progress_enabled; the format supplies event=... and the rest.

A time in milliseconds as progress lines print it: %.4f, or none when not finite.

Starts a clock; the returned function reads the seconds since.

The stable one-word name of an outcome state — "searched", "search-died", "cache-replay", "search-disabled", "pre-search-failure", "abandoned" — for logs, JSON records and test goldens.

The fatal failure that ended the call, from whichever of the two failing states carried it; None otherwise. A projection over outcome, not a re-derivation of it: "did this call fail" spans two states, and every caller that ranks or attributes arms asks exactly that — an arm carrying one is never the shipped arm, whatever its pre-failure best_ms says (gh-ocannl-550). The failure's phase is the one it carries — where the call actually died (at link, at launch, at sync), not where the report was assembled.

tune reports exactly once per call, on every path that does any work. 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.

What the call crowned and how the beam finals decided it, as one line of fields (gh-ocannl-1718): outcome=<{!outcome_name}> crowned=<{!report.best_label}, quoted> best_ms=<%.4f> then finals_fields. The label is "" exactly when nothing was timed, which outcome then explains. The line config autotune_log=crown prints once per tune call, autotune-crown: routine=<name, quoted> <fields> on stderr, carries exactly these fields, so a caller rendering a report itself (a test's stderr, a bench's trace) spells it the same way.

The finals' finals_outcome_name, its spaces as underscores (finals=not_run), and how many contenders they re-timed (finals_contenders=<n>, zero when they did not run).

The analytic cost model's ranking score of a candidate schedule (gh-ocannl-491, the selection half): Ir.Schedule.apply on a hermetic copy, Ir.Cost_model.analyze, then the roofline lower-bound seconds under the envelope constants — limits' advisory peak_flops / peak_memory_bandwidth, each overridable by config model_peak_flops / model_peak_memory_bandwidth (calibrated per-machine values beat the class constants). None — no model coverage — when the schedule fails to apply, the code is opaque to the extraction (its counts may under-estimate, so ranking on them could prune the true winner), or no envelope constant is present. A ranking score, not a runtime prediction. Exposed for tests.

The envelope constants model_score scores against — (peak_flops, peak_memory_bandwidth), FLOP/s and bytes/s — each with where it came from: `Config for a model_peak_flops / model_peak_memory_bandwidth override, `Backend for limits' advisory class constant. None for a leg neither provides (the C backends carry no class constant). Exposed so that a report scoring a measured kernel against the envelope reads the very constants the model ranks with, and can say whose they are (gh-ocannl-1006).

The cache capacity (bytes) and device residency (threads) the ranking score (Ir.Cost_model.ranking_seconds, gh-ocannl-1253) uses: config model_cache_capacity (none turns the capacity off) over the backend's advisory cache_capacity_bytes, and its max_resident_threads. Both are Untimed readings of the device description: only the untimed choosers and the calibration tools call this, never anything tune reaches.

The ranking score's within-capacity tier, in bytes/s: config model_cache_bandwidth (none turns it off) over the backend's advisory cache_bandwidth. An Untimed reading, like ranking_capacity.

The ranking score's scalar issue rate, in operations/s (gh-ocannl-1442): config model_issue_rate (none: scalar work priced at the envelope's peak_flops) over the backend's advisory issue_rate. An Untimed reading, like ranking_capacity.

The ranking score's tile-MMA rate, in operations/s (gh-ocannl-1495): config model_mma_rate (none: accepted tile-MMA work priced at the envelope's peak_flops) over the backend's advisory mma_rate. An Untimed reading, like ranking_capacity.

The ranking score's device-gather rate, in per-lane gathers/s (gh-ocannl-1495, Ir.Cost_model.device_operand_gathers): config model_device_gather_rate (none: no gather term) over the backend's advisory device_gather_rate. An Untimed reading, like ranking_capacity.

The ranking score's memory-transaction rate, in excess 32-byte sectors/s (gh-ocannl-1600, Ir.Cost_model.memory_transactions): config model_transaction_rate (none: no transaction term, and no coalesced leaves in model_default) over the backend's advisory transaction_rate. An Untimed reading, like ranking_capacity.

The ranking score's occupancy capacity, in workgroup bytes per multiprocessor (gh-ocannl-1600, Ir.Cost_model.occupancy): config model_workgroup_bytes_per_multiprocessor (none: no occupancy factor, and no coalesced leaves in model_default) over the backend's advisory workgroup_bytes_per_multiprocessor. An Untimed reading, like ranking_capacity.

The ranking score's launch fill model (gh-ocannl-1479, Ir.Cost_model.context_fill): config model_multiprocessors and model_fill_threads (each none: no launch fill) over the backend's advisory multiprocessors / fill_threads; None unless both resolve. An Untimed reading, like ranking_capacity.

The ranking score's achieved DRAM rate, in bytes/s (gh-ocannl-1442): config model_dram_bandwidth (none: DRAM traffic priced at the envelope's peak_memory_bandwidth) over the backend's advisory dram_bandwidth. An Untimed reading, like ranking_capacity.

(rank, bound) in milliseconds for scheduled kernels run in sequence: the ranking score model_default minimizes and model_score's roofline lower bound, under envelope_legs' constants and ranking_capacity, pricing at the matrix units' rate only the tile-MMA work capabilities' hook accepts (none without them, gh-ocannl-1442). None without model coverage. For reports (benchmarks/runners/ocannl/bench_wgrad.ml, tools/calibrate_cache_capacity.exe): a ranking score, not a runtime prediction.

The ranking score's (compute, memory) legs in milliseconds, each summed over the kernels (Ir.Cost_model.ranking_legs_of; None for a leg whose envelope constant is absent), under the same readings as ranking_ms — the issue and DRAM rates included (gh-ocannl-1442). None where ranking_ms is. For reports.

The order-preserving pre-filter over model-scored candidates: keeps every unscored (None) candidate — the no-coverage exemption: never dropped, only measured — plus the best ceil (keep_fraction * n) of the n scored ones (at least one; ties at the cutoff are all kept, so the outcome is independent of enumeration order). The identity when keep_fraction >= 1. Exposed for tests.

The enablement prior of the placement levels (gh-ocannl-514, the gh-ocannl-558 lesson): given the default-policy lowering and its all-materialized specialization, classify the flip candidates by whether their placement decides a sketch family's expressibility — computable from the seeders' own site classification, before any compile. Returns (enablement, disablement):

• enablement: operand/destination nodes of an mma-eligible matmul site (the backend advertises a format tile and the wide-f16 policy's required scope for the site's unstaged form, whole-routine or per-fission-segment — the granularity the seeders detect at, segmented as the seeders of a GPU (is_gpu) or a CPU backend segment, gh-ocannl-1430) that exists in the all-materialized lowering but has no eligible counterpart under default placements. Materializing such a node is what makes the tensorized family expressible — the flip changes the feasible set, not just the objective, which the per-node recompute-cost bound has no term for (on gh-558's mlp_wide/hip/bf16, cost ranking buried the family-unlocking cast twins below four no-op `Inline flips and a budget-5 chain found nothing).
• disablement: operand/destination nodes of sites already eligible under default placements. An `Inline flip of a node in either set can only move away from an eligible site — rank_flip_candidates demotes those.

Empty on backends without an mma capability. A classified fission failure degrades to whole-routine detection; the classification is a ranking prior, never a legality fact.

Parse config tune_flip_profit_margin (gh-ocannl-579): a ratio of at least 1.0. Anything else — unparseable, non-finite, or below 1.0, which would demote a family that WON — raises Utils.User_error rather than falling back to the default, since a run that asked for a profitability policy it also made impossible should not quietly get a different one. Exposed for tests.

Raised by tune when its ?abandon rule decides, including from cached evidence. Its report (Abandoned or Abandonment_replay) has already been delivered, and every candidate this call compiled released.

best_after steps k: the best after the first k admitted timings of the search whose report.best_steps is steps — its final best when it timed fewer than k, infinity when it timed nothing.

Some exactly when best_after steps k exceeds trailing_ratio times the incumbent's best_after at the same k — strictly, so a flip trailing by exactly the ratio keeps searching — and the incumbent timed something by then. tune decides once, as soon as it has k = beam_width admitted timings (the depth at which its first beam is full), before its next attempt. Exposed for tests.

The trailing ratio the flip chain abandons at: config tune_flip_profit_margin, squared (1.5625 at the default 1.25). The margin is the gap the chain already calls a measured loss for a family; squared, a flip must trail by that much once more than the rest of its search could be granted to catch up. That separates gh-719's hopeless flips (2.0x, 1.7x at equal depth) from arm B's 1.07x with room on both sides. margin overrides the configured one; a malformed configured value raises Utils.User_error as flip_profit_margin_of_string does.

What completed searches measured about the tensorized family's profitability on this device (gh-ocannl-579): mma_best_ms against best_ms, compared to config tune_flip_profit_margin. A report with any timings_contended contributes Unmeasured: its admitted minima cover an incomplete candidate set and cannot safely price the family. Over several reports the most favourable evidence wins — the expressibility prior is deleted only by evidence that contradicts it, never by the absence of a confirmation. A failing arm's report counts: its timings are measurements of the family even though its best_ms is not shippable. Exposed for tests and for Train.tune_placements, which derives it from the placement A/B's two arm reports.

A log-line phrase naming the evidence and its ratio.

The ordering `Profitable resolves to under the given evidence: `Enablement when the family is unmeasured or competitive, `Cost when it is measured to lose here. Both of the prior's classes go at once, because the promotion of family-unlocking flips and the demotion of family-breaking ones are the same bet on the same family. Exposed for tests.

Deduplicate (by Tn.uid, keep-first), drop refused alternatives (Ir.Low_level.fa_refused, gh-ocannl-1093: each replays to the materialized placement) and the nodes left with none, and rank the decision surface. `Cost is the legacy recompute-cost-descending order (the gh-555 chain's, kept as the evaluation baseline); `Enablement sorts family-unlocking `Materialize flips (enablement members) first and family-breaking `Inline flips (members of either set) last, cost-descending within each class. The unit ranked is the candidate (gh-ocannl-1017): each node's alternatives are sorted by that order and the node ranks where its best-ranked alternative does, so a top-N prefix is N nodes; equal ranks keep the input's order (gh-ocannl-1777: the surface's program order, never node id). `Profitable (gh-ocannl-579) is `Enablement weighed against profit per effective_flip_ordering — the prior models expressibility, and on a device where the family it unlocks is measured hopeless, promotion is pure opportunity cost that displaces the winning flip out of a small budget. profit defaults to Unmeasured (so a caller with no measurements, such as model_default, gets the prior). Config tune_flip_ordering selects the default ordering. Exposed for tests.

Whether placement_surface withholds ps_floor_ms over these candidates: when one of them is not materialized by default (fc_default) and offers no `Materialize alternative — a node an earlier routine of the lineage left virtual and this routine footprint-scoped, which nothing here writes (gh-ocannl-616). The all-materialized specialization the floor is read from keeps that node's scratch, so the floor would not lower-bound its inline completion. Decided by the default reading (gh-ocannl-1017), not by which alternatives exist: a cap-materialized node with no smaller footprint offers the same lone `Inline and leaves the floor sound. Exposed for tests.

The placement decision surface prepared for search (gh-ocannl-514): the per-node inline/materialize levels of the joint placement x sketch x fission space.

The rule behind placement_surface's ps_twin_identity, over an already-lowered routine: placement_surface applies it to its decision lowering with the context's placements as lineage, Context.inherits_computation as inherited and the surface's enablement classes. Exposed so a test can reach the two refusals no Assignments lowering can isolate (test/operations/flip_twins.ml): a neighbourhood whose statement-level local is defined in a separate top-level statement, or by none -- shapes only hand-built raw code has -- and the inherited-computation refusal with everything else held fixed (inherited swapped on the same lowering).

The target model_explain and model_pick judge for, in place of the context's (gh-ocannl-1780): what a host without the device reads of another backend's model decision, the premise of a GPU-gated claim checked on cc. A record threaded through ?target, not driver members, because only the decision-only entry points may take it: a driver overriding these would also redirect every compile of its instance, and a GPU-scheduled pick would be compiled by the context's own backend. The lowering takes the target's facts and limits (Context.lowered_for_decisions); the optimize context and placements stay the context's.

Config model_default_schedule: recipe-level untuned compiles (Train.to_routine, Train.run_once, the benchmark runners) route through model_default instead of Context.compile.

Ir.Cost_model.operand_load_count under capabilities' mma_operand_loads rule and mma_operand_fragments structure, for the statements its mma_accepts hook probe accepts: the count model_family_search breaks exact ties with and model_explain reports (gh-ocannl-1254): Undescribed where the backend describes no arm for some statement (every backend but CUDA). The walk keys only Loads.

The numerics-preserving candidate set the seeded untuned default draws from and model_default's family search is restricted to where it starts from the seeded plan (gh-ocannl-1324, gh-ocannl-1253): the unfused GPU scalar blocktile with no twin flavor. Exposed for tests.

model_default's branch-and-bound walk over the factored family of one lowering (sketch_family_tree: the matmul family, or since gh-ocannl-697 the conv family): (best, stats, bound), where best is the first leaf whose score (of its scheduled form) is strictly below incumbent, the threshold tightening as leaves improve on it, and bound the family's schedule-invariant roofline floor under the envelope. Exact ties between leaves go to fewer tile-MMA operand load instructions (model_operand_loads under capabilities — model_default passes the backend's; gh-ocannl-1254) between leaves that both have tile-MMA sites, then to the first; a tie never displaces incumbent. Sketches are scheduled at capabilities' accum_prec. on_rejected is called for each leaf whose schedule fails to apply; a leaf admit refuses is left unscored, on_excluded called, before it is scheduled (model_default's numerics-preserving restriction). None for a lowering neither family claims. A conv path carries no certain-traffic increment, so its bound is the schedule-invariant floor, sound for every completion. With coalesced (default false; model_default passes model_ranks_coalesced), the coalesced layouts' leaves (coalesced_seed_params) are scored after the walk, leaf by leaf under the same admit and accounting and with no bound, and one displaces the walk's pick (or incumbent) only by strict improvement (gh-ocannl-1600). Exposed so a test can drive the walk with stand-in limits and load rules on any backend.

gh-ocannl-1600: whether model_default ranks the coalesced layouts -- where the terms that tell them from their uncoalesced twins are priced: ranking_transaction_rate, ranking_workgroup_capacity, the device residency and ranking_fill_model all resolve (the occupancy factor reads the last two) and the backend states its simdgroup_width. Its numerics-preserving set then also admits a coalesced scalar blocktile.

What seeded_default did to one compile.

A matmul site's reduction extent: its innermost contraction loop's extent times every enclosing contraction loop's — for a backprop weight gradient, the batch-and-sequence product.

The parameters seeded_default seeds into one fission segment (gh-ocannl-1324): None unless the segment is a matmul site (detect_matmul_canonical, so backprop's contractions count) with a site_reduction_extent of at least min_reduction, and whose output's storage precision is its own accumulator precision under accum_prec (the backend's resolution): the sketch keeps a wider accumulator across the whole reduction where the default rounds it back per contraction step, so a narrow-storage site stays on the default rather than change its result -- admit_narrow (default false; seeded_default's seed_narrow, gh-ocannl-1405) seeds it anyway. (The premise is conservative: Privatize mints its tile wide only where the default's serial rendering widens too, gh-ocannl-1151, so a seeded backprop weight gradient keeps the default's narrowing points; see seeded_default.) Otherwise one leaf of the segment's own GPU matmul_sketch_tree — so every refutation the search applies applies here — restricted to the unfused scalar blocktile pipeline without twin flavors: batch loops as grid blocks on a batched site where the device admits them, and the first geometry of a fixed preference list (64x64x8/4x4, 32x32x8/4x4, 32x32x16/2x2, 16x16x8/2x2, 16x16x8/4x4) whose launch has 128 blocks, else the one putting the most threads on the output — among the geometries padding the output by at most an eighth, where there are any. capabilities as for matmul_sketch_tree: the compiling context's Context.codegen_capabilities, so the tree's workgroup-memory refutation charges the staged tiles exactly as the gate judging the seeded kernel does; every caller holding a context passes them, the seeded plan's decision rule included. Exposed for tests.

seeded_params with the refusing gate named (gh-ocannl-1407): Ok exactly where seeded_params is Some.

Whether seeded_default seeds on a backend with these facts: its seeds_untuned_default (CUDA and HIP).

Whether seeded_default splits long reductions on this backend: wherever it seeds, CUDA and HIP (see seeded_split_sites). A test states what each backend promises through these, never a restated list.

Whether a search on a backend with facts can read the Utils.Search_shaping configuration key key (gh-ocannl-1331): the seeded plan's gpu_default_* keys where seeded_default_backend (and, for the split threshold, seeded_split_backend) holds, autotune_register_tile_rm_twin where Ir.Backend_intf.renders_on_host_pool does (only the CPU register-tiled rendering reads it), the default pipeline's keys per Ir.Schedule.search_shaping_key_read, and every other key everywhere. A key a backend's search cannot read keys nothing in its trajectory identity (search_shaping_identity).

The Search_shaping part of tune's search-trajectory identity on a backend with facts at limits: Utils.config_class_fingerprint of the class, over the keys search_shaping_key_read says the backend reads, with defaults resolved per device (Ir.Schedule.resolve_search_shaping_value).

The reductions seeded_default splits (gh-ocannl-1325), each with its block count: the split_reduce_sites (the split's own legality and enabling interchange, as the search proposes them) whose serial chain per output cell -- sr_cost / sr_out -- is at least min_serial (0: none), scatter sites excepted; each at the block count of the search's menu (32; 128; 512, at most half the split loop's extent and at most the square root of the chain, gh-ocannl-1414) giving the most first-pass threads up to 32768, else the smallest such; a chain too short for every count is not split. The choice reads no device property, so the split, and the summation order it fixes, depend on the routine alone. Empty where seeded_split_backend is false (backend is the Context.backend_name). The split was CUDA's alone until its first pass ran the block loop outside the cell loops (sr_block_hoist, gh-ocannl-1412): before that, HIP's gpt2_mini_train b256 step measured 1.42x SLOWER split (885 to 1256 ms, gfx1151 unified memory) where CUDA gained 1.39x. Exposed for tests.

Config gpu_default_sketch_min_reduction: an integer is Min_reduction; auto is Ranked under ranking_capacity's capacity and ranking_cache_bandwidth, and Min_reduction 32 — the threshold's measured default — where nothing calibrates either tier: no advisory (Metal) and no model_cache_capacity / model_cache_bandwidth override. An explicit none override is a calibration and keeps Ranked, even with both tiers off. Raises Utils.Invalid_config_value naming the key on anything else (gh-ocannl-1332).

Whether model_default starts from the seeded untuned plan on this backend under the current configuration (CUDA and HIP with the seeding settings resolving): its gate, split threshold, reduction-sink flag and narrow-storage admission (gh-ocannl-1405), as seeded_default resolves them; None where the incumbent is the default pipeline.

The per-segment decisions several derivations of one search share (gh-ocannl-1697): each distinct segment code's seed and sink, as one derivation decides them. Sound across derivations under one gate, limits and settings: a decision is a function of the segment's code.

An empty seeded_memo.

The seeded plan's decision rule, for tune's staffed start (gh-ocannl-1138, config autotune_staffed_singles), which applies it to the search's own segments: the plan's recorded decisions are taken on the split routine under the untuned segmentation and match no search key. Carried in the plan so that the device readings the gate rests on reach tune only through seeded_plan.

The seeded untuned plan as a replayable value (gh-ocannl-1388): what seeded_default decides for one lowering. tune derives it on its base lowering and seeds it as its FIRST candidate, replayed the way the untuned compile replays it, so the step the recipes ship untuned is the search's floor by construction (where untuned_compile is seeded_default, i.e. without model_default_schedule=true); gh-ocannl-1138 extends it from there.

The plan seeded_default would compile opt under, derived on a hermetic copy; None where that is the plain default pipeline (another backend, scheduling or fission off, the thresholds at 0, or nothing to split, seed or sink). The optional arguments are seeded_default's, the auto gate included: tune seeds this plan first, and the plan's seeded_plan_digest joins the search trajectory's identity, so a gate steered by the device description's Untimed capacity reaches the search only as the plan it resolved to (gh-ocannl-1253). capabilities are the compiling context's, which seeded_params prices workgroup memory by — in the plan's segments and in its decision rule; tune passes its context's, as the untuned compile does. memo (default: a fresh one) takes and records the derivation's per-segment decisions; tune shares one with its seeded_resplits.