use crate::{Error, Result};
pub const MAX_TILED_DEPTH: usize = 8;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct OuterStrides {
pub strides: Vec<i64>,
}
impl OuterStrides {
pub fn new(strides: Vec<i64>) -> Self {
Self { strides }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct InnerStrides {
pub strides: Vec<i64>,
}
impl InnerStrides {
pub fn new(strides: Vec<i64>) -> Self {
Self { strides }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct TiledLayout {
pub tile_shape: Vec<u64>,
pub outer_layout: u8,
pub inner_layout: u8,
pub outer_strides: Option<OuterStrides>,
pub inner_strides: Option<InnerStrides>,
pub inner_tiled: Option<Box<TiledLayout>>,
}
impl TiledLayout {
pub fn new(
tile_shape: Vec<u64>,
outer_layout: u8,
inner_layout: u8,
outer_strides: Option<OuterStrides>,
inner_strides: Option<InnerStrides>,
inner_tiled: Option<Box<TiledLayout>>,
) -> Result<Self> {
Self::new_at_depth(
tile_shape,
outer_layout,
inner_layout,
outer_strides,
inner_strides,
inner_tiled,
0,
)
}
fn new_at_depth(
tile_shape: Vec<u64>,
outer_layout: u8,
inner_layout: u8,
outer_strides: Option<OuterStrides>,
inner_strides: Option<InnerStrides>,
inner_tiled: Option<Box<TiledLayout>>,
depth: usize,
) -> Result<Self> {
if depth >= MAX_TILED_DEPTH {
return Err(Error::InvalidLayout(format!(
"tiled layout recursion depth {depth} exceeds maximum of {MAX_TILED_DEPTH}"
)));
}
if tile_shape.is_empty() {
return Err(Error::InvalidLayout(
"tile_shape must not be empty".to_string(),
));
}
for (k, &dim) in tile_shape.iter().enumerate() {
if dim == 0 {
return Err(Error::InvalidLayout(format!(
"tile_shape[{k}] must be > 0, got 0"
)));
}
}
if !matches!(outer_layout, 0x01..=0x03) {
return Err(Error::InvalidLayout(format!(
"outer_layout 0x{outer_layout:02X} is invalid: must be 0x01, 0x02, or 0x03"
)));
}
if !matches!(inner_layout, 0x01..=0x04) {
return Err(Error::InvalidLayout(format!(
"inner_layout 0x{inner_layout:02X} is invalid: must be 0x01, 0x02, 0x03, or 0x04"
)));
}
match (outer_layout, outer_strides.is_some()) {
(0x03, false) => {
return Err(Error::InvalidLayout(
"outer_strides must be present when outer_layout is 0x03 (strided)".to_string(),
));
}
(layout, true) if layout != 0x03 => {
return Err(Error::InvalidLayout(format!(
"outer_strides present but outer_layout is 0x{layout:02X} (not strided)"
)));
}
_ => {}
}
match (inner_layout, inner_strides.is_some()) {
(0x03, false) => {
return Err(Error::InvalidLayout(
"inner_strides must be present when inner_layout is 0x03 (strided)".to_string(),
));
}
(layout, true) if layout != 0x03 => {
return Err(Error::InvalidLayout(format!(
"inner_strides present but inner_layout is 0x{layout:02X} (not strided)"
)));
}
_ => {}
}
match (inner_layout, inner_tiled.is_some()) {
(0x04, false) => {
return Err(Error::InvalidLayout(
"inner_tiled must be present when inner_layout is 0x04 (tiled)".to_string(),
));
}
(layout, true) if layout != 0x04 => {
return Err(Error::InvalidLayout(format!(
"inner_tiled present but inner_layout is 0x{layout:02X} (not tiled)"
)));
}
_ => {}
}
let inner_tiled = if let Some(inner) = inner_tiled {
let validated = Self::new_at_depth(
inner.tile_shape.clone(),
inner.outer_layout,
inner.inner_layout,
inner.outer_strides.clone(),
inner.inner_strides.clone(),
inner.inner_tiled.clone(),
depth + 1,
)?;
Some(Box::new(validated))
} else {
None
};
Ok(Self {
tile_shape,
outer_layout,
inner_layout,
outer_strides,
inner_strides,
inner_tiled,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::layout::LayoutDescriptor;
#[test]
fn tiled_tag_is_0x04() {
let t = TiledLayout::new(vec![4, 4], 0x01, 0x01, None, None, None).unwrap();
let layout = LayoutDescriptor::Tiled(Box::new(t));
assert_eq!(layout.tag(), 0x04);
}
#[test]
fn tiled_buffer_count_is_1() {
use std::num::NonZeroU8;
let t = TiledLayout::new(vec![4, 4], 0x01, 0x01, None, None, None).unwrap();
let layout = LayoutDescriptor::Tiled(Box::new(t));
assert_eq!(layout.buffer_count(), Some(NonZeroU8::new(1).unwrap()));
}
#[test]
fn rejects_zero_tile_dim() {
let err = TiledLayout::new(vec![4, 0], 0x01, 0x01, None, None, None).unwrap_err();
assert!(matches!(err, Error::InvalidLayout(_)));
}
#[test]
fn rejects_invalid_outer_layout() {
let err = TiledLayout::new(vec![4, 4], 0x04, 0x01, None, None, None).unwrap_err();
assert!(matches!(err, Error::InvalidLayout(_)));
}
#[test]
fn rejects_invalid_inner_layout() {
let err = TiledLayout::new(vec![4, 4], 0x01, 0x05, None, None, None).unwrap_err();
assert!(matches!(err, Error::InvalidLayout(_)));
}
#[test]
fn rejects_missing_outer_strides_when_outer_is_strided() {
let err = TiledLayout::new(vec![4, 4], 0x03, 0x01, None, None, None).unwrap_err();
assert!(matches!(err, Error::InvalidLayout(_)));
}
#[test]
fn rejects_outer_strides_when_outer_not_strided() {
let outer_strides = Some(OuterStrides {
strides: vec![2, 1],
});
let err = TiledLayout::new(vec![4, 4], 0x01, 0x01, outer_strides, None, None).unwrap_err();
assert!(matches!(err, Error::InvalidLayout(_)));
}
#[test]
fn accepts_strided_outer_with_outer_strides() {
let outer_strides = Some(OuterStrides {
strides: vec![2, 1],
});
let t = TiledLayout::new(vec![4, 4], 0x03, 0x01, outer_strides, None, None);
assert!(t.is_ok());
}
#[test]
fn rejects_excessive_recursion_depth() {
fn make_tiled_at_depth(remaining: usize) -> Box<TiledLayout> {
if remaining == 0 {
Box::new(TiledLayout::new(vec![2, 2], 0x01, 0x01, None, None, None).unwrap())
} else {
let inner = make_tiled_at_depth(remaining - 1);
Box::new(TiledLayout::new(vec![2, 2], 0x01, 0x04, None, None, Some(inner)).unwrap())
}
}
let _valid = make_tiled_at_depth(MAX_TILED_DEPTH - 1);
let too_deep = TiledLayout::new(
vec![2, 2],
0x01,
0x04,
None,
None,
Some(make_tiled_at_depth(MAX_TILED_DEPTH - 1)),
);
assert!(
too_deep.is_err(),
"depth {} should be rejected (max is {})",
MAX_TILED_DEPTH + 1,
MAX_TILED_DEPTH
);
}
}