Eigen  3.2.93
AVX/PacketMath.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_PACKET_MATH_AVX_H
11 #define EIGEN_PACKET_MATH_AVX_H
12 
13 namespace Eigen {
14 
15 namespace internal {
16 
17 #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
18 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
19 #endif
20 
21 #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
22 #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
23 #endif
24 
25 #ifdef __FMA__
26 #ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
27 #define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
28 #endif
29 #endif
30 
31 typedef __m256 Packet8f;
32 typedef __m256i Packet8i;
33 typedef __m256d Packet4d;
34 
35 template<> struct is_arithmetic<__m256> { enum { value = true }; };
36 template<> struct is_arithmetic<__m256i> { enum { value = true }; };
37 template<> struct is_arithmetic<__m256d> { enum { value = true }; };
38 
39 #define _EIGEN_DECLARE_CONST_Packet8f(NAME,X) \
40  const Packet8f p8f_##NAME = pset1<Packet8f>(X)
41 
42 #define _EIGEN_DECLARE_CONST_Packet4d(NAME,X) \
43  const Packet4d p4d_##NAME = pset1<Packet4d>(X)
44 
45 #define _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(NAME,X) \
46  const Packet8f p8f_##NAME = _mm256_castsi256_ps(pset1<Packet8i>(X))
47 
48 #define _EIGEN_DECLARE_CONST_Packet8i(NAME,X) \
49  const Packet8i p8i_##NAME = pset1<Packet8i>(X)
50 
51 
52 template<> struct packet_traits<float> : default_packet_traits
53 {
54  typedef Packet8f type;
55  typedef Packet4f half;
56  enum {
57  Vectorizable = 1,
58  AlignedOnScalar = 1,
59  size=8,
60  HasHalfPacket = 1,
61 
62  HasDiv = 1,
63  HasSin = EIGEN_FAST_MATH,
64  HasCos = 0,
65  HasLog = 1,
66  HasExp = 1,
67  HasSqrt = 1,
68  HasRsqrt = 1,
69  HasTanh = EIGEN_FAST_MATH,
70  HasBlend = 1,
71  HasRound = 1,
72  HasFloor = 1,
73  HasCeil = 1
74  };
75 };
76 template<> struct packet_traits<double> : default_packet_traits
77 {
78  typedef Packet4d type;
79  typedef Packet2d half;
80  enum {
81  Vectorizable = 1,
82  AlignedOnScalar = 1,
83  size=4,
84  HasHalfPacket = 1,
85 
86  HasDiv = 1,
87  HasExp = 1,
88  HasSqrt = 1,
89  HasRsqrt = 1,
90  HasBlend = 1,
91  HasRound = 1,
92  HasFloor = 1,
93  HasCeil = 1
94  };
95 };
96 
97 /* Proper support for integers is only provided by AVX2. In the meantime, we'll
98  use SSE instructions and packets to deal with integers.
99 template<> struct packet_traits<int> : default_packet_traits
100 {
101  typedef Packet8i type;
102  enum {
103  Vectorizable = 1,
104  AlignedOnScalar = 1,
105  size=8
106  };
107 };
108 */
109 
110 template<> struct unpacket_traits<Packet8f> { typedef float type; typedef Packet4f half; enum {size=8, alignment=Aligned32}; };
111 template<> struct unpacket_traits<Packet4d> { typedef double type; typedef Packet2d half; enum {size=4, alignment=Aligned32}; };
112 template<> struct unpacket_traits<Packet8i> { typedef int type; typedef Packet4i half; enum {size=8, alignment=Aligned32}; };
113 
114 template<> EIGEN_STRONG_INLINE Packet8f pset1<Packet8f>(const float& from) { return _mm256_set1_ps(from); }
115 template<> EIGEN_STRONG_INLINE Packet4d pset1<Packet4d>(const double& from) { return _mm256_set1_pd(from); }
116 template<> EIGEN_STRONG_INLINE Packet8i pset1<Packet8i>(const int& from) { return _mm256_set1_epi32(from); }
117 
118 template<> EIGEN_STRONG_INLINE Packet8f pload1<Packet8f>(const float* from) { return _mm256_broadcast_ss(from); }
119 template<> EIGEN_STRONG_INLINE Packet4d pload1<Packet4d>(const double* from) { return _mm256_broadcast_sd(from); }
120 
121 template<> EIGEN_STRONG_INLINE Packet8f plset<Packet8f>(const float& a) { return _mm256_add_ps(_mm256_set1_ps(a), _mm256_set_ps(7.0,6.0,5.0,4.0,3.0,2.0,1.0,0.0)); }
122 template<> EIGEN_STRONG_INLINE Packet4d plset<Packet4d>(const double& a) { return _mm256_add_pd(_mm256_set1_pd(a), _mm256_set_pd(3.0,2.0,1.0,0.0)); }
123 
124 template<> EIGEN_STRONG_INLINE Packet8f padd<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_add_ps(a,b); }
125 template<> EIGEN_STRONG_INLINE Packet4d padd<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_add_pd(a,b); }
126 
127 template<> EIGEN_STRONG_INLINE Packet8f psub<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_sub_ps(a,b); }
128 template<> EIGEN_STRONG_INLINE Packet4d psub<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_sub_pd(a,b); }
129 
130 template<> EIGEN_STRONG_INLINE Packet8f pnegate(const Packet8f& a)
131 {
132  return _mm256_sub_ps(_mm256_set1_ps(0.0),a);
133 }
134 template<> EIGEN_STRONG_INLINE Packet4d pnegate(const Packet4d& a)
135 {
136  return _mm256_sub_pd(_mm256_set1_pd(0.0),a);
137 }
138 
139 template<> EIGEN_STRONG_INLINE Packet8f pconj(const Packet8f& a) { return a; }
140 template<> EIGEN_STRONG_INLINE Packet4d pconj(const Packet4d& a) { return a; }
141 template<> EIGEN_STRONG_INLINE Packet8i pconj(const Packet8i& a) { return a; }
142 
143 template<> EIGEN_STRONG_INLINE Packet8f pmul<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_mul_ps(a,b); }
144 template<> EIGEN_STRONG_INLINE Packet4d pmul<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_mul_pd(a,b); }
145 
146 
147 template<> EIGEN_STRONG_INLINE Packet8f pdiv<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_div_ps(a,b); }
148 template<> EIGEN_STRONG_INLINE Packet4d pdiv<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_div_pd(a,b); }
149 template<> EIGEN_STRONG_INLINE Packet8i pdiv<Packet8i>(const Packet8i& /*a*/, const Packet8i& /*b*/)
150 { eigen_assert(false && "packet integer division are not supported by AVX");
151  return pset1<Packet8i>(0);
152 }
153 
154 #ifdef __FMA__
155 template<> EIGEN_STRONG_INLINE Packet8f pmadd(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
156 #if EIGEN_COMP_GNUC || EIGEN_COMP_CLANG
157  // clang stupidly generates a vfmadd213ps instruction plus some vmovaps on registers,
158  // and gcc stupidly generates a vfmadd132ps instruction,
159  // so let's enforce it to generate a vfmadd231ps instruction since the most common use case is to accumulate
160  // the result of the product.
161  Packet8f res = c;
162  __asm__("vfmadd231ps %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
163  return res;
164 #else
165  return _mm256_fmadd_ps(a,b,c);
166 #endif
167 }
168 template<> EIGEN_STRONG_INLINE Packet4d pmadd(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
169 #if EIGEN_COMP_GNUC || EIGEN_COMP_CLANG
170  // see above
171  Packet4d res = c;
172  __asm__("vfmadd231pd %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
173  return res;
174 #else
175  return _mm256_fmadd_pd(a,b,c);
176 #endif
177 }
178 #endif
179 
180 template<> EIGEN_STRONG_INLINE Packet8f pmin<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_min_ps(a,b); }
181 template<> EIGEN_STRONG_INLINE Packet4d pmin<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_min_pd(a,b); }
182 
183 template<> EIGEN_STRONG_INLINE Packet8f pmax<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_max_ps(a,b); }
184 template<> EIGEN_STRONG_INLINE Packet4d pmax<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_max_pd(a,b); }
185 
186 template<> EIGEN_STRONG_INLINE Packet8f pround<Packet8f>(const Packet8f& a) { return _mm256_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
187 template<> EIGEN_STRONG_INLINE Packet4d pround<Packet4d>(const Packet4d& a) { return _mm256_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
188 
189 template<> EIGEN_STRONG_INLINE Packet8f pceil<Packet8f>(const Packet8f& a) { return _mm256_ceil_ps(a); }
190 template<> EIGEN_STRONG_INLINE Packet4d pceil<Packet4d>(const Packet4d& a) { return _mm256_ceil_pd(a); }
191 
192 template<> EIGEN_STRONG_INLINE Packet8f pfloor<Packet8f>(const Packet8f& a) { return _mm256_floor_ps(a); }
193 template<> EIGEN_STRONG_INLINE Packet4d pfloor<Packet4d>(const Packet4d& a) { return _mm256_floor_pd(a); }
194 
195 template<> EIGEN_STRONG_INLINE Packet8f pand<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_and_ps(a,b); }
196 template<> EIGEN_STRONG_INLINE Packet4d pand<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_and_pd(a,b); }
197 
198 template<> EIGEN_STRONG_INLINE Packet8f por<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_or_ps(a,b); }
199 template<> EIGEN_STRONG_INLINE Packet4d por<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_or_pd(a,b); }
200 
201 template<> EIGEN_STRONG_INLINE Packet8f pxor<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_xor_ps(a,b); }
202 template<> EIGEN_STRONG_INLINE Packet4d pxor<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_xor_pd(a,b); }
203 
204 template<> EIGEN_STRONG_INLINE Packet8f pandnot<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_andnot_ps(a,b); }
205 template<> EIGEN_STRONG_INLINE Packet4d pandnot<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_andnot_pd(a,b); }
206 
207 template<> EIGEN_STRONG_INLINE Packet8f pload<Packet8f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_ps(from); }
208 template<> EIGEN_STRONG_INLINE Packet4d pload<Packet4d>(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_pd(from); }
209 template<> EIGEN_STRONG_INLINE Packet8i pload<Packet8i>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from)); }
210 
211 template<> EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_ps(from); }
212 template<> EIGEN_STRONG_INLINE Packet4d ploadu<Packet4d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_pd(from); }
213 template<> EIGEN_STRONG_INLINE Packet8i ploadu<Packet8i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from)); }
214 
215 // Loads 4 floats from memory a returns the packet {a0, a0 a1, a1, a2, a2, a3, a3}
216 template<> EIGEN_STRONG_INLINE Packet8f ploaddup<Packet8f>(const float* from)
217 {
218  // TODO try to find a way to avoid the need of a temporary register
219 // Packet8f tmp = _mm256_castps128_ps256(_mm_loadu_ps(from));
220 // tmp = _mm256_insertf128_ps(tmp, _mm_movehl_ps(_mm256_castps256_ps128(tmp),_mm256_castps256_ps128(tmp)), 1);
221 // return _mm256_unpacklo_ps(tmp,tmp);
222 
223  // _mm256_insertf128_ps is very slow on Haswell, thus:
224  Packet8f tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
225  // mimic an "inplace" permutation of the lower 128bits using a blend
226  tmp = _mm256_blend_ps(tmp,_mm256_castps128_ps256(_mm_permute_ps( _mm256_castps256_ps128(tmp), _MM_SHUFFLE(1,0,1,0))), 15);
227  // then we can perform a consistent permutation on the global register to get everything in shape:
228  return _mm256_permute_ps(tmp, _MM_SHUFFLE(3,3,2,2));
229 }
230 // Loads 2 doubles from memory a returns the packet {a0, a0 a1, a1}
231 template<> EIGEN_STRONG_INLINE Packet4d ploaddup<Packet4d>(const double* from)
232 {
233  Packet4d tmp = _mm256_broadcast_pd((const __m128d*)(const void*)from);
234  return _mm256_permute_pd(tmp, 3<<2);
235 }
236 
237 // Loads 2 floats from memory a returns the packet {a0, a0 a0, a0, a1, a1, a1, a1}
238 template<> EIGEN_STRONG_INLINE Packet8f ploadquad<Packet8f>(const float* from)
239 {
240  Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
241  return _mm256_insertf128_ps(tmp, _mm_broadcast_ss(from+1), 1);
242 }
243 
244 template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet8f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_ps(to, from); }
245 template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_pd(to, from); }
246 template<> EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet8i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
247 
248 template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet8f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_ps(to, from); }
249 template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_pd(to, from); }
250 template<> EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet8i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
251 
252 // NOTE: leverage _mm256_i32gather_ps and _mm256_i32gather_pd if AVX2 instructions are available
253 // NOTE: for the record the following seems to be slower: return _mm256_i32gather_ps(from, _mm256_set1_epi32(stride), 4);
254 template<> EIGEN_DEVICE_FUNC inline Packet8f pgather<float, Packet8f>(const float* from, Index stride)
255 {
256  return _mm256_set_ps(from[7*stride], from[6*stride], from[5*stride], from[4*stride],
257  from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
258 }
259 template<> EIGEN_DEVICE_FUNC inline Packet4d pgather<double, Packet4d>(const double* from, Index stride)
260 {
261  return _mm256_set_pd(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
262 }
263 
264 template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet8f>(float* to, const Packet8f& from, Index stride)
265 {
266  __m128 low = _mm256_extractf128_ps(from, 0);
267  to[stride*0] = _mm_cvtss_f32(low);
268  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1));
269  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 2));
270  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3));
271 
272  __m128 high = _mm256_extractf128_ps(from, 1);
273  to[stride*4] = _mm_cvtss_f32(high);
274  to[stride*5] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1));
275  to[stride*6] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 2));
276  to[stride*7] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3));
277 }
278 template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet4d>(double* to, const Packet4d& from, Index stride)
279 {
280  __m128d low = _mm256_extractf128_pd(from, 0);
281  to[stride*0] = _mm_cvtsd_f64(low);
282  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1));
283  __m128d high = _mm256_extractf128_pd(from, 1);
284  to[stride*2] = _mm_cvtsd_f64(high);
285  to[stride*3] = _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1));
286 }
287 
288 template<> EIGEN_STRONG_INLINE void pstore1<Packet8f>(float* to, const float& a)
289 {
290  Packet8f pa = pset1<Packet8f>(a);
291  pstore(to, pa);
292 }
293 template<> EIGEN_STRONG_INLINE void pstore1<Packet4d>(double* to, const double& a)
294 {
295  Packet4d pa = pset1<Packet4d>(a);
296  pstore(to, pa);
297 }
298 template<> EIGEN_STRONG_INLINE void pstore1<Packet8i>(int* to, const int& a)
299 {
300  Packet8i pa = pset1<Packet8i>(a);
301  pstore(to, pa);
302 }
303 
304 template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
305 template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
306 template<> EIGEN_STRONG_INLINE void prefetch<int>(const int* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
307 
308 template<> EIGEN_STRONG_INLINE float pfirst<Packet8f>(const Packet8f& a) {
309  return _mm_cvtss_f32(_mm256_castps256_ps128(a));
310 }
311 template<> EIGEN_STRONG_INLINE double pfirst<Packet4d>(const Packet4d& a) {
312  return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));
313 }
314 template<> EIGEN_STRONG_INLINE int pfirst<Packet8i>(const Packet8i& a) {
315  return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
316 }
317 
318 
319 template<> EIGEN_STRONG_INLINE Packet8f preverse(const Packet8f& a)
320 {
321  __m256 tmp = _mm256_shuffle_ps(a,a,0x1b);
322  return _mm256_permute2f128_ps(tmp, tmp, 1);
323 }
324 template<> EIGEN_STRONG_INLINE Packet4d preverse(const Packet4d& a)
325 {
326  __m256d tmp = _mm256_shuffle_pd(a,a,5);
327  return _mm256_permute2f128_pd(tmp, tmp, 1);
328 
329  __m256d swap_halves = _mm256_permute2f128_pd(a,a,1);
330  return _mm256_permute_pd(swap_halves,5);
331 }
332 
333 // pabs should be ok
334 template<> EIGEN_STRONG_INLINE Packet8f pabs(const Packet8f& a)
335 {
336  const Packet8f mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
337  return _mm256_and_ps(a,mask);
338 }
339 template<> EIGEN_STRONG_INLINE Packet4d pabs(const Packet4d& a)
340 {
341  const Packet4d mask = _mm256_castsi256_pd(_mm256_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
342  return _mm256_and_pd(a,mask);
343 }
344 
345 // preduxp should be ok
346 // FIXME: why is this ok? why isn't the simply implementation working as expected?
347 template<> EIGEN_STRONG_INLINE Packet8f preduxp<Packet8f>(const Packet8f* vecs)
348 {
349  __m256 hsum1 = _mm256_hadd_ps(vecs[0], vecs[1]);
350  __m256 hsum2 = _mm256_hadd_ps(vecs[2], vecs[3]);
351  __m256 hsum3 = _mm256_hadd_ps(vecs[4], vecs[5]);
352  __m256 hsum4 = _mm256_hadd_ps(vecs[6], vecs[7]);
353 
354  __m256 hsum5 = _mm256_hadd_ps(hsum1, hsum1);
355  __m256 hsum6 = _mm256_hadd_ps(hsum2, hsum2);
356  __m256 hsum7 = _mm256_hadd_ps(hsum3, hsum3);
357  __m256 hsum8 = _mm256_hadd_ps(hsum4, hsum4);
358 
359  __m256 perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
360  __m256 perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
361  __m256 perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
362  __m256 perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
363 
364  __m256 sum1 = _mm256_add_ps(perm1, hsum5);
365  __m256 sum2 = _mm256_add_ps(perm2, hsum6);
366  __m256 sum3 = _mm256_add_ps(perm3, hsum7);
367  __m256 sum4 = _mm256_add_ps(perm4, hsum8);
368 
369  __m256 blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
370  __m256 blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
371 
372  __m256 final = _mm256_blend_ps(blend1, blend2, 0xf0);
373  return final;
374 }
375 template<> EIGEN_STRONG_INLINE Packet4d preduxp<Packet4d>(const Packet4d* vecs)
376 {
377  Packet4d tmp0, tmp1;
378 
379  tmp0 = _mm256_hadd_pd(vecs[0], vecs[1]);
380  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
381 
382  tmp1 = _mm256_hadd_pd(vecs[2], vecs[3]);
383  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
384 
385  return _mm256_blend_pd(tmp0, tmp1, 0xC);
386 }
387 
388 template<> EIGEN_STRONG_INLINE float predux<Packet8f>(const Packet8f& a)
389 {
390  Packet8f tmp0 = _mm256_hadd_ps(a,_mm256_permute2f128_ps(a,a,1));
391  tmp0 = _mm256_hadd_ps(tmp0,tmp0);
392  return pfirst(_mm256_hadd_ps(tmp0, tmp0));
393 }
394 template<> EIGEN_STRONG_INLINE double predux<Packet4d>(const Packet4d& a)
395 {
396  Packet4d tmp0 = _mm256_hadd_pd(a,_mm256_permute2f128_pd(a,a,1));
397  return pfirst(_mm256_hadd_pd(tmp0,tmp0));
398 }
399 
400 template<> EIGEN_STRONG_INLINE Packet4f predux4<Packet8f>(const Packet8f& a)
401 {
402  return _mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1));
403 }
404 
405 template<> EIGEN_STRONG_INLINE float predux_mul<Packet8f>(const Packet8f& a)
406 {
407  Packet8f tmp;
408  tmp = _mm256_mul_ps(a, _mm256_permute2f128_ps(a,a,1));
409  tmp = _mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
410  return pfirst(_mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
411 }
412 template<> EIGEN_STRONG_INLINE double predux_mul<Packet4d>(const Packet4d& a)
413 {
414  Packet4d tmp;
415  tmp = _mm256_mul_pd(a, _mm256_permute2f128_pd(a,a,1));
416  return pfirst(_mm256_mul_pd(tmp, _mm256_shuffle_pd(tmp,tmp,1)));
417 }
418 
419 template<> EIGEN_STRONG_INLINE float predux_min<Packet8f>(const Packet8f& a)
420 {
421  Packet8f tmp = _mm256_min_ps(a, _mm256_permute2f128_ps(a,a,1));
422  tmp = _mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
423  return pfirst(_mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
424 }
425 template<> EIGEN_STRONG_INLINE double predux_min<Packet4d>(const Packet4d& a)
426 {
427  Packet4d tmp = _mm256_min_pd(a, _mm256_permute2f128_pd(a,a,1));
428  return pfirst(_mm256_min_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
429 }
430 
431 template<> EIGEN_STRONG_INLINE float predux_max<Packet8f>(const Packet8f& a)
432 {
433  Packet8f tmp = _mm256_max_ps(a, _mm256_permute2f128_ps(a,a,1));
434  tmp = _mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
435  return pfirst(_mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
436 }
437 
438 template<> EIGEN_STRONG_INLINE double predux_max<Packet4d>(const Packet4d& a)
439 {
440  Packet4d tmp = _mm256_max_pd(a, _mm256_permute2f128_pd(a,a,1));
441  return pfirst(_mm256_max_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
442 }
443 
444 
445 template<int Offset>
446 struct palign_impl<Offset,Packet8f>
447 {
448  static EIGEN_STRONG_INLINE void run(Packet8f& first, const Packet8f& second)
449  {
450  if (Offset==1)
451  {
452  first = _mm256_blend_ps(first, second, 1);
453  Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(0,3,2,1));
454  Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
455  first = _mm256_blend_ps(tmp1, tmp2, 0x88);
456  }
457  else if (Offset==2)
458  {
459  first = _mm256_blend_ps(first, second, 3);
460  Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(1,0,3,2));
461  Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
462  first = _mm256_blend_ps(tmp1, tmp2, 0xcc);
463  }
464  else if (Offset==3)
465  {
466  first = _mm256_blend_ps(first, second, 7);
467  Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(2,1,0,3));
468  Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
469  first = _mm256_blend_ps(tmp1, tmp2, 0xee);
470  }
471  else if (Offset==4)
472  {
473  first = _mm256_blend_ps(first, second, 15);
474  Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(3,2,1,0));
475  Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
476  first = _mm256_permute_ps(tmp2, _MM_SHUFFLE(3,2,1,0));
477  }
478  else if (Offset==5)
479  {
480  first = _mm256_blend_ps(first, second, 31);
481  first = _mm256_permute2f128_ps(first, first, 1);
482  Packet8f tmp = _mm256_permute_ps (first, _MM_SHUFFLE(0,3,2,1));
483  first = _mm256_permute2f128_ps(tmp, tmp, 1);
484  first = _mm256_blend_ps(tmp, first, 0x88);
485  }
486  else if (Offset==6)
487  {
488  first = _mm256_blend_ps(first, second, 63);
489  first = _mm256_permute2f128_ps(first, first, 1);
490  Packet8f tmp = _mm256_permute_ps (first, _MM_SHUFFLE(1,0,3,2));
491  first = _mm256_permute2f128_ps(tmp, tmp, 1);
492  first = _mm256_blend_ps(tmp, first, 0xcc);
493  }
494  else if (Offset==7)
495  {
496  first = _mm256_blend_ps(first, second, 127);
497  first = _mm256_permute2f128_ps(first, first, 1);
498  Packet8f tmp = _mm256_permute_ps (first, _MM_SHUFFLE(2,1,0,3));
499  first = _mm256_permute2f128_ps(tmp, tmp, 1);
500  first = _mm256_blend_ps(tmp, first, 0xee);
501  }
502  }
503 };
504 
505 template<int Offset>
506 struct palign_impl<Offset,Packet4d>
507 {
508  static EIGEN_STRONG_INLINE void run(Packet4d& first, const Packet4d& second)
509  {
510  if (Offset==1)
511  {
512  first = _mm256_blend_pd(first, second, 1);
513  __m256d tmp = _mm256_permute_pd(first, 5);
514  first = _mm256_permute2f128_pd(tmp, tmp, 1);
515  first = _mm256_blend_pd(tmp, first, 0xA);
516  }
517  else if (Offset==2)
518  {
519  first = _mm256_blend_pd(first, second, 3);
520  first = _mm256_permute2f128_pd(first, first, 1);
521  }
522  else if (Offset==3)
523  {
524  first = _mm256_blend_pd(first, second, 7);
525  __m256d tmp = _mm256_permute_pd(first, 5);
526  first = _mm256_permute2f128_pd(tmp, tmp, 1);
527  first = _mm256_blend_pd(tmp, first, 5);
528  }
529  }
530 };
531 
532 EIGEN_DEVICE_FUNC inline void
533 ptranspose(PacketBlock<Packet8f,8>& kernel) {
534  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
535  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
536  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
537  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
538  __m256 T4 = _mm256_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
539  __m256 T5 = _mm256_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
540  __m256 T6 = _mm256_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
541  __m256 T7 = _mm256_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
542  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
543  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
544  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
545  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
546  __m256 S4 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(1,0,1,0));
547  __m256 S5 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(3,2,3,2));
548  __m256 S6 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(1,0,1,0));
549  __m256 S7 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(3,2,3,2));
550  kernel.packet[0] = _mm256_permute2f128_ps(S0, S4, 0x20);
551  kernel.packet[1] = _mm256_permute2f128_ps(S1, S5, 0x20);
552  kernel.packet[2] = _mm256_permute2f128_ps(S2, S6, 0x20);
553  kernel.packet[3] = _mm256_permute2f128_ps(S3, S7, 0x20);
554  kernel.packet[4] = _mm256_permute2f128_ps(S0, S4, 0x31);
555  kernel.packet[5] = _mm256_permute2f128_ps(S1, S5, 0x31);
556  kernel.packet[6] = _mm256_permute2f128_ps(S2, S6, 0x31);
557  kernel.packet[7] = _mm256_permute2f128_ps(S3, S7, 0x31);
558 }
559 
560 EIGEN_DEVICE_FUNC inline void
561 ptranspose(PacketBlock<Packet8f,4>& kernel) {
562  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
563  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
564  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
565  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
566 
567  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
568  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
569  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
570  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
571 
572  kernel.packet[0] = _mm256_permute2f128_ps(S0, S1, 0x20);
573  kernel.packet[1] = _mm256_permute2f128_ps(S2, S3, 0x20);
574  kernel.packet[2] = _mm256_permute2f128_ps(S0, S1, 0x31);
575  kernel.packet[3] = _mm256_permute2f128_ps(S2, S3, 0x31);
576 }
577 
578 EIGEN_DEVICE_FUNC inline void
579 ptranspose(PacketBlock<Packet4d,4>& kernel) {
580  __m256d T0 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 15);
581  __m256d T1 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
582  __m256d T2 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 15);
583  __m256d T3 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
584 
585  kernel.packet[1] = _mm256_permute2f128_pd(T0, T2, 32);
586  kernel.packet[3] = _mm256_permute2f128_pd(T0, T2, 49);
587  kernel.packet[0] = _mm256_permute2f128_pd(T1, T3, 32);
588  kernel.packet[2] = _mm256_permute2f128_pd(T1, T3, 49);
589 }
590 
591 template<> EIGEN_STRONG_INLINE Packet8f pblend(const Selector<8>& ifPacket, const Packet8f& thenPacket, const Packet8f& elsePacket) {
592  const __m256 zero = _mm256_setzero_ps();
593  const __m256 select = _mm256_set_ps(ifPacket.select[7], ifPacket.select[6], ifPacket.select[5], ifPacket.select[4], ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
594  __m256 false_mask = _mm256_cmp_ps(select, zero, _CMP_EQ_UQ);
595  return _mm256_blendv_ps(thenPacket, elsePacket, false_mask);
596 }
597 template<> EIGEN_STRONG_INLINE Packet4d pblend(const Selector<4>& ifPacket, const Packet4d& thenPacket, const Packet4d& elsePacket) {
598  const __m256d zero = _mm256_setzero_pd();
599  const __m256d select = _mm256_set_pd(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
600  __m256d false_mask = _mm256_cmp_pd(select, zero, _CMP_EQ_UQ);
601  return _mm256_blendv_pd(thenPacket, elsePacket, false_mask);
602 }
603 
604 } // end namespace internal
605 
606 } // end namespace Eigen
607 
608 #endif // EIGEN_PACKET_MATH_AVX_H
Namespace containing all symbols from the Eigen library.
Definition: Core:271
Definition: Constants.h:231
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: XprHelper.h:35
Definition: Eigen_Colamd.h:50