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 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 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 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 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 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 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 unsafe { self.simd.copy_to_slice_unchecked(self.slice) };
135 } else {
136 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 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 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 }
177
178 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
206pub 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 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 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}