Enum TensorStorage 

pub enum TensorStorage<T: TensorElement> {
    InMemory(Arc<RwLock<Vec<T>>>),
    MemoryMapped(Arc<RwLock<MemoryMappedStorage<T>>>),
}

Storage abstraction for tensor data

Variants

InMemory(Arc<RwLock<Vec<T>>>)

In-memory storage for smaller tensors

MemoryMapped(Arc<RwLock<MemoryMappedStorage<T>>>)

Memory-mapped storage for large tensors

Implementations

impl<T: TensorElement + Copy> TensorStorage<T>

pub fn in_memory(data: Vec<T>) -> Self

Create in-memory storage

pub fn memory_mapped(data: Vec<T>, file_path: Option<PathBuf>) -> Result<Self>

Create memory-mapped storage

pub fn fast_result(data: Vec<T>) -> Self

🚀 Phase 7: Create fast result storage (skips alignment copy)

For SIMD operation results where we already have the data in a Vec, uses InMemory storage to avoid the ~10µs alignment copy overhead.

Performance

• Skips AlignedVec copy (saves ~10µs for 50K elements)
• Uses InMemory storage (has RwLock but we just created it)
• Optimal for result tensors that won’t be immediately used in SIMD ops

pub fn create_optimal(data: Vec<T>) -> Result<Self>

Create storage automatically based on size and performance characteristics

Storage Selection Strategy:

• Very large (>1GB): Memory-mapped for virtual memory efficiency
• Large (>10KB, SIMD enabled): SimdOptimized (lock-free reads)
• Medium (>1KB, SIMD enabled): Aligned storage for SIMD alignment
• Small (<1KB): In-memory with RwLock

pub fn len(&self) -> usize

Get the number of elements

pub fn is_empty(&self) -> bool

Check if storage is empty

pub fn get(&self, index: usize) -> Result<T>

where T: Copy,

Get element at index

pub fn set(&self, index: usize, value: T) -> Result<()>

where T: Copy,

Set element at index

pub fn get_slice(&self, start: usize, len: usize) -> Result<Vec<T>>

where T: Copy,

Get multiple elements

pub fn set_slice(&self, start: usize, values: &[T]) -> Result<()>

where T: Copy,

Set multiple elements

pub fn to_vec(&self) -> Result<Vec<T>>

where T: Copy,

Convert to vector (useful for small tensors or debugging)

pub fn storage_type(&self) -> &'static str

Get storage type information

pub fn memory_usage(&self) -> usize

Get estimated memory usage in bytes

pub fn with_slice<R, F>(&self, f: F) -> Result<R>

where F: FnOnce(&[T]) -> Result<R>, T: Copy,

Execute a function with immutable access to data slice (zero-copy within scope)

This enables zero-copy SIMD operations by providing direct &[T] access within the closure scope while the lock is held.

Arguments

• f - Closure that receives &[T] and returns Result<R>

Returns

Result from the closure

Performance

• Zero allocations for in-memory and aligned storage
• Converts memory-mapped storage to Vec (one allocation)

Examples

storage.with_slice(|data| {
    // Direct SIMD access to data
    f32::simd_add(&data, &other_data)
})?;

pub fn with_slice_mut<R, F>(&self, f: F) -> Result<R>

where F: FnOnce(&mut [T]) -> Result<R>, T: Copy,

Execute a function with mutable access to data slice (zero-copy within scope)

This enables zero-copy in-place operations by providing direct &mut [T] access within the closure scope while the lock is held.

Arguments

• f - Closure that receives &mut [T] and returns Result<R>

Returns

Result from the closure

Performance

• Zero allocations for in-memory storage
• Aligned storage not yet supported (returns error)
• Memory-mapped storage not supported for mutable access (returns error)

Examples

storage.with_slice_mut(|data| {
    // In-place SIMD operation
    f32::simd_add_inplace(data, &other_data)
})?;

Trait Implementations

impl<T: TensorElement> Clone for TensorStorage<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: TensorElement> Debug for TensorStorage<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.