Skip to main content

wickra_simd/
portable.rs

1//! Four lanes as a plain array: available on every target.
2
3// Every function here must inline into the kernel that calls it for the
4// kernel to be compiled as one unit; see `crate::Kernel`.
5#![allow(clippy::inline_always)]
6
7use crate::Simd;
8
9/// Lanes as `[f64; 4]` in ordinary Rust arithmetic.
10///
11/// Available everywhere; on `aarch64` the compiler maps the lane loops onto
12/// NEON registers. Each method performs exactly the IEEE-754 operation the
13/// [`Simd`] contract names, lane by lane.
14#[derive(Debug, Clone, Copy, Default)]
15pub struct Portable;
16
17#[inline(always)]
18fn map(a: [f64; 4], f: impl Fn(f64) -> f64) -> [f64; 4] {
19    [f(a[0]), f(a[1]), f(a[2]), f(a[3])]
20}
21
22#[inline(always)]
23fn zip(a: [f64; 4], b: [f64; 4], f: impl Fn(f64, f64) -> f64) -> [f64; 4] {
24    [f(a[0], b[0]), f(a[1], b[1]), f(a[2], b[2]), f(a[3], b[3])]
25}
26
27impl Simd for Portable {
28    type V = [f64; 4];
29
30    #[inline(always)]
31    fn splat(self, x: f64) -> [f64; 4] {
32        [x; 4]
33    }
34    #[inline(always)]
35    fn load(self, a: &[f64; 4]) -> [f64; 4] {
36        *a
37    }
38    #[inline(always)]
39    fn store(self, v: [f64; 4], a: &mut [f64; 4]) {
40        *a = v;
41    }
42    #[inline(always)]
43    fn to_array(self, v: [f64; 4]) -> [f64; 4] {
44        v
45    }
46    #[inline(always)]
47    fn add(self, a: [f64; 4], b: [f64; 4]) -> [f64; 4] {
48        zip(a, b, |x, y| x + y)
49    }
50    #[inline(always)]
51    fn sub(self, a: [f64; 4], b: [f64; 4]) -> [f64; 4] {
52        zip(a, b, |x, y| x - y)
53    }
54    #[inline(always)]
55    fn mul(self, a: [f64; 4], b: [f64; 4]) -> [f64; 4] {
56        zip(a, b, |x, y| x * y)
57    }
58    #[inline(always)]
59    fn div(self, a: [f64; 4], b: [f64; 4]) -> [f64; 4] {
60        zip(a, b, |x, y| x / y)
61    }
62    #[inline(always)]
63    fn sqrt(self, a: [f64; 4]) -> [f64; 4] {
64        map(a, f64::sqrt)
65    }
66    #[inline(always)]
67    fn mul_add(self, a: [f64; 4], b: [f64; 4], c: [f64; 4]) -> [f64; 4] {
68        [
69            a[0].mul_add(b[0], c[0]),
70            a[1].mul_add(b[1], c[1]),
71            a[2].mul_add(b[2], c[2]),
72            a[3].mul_add(b[3], c[3]),
73        ]
74    }
75    #[inline(always)]
76    fn max(self, a: [f64; 4], b: [f64; 4]) -> [f64; 4] {
77        zip(a, b, |x, y| if x > y { x } else { y })
78    }
79    #[inline(always)]
80    fn min(self, a: [f64; 4], b: [f64; 4]) -> [f64; 4] {
81        zip(a, b, |x, y| if x < y { x } else { y })
82    }
83    #[inline(always)]
84    fn abs(self, a: [f64; 4]) -> [f64; 4] {
85        map(a, f64::abs)
86    }
87    #[inline(always)]
88    fn select_positive(self, test: [f64; 4], yes: [f64; 4], no: [f64; 4]) -> [f64; 4] {
89        let pick = |k: usize| if test[k] > 0.0 { yes[k] } else { no[k] };
90        [pick(0), pick(1), pick(2), pick(3)]
91    }
92    #[inline(always)]
93    fn shift1(self, v: [f64; 4]) -> [f64; 4] {
94        [0.0, v[0], v[1], v[2]]
95    }
96    #[inline(always)]
97    fn shift2(self, v: [f64; 4]) -> [f64; 4] {
98        [0.0, 0.0, v[0], v[1]]
99    }
100    #[inline(always)]
101    fn broadcast_last(self, v: [f64; 4]) -> [f64; 4] {
102        [v[3]; 4]
103    }
104    #[inline(always)]
105    fn last_lane(self, v: [f64; 4]) -> f64 {
106        v[3]
107    }
108    #[inline(always)]
109    fn transpose4(self, a: [f64; 4], b: [f64; 4], c: [f64; 4], d: [f64; 4]) -> [[f64; 4]; 4] {
110        [
111            [a[0], b[0], c[0], d[0]],
112            [a[1], b[1], c[1], d[1]],
113            [a[2], b[2], c[2], d[2]],
114            [a[3], b[3], c[3], d[3]],
115        ]
116    }
117
118    type W = [f64; 8];
119
120    #[inline(always)]
121    fn load8(self, a: &[f64; 8]) -> [f64; 8] {
122        *a
123    }
124    #[inline(always)]
125    fn store8(self, v: [f64; 8], a: &mut [f64; 8]) {
126        *a = v;
127    }
128    #[inline(always)]
129    fn splat8(self, x: f64) -> [f64; 8] {
130        [x; 8]
131    }
132    #[inline(always)]
133    fn add8(self, a: [f64; 8], b: [f64; 8]) -> [f64; 8] {
134        std::array::from_fn(|k| a[k] + b[k])
135    }
136    #[inline(always)]
137    fn sub8(self, a: [f64; 8], b: [f64; 8]) -> [f64; 8] {
138        std::array::from_fn(|k| a[k] - b[k])
139    }
140    #[inline(always)]
141    fn mul8(self, a: [f64; 8], b: [f64; 8]) -> [f64; 8] {
142        std::array::from_fn(|k| a[k] * b[k])
143    }
144    #[inline(always)]
145    fn div8(self, a: [f64; 8], b: [f64; 8]) -> [f64; 8] {
146        std::array::from_fn(|k| a[k] / b[k])
147    }
148    #[inline(always)]
149    fn sqrt8(self, a: [f64; 8]) -> [f64; 8] {
150        std::array::from_fn(|k| a[k].sqrt())
151    }
152    #[inline(always)]
153    fn max8(self, a: [f64; 8], b: [f64; 8]) -> [f64; 8] {
154        std::array::from_fn(|k| if a[k] > b[k] { a[k] } else { b[k] })
155    }
156    #[inline(always)]
157    fn select_positive8(self, test: [f64; 8], yes: [f64; 8], no: [f64; 8]) -> [f64; 8] {
158        std::array::from_fn(|k| if test[k] > 0.0 { yes[k] } else { no[k] })
159    }
160}