Struct MaskPlan 

pub struct MaskPlan { /* private fields */ }

Per-layer attention-mask variation — the axis GAP-029 measured across increment 3’s families and the earlier six-axis check could not see, every one of its axes being model-scalar.

Note the axis is named for the behaviour that varies, not the first mechanism found: three families vary by sliding window, SmolLm3 varies by skipping RoPE entirely, and a checklist keyed on sliding_window would have cleared SmolLm3 outright.

Shape in the graph

The mask Const is [n_variants, 1, seq, max_seq_len]; the build path hoists n_variants width-1 slices once, before the layer loop, and layer i takes variant_for_layer(i). DecodeTokenData, DecodeSession and the rebind driver are untouched — still one mask Arc, one mask_node.

n_variants == 1 mints [1, 1, seq, max_seq_len] and emits no slice node at all, so a uniform family’s graph is byte-identical to the pre-GAP-029 one. That is asserted, not claimed: see mask_variants_are_byte_identical_ to_the_dense_builder_when_uniform.

Implementations

impl MaskPlan

pub fn dense(n_layers: usize) -> Self

The uniform dense plan — every layer attends causally to the whole prefix. What LlamaModel and every other non-varying family use, and byte-identical to the pre-GAP-029 single-mask decode path.

pub fn new(windows: Vec<Option<usize>>, per_layer: Vec<usize>) -> Result<Self>

Validated at construction, per the build-time-validation rule: an out-of-range variant index would otherwise surface as a panic deep in the layer loop, or — worse — as a silently mis-masked layer.

pub fn split_window(n_layers: usize, split: usize, window: usize) -> Self

The layer_idx < split plan: the first split layers attend through a window, the rest densely. This is exactly the predicate Qwen2, Qwen3 and Qwen3Moe share (use_sliding_window && layer_idx < max_window_layers), so all three express their variation by calling this rather than hand-rolling a variant table.

Total by construction — no Result, no panic. Both degenerate splits collapse to a single variant, so a model that is entirely dense or entirely windowed emits no slice node and pays nothing: split == 0 is Self::dense, split >= n_layers is one windowed variant.

pub fn per_layer_window( n_layers: usize, window: usize, uses_window: impl Fn(usize) -> bool, ) -> Self

Arbitrary per-layer window selection, TOTAL by construction.

Self::split_window covers the prefix predicate Qwen2/Qwen3/Qwen3Moe share. Gemma3’s is modular ((i + 1) % sliding_window_pattern > 0), so it needs a free selector — and it cannot use Self::new, because decode_mask_plan is infallible and expect-ing a Result on a production path is exactly the never-panic violation this project bans. A closure returning bool over exactly two defined variants cannot produce an out-of-range index, so this needs no Result at all.

Collapses to a single variant when the selector is constant, so a config that happens to window every layer (or none) still emits no slice.

pub fn n_variants(&self) -> usize

pub fn n_layers(&self) -> usize

pub fn variant_for_layer(&self, layer_idx: usize) -> usize

pub fn window_for_layer(&self, layer_idx: usize) -> Option<usize>

This layer’s window width, or None if it attends densely.

The single source shared with the mask bytes — the CUDA flash arm’s window_size_* and the mask Const come from the same plan entry, so they cannot disagree. A family deriving the window separately for the arm would be free to drift from the mask it actually applies, and “arm says dense, mask says windowed” is precisely the silent defect GAP-194 was filed about.

pub fn mix_into(&self, h: &mut ShapeKeyHasher)

Mix the plan’s structural content into a decode shape key.

The variant count and the per-layer assignment change the graph’s shape and wiring, so a session built under one plan must not be reused under another. The window widths are deliberately excluded: they are data, rebound per token like the RoPE tables, and baking them would forfeit plan reuse across a change that is already handled correctly — the same argument decode_shape_key’s own doc makes for rope_base.

Trait Implementations

impl Clone for MaskPlan

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MaskPlan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for MaskPlan

impl PartialEq for MaskPlan

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for MaskPlan