Struct TilingPolicy 

pub struct TilingPolicy<const TILE_M: usize, const TILE_N: usize>;

Zero-sized strategy marker for tiled execution policy.

Encode tile shape in the type system as a ZST so tiling parameters are resolved at compile time with no runtime storage.

Examples

Dot product via the tiled_dot free function (preferred API):

use hermes_simd_core::tiling::tiled_dot;
use hermes_simd_core::view::SimdView;
use hermes_simd_core::align::Unaligned;
use hermes_simd_intrinsics::Scalar;

let a = [1.0_f32, 2.0, 3.0, 4.0];
let b = [1.0_f32, 1.0, 1.0, 1.0];
let va = SimdView::<f32, Scalar, Unaligned>::new(&a).unwrap();
let vb = SimdView::<f32, Scalar, Unaligned>::new(&b).unwrap();
// TILE_M = 4 unrolls into 4 independent FMA accumulators.
let result = tiled_dot::<f32, Scalar, Unaligned, 4>(&va, &vb).unwrap();
assert!((result - 10.0_f32).abs() < 1e-6);

Implementations

impl<const TILE_M: usize, const TILE_N: usize> TilingPolicy<TILE_M, TILE_N>

pub const AVX2_STANDARD: TilingPolicy<4, 4> = TilingPolicy

Standard tile for AVX2 (4 accumulators x 8 f32 lanes = 256 bits).

pub const AVX512_OPTIMAL: TilingPolicy<8, 4> = TilingPolicy

Optimal tile for AVX-512 (8 accumulators x 16 f32 lanes = 1024 bits).

pub const SCALAR_DEGENERATE: TilingPolicy<1, 1> = TilingPolicy

Scalar degenerate tile: TILE_M = 1, TILE_N = 1 — no tiling overhead.

Named SCALAR_DEGENERATE (SCREAMING_SNAKE_CASE) to satisfy Rust naming lints.

pub const fn validate(&self)

Verify that the tile shape is valid at compile time.

Trait Implementations

impl<const TILE_M: usize, const TILE_N: usize> Clone for TilingPolicy<TILE_M, TILE_N>

fn clone(&self) -> TilingPolicy<TILE_M, TILE_N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const TILE_M: usize, const TILE_N: usize> Copy for TilingPolicy<TILE_M, TILE_N>

impl<const TILE_M: usize, const TILE_N: usize> Debug for TilingPolicy<TILE_M, TILE_N>

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

Formats the value using the given formatter.

impl<const TILE_M: usize, const TILE_N: usize> Eq for TilingPolicy<TILE_M, TILE_N>

impl<const TILE_M: usize, const TILE_N: usize> PartialEq for TilingPolicy<TILE_M, TILE_N>

fn eq(&self, other: &TilingPolicy<TILE_M, TILE_N>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const TILE_M: usize, const TILE_N: usize> StructuralPartialEq for TilingPolicy<TILE_M, TILE_N>

impl<T, Arch, Align, const TILE_M: usize, const TILE_N: usize> TilingStrategy<T, Arch, Align> for TilingPolicy<TILE_M, TILE_N>

where Arch: SimdArch + SimdKernel<T>, Align: Alignment, T: Scalar,

const TILE_M: usize = TILE_M

The number of rows in the register block.

const TILE_N: usize = TILE_N

The number of columns (vectors of size LANE_COUNT) in the register block.

fn gemm( a: &SimdView<'_, T, Arch, Align>, b: &SimdView<'_, T, Arch, Align>, c: &mut [T], m: usize, n: usize, k: usize, ) -> Result<(), SimdError>

Perform tiled matrix multiplication c += a * b using this strategy.

fn gemv( a: &SimdView<'_, T, Arch, Align>, x: &SimdView<'_, T, Arch, Align>, y: &mut [T], nrows: usize, ncols: usize, ) -> Result<(), SimdError>

Perform tiled matrix-vector multiplication y += A * x using this strategy.

fn gemv_transpose( a: &SimdView<'_, T, Arch, Align>, x: &SimdView<'_, T, Arch, Align>, y: &mut [T], nrows: usize, ncols: usize, ) -> Result<(), SimdError>

Perform tiled transposed matrix-vector multiplication y += Aᵀ * x (A row-major nrows × ncols, x length nrows, y length ncols).

fn gemv_strided( a: &SimdView<'_, T, Arch, Align>, x: &SimdView<'_, T, Arch, Align>, y: &mut [T], nrows: usize, ncols: usize, lda: usize, ) -> Result<(), SimdError>

Perform tiled matrix-vector multiplication y += A * x over a row-major sub-matrix: nrows × ncols with row stride lda ≥ ncols (lda = ncols is the packed Self::gemv).

fn gemv_transpose_strided( a: &SimdView<'_, T, Arch, Align>, x: &SimdView<'_, T, Arch, Align>, y: &mut [T], nrows: usize, ncols: usize, lda: usize, ) -> Result<(), SimdError>

Perform tiled transposed matrix-vector multiplication y += Aᵀ * x over a row-major sub-matrix: nrows × ncols with row stride lda ≥ ncols (lda = ncols is the packed Self::gemv_transpose).

fn dot( a: &SimdView<'_, T, Arch, Align>, b: &SimdView<'_, T, Arch, Align>, ) -> Result<T, SimdError>

Perform tiled dot product computation using this strategy.