pub mod block_paged;
pub mod col_major;
pub mod coo;
pub mod csc;
pub mod csf;
pub mod csr;
pub mod hilbert;
pub mod morton;
pub mod row_major;
pub mod strided;
pub mod tiled;
use crate::{ElementType, Error, Result, Shape, DYNAMIC};
pub trait ElementAddress {
fn element_offset(&self, index: &[u64], shape: &Shape) -> Result<u64>;
}
pub fn byte_address_from_element_offset(
element_offset: u64,
byte_offset: u64,
element_type: ElementType,
buffer_size: u64,
) -> Result<u64> {
let signed = element_offset as i64;
let bits = element_type.bit_width() as i64;
let byte_delta: i64 = if bits >= 8 {
signed.checked_mul(bits / 8).ok_or(Error::AddressOverflow)?
} else if bits == 6 {
signed
.div_euclid(4)
.checked_mul(3)
.ok_or(Error::AddressOverflow)?
} else {
signed.div_euclid(8 / bits)
};
let byte_addr = (byte_offset as i64)
.checked_add(byte_delta)
.ok_or(Error::AddressOverflow)?;
if byte_addr < 0 || byte_addr as u64 >= buffer_size {
return Err(Error::ByteAddressOverflow { buffer_size });
}
Ok(byte_addr as u64)
}
pub(crate) fn validate_index(index: &[u64], shape: &Shape) -> Result<()> {
if index.len() != shape.rank() {
return Err(Error::IndexRankMismatch {
index_rank: index.len(),
shape_rank: shape.rank(),
});
}
for (k, (&idx, &dim)) in index.iter().zip(shape.dims().iter()).enumerate() {
if dim == DYNAMIC {
return Err(Error::DynamicDimInIndexing { dim: k as u32 });
}
if idx >= dim {
return Err(Error::IndexOutOfRange {
dim: k as u32,
index: idx,
size: dim,
});
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use crate::layout::{CooLayout, LayoutDescriptor, MortonLayout, StridedLayout};
use crate::{ElementType, Error, Shape};
use super::byte_address_from_element_offset;
#[test]
fn dispatch_row_major() {
let shape = Shape::new(vec![3, 4]).unwrap();
assert_eq!(
LayoutDescriptor::RowMajor
.element_offset(&[1, 2], &shape)
.unwrap(),
6
);
}
#[test]
fn dispatch_col_major() {
let shape = Shape::new(vec![3, 4]).unwrap();
assert_eq!(
LayoutDescriptor::ColMajor
.element_offset(&[1, 2], &shape)
.unwrap(),
7
);
}
#[test]
fn dispatch_strided() {
let shape = Shape::new(vec![3, 4]).unwrap();
let layout = LayoutDescriptor::Strided(StridedLayout::new(vec![4, 1]));
assert_eq!(layout.element_offset(&[1, 2], &shape).unwrap(), 6);
}
#[test]
fn dispatch_morton() {
let shape = Shape::new(vec![4, 4]).unwrap();
let layout = LayoutDescriptor::Morton(MortonLayout::new(vec![2, 2]).unwrap());
assert_eq!(layout.element_offset(&[2, 3], &shape).unwrap(), 14);
}
#[test]
fn dispatch_coo_returns_multi_buffer_error() {
let layout = LayoutDescriptor::Coo(CooLayout::new(0, false));
let shape = Shape::new(vec![4, 4]).unwrap();
let err = layout.element_offset(&[0, 0], &shape).unwrap_err();
assert!(
matches!(err, Error::LayoutRequiresMultiBuffer { layout_tag: 0x06 }),
"expected LayoutRequiresMultiBuffer{{0x06}}, got {err:?}"
);
}
#[test]
fn byte_addr_float32_offset_6() {
let addr = byte_address_from_element_offset(6, 0, ElementType::Float32, 100).unwrap();
assert_eq!(addr, 24);
}
#[test]
fn byte_addr_bool_offset_9() {
let addr = byte_address_from_element_offset(9, 0, ElementType::Bool, 100).unwrap();
assert_eq!(addr, 1);
}
#[test]
fn byte_addr_int4_offset_7() {
let addr = byte_address_from_element_offset(7, 0, ElementType::Int4, 100).unwrap();
assert_eq!(addr, 3);
}
#[test]
fn byte_addr_uint4_offset_8() {
let addr = byte_address_from_element_offset(8, 0, ElementType::Uint4, 100).unwrap();
assert_eq!(addr, 4);
}
#[test]
fn byte_addr_float64_with_byte_offset() {
let addr = byte_address_from_element_offset(3, 8, ElementType::Float64, 200).unwrap();
assert_eq!(addr, 32);
}
#[test]
fn byte_addr_negative_strided_offset() {
let element_offset = (-5i64) as u64;
let addr = byte_address_from_element_offset(element_offset, 40, ElementType::Float32, 100)
.unwrap();
assert_eq!(addr, 20);
}
#[test]
fn byte_addr_overflow_at_exact_buffer_size() {
let err = byte_address_from_element_offset(25, 0, ElementType::Float32, 100).unwrap_err();
assert!(
matches!(err, Error::ByteAddressOverflow { buffer_size: 100 }),
"expected ByteAddressOverflow{{100}}, got {err:?}"
);
}
#[test]
fn byte_addr_overflow_negative_offset_underflows_byte_offset() {
let element_offset = (-5i64) as u64;
let err = byte_address_from_element_offset(element_offset, 4, ElementType::Float32, 100)
.unwrap_err();
assert!(
matches!(err, Error::ByteAddressOverflow { .. }),
"expected ByteAddressOverflow, got {err:?}"
);
}
#[test]
fn byte_addr_offset_zero_is_always_valid() {
let addr = byte_address_from_element_offset(0, 0, ElementType::Float32, 4).unwrap();
assert_eq!(addr, 0);
}
#[test]
fn byte_addr_last_valid_float32_element() {
let addr = byte_address_from_element_offset(9, 0, ElementType::Float32, 40).unwrap();
assert_eq!(addr, 36);
}
}