Struct SimdStorage 

pub struct SimdStorage<T> { /* private fields */ }

SIMD-optimized storage with Copy-on-Write semantics (Phase 5)

This storage variant eliminates lock overhead for read operations while the tensor has never been written to, which is the dominant case for SIMD workloads:

• The buffer handed to SimdStorage::new is never mutated in place, so SimdStorage::try_as_slice can hand out a plain &[T] with no guard at all (that is the “lock-free read” this variant exists for).
• The first write copies that buffer once into a private copy-on-write buffer guarded by an RwLock; every later write mutates it in place, so a for i in 0..n { t.set(i, v) } loop is O(n), not O(n²).
• Once the copy exists, readers go through the same RwLock, exactly like TensorStorage::Aligned. Slices handed out earlier stay valid because the original buffer is kept alive and untouched for the storage’s lifetime.

This is what makes set/set_slice/with_slice_mut work on tensors of every size instead of failing above the 10 KB SimdOptimized threshold.

Implementations

impl<T> SimdStorage<T>

pub fn new(data: AlignedVec<T>) -> Self

Create new SIMD storage from data

pub fn len(&self) -> usize

Get the length of the storage

Mutation never changes the element count, so this stays lock-free.

pub fn is_empty(&self) -> bool

Check if storage is empty

pub fn capacity(&self) -> usize

Get the capacity

pub fn is_mutated(&self) -> bool

Whether this storage has been written to (and therefore keeps its authoritative data in the guarded copy-on-write buffer).

pub fn try_as_slice(&self) -> Option<&[T]>

Get the immutable, lock-free slice.

Returns None once the storage has been written to: after that the authoritative data lives behind a lock and cannot be exposed as an unguarded borrow. Callers should fall back to SimdStorage::with_slice.

pub fn mark_shared(&self)

Mark as shared (for Clone)

pub fn is_shared(&self) -> bool

Check if shared

impl<T: Copy> SimdStorage<T>

pub fn with_slice<R>(&self, f: impl FnOnce(&[T]) -> R) -> R

Read the storage contents, lock-free while it has never been written to.

pub fn with_slice_mut<R>(&self, f: impl FnOnce(&mut [T]) -> R) -> Result<R>

Mutate the storage contents, promoting to the copy-on-write buffer on the first call.

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

Convert to Vec (copying data)

Trait Implementations

impl<T> Debug for SimdStorage<T>

Available on crate feature simd only.

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

Formats the value using the given formatter.