use crate::descriptor::cursor::{ByteCursor, ByteWriter};
use crate::{Error, Result, Shape};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ShardDescriptor {
pub parent_shape: Vec<u64>,
pub shard_offset: Vec<u64>,
}
impl ShardDescriptor {
pub fn new(parent_shape: Vec<u64>, shard_offset: Vec<u64>) -> Result<Self> {
if parent_shape.len() != shard_offset.len() {
return Err(Error::InvalidShape(format!(
"shard: parent_shape.len() ({}) != shard_offset.len() ({})",
parent_shape.len(),
shard_offset.len()
)));
}
Ok(Self {
parent_shape,
shard_offset,
})
}
pub fn validate_against_shape(&self, shape: &Shape) -> Result<()> {
for k in 0..self.parent_shape.len() {
let dim = shape.dims()[k];
let offset = self.shard_offset[k];
let parent = self.parent_shape[k];
if offset.saturating_add(dim) > parent {
return Err(Error::ShardOutOfBounds {
dim: k,
offset,
size: dim,
parent,
});
}
}
Ok(())
}
pub(crate) fn encode_into(&self, w: &mut ByteWriter) {
for &v in &self.parent_shape {
w.write_u64_le(v);
}
for &v in &self.shard_offset {
w.write_u64_le(v);
}
}
pub(crate) fn decode_from(cursor: &mut ByteCursor<'_>, rank: u32) -> Result<Self> {
let rank = rank as usize;
let mut parent_shape = Vec::with_capacity(rank);
for _ in 0..rank {
parent_shape.push(cursor.read_u64_le()?);
}
let mut shard_offset = Vec::with_capacity(rank);
for _ in 0..rank {
shard_offset.push(cursor.read_u64_le()?);
}
Ok(Self {
parent_shape,
shard_offset,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::descriptor::cursor::ByteWriter;
use crate::Shape;
fn round_trip(parent: Vec<u64>, offset: Vec<u64>) -> ShardDescriptor {
let rank = parent.len() as u32;
let shard = ShardDescriptor::new(parent, offset).unwrap();
let mut w = ByteWriter::new();
shard.encode_into(&mut w);
let bytes = w.into_vec();
let mut c = ByteCursor::new(&bytes, bytes.len());
ShardDescriptor::decode_from(&mut c, rank).unwrap()
}
#[test]
fn shard_round_trip() {
let parent = vec![100u64, 200, 300];
let offset = vec![10u64, 20, 30];
let decoded = round_trip(parent.clone(), offset.clone());
assert_eq!(decoded.parent_shape, parent);
assert_eq!(decoded.shard_offset, offset);
}
#[test]
fn shard_out_of_bounds_rejected() {
let shape = Shape::new(vec![3u64, 4]).unwrap();
let shard = ShardDescriptor::new(vec![10, 10], vec![0, 7]).unwrap();
let err = shard.validate_against_shape(&shape).unwrap_err();
assert!(matches!(err, Error::ShardOutOfBounds { dim: 1, .. }));
}
#[test]
fn shard_length_mismatch_rejected() {
let err = ShardDescriptor::new(vec![10], vec![0, 5]).unwrap_err();
assert!(matches!(err, Error::InvalidShape(_)));
}
#[test]
fn shard_exact_bound_is_valid() {
let shape = Shape::new(vec![5u64]).unwrap();
let shard = ShardDescriptor::new(vec![10], vec![5]).unwrap();
assert!(shard.validate_against_shape(&shape).is_ok());
}
}