Struct RopePlan 

pub struct RopePlan { /* private fields */ }

Per-layer RoPE-BASE variation — the sibling axis to MaskPlan, and the one Gemma3 forced.

A family with two RoPE bases (Gemma3: rope_theta for global layers, rope_local_base_freq for sliding ones) produces different table bytes per variant, so — exactly like the mask — the Const must physically carry N of them and the layer loop must select.

This is the criterion that separates it from SmolLm3’s per-layer RoPE gating, which needs nothing: variation in DATA needs a variant axis; variation in WHETHER-TO-APPLY does not. A skipping layer simply does not consume the shared tables; a differently-based layer needs different bytes.

Shape, and an honest asymmetry with MaskPlan

n_variants == 1 mints [seq, rope_width] — exactly today’s shape, with no slice and no reshape — so every single-base family’s graph is unchanged (pinned by the *_held_decode_graph_has_not_grown node-count tests).

n_variants > 1 mints [n, seq, rope_width] and hoists the per-variant views once before the layer loop. Unlike the mask — whose Const is already rank-4, so a width-1 slice is directly usable — RoPE tables are rank-2, so each variant costs a slice and a reshape. That cost is real and is named here rather than presented as symmetric.

Implementations

impl RopePlan

pub fn single(base: f64, n_layers: usize) -> Self

The single-base plan — what every family except Gemma3 uses.

pub fn new(bases: Vec<f64>, per_layer: Vec<usize>) -> Result<Self>

Validated at construction, like MaskPlan::new: an out-of-range variant index would otherwise be a panic in the layer loop or, worse, a layer silently roped at the wrong frequency.

pub fn per_layer_base( n_layers: usize, base_when_true: f64, base_when_false: f64, uses_first: impl Fn(usize) -> bool, ) -> Self

Two-base per-layer selection, TOTAL by construction — the sibling of MaskPlan::per_layer_window, and what Gemma3 uses: base_when_true is its rope_local_base_freq (sliding layers), base_when_false its rope_theta (full-causal layers).

Infallible for the same reason: a bool selector over exactly two defined bases cannot index out of range, so decode_rope_plan needs no Result and no expect.

⚠️ Collapses to a single base when the two are EQUAL — which is not a micro-optimisation but a correctness-of-measurement matter: Gemma3’s shipped fixtures set rope_local_base_freq == rope_theta, and a plan that still reported 2 variants there would make the graph look dual-base while every layer read identical bytes. Collapsing makes the degeneracy visible in n_variants(), which is what the non-vacuity assertions in Gemma3’s tests key on.

pub fn n_variants(&self) -> usize

pub fn n_layers(&self) -> usize

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

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

Mix the plan’s structural content into a decode shape key: the variant count and per-layer assignment wire the graph. The base values are excluded for the same reason rope_base always was — they are data, recomputed and rebound every token, so baking them would forfeit plan reuse across a change already handled correctly.

Trait Implementations

impl Clone for RopePlan

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 RopePlan

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

Formats the value using the given formatter.

impl PartialEq for RopePlan

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RopePlan