pub mod buffer;
pub mod composite;
pub mod descriptor;
pub mod element_type;
pub mod error;
pub mod layout;
pub mod quantization;
pub mod shape;
pub use buffer::{
validate_colocation, BufferHandle, DeviceTag, MemoryClass, PrivateMemoryClass, PrivateTag,
SyncMode, MIN_BUFFER_ALIGNMENT, PAGE_ALIGNMENT,
};
pub use composite::{CompositeTensor, CompositeValidator};
pub use descriptor::{
CompositeMemberDescriptor, DescriptorFlags, ExtensionTypeDescriptor, MemberRole,
ShardDescriptor, Statistics, StatisticsMask, TensorDescriptor, DESCRIPTOR_VERSION_MAJOR,
DESCRIPTOR_VERSION_MINOR, MAGIC,
};
pub use element_type::ElementType;
pub use error::{Error, Result};
pub use layout::{
byte_address_from_element_offset, BlockPagedLayout, BlockTableIndexType, CombineOp,
CompositeLayout, CompositionRule, CsfLayout, ElementAddress, KvRole, LayoutDescriptor,
};
pub use quantization::{
validate_axis, validate_buffer_placement, Mxfp, Nf4, PerBlockAffine, PerChannelAffine,
PerTensorAffine, QuantizationDescriptor, QuantizationSchemeTag, MXFP_CANONICAL_BLOCK_SIZE,
MXFP_MAX_BLOCK_SIZE, MXFP_MIN_BLOCK_SIZE, NF4_LUT, NF4_MIN_BLOCK_SIZE,
PER_BLOCK_AFFINE_MIN_BLOCK_SIZE,
};
pub use shape::{Shape, DYNAMIC, MAX_RANK};
pub fn buffer_size_bytes(ty: ElementType, element_count: u64) -> u64 {
let bits = ty.bit_width() as u64;
if bits == 0 {
return 0;
}
if bits >= 8 {
element_count * (bits / 8)
} else if bits == 6 {
element_count.div_ceil(4) * 3
} else {
(element_count as u128 * bits as u128).div_ceil(8) as u64
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn buffer_size_float32_60_elements() {
assert_eq!(buffer_size_bytes(ElementType::Float32, 60), 240);
}
#[test]
fn buffer_size_int64_1_element() {
assert_eq!(buffer_size_bytes(ElementType::Int64, 1), 8);
}
#[test]
fn buffer_size_float128_2_elements() {
assert_eq!(buffer_size_bytes(ElementType::Float128, 2), 32);
}
#[test]
fn buffer_size_uint8_5_elements() {
assert_eq!(buffer_size_bytes(ElementType::Uint8, 5), 5);
}
#[test]
fn buffer_size_float16_4_elements() {
assert_eq!(buffer_size_bytes(ElementType::Float16, 4), 8);
}
#[test]
fn buffer_size_complex64_3_elements() {
assert_eq!(buffer_size_bytes(ElementType::Complex64, 3), 24);
}
#[test]
fn buffer_size_complex128_1_element() {
assert_eq!(buffer_size_bytes(ElementType::Complex128, 1), 16);
}
#[test]
fn buffer_size_bool_9_elements() {
assert_eq!(buffer_size_bytes(ElementType::Bool, 9), 2);
}
#[test]
fn buffer_size_bool_8_elements_exact_byte() {
assert_eq!(buffer_size_bytes(ElementType::Bool, 8), 1);
}
#[test]
fn buffer_size_bool_1_element() {
assert_eq!(buffer_size_bytes(ElementType::Bool, 1), 1);
}
#[test]
fn buffer_size_bool_16_elements() {
assert_eq!(buffer_size_bytes(ElementType::Bool, 16), 2);
}
#[test]
fn buffer_size_int4_7_elements() {
assert_eq!(buffer_size_bytes(ElementType::Int4, 7), 4);
}
#[test]
fn buffer_size_int4_8_elements_exact_byte() {
assert_eq!(buffer_size_bytes(ElementType::Int4, 8), 4);
}
#[test]
fn buffer_size_uint4_1_element() {
assert_eq!(buffer_size_bytes(ElementType::Uint4, 1), 1);
}
#[test]
fn buffer_size_uint4_2_elements() {
assert_eq!(buffer_size_bytes(ElementType::Uint4, 2), 1);
}
#[test]
fn buffer_size_int2_5_elements() {
assert_eq!(buffer_size_bytes(ElementType::Int2, 5), 2);
}
#[test]
fn buffer_size_uint2_4_elements_exact_byte() {
assert_eq!(buffer_size_bytes(ElementType::Uint2, 4), 1);
}
#[test]
fn buffer_size_float4e2m1_3_elements() {
assert_eq!(buffer_size_bytes(ElementType::Float4E2M1, 3), 2);
}
#[test]
fn buffer_size_float6e2m3_4_elements_exact_group() {
assert_eq!(buffer_size_bytes(ElementType::Float6E2M3, 4), 3);
}
#[test]
fn buffer_size_float6e2m3_5_elements_partial_group() {
assert_eq!(buffer_size_bytes(ElementType::Float6E2M3, 5), 6);
}
#[test]
fn buffer_size_float6e2m3_8_elements_two_full_groups() {
assert_eq!(buffer_size_bytes(ElementType::Float6E2M3, 8), 6);
}
#[test]
fn buffer_size_float6e2m3_9_elements_partial_third_group() {
assert_eq!(buffer_size_bytes(ElementType::Float6E2M3, 9), 9);
}
#[test]
fn buffer_size_float6e3m2_4_elements() {
assert_eq!(buffer_size_bytes(ElementType::Float6E3M2, 4), 3);
}
#[test]
fn buffer_size_float6e3m2_1_element() {
assert_eq!(buffer_size_bytes(ElementType::Float6E3M2, 1), 3);
}
#[test]
fn buffer_size_zero_elements_whole_byte_type() {
assert_eq!(buffer_size_bytes(ElementType::Float32, 0), 0);
}
#[test]
fn buffer_size_zero_elements_bool() {
assert_eq!(buffer_size_bytes(ElementType::Bool, 0), 0);
}
#[test]
fn buffer_size_zero_elements_int4() {
assert_eq!(buffer_size_bytes(ElementType::Int4, 0), 0);
}
#[test]
fn buffer_size_zero_elements_int2() {
assert_eq!(buffer_size_bytes(ElementType::Int2, 0), 0);
}
#[test]
fn buffer_size_zero_elements_float6e2m3() {
assert_eq!(buffer_size_bytes(ElementType::Float6E2M3, 0), 0);
}
#[test]
fn buffer_size_large_count_uint8_no_overflow() {
assert_eq!(buffer_size_bytes(ElementType::Uint8, u64::MAX), u64::MAX);
}
#[test]
fn buffer_size_large_count_int4_no_overflow() {
let n = 1u64 << 62;
let expected = n / 2; assert_eq!(buffer_size_bytes(ElementType::Int4, n), expected);
}
#[test]
fn buffer_size_large_count_bool_no_overflow() {
let n = 1u64 << 63;
let expected = n / 8;
assert_eq!(buffer_size_bytes(ElementType::Bool, n), expected);
}
}