Struct RmsNormOp 

pub struct RmsNormOp {
    pub tokens: usize,
    pub dim: usize,
    pub eps: f32,
}

One concrete rms_norm invocation. Inputs:

• x: tokens × dim activation
• w: dim weight (per-channel scale)
• eps: the usual RMSNorm epsilon

Output: tokens × dim. This fixture uses F32 buffers on CPU and Metal; CUDA’s existing default buffers are F16. Host results are returned as f32.

Fields

tokens: usize

dim: usize

eps: f32

Implementations

impl RmsNormOp

pub fn validate(&self) -> Result<(), String>

Validate the shared fixture before allocation or backend submission.

pub fn expected_output_len(&self) -> Result<usize, String>

Checked host result size, including the kernels’ signed 32-bit row and column indices and the final column-loop increment. These are kernel/host limits, not a promise that the allocation fits available device memory.

Examples found in repository

examples/backend_numerics/config.rs (line 90)

    fn expected_output_len(&self) -> Result<usize, String> {
        match *self {
            Self::MetalContext {
                tokens,
                intermediate,
                k,
            } => MetalContextOp {
                tokens,
                intermediate,
                k,
            }
            .expected_output_len(),
            Self::RmsNorm { tokens, dim, eps } => {
                RmsNormOp { tokens, dim, eps }.expected_output_len()
            }
            Self::Gemm { m, n, k } => GemmOp { m, n, k }.expected_output_len(),
            Self::SiluMul {
                tokens,
                intermediate,
            } => SiluMulOp {
                tokens,
                intermediate,
            }
            .expected_output_len(),
        }
    }

Trait Implementations

impl OpUnderTest for RmsNormOp

fn name(&self) -> &str

Display name (used in test failure messages).

fn run_cpu(&self, seed: u64) -> Output

Run on CPU (reference). Always available.