dl
dl_array_simd.h
浏览该文件的文档.
1
13#pragma once
14
15#include <simde/x86/sse.h>
16
17namespace dl
18{
19 template<typename T, size_t N>
20 requires std::is_arithmetic_v<T>
21 class alignas(16) ArrayS2;
22
23 template<size_t N>
24 ArrayS2<float, N> simd_m128u_op(simde__m128(*op)(simde__m128, simde__m128),
25 const ArrayS2<float, N>& a, const Array<float, 2>& b)
26 {
28 if constexpr (N == 4)
29 {
30 simde__m128 vec_ax = simde_mm_load_ps(a.x);
31 simde__m128 vec_bx = simde_mm_set1_ps(b.x);
32 vec_ax = op(vec_ax, vec_bx);
33 simde_mm_store_ps(ret.x, vec_ax);
34
35 simde__m128 vec_ay = simde_mm_load_ps(a.y);
36 simde__m128 vec_by = simde_mm_set1_ps(b.y);
37 vec_ay = op(vec_ay, vec_by);
38 simde_mm_store_ps(ret.y, vec_ay);
39 }
40 else
41 {
42 static_assert(N == 4);
43 }
44 return ret;
45 }
46}
47
48namespace dl
49{
50template<typename T, size_t N>
51 requires std::is_arithmetic_v<T>
52class alignas(16) ArrayS2
53{
54public:
55 union
56 {
57 T _data[N * 2];
58 struct
59 {
60 T x[N];
61 T y[N];
62 };
63 };
64
65
66 ArrayS2() = default;
67
68 // slow
69 constexpr Array<T, 2> Get(size_t i) const
70 {
71 return { x[i], y[i] };
72 }
73 constexpr Array<T, 2> Sum(size_t i, size_t j) const
74 {
75 Array<T, 2> ret;
76 ret[0] = x[i] + x[j];
77 ret[1] = y[i] + y[j];
78 return ret;
79 }
80 /*constexpr const Array<T, 2> operator[](size_t i) const
81 {
82 return { x[i], y[i] };
83 }*/
84
85 constexpr ArrayS2(std::initializer_list<Array<T, 2>> data)
86 {
87 size_t N_LIST = std::size(data);
88 for (size_t i = 0; i < N; ++i)
89 x[i] = i < N_LIST ? data.x : T{};
90 for (size_t i = 0; i < N; ++i)
91 y[i] = i < N_LIST ? data.y : T{};
92 }
93};
94
95template<typename T, std::size_t N>
97{
98 if constexpr (N == 4)
99 a = a + b;
100 else
101 {
102 for (size_t i = 0; i < N; ++i)
103 {
104 a.x[i] += b[0];
105 a.y[i] += b[1];
106 }
107 }
108 return a;
109}
110template<typename T, std::size_t N>
112{
113 if constexpr (N == 4)
114 return simd_m128u_op(simde_mm_add_ps, a, b);
115 else
116 {
117 ArrayS2<T, N> ret = a;
118 ret += b;
119 return ret;
120 }
121}
122
123template<typename T, std::size_t N>
125{
126 if constexpr (N == 4)
127 a = a - b;
128 else
129 {
130 for (size_t i = 0; i < N; ++i)
131 {
132 a.x[i] -= b[0];
133 a.y[i] -= b[1];
134 }
135 }
136 return a;
137}
138template<typename T, std::size_t N>
140{
141 if constexpr (N == 4)
142 return simd_m128u_op(simde_mm_sub_ps, a, b);
143 else
144 {
145 ArrayS2<T, N> ret = a;
146 ret -= b;
147 return ret;
148 }
149}
150
151template<typename T, std::size_t N>
153{
154 if constexpr (N == 4)
155 a = a * b;
156 else
157 {
158 for (size_t i = 0; i < N; ++i)
159 {
160 a.x[i] *= b[0];
161 a.y[i] *= b[1];
162 }
163 }
164 return a;
165}
166template<typename T, std::size_t N>
168{
169 if constexpr (N == 4)
170 return simd_m128u_op(simde_mm_mul_ps, a, b);
171 else
172 {
173 ArrayS2<T, N> ret = a;
174 ret *= b;
175 return ret;
176 }
177}
178
179template<typename T, std::size_t N>
181{
182 if constexpr (N == 4)
183 a = a / b;
184 else
185 {
186 for (size_t i = 0; i < N; ++i)
187 {
188 a.x[i] /= b[0];
189 a.y[i] /= b[1];
190 }
191 }
192 return a;
193}
194template<typename T, std::size_t N>
196{
197 if constexpr (N == 4)
198 return simd_m128u_op(simde_mm_div_ps, a, b);
199 else
200 {
201 ArrayS2<T, N> ret = a;
202 ret /= b;
203 return ret;
204 }
205}
206
207
208template<size_t M = 1, typename T, size_t N>
209constexpr ArrayS2<T, N - M> toShorter(const ArrayS2<T, N>& a)
210{
211 static_assert(M <= N);
212 ArrayS2<T, N - M> ret;
213 for (size_t i = 0; i < N - M; ++i)
214 {
215 ret.x[i] = a.x[i];
216 ret.y[i] = a.y[i];
217 }
218 return ret;
219}
220
221}
ArrayS2()=default
constexpr Array< T, 2 > Get(size_t i) const
constexpr Array< T, 2 > Sum(size_t i, size_t j) const
constexpr ArrayS2(std::initializer_list< Array< T, 2 > > data)
ArrayS2< float, N > simd_m128u_op(simde__m128(*op)(simde__m128, simde__m128), const ArrayS2< float, N > &a, const Array< float, 2 > &b)
constexpr ArrayS2< T, N > & operator/=(ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N - M > toShorter(const ArrayS2< T, N > &a)
constexpr ArrayS2< T, N > & operator*=(ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > & operator+=(ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > operator+(const ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > operator-(const ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > operator/(const ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > & operator-=(ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > operator*(const ArrayS2< T, N > &a, const Array< T, 2 > &b)