Struct StridedMapMutSimd

pub struct StridedMapMutSimd<'a, T>
where
    T: Copy + TypeCommon + Send + Sync,
{ /* private fields */ }

A SIMD-optimized mutable mapped strided iterator over tensor elements.

This struct provides mutable access to tensor elements with SIMD optimizations, allowing for efficient parallel processing of tensor data.

Implementations

impl<'a, T> StridedMapMutSimd<'a, T>

where T: CommonBounds, T::Vec: Send,

pub fn new<U: TensorInfo<T>>(res_tensor: U) -> Self

Creates a new StridedMapMutSimd instance from a given tensor.

Arguments

• res_tensor - The tensor implementing the TensorInfo<T> trait to iterate over mutably.

Returns

A new instance of StridedMapMutSimd initialized with the provided tensor.

Trait Implementations

impl<'a, T: 'a + CommonBounds> IterGetSetSimd for StridedMapMutSimd<'a, T>

where T::Vec: Send,

type Item = &'a mut T

The type of the iterator’s elements.

type SimdItem = &'a mut <T as TypeCommon>::Vec

The type of the iterator’s simd elements.

fn set_end_index(&mut self, _: usize)

set the end index of the iterator, this is used when rayon perform data splitting

fn set_intervals(&mut self, _: Arc<Vec<(usize, usize)>>)

set the chunk intervals of the iterator, we chunk the outer loop

fn set_strides(&mut self, strides: Strides)

set the strides for the iterator, we call this method normally when we do broadcasting

fn set_shape(&mut self, shape: Shape)

set the shape for the iterator, we call this method normally when we do broadcasting

fn set_prg(&mut self, prg: Vec<i64>)

set the loop progress for the iterator

fn intervals(&self) -> &Arc<Vec<(usize, usize)>>

get the intervals of the iterator

fn strides(&self) -> &Strides

get the strides of the iterator

fn shape(&self) -> &Shape

get the shape of the iterator

fn layout(&self) -> &Layout

get the layout of the iterator

fn broadcast_set_strides(&mut self, shape: &Shape)

set the strides for all the iterators

fn outer_loop_size(&self) -> usize

get the outer loop size

fn inner_loop_size(&self) -> usize

get the inner loop size

fn next(&mut self)

update the loop progress, this is called when we don’t do simd iteration

fn next_simd(&mut self)

update the loop progress, this is called when we do simd iteration

fn inner_loop_next(&mut self, index: usize) -> Self::Item

get the next element of the inner loop

fn inner_loop_next_simd(&mut self, _: usize) -> Self::SimdItem

get the next vector of the inner loop, this is called when we do simd iteration

fn all_last_stride_one(&self) -> bool

check if all iterators’ last stride is one, only when all iterators’ last stride is one, we can do simd iteration

fn lanes(&self) -> Option<usize>

get the simd vector size, if any of the iterator returned different vector size, it will return None

impl<'a, T> StridedIteratorSimd for StridedMapMutSimd<'a, T>

where T: 'a + CommonBounds,

fn for_each<F, F2>(self, op: F, vec_op: F2)

where F: Fn(Self::Item), F2: Fn(Self::SimdItem),

perform simd iteration, this method is for single thread simd iterator

fn for_each_init<F, INIT, T>(self, init: INIT, func: F)

where F: Fn(&mut T, Self::Item), INIT: Fn() -> T,

perform simd iteration with init, this method is for single thread simd iterator