Method read_tensors

cake-core/src/utils/tensor_storage.rs:505–570

(&self, names: &[&str])

    }

    fn read_tensors(&self, names: &[&str]) -> Result<Vec<TensorData>> {
        if names.is_empty() {
            return Ok(Vec::new());
        }

        // Resolve all metadata first
        let metas: Vec<&TensorMeta> = names
            .iter()
            .map(|n| {
                self.index
                    .get(*n)
                    .ok_or_else(|| anyhow::anyhow!("tensor '{}' not found in storage", n))
            })
            .collect::<Result<_>>()?;

        // Check if all tensors are in the same shard and contiguous
        let same_shard = metas.windows(2).all(|w| w[0].shard_idx == w[1].shard_idx);
        let contiguous = same_shard
            && metas
                .windows(2)
                .all(|w| w[0].abs_offset + w[0].byte_size == w[1].abs_offset);

        if contiguous && metas.len() > 1 {
            // Single pread for the entire contiguous region
            let first = metas[0];
            let last = metas[metas.len() - 1];
            let total_size = (last.abs_offset + last.byte_size - first.abs_offset) as usize;

            let shard = self
                .shards
                .get(first.shard_idx as usize)
                .ok_or_else(|| anyhow::anyhow!("shard index {} out of range", first.shard_idx))?;

            // mmap: zero-syscall read — just memcpy from mapped memory
            #[cfg(unix)]
            let buf = shard.read_bytes(first.abs_offset, total_size);

            #[cfg(not(unix))]
            let buf = {
                use std::io::{Read as _, Seek, SeekFrom};
                let mut f = shard.file.try_clone()?;
                let mut buf = vec![0u8; total_size];
                f.seek(SeekFrom::Start(first.abs_offset))?;
                f.read_exact(&mut buf)?;
                buf
            };

            // Split the buffer into individual tensor data
            let mut results = Vec::with_capacity(metas.len());
            let mut offset = 0usize;
            for meta in &metas {
                let size = meta.byte_size as usize;
                let bytes = buf[offset..offset + size].to_vec();
                results.push(TensorData {
                    bytes,
                    dtype: meta.dtype,
                    shape: meta.shape.to_vec(),
                });