simd-slice 0.1.0

High-level simd abstraction on slices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#![feature(portable_simd)]

use std::simd::{Simd, SimdElement};

pub trait AsSimdSlice<T: SimdElement> {
    fn as_simd_slice<'a>(&'a self) -> SimdSlice<'a, T>;
}

impl<T: SimdElement> AsSimdSlice<T> for [T] {
    fn as_simd_slice<'a>(&'a self) -> SimdSlice<'a, T> {
        SimdSlice(self)
    }
}

pub struct SimdSlice<'a, T: SimdElement>(&'a [T]);

macro_rules! impl_op {
    ($t: ty) => {
        impl<'a> SimdSlice<'a, $t> {
            pub fn sum(&self) -> $t {
                let n = self.0.len() & (!3); // round down to a multiple of 4
                let slice = &self.0[..n];

                let mut i = 0;
                let mut agg = Simd::<$t, 4>::splat(num::zero());

                // this is much slower:
                // slice
                //     .chunks(4)
                //     .for_each(|s| agg += Simd::<$t, 4>::from_slice(s));

                while i < n {
                    agg += Simd::<$t, 4>::from_slice(unsafe { &slice.get_unchecked(i..i + 4) });
                    i += 4;
                }
                let mut agg = agg.horizontal_sum();
                self.0[n..].iter().for_each(|x| agg += x);
                agg
            }

            pub fn min(&self) -> Option<$t> {
                let n = self.0.len() & (!3); // round down to a multiple of 4

                if n > 0 {
                    let slice = &self.0[..n];
                    let mut i = 4;
                    let mut agg = Simd::<$t, 4>::from_slice(&slice[..4]);
                    while i < n {
                        agg += Simd::<$t, 4>::from_slice(unsafe { &slice.get_unchecked(i..i + 4) });
                        i += 4;
                    }
                    let mut agg = agg.horizontal_min();
                    self.0[n..].iter().for_each(|&x| {
                        if x < agg {
                            agg = x;
                        }
                    });
                    Some(agg)
                } else if self.0.len() > 0 {
                    let mut agg = self.0[0];
                    self.0[1..].iter().for_each(|&x| {
                        if x < agg {
                            agg = x;
                        }
                    });
                    Some(agg)
                } else {
                    None
                }
            }

            pub fn max(&self) -> Option<$t> {
                let n = self.0.len() & (!3); // round down to a multiple of 4

                if n > 0 {
                    let slice = &self.0[..n];
                    let mut i = 4;
                    let mut agg = Simd::<$t, 4>::from_slice(&slice[..4]);
                    while i < n {
                        agg += Simd::<$t, 4>::from_slice(unsafe { &slice.get_unchecked(i..i + 4) });
                        i += 4;
                    }
                    let mut agg = agg.horizontal_max();
                    self.0[n..].iter().for_each(|&x| {
                        if x < agg {
                            agg = x;
                        }
                    });
                    Some(agg)
                } else if self.0.len() > 0 {
                    let mut agg = self.0[0];
                    self.0[1..].iter().for_each(|&x| {
                        if x < agg {
                            agg = x;
                        }
                    });
                    Some(agg)
                } else {
                    None
                }
            }
        }
    };
}
impl_op!(u8);
impl_op!(u16);
impl_op!(u32);
impl_op!(u64);
impl_op!(usize);
impl_op!(i8);
impl_op!(i16);
impl_op!(i32);
impl_op!(i64);
impl_op!(isize);
impl_op!(f32);
impl_op!(f64);

#[cfg(test)]
mod tests {

    #[test]
    fn it_works() {
        use super::AsSimdSlice;

        let a = &[10, 20, 3, 4, 5, 6, 7_i32];
        assert_eq!(a[1..5].iter().sum::<i32>(), a[1..5].as_simd_slice().sum());
        assert_eq!(a[1..5].iter().max().cloned(), a[1..5].as_simd_slice().max());
        assert_eq!(a[1..5].iter().min().cloned(), a[1..5].as_simd_slice().min());
    }
}