Skip to main content

simply_simd/register/
iters.rs

1use std::iter::zip;
2use std::marker::PhantomData;
3use std::ops::{Deref, DerefMut};
4
5use crate::StaticArch;
6use crate::architectures::interface::*;
7use crate::simd_array::SimdToArray;
8use crate::register::Simd;
9use crate::simd_types::*;
10
11pub trait SimdSliceIterExt<T: SimdElement> {
12    fn simd_iter_static<'a>(&'a self) -> SimdSliceIter<'a, T, StaticArch>;
13    fn simd_iter_mut_static<'a>(&'a mut self) -> SimdSliceIterMut<'a, T, StaticArch>;
14
15    fn simd_iter<'a, A: Arch>(&'a self) -> SimdSliceIter<'a, T, A>;
16    fn simd_iter_mut<'a, A: Arch>(&'a mut self) -> SimdSliceIterMut<'a, T, A>;
17}
18
19impl<T: SimdElement> SimdSliceIterExt<T> for [T] {
20    /// Creates an iterator of simd chunks using the statically dispatched simd feature set.
21    fn simd_iter_static<'a>(&'a self) -> SimdSliceIter<'a, T, StaticArch> {
22        SimdSliceIter {
23            slice: self,
24            index: 0,
25            _architecture: PhantomData::<StaticArch>,
26        }
27    }
28
29    /// Creates an iterator of mutable simd chunks using the statically dispatched simd feature set..
30    fn simd_iter_mut_static<'a>(&'a mut self) -> SimdSliceIterMut<'a, T, StaticArch> {
31        SimdSliceIterMut {
32            slice: self,
33            _architecture: PhantomData::<StaticArch>,
34        }
35    }
36
37    /// Creates an iterator of simd chunks with a specified simd feature set.
38    fn simd_iter<'a, A: Arch>(&'a self) -> SimdSliceIter<'a, T, A> {
39        SimdSliceIter {
40            slice: self,
41            index: 0,
42            _architecture: PhantomData::<A>,
43        }
44    }
45
46    /// Creates an iterator of mutable simd chunks with a specified simd architecture.
47    fn simd_iter_mut<'a, A: Arch>(&'a mut self) -> SimdSliceIterMut<'a, T, A> {
48        SimdSliceIterMut {
49            slice: self,
50            _architecture: PhantomData::<A>,
51        }
52    }
53}
54
55pub struct SimdSliceIter<'a, T: SimdElement, A: Arch> {
56    slice: &'a [T],
57    index: usize,
58    _architecture: PhantomData<A>,
59}
60
61impl<'a, T: SimdElement, A: Arch> Iterator for SimdSliceIter<'a, T, A> {
62    type Item = Simd<T, A>;
63
64    fn next(&mut self) -> Option<Self::Item> {
65        if self.index == self.slice.len() {
66            return None;
67        }
68
69        // Scalar case.
70        if self.slice.len() < Self::Item::LANES {
71            let mut array = Self::Item::zero().to_array();
72            for i in 0..self.slice.len() {
73                array[i] = self.slice[i];
74            }
75            let result = Self::Item::from_slice(array.as_mut_slice());
76            self.index = self.slice.len();
77            return Some(result);
78        }
79
80        let amount_left = self.slice.len() - self.index;
81        if amount_left < Self::Item::LANES {
82            let offset = Self::Item::LANES - (self.slice.len() - self.index);
83            let new_index = self.index - offset;
84            let simd = unsafe { Self::Item::from_slice(self.slice.get_unchecked(new_index..)) };
85            let simd_shifted = simd.left_lane_shift(offset as u32);
86            self.index = self.slice.len();
87            return Some(simd_shifted);
88        }
89
90        // Regular case.
91        let next =
92            unsafe { Self::Item::from_slice_unchecked(self.slice.get_unchecked(self.index..)) };
93        self.index += Self::Item::LANES;
94        Some(next)
95    }
96
97    fn size_hint(&self) -> (usize, Option<usize>) {
98        let amount_left = self.slice.len() - self.index;
99        let rem_chunks = amount_left.div_ceil(Self::Item::LANES);
100        (rem_chunks, Some(rem_chunks))
101    }
102}
103impl<'a, T: SimdElement, A: Arch> ExactSizeIterator for SimdSliceIter<'a, T, A> {}
104
105pub struct SimdSliceChunk<'a, T: SimdElement, A: Arch> {
106    simd: Simd<T, A>,
107    slice: &'a mut [T],
108}
109
110impl<'a, T: SimdElement, A: Arch> SimdSliceChunk<'a, T, A> {
111    pub fn new(simd: Simd<T, A>, slice: &'a mut [T]) -> Self {
112        Self { simd, slice }
113    }
114}
115
116impl<'a, T: SimdElement, A: Arch> Deref for SimdSliceChunk<'a, T, A> {
117    type Target = Simd<T, A>;
118    fn deref(&self) -> &Self::Target {
119        &self.simd
120    }
121}
122
123impl<'a, T: SimdElement, A: Arch> DerefMut for SimdSliceChunk<'a, T, A> {
124    fn deref_mut(&mut self) -> &mut Self::Target {
125        &mut self.simd
126    }
127}
128
129impl<'a, T: SimdElement, A: Arch> Drop for SimdSliceChunk<'a, T, A> {
130    #[inline(always)]
131    fn drop(&mut self) {
132        if self.slice.len() >= Simd::<T, A>::LANES {
133            // Regular case.
134            unsafe { self.simd.copy_to_slice_unchecked(self.slice) };
135        } else {
136            // Tail/Partial case.
137            let array = self.simd.to_array();
138            self.slice
139                .iter_mut()
140                .zip(array.iter())
141                .for_each(|(src, new)| *src = *new);
142        }
143    }
144}
145
146pub struct SimdSliceIterMut<'a, T: SimdElement, A: Arch> {
147    slice: &'a mut [T],
148    _architecture: PhantomData<A>,
149}
150
151impl<'a, T: SimdElement, A: Arch> Iterator for SimdSliceIterMut<'a, T, A> {
152    type Item = SimdSliceChunk<'a, T, A>;
153
154    #[inline(always)]
155    fn next(&mut self) -> Option<Self::Item> {
156        // Empty case.
157        let slice_len = self.slice.len();
158        if self.slice.is_empty() {
159            return None;
160        }
161        let slice = std::mem::take(&mut self.slice);
162
163        // Scalar + Tail case.
164        if slice_len < Simd::<T, A>::LANES {
165            let mut array = Simd::<T, A>::zero().to_array();
166            for i in 0..slice_len {
167                array[i] = slice[i];
168            }
169            let simd = unsafe { Simd::<T, A>::from_slice_unchecked(array.as_mut_slice()) };
170            let chunk = SimdSliceChunk::new(simd, slice);
171            return Some(chunk);
172
173            // let next_simd = unsafe { Simd::from_slice_partial(slice) };
174            // let chunk = SimdSliceChunk::new(next_simd, slice);
175            // return Some(chunk);
176        }
177
178        // Tail case.
179        // if slice_len < Simd::<T, F>::LANES {
180        //     let offset = Simd::<T, F>::LANES - slice_len;
181        //     let new_index = slice_len - offset;
182        //     let simd =
183        //         Simd::<T, F>::from_slice(&self.slice[new_index..]);
184        //     let shifted_simd = simd.left_lane_shift(offset as u32)
185        //     let chunk = SimdSliceChunk::new(shifted_result, &mut slice[new_index..new_index + slice_len]);
186        //     self.index = slice_len;
187        //     return Some(chunk);
188        // }
189
190        // Regular case.
191        let (cur_slice, rem_slice) = slice.split_at_mut(Simd::<T, A>::LANES);
192        self.slice = rem_slice;
193
194        let next_simd = unsafe { Simd::from_slice_unchecked(cur_slice) };
195        let chunk = SimdSliceChunk::new(next_simd, cur_slice);
196        Some(chunk)
197    }
198
199    fn size_hint(&self) -> (usize, Option<usize>) {
200        let rem_chunks = self.slice.len().div_ceil(Simd::<T, A>::LANES);
201        (rem_chunks, Some(rem_chunks))
202    }
203}
204impl<'a, T: SimdElement, A: Arch> ExactSizeIterator for SimdSliceIterMut<'a, T, A> {}
205
206// Vec into iter
207
208pub trait IntoSimdIterator<T: SimdElement, A: Arch = StaticArch> {
209    fn into_simd_iter(self) -> SimdVecIntoIter<T, A>;
210}
211
212impl<T: SimdElement, A: Arch> IntoSimdIterator<T, A> for Vec<T> {
213    fn into_simd_iter(self) -> SimdVecIntoIter<T, A> {
214        SimdVecIntoIter {
215            vec: self,
216            index: 0,
217            _architecture: PhantomData::<A>,
218        }
219    }
220}
221pub struct SimdVecIntoIter<T: SimdElement, A: Arch> {
222    vec: Vec<T>,
223    index: usize,
224    _architecture: PhantomData<A>,
225}
226
227impl<T: SimdElement, A: Arch> Iterator for SimdVecIntoIter<T, A> {
228    type Item = Simd<T, A>;
229
230    fn next(&mut self) -> Option<Self::Item> {
231        if self.index >= self.vec.len() {
232            return None;
233        }
234
235        // Scalar case.
236        if self.vec.len() < Self::Item::LANES {
237            let mut array = Self::Item::zero().to_array();
238            for i in 0..self.vec.len() {
239                array[i] = self.vec[i];
240            }
241            let result = Self::Item::from_slice(array.as_mut_slice());
242            self.index = self.vec.len();
243            return Some(result);
244        }
245
246        let amount_left = self.vec.len() - self.index;
247        if amount_left < Self::Item::LANES {
248            let offset = Self::Item::LANES - (self.vec.len() - self.index);
249            let new_index = self.index - offset;
250            let simd = unsafe { Self::Item::from_slice(self.vec.get_unchecked(new_index..)) };
251            let simd_shifted = simd.left_lane_shift(offset as u32);
252            self.index = self.vec.len();
253            return Some(simd_shifted);
254        }
255
256        // Regular case.
257        let next =
258            unsafe { Self::Item::from_slice_unchecked(self.vec.get_unchecked(self.index..)) };
259        self.index += Self::Item::LANES;
260        Some(next)
261    }
262
263    fn size_hint(&self) -> (usize, Option<usize>) {
264        let amount_left = self.vec.len() - self.index;
265        let rem_chunks = amount_left.div_ceil(Self::Item::LANES);
266        (rem_chunks, Some(rem_chunks))
267    }
268}
269impl<T: SimdElement, A: Arch> ExactSizeIterator for SimdVecIntoIter<T, A> {}
270
271impl<T: SimdElement, A: Arch, const N: usize> FromIterator<Simd<T, A>> for [T; N] {
272    fn from_iter<I: IntoIterator<Item = Simd<T, A>>>(iter: I) -> Self {
273        let mut array = [T::default(); N];
274
275        let lane_iter = (0..N).step_by(Simd::<T, A>::LANES);
276        for (i, x) in zip(lane_iter, iter) {
277            x.copy_to_slice(&mut array[i..]);
278        }
279
280        array
281    }
282}
283
284impl<T: SimdElement, A: Arch> FromIterator<Simd<T, A>> for Vec<T> {
285    fn from_iter<I: IntoIterator<Item = Simd<T, A>>>(iter: I) -> Self {
286        let iter = iter.into_iter();
287        let (lower_bound, upper_bound) = iter.size_hint();
288        if let Some(upper_bound) = upper_bound {
289            let mut vec = vec![T::default(); upper_bound * Simd::<T, A>::LANES];
290            for (i, x) in iter.enumerate() {
291                x.copy_to_slice(&mut vec[i * Simd::<T, A>::LANES..]);
292            }
293            vec
294        } else {
295            let mut vec = Vec::with_capacity(lower_bound);
296            for x in iter {
297                let array = x.to_array();
298                vec.extend_from_slice(array.as_slice());
299            }
300            vec
301        }
302    }
303}