Eigen  5.0.1-dev+284dcc12
 
Loading...
Searching...
No Matches
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// IWYU pragma: private
14#include "../../InternalHeaderCheck.h"
15
16namespace Eigen {
17
18namespace internal {
19
20#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
21#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
22#endif
23
24#if !defined(EIGEN_VECTORIZE_AVX512) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
25#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
26#endif
27
28#ifdef EIGEN_VECTORIZE_FMA
29#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
30#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
31#endif
32#endif
33
34typedef __m256 Packet8f;
35typedef eigen_packet_wrapper<__m256i, 0> Packet8i;
36typedef __m256d Packet4d;
37#ifndef EIGEN_VECTORIZE_AVX512FP16
38typedef eigen_packet_wrapper<__m128i, 2> Packet8h;
39#endif
40typedef eigen_packet_wrapper<__m128i, 3> Packet8bf;
41typedef eigen_packet_wrapper<__m256i, 4> Packet8ui;
42
43#ifdef EIGEN_VECTORIZE_AVX2
44// Start from 3 to be compatible with AVX512
45typedef eigen_packet_wrapper<__m256i, 3> Packet4l;
46typedef eigen_packet_wrapper<__m256i, 5> Packet4ul;
47#endif
48
49template <>
50struct is_arithmetic<__m256> {
51 enum { value = true };
52};
53template <>
54struct is_arithmetic<__m256i> {
55 enum { value = true };
56};
57template <>
58struct is_arithmetic<__m256d> {
59 enum { value = true };
60};
61template <>
62struct is_arithmetic<Packet8i> {
63 enum { value = true };
64};
65// Note that `Packet8ui` uses the underlying type `__m256i`, which is
66// interpreted as a vector of _signed_ `int32`s, which breaks some arithmetic
67// operations used in `GenericPacketMath.h`.
68template <>
69struct is_arithmetic<Packet8ui> {
70 enum { value = false };
71};
72#ifndef EIGEN_VECTORIZE_AVX512FP16
73template <>
74struct is_arithmetic<Packet8h> {
75 enum { value = true };
76};
77#endif
78template <>
79struct is_arithmetic<Packet8bf> {
80 enum { value = true };
81};
82#ifdef EIGEN_VECTORIZE_AVX2
83template <>
84struct is_arithmetic<Packet4l> {
85 enum { value = true };
86};
87// Note that `Packet4ul` uses the underlying type `__m256i`, which is
88// interpreted as a vector of _signed_ `int32`s, which breaks some arithmetic
89// operations used in `GenericPacketMath.h`.
90template <>
91struct is_arithmetic<Packet4ul> {
92 enum { value = false };
93};
94#endif
95
96// Use the packet_traits defined in AVX512/PacketMath.h instead if we're going
97// to leverage AVX512 instructions.
98#ifndef EIGEN_VECTORIZE_AVX512
99template <>
100struct packet_traits<float> : default_packet_traits {
101 typedef Packet8f type;
102 typedef Packet4f half;
103 enum {
104 Vectorizable = 1,
105 AlignedOnScalar = 1,
106 size = 8,
107
108 HasCmp = 1,
109 HasDiv = 1,
110 HasReciprocal = EIGEN_FAST_MATH,
111 HasSin = EIGEN_FAST_MATH,
112 HasCos = EIGEN_FAST_MATH,
113 HasACos = 1,
114 HasASin = 1,
115 HasATan = 1,
116 HasATanh = 1,
117 HasLog = 1,
118 HasLog1p = 1,
119 HasExpm1 = 1,
120 HasExp = 1,
121 HasPow = 1,
122 HasNdtri = 1,
123 HasBessel = 1,
124 HasSqrt = 1,
125 HasRsqrt = 1,
126 HasCbrt = 1,
127 HasTanh = EIGEN_FAST_MATH,
128 HasErf = EIGEN_FAST_MATH,
129 HasErfc = EIGEN_FAST_MATH,
130 HasBlend = 1
131 };
132};
133template <>
134struct packet_traits<double> : default_packet_traits {
135 typedef Packet4d type;
136 typedef Packet2d half;
137 enum {
138 Vectorizable = 1,
139 AlignedOnScalar = 1,
140 size = 4,
141
142 HasCmp = 1,
143 HasDiv = 1,
144#ifdef EIGEN_VECTORIZE_AVX2
145 HasSin = EIGEN_FAST_MATH,
146 HasCos = EIGEN_FAST_MATH,
147#endif
148 HasTanh = EIGEN_FAST_MATH,
149 HasLog = 1,
150 HasErf = 1,
151 HasErfc = 1,
152 HasExp = 1,
153 HasPow = 1,
154 HasSqrt = 1,
155 HasRsqrt = 1,
156 HasCbrt = 1,
157 HasATan = 1,
158 HasATanh = 1,
159 HasBlend = 1
160 };
161};
162
163template <>
164struct packet_traits<Eigen::half> : default_packet_traits {
165 typedef Packet8h type;
166 // There is no half-size packet for Packet8h.
167 typedef Packet8h half;
168 enum {
169 Vectorizable = 1,
170 AlignedOnScalar = 1,
171 size = 8,
172
173 HasCmp = 1,
174 HasAdd = 1,
175 HasSub = 1,
176 HasMul = 1,
177 HasDiv = 1,
178 HasSin = EIGEN_FAST_MATH,
179 HasCos = EIGEN_FAST_MATH,
180 HasNegate = 1,
181 HasAbs = 1,
182 HasAbs2 = 0,
183 HasMin = 1,
184 HasMax = 1,
185 HasConj = 1,
186 HasSetLinear = 0,
187 HasLog = 1,
188 HasLog1p = 1,
189 HasExpm1 = 1,
190 HasExp = 1,
191 HasSqrt = 1,
192 HasRsqrt = 1,
193 HasTanh = EIGEN_FAST_MATH,
194 HasErf = EIGEN_FAST_MATH,
195 HasBlend = 0,
196 HasBessel = 1,
197 HasNdtri = 1
198 };
199};
200
201template <>
202struct packet_traits<bfloat16> : default_packet_traits {
203 typedef Packet8bf type;
204 // There is no half-size packet for current Packet8bf.
205 // TODO: support as SSE path.
206 typedef Packet8bf half;
207 enum {
208 Vectorizable = 1,
209 AlignedOnScalar = 1,
210 size = 8,
211
212 HasCmp = 1,
213 HasAdd = 1,
214 HasSub = 1,
215 HasMul = 1,
216 HasDiv = 1,
217 HasSin = EIGEN_FAST_MATH,
218 HasCos = EIGEN_FAST_MATH,
219 HasNegate = 1,
220 HasAbs = 1,
221 HasAbs2 = 0,
222 HasMin = 1,
223 HasMax = 1,
224 HasConj = 1,
225 HasSetLinear = 0,
226 HasLog = 1,
227 HasLog1p = 1,
228 HasExpm1 = 1,
229 HasExp = 1,
230 HasSqrt = 1,
231 HasRsqrt = 1,
232 HasTanh = EIGEN_FAST_MATH,
233 HasErf = EIGEN_FAST_MATH,
234 HasBlend = 0,
235 HasBessel = 1,
236 HasNdtri = 1
237 };
238};
239
240template <>
241struct packet_traits<int> : default_packet_traits {
242 typedef Packet8i type;
243 typedef Packet4i half;
244 enum { Vectorizable = 1, AlignedOnScalar = 1, HasCmp = 1, HasDiv = 1, size = 8 };
245};
246template <>
247struct packet_traits<uint32_t> : default_packet_traits {
248 typedef Packet8ui type;
249 typedef Packet4ui half;
250 enum {
251 Vectorizable = 1,
252 AlignedOnScalar = 1,
253 size = 8,
254
255 HasDiv = 0,
256 HasNegate = 0,
257 HasSqrt = 0,
258
259 HasCmp = 1,
260 HasMin = 1,
261 HasMax = 1,
262 HasShift = 1
263 };
264};
265
266#ifdef EIGEN_VECTORIZE_AVX2
267template <>
268struct packet_traits<int64_t> : default_packet_traits {
269 typedef Packet4l type;
270 typedef Packet2l half;
271 enum { Vectorizable = 1, AlignedOnScalar = 1, HasCmp = 1, size = 4 };
272};
273template <>
274struct packet_traits<uint64_t> : default_packet_traits {
275 typedef Packet4ul type;
276 // There is no half-size packet for current Packet4ul.
277 // TODO: support as SSE path.
278 typedef Packet4ul half;
279 enum {
280 Vectorizable = 1,
281 AlignedOnScalar = 1,
282 size = 4,
283
284 // HasMin = 0,
285 // HasMax = 0,
286 HasDiv = 0,
287 HasBlend = 0,
288 HasTranspose = 0,
289 HasNegate = 0,
290 HasSqrt = 0,
291 HasCmp = 1,
292 HasShift = 1
293 };
294};
295#endif
296
297#endif
298
299template <>
300struct scalar_div_cost<float, true> {
301 enum { value = 14 };
302};
303template <>
304struct scalar_div_cost<double, true> {
305 enum { value = 16 };
306};
307
308template <>
309struct unpacket_traits<Packet8f> {
310 typedef float type;
311 typedef Packet4f half;
312 typedef Packet8i integer_packet;
313 typedef uint8_t mask_t;
314 enum {
315 size = 8,
316 alignment = Aligned32,
317 vectorizable = true,
318 masked_load_available = true,
319 masked_store_available = true
320#ifdef EIGEN_VECTORIZE_AVX512
321 ,
322 masked_fpops_available = true
323#endif
324 };
325};
326template <>
327struct unpacket_traits<Packet4d> {
328 typedef double type;
329 typedef Packet2d half;
330#ifdef EIGEN_VECTORIZE_AVX2
331 typedef Packet4l integer_packet;
332#endif
333 enum {
334 size = 4,
335 alignment = Aligned32,
336 vectorizable = true,
337 masked_load_available = false,
338 masked_store_available = false
339 };
340};
341template <>
342struct unpacket_traits<Packet8i> {
343 typedef int type;
344 typedef Packet4i half;
345 enum {
346 size = 8,
347 alignment = Aligned32,
348 vectorizable = true,
349 masked_load_available = false,
350 masked_store_available = false
351 };
352};
353template <>
354struct unpacket_traits<Packet8ui> {
355 typedef uint32_t type;
356 typedef Packet4ui half;
357 enum {
358 size = 8,
359 alignment = Aligned32,
360 vectorizable = true,
361 masked_load_available = false,
362 masked_store_available = false
363 };
364};
365#ifdef EIGEN_VECTORIZE_AVX2
366template <>
367struct unpacket_traits<Packet4l> {
368 typedef int64_t type;
369 typedef Packet2l half;
370 enum {
371 size = 4,
372 alignment = Aligned32,
373 vectorizable = true,
374 masked_load_available = false,
375 masked_store_available = false
376 };
377};
378template <>
379struct unpacket_traits<Packet4ul> {
380 typedef uint64_t type;
381 typedef Packet4ul half;
382 enum {
383 size = 4,
384 alignment = Aligned32,
385 vectorizable = true,
386 masked_load_available = false,
387 masked_store_available = false
388 };
389};
390#endif
391template <>
392struct unpacket_traits<Packet8bf> {
393 typedef bfloat16 type;
394 typedef Packet8bf half;
395 enum {
396 size = 8,
397 alignment = Aligned16,
398 vectorizable = true,
399 masked_load_available = false,
400 masked_store_available = false
401 };
402};
403
404// Helper function for bit packing snippet of low precision comparison.
405// It packs the flags from 16x16 to 8x16.
406EIGEN_STRONG_INLINE __m128i Pack16To8(Packet8f rf) {
407 return _mm_packs_epi32(_mm256_extractf128_si256(_mm256_castps_si256(rf), 0),
408 _mm256_extractf128_si256(_mm256_castps_si256(rf), 1));
409}
410
411#ifdef EIGEN_VECTORIZE_AVX2
412template <>
413EIGEN_STRONG_INLINE Packet4l pset1<Packet4l>(const int64_t& from) {
414 return _mm256_set1_epi64x(from);
415}
416template <>
417EIGEN_STRONG_INLINE Packet4ul pset1<Packet4ul>(const uint64_t& from) {
418 return _mm256_set1_epi64x(numext::bit_cast<uint64_t>(from));
419}
420template <>
421EIGEN_STRONG_INLINE Packet4l pzero(const Packet4l& /*a*/) {
422 return _mm256_setzero_si256();
423}
424template <>
425EIGEN_STRONG_INLINE Packet4ul pzero(const Packet4ul& /*a*/) {
426 return _mm256_setzero_si256();
427}
428template <>
429EIGEN_STRONG_INLINE Packet4l peven_mask(const Packet4l& /*a*/) {
430 return _mm256_set_epi64x(0ll, -1ll, 0ll, -1ll);
431}
432template <>
433EIGEN_STRONG_INLINE Packet4ul peven_mask(const Packet4ul& /*a*/) {
434 return _mm256_set_epi64x(0ll, -1ll, 0ll, -1ll);
435}
436template <>
437EIGEN_STRONG_INLINE Packet4l pload1<Packet4l>(const int64_t* from) {
438 return _mm256_set1_epi64x(*from);
439}
440template <>
441EIGEN_STRONG_INLINE Packet4ul pload1<Packet4ul>(const uint64_t* from) {
442 return _mm256_set1_epi64x(*from);
443}
444template <>
445EIGEN_STRONG_INLINE Packet4l padd<Packet4l>(const Packet4l& a, const Packet4l& b) {
446 return _mm256_add_epi64(a, b);
447}
448template <>
449EIGEN_STRONG_INLINE Packet4ul padd<Packet4ul>(const Packet4ul& a, const Packet4ul& b) {
450 return _mm256_add_epi64(a, b);
451}
452template <>
453EIGEN_STRONG_INLINE Packet4l plset<Packet4l>(const int64_t& a) {
454 return padd(pset1<Packet4l>(a), Packet4l(_mm256_set_epi64x(3ll, 2ll, 1ll, 0ll)));
455}
456template <>
457EIGEN_STRONG_INLINE Packet4ul plset<Packet4ul>(const uint64_t& a) {
458 return padd(pset1<Packet4ul>(a), Packet4ul(_mm256_set_epi64x(3ll, 2ll, 1ll, 0ll)));
459}
460template <>
461EIGEN_STRONG_INLINE Packet4l psub<Packet4l>(const Packet4l& a, const Packet4l& b) {
462 return _mm256_sub_epi64(a, b);
463}
464template <>
465EIGEN_STRONG_INLINE Packet4ul psub<Packet4ul>(const Packet4ul& a, const Packet4ul& b) {
466 return _mm256_sub_epi64(a, b);
467}
468template <>
469EIGEN_STRONG_INLINE Packet4l pnegate(const Packet4l& a) {
470 return psub(pzero(a), a);
471}
472template <>
473EIGEN_STRONG_INLINE Packet4l pconj(const Packet4l& a) {
474 return a;
475}
476template <>
477EIGEN_STRONG_INLINE Packet4l pcmp_le(const Packet4l& a, const Packet4l& b) {
478 return _mm256_xor_si256(_mm256_cmpgt_epi64(a, b), _mm256_set1_epi32(-1));
479}
480template <>
481EIGEN_STRONG_INLINE Packet4ul pcmp_le(const Packet4ul& a, const Packet4ul& b) {
482 return (Packet4ul)pcmp_le((Packet4l)psub(a, pset1<Packet4ul>(0x8000000000000000UL)),
483 (Packet4l)psub(b, pset1<Packet4ul>(0x8000000000000000UL)));
484}
485template <>
486EIGEN_STRONG_INLINE Packet4l pcmp_lt(const Packet4l& a, const Packet4l& b) {
487 return _mm256_cmpgt_epi64(b, a);
488}
489template <>
490EIGEN_STRONG_INLINE Packet4ul pcmp_lt(const Packet4ul& a, const Packet4ul& b) {
491 return (Packet4ul)pcmp_lt((Packet4l)psub(a, pset1<Packet4ul>(0x8000000000000000UL)),
492 (Packet4l)psub(b, pset1<Packet4ul>(0x8000000000000000UL)));
493}
494template <>
495EIGEN_STRONG_INLINE Packet4l pcmp_eq(const Packet4l& a, const Packet4l& b) {
496 return _mm256_cmpeq_epi64(a, b);
497}
498template <>
499EIGEN_STRONG_INLINE Packet4ul pcmp_eq(const Packet4ul& a, const Packet4ul& b) {
500 return _mm256_cmpeq_epi64(a, b);
501}
502template <>
503EIGEN_STRONG_INLINE Packet4l ptrue<Packet4l>(const Packet4l& a) {
504 return _mm256_cmpeq_epi64(a, a);
505}
506template <>
507EIGEN_STRONG_INLINE Packet4ul ptrue<Packet4ul>(const Packet4ul& a) {
508 return _mm256_cmpeq_epi64(a, a);
509}
510template <>
511EIGEN_STRONG_INLINE Packet4l pand<Packet4l>(const Packet4l& a, const Packet4l& b) {
512 return _mm256_and_si256(a, b);
513}
514template <>
515EIGEN_STRONG_INLINE Packet4l por<Packet4l>(const Packet4l& a, const Packet4l& b) {
516 return _mm256_or_si256(a, b);
517}
518template <>
519EIGEN_STRONG_INLINE Packet4l pxor<Packet4l>(const Packet4l& a, const Packet4l& b) {
520 return _mm256_xor_si256(a, b);
521}
522template <>
523EIGEN_STRONG_INLINE Packet4ul pxor<Packet4ul>(const Packet4ul& a, const Packet4ul& b) {
524 return _mm256_xor_si256(a, b);
525}
526template <>
527EIGEN_STRONG_INLINE Packet4l pandnot<Packet4l>(const Packet4l& a, const Packet4l& b) {
528 return _mm256_andnot_si256(b, a);
529}
530template <int N>
531EIGEN_STRONG_INLINE Packet4l plogical_shift_right(Packet4l a) {
532 return _mm256_srli_epi64(a, N);
533}
534template <int N>
535EIGEN_STRONG_INLINE Packet4l plogical_shift_left(Packet4l a) {
536 return _mm256_slli_epi64(a, N);
537}
538#ifdef EIGEN_VECTORIZE_AVX512FP16
539template <int N>
540EIGEN_STRONG_INLINE Packet4l parithmetic_shift_right(Packet4l a) {
541 return _mm256_srai_epi64(a, N);
542}
543#else
544template <int N>
545EIGEN_STRONG_INLINE std::enable_if_t<(N == 0), Packet4l> parithmetic_shift_right(Packet4l a) {
546 return a;
547}
548template <int N>
549EIGEN_STRONG_INLINE std::enable_if_t<(N > 0) && (N < 32), Packet4l> parithmetic_shift_right(Packet4l a) {
550 __m256i hi_word = _mm256_srai_epi32(a, N);
551 __m256i lo_word = _mm256_srli_epi64(a, N);
552 return _mm256_blend_epi32(hi_word, lo_word, 0b01010101);
553}
554template <int N>
555EIGEN_STRONG_INLINE std::enable_if_t<(N >= 32) && (N < 63), Packet4l> parithmetic_shift_right(Packet4l a) {
556 __m256i hi_word = _mm256_srai_epi32(a, 31);
557 __m256i lo_word = _mm256_shuffle_epi32(_mm256_srai_epi32(a, N - 32), (shuffle_mask<1, 1, 3, 3>::mask));
558 return _mm256_blend_epi32(hi_word, lo_word, 0b01010101);
559}
560template <int N>
561EIGEN_STRONG_INLINE std::enable_if_t<(N == 63), Packet4l> parithmetic_shift_right(Packet4l a) {
562 return _mm256_cmpgt_epi64(_mm256_setzero_si256(), a);
563}
564template <int N>
565EIGEN_STRONG_INLINE std::enable_if_t<(N < 0) || (N > 63), Packet4l> parithmetic_shift_right(Packet4l a) {
566 return parithmetic_shift_right<int(N & 63)>(a);
567}
568#endif
569template <>
570EIGEN_STRONG_INLINE Packet4l pload<Packet4l>(const int64_t* from) {
571 EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
572}
573template <>
574EIGEN_STRONG_INLINE Packet4ul pload<Packet4ul>(const uint64_t* from) {
575 EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
576}
577template <>
578EIGEN_STRONG_INLINE Packet4l ploadu<Packet4l>(const int64_t* from) {
579 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
580}
581template <>
582EIGEN_STRONG_INLINE Packet4ul ploadu<Packet4ul>(const uint64_t* from) {
583 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
584}
585// Loads 2 int64_ts from memory a returns the packet {a0, a0, a1, a1}
586template <>
587EIGEN_STRONG_INLINE Packet4l ploaddup<Packet4l>(const int64_t* from) {
588 const Packet4l a = _mm256_castsi128_si256(_mm_loadu_si128(reinterpret_cast<const __m128i*>(from)));
589 return _mm256_permutevar8x32_epi32(a, _mm256_setr_epi32(0, 1, 0, 1, 2, 3, 2, 3));
590}
591// Loads 2 uint64_ts from memory a returns the packet {a0, a0, a1, a1}
592template <>
593EIGEN_STRONG_INLINE Packet4ul ploaddup<Packet4ul>(const uint64_t* from) {
594 const Packet4ul a = _mm256_castsi128_si256(_mm_loadu_si128(reinterpret_cast<const __m128i*>(from)));
595 return _mm256_permutevar8x32_epi32(a, _mm256_setr_epi32(0, 1, 0, 1, 2, 3, 2, 3));
596}
597template <>
598EIGEN_STRONG_INLINE void pstore<int64_t>(int64_t* to, const Packet4l& from) {
599 EIGEN_DEBUG_ALIGNED_STORE _mm256_store_si256(reinterpret_cast<__m256i*>(to), from);
600}
601template <>
602EIGEN_STRONG_INLINE void pstore<uint64_t>(uint64_t* to, const Packet4ul& from) {
603 EIGEN_DEBUG_ALIGNED_STORE _mm256_store_si256(reinterpret_cast<__m256i*>(to), from);
604}
605template <>
606EIGEN_STRONG_INLINE void pstoreu<int64_t>(int64_t* to, const Packet4l& from) {
607 EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from);
608}
609template <>
610EIGEN_STRONG_INLINE void pstoreu<uint64_t>(uint64_t* to, const Packet4ul& from) {
611 EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from);
612}
613template <>
614EIGEN_DEVICE_FUNC inline Packet4l pgather<int64_t, Packet4l>(const int64_t* from, Index stride) {
615 return _mm256_set_epi64x(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
616}
617template <>
618EIGEN_DEVICE_FUNC inline Packet4ul pgather<uint64_t, Packet4ul>(const uint64_t* from, Index stride) {
619 return _mm256_set_epi64x(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
620}
621template <>
622EIGEN_DEVICE_FUNC inline void pscatter<int64_t, Packet4l>(int64_t* to, const Packet4l& from, Index stride) {
623 __m128i low = _mm256_extractf128_si256(from, 0);
624 to[stride * 0] = _mm_extract_epi64_0(low);
625 to[stride * 1] = _mm_extract_epi64_1(low);
626
627 __m128i high = _mm256_extractf128_si256(from, 1);
628 to[stride * 2] = _mm_extract_epi64_0(high);
629 to[stride * 3] = _mm_extract_epi64_1(high);
630}
631template <>
632EIGEN_DEVICE_FUNC inline void pscatter<uint64_t, Packet4ul>(uint64_t* to, const Packet4ul& from, Index stride) {
633 __m128i low = _mm256_extractf128_si256(from, 0);
634 to[stride * 0] = _mm_extract_epi64_0(low);
635 to[stride * 1] = _mm_extract_epi64_1(low);
636
637 __m128i high = _mm256_extractf128_si256(from, 1);
638 to[stride * 2] = _mm_extract_epi64_0(high);
639 to[stride * 3] = _mm_extract_epi64_1(high);
640}
641template <>
642EIGEN_STRONG_INLINE void pstore1<Packet4l>(int64_t* to, const int64_t& a) {
643 Packet4l pa = pset1<Packet4l>(a);
644 pstore(to, pa);
645}
646template <>
647EIGEN_STRONG_INLINE void pstore1<Packet4ul>(uint64_t* to, const uint64_t& a) {
648 Packet4ul pa = pset1<Packet4ul>(a);
649 pstore(to, pa);
650}
651template <>
652EIGEN_STRONG_INLINE int64_t pfirst<Packet4l>(const Packet4l& a) {
653 return _mm_extract_epi64_0(_mm256_castsi256_si128(a));
654}
655template <>
656EIGEN_STRONG_INLINE uint64_t pfirst<Packet4ul>(const Packet4ul& a) {
657 return _mm_extract_epi64_0(_mm256_castsi256_si128(a));
658}
659
660#define MM256_SHUFFLE_EPI64(A, B, M) _mm256_shuffle_pd(_mm256_castsi256_pd(A), _mm256_castsi256_pd(B), M)
661EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4l, 4>& kernel) {
662 __m256d T0 = MM256_SHUFFLE_EPI64(kernel.packet[0], kernel.packet[1], 15);
663 __m256d T1 = MM256_SHUFFLE_EPI64(kernel.packet[0], kernel.packet[1], 0);
664 __m256d T2 = MM256_SHUFFLE_EPI64(kernel.packet[2], kernel.packet[3], 15);
665 __m256d T3 = MM256_SHUFFLE_EPI64(kernel.packet[2], kernel.packet[3], 0);
666
667 kernel.packet[1] = _mm256_castpd_si256(_mm256_permute2f128_pd(T0, T2, 32));
668 kernel.packet[3] = _mm256_castpd_si256(_mm256_permute2f128_pd(T0, T2, 49));
669 kernel.packet[0] = _mm256_castpd_si256(_mm256_permute2f128_pd(T1, T3, 32));
670 kernel.packet[2] = _mm256_castpd_si256(_mm256_permute2f128_pd(T1, T3, 49));
671}
672EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4ul, 4>& kernel) {
673 ptranspose((PacketBlock<Packet4l, 4>&)kernel);
674}
675template <>
676EIGEN_STRONG_INLINE Packet4l pmin<Packet4l>(const Packet4l& a, const Packet4l& b) {
677 __m256i cmp = _mm256_cmpgt_epi64(a, b);
678 __m256i a_min = _mm256_andnot_si256(cmp, a);
679 __m256i b_min = _mm256_and_si256(cmp, b);
680 return Packet4l(_mm256_or_si256(a_min, b_min));
681}
682template <>
683EIGEN_STRONG_INLINE Packet4ul pmin<Packet4ul>(const Packet4ul& a, const Packet4ul& b) {
684 return padd((Packet4ul)pmin((Packet4l)psub(a, pset1<Packet4ul>(0x8000000000000000UL)),
685 (Packet4l)psub(b, pset1<Packet4ul>(0x8000000000000000UL))),
686 pset1<Packet4ul>(0x8000000000000000UL));
687}
688template <>
689EIGEN_STRONG_INLINE Packet4l pmax<Packet4l>(const Packet4l& a, const Packet4l& b) {
690 __m256i cmp = _mm256_cmpgt_epi64(a, b);
691 __m256i a_min = _mm256_and_si256(cmp, a);
692 __m256i b_min = _mm256_andnot_si256(cmp, b);
693 return Packet4l(_mm256_or_si256(a_min, b_min));
694}
695template <>
696EIGEN_STRONG_INLINE Packet4ul pmax<Packet4ul>(const Packet4ul& a, const Packet4ul& b) {
697 return padd((Packet4ul)pmax((Packet4l)psub(a, pset1<Packet4ul>(0x8000000000000000UL)),
698 (Packet4l)psub(b, pset1<Packet4ul>(0x8000000000000000UL))),
699 pset1<Packet4ul>(0x8000000000000000UL));
700}
701template <>
702EIGEN_STRONG_INLINE Packet4l pabs<Packet4l>(const Packet4l& a) {
703 Packet4l pz = pzero<Packet4l>(a);
704 Packet4l cmp = _mm256_cmpgt_epi64(a, pz);
705 return psub(cmp, pxor(a, cmp));
706}
707template <>
708EIGEN_STRONG_INLINE Packet4ul pabs<Packet4ul>(const Packet4ul& a) {
709 return a;
710}
711template <>
712EIGEN_STRONG_INLINE Packet4l pmul<Packet4l>(const Packet4l& a, const Packet4l& b) {
713 // 64-bit mul requires avx512, so do this with 32-bit multiplication
714 __m256i upper32_a = _mm256_srli_epi64(a, 32);
715 __m256i upper32_b = _mm256_srli_epi64(b, 32);
716
717 // upper * lower
718 __m256i mul1 = _mm256_mul_epu32(upper32_a, b);
719 __m256i mul2 = _mm256_mul_epu32(upper32_b, a);
720 // Gives us both upper*upper and lower*lower
721 __m256i mul3 = _mm256_mul_epu32(a, b);
722
723 __m256i high = _mm256_slli_epi64(_mm256_add_epi64(mul1, mul2), 32);
724 return _mm256_add_epi64(high, mul3);
725}
726template <>
727EIGEN_STRONG_INLINE Packet4ul pmul<Packet4ul>(const Packet4ul& a, const Packet4ul& b) {
728 return (Packet4ul)pmul<Packet4l>((Packet4l)a, (Packet4l)b);
729}
730#endif
731
732template <>
733EIGEN_STRONG_INLINE Packet8f pset1<Packet8f>(const float& from) {
734 return _mm256_set1_ps(from);
735}
736template <>
737EIGEN_STRONG_INLINE Packet4d pset1<Packet4d>(const double& from) {
738 return _mm256_set1_pd(from);
739}
740template <>
741EIGEN_STRONG_INLINE Packet8i pset1<Packet8i>(const int& from) {
742 return _mm256_set1_epi32(from);
743}
744template <>
745EIGEN_STRONG_INLINE Packet8ui pset1<Packet8ui>(const uint32_t& from) {
746 return _mm256_set1_epi32(from);
747}
748
749template <>
750EIGEN_STRONG_INLINE Packet8f pset1frombits<Packet8f>(unsigned int from) {
751 return _mm256_castsi256_ps(pset1<Packet8i>(from));
752}
753template <>
754EIGEN_STRONG_INLINE Packet4d pset1frombits<Packet4d>(uint64_t from) {
755 return _mm256_castsi256_pd(_mm256_set1_epi64x(from));
756}
757
758template <>
759EIGEN_STRONG_INLINE Packet8f pzero(const Packet8f& /*a*/) {
760 return _mm256_setzero_ps();
761}
762template <>
763EIGEN_STRONG_INLINE Packet4d pzero(const Packet4d& /*a*/) {
764 return _mm256_setzero_pd();
765}
766template <>
767EIGEN_STRONG_INLINE Packet8i pzero(const Packet8i& /*a*/) {
768 return _mm256_setzero_si256();
769}
770template <>
771EIGEN_STRONG_INLINE Packet8ui pzero(const Packet8ui& /*a*/) {
772 return _mm256_setzero_si256();
773}
774
775template <>
776EIGEN_STRONG_INLINE Packet8f peven_mask(const Packet8f& /*a*/) {
777 return _mm256_castsi256_ps(_mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1));
778}
779template <>
780EIGEN_STRONG_INLINE Packet8i peven_mask(const Packet8i& /*a*/) {
781 return _mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1);
782}
783template <>
784EIGEN_STRONG_INLINE Packet8ui peven_mask(const Packet8ui& /*a*/) {
785 return _mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1);
786}
787template <>
788EIGEN_STRONG_INLINE Packet4d peven_mask(const Packet4d& /*a*/) {
789 return _mm256_castsi256_pd(_mm256_set_epi32(0, 0, -1, -1, 0, 0, -1, -1));
790}
791
792template <>
793EIGEN_STRONG_INLINE Packet8f pload1<Packet8f>(const float* from) {
794 return _mm256_broadcast_ss(from);
795}
796template <>
797EIGEN_STRONG_INLINE Packet4d pload1<Packet4d>(const double* from) {
798 return _mm256_broadcast_sd(from);
799}
800
801template <>
802EIGEN_STRONG_INLINE Packet8f padd<Packet8f>(const Packet8f& a, const Packet8f& b) {
803 return _mm256_add_ps(a, b);
804}
805#ifdef EIGEN_VECTORIZE_AVX512
806template <>
807EIGEN_STRONG_INLINE Packet8f padd<Packet8f>(const Packet8f& a, const Packet8f& b, uint8_t umask) {
808 __mmask16 mask = static_cast<__mmask16>(umask & 0x00FF);
809 return _mm512_castps512_ps256(_mm512_maskz_add_ps(mask, _mm512_castps256_ps512(a), _mm512_castps256_ps512(b)));
810}
811#endif
812template <>
813EIGEN_STRONG_INLINE Packet4d padd<Packet4d>(const Packet4d& a, const Packet4d& b) {
814 return _mm256_add_pd(a, b);
815}
816template <>
817EIGEN_STRONG_INLINE Packet8i padd<Packet8i>(const Packet8i& a, const Packet8i& b) {
818#ifdef EIGEN_VECTORIZE_AVX2
819 return _mm256_add_epi32(a, b);
820#else
821 __m128i lo = _mm_add_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
822 __m128i hi = _mm_add_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
823 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
824#endif
825}
826template <>
827EIGEN_STRONG_INLINE Packet8ui padd<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
828#ifdef EIGEN_VECTORIZE_AVX2
829 return _mm256_add_epi32(a, b);
830#else
831 __m128i lo = _mm_add_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
832 __m128i hi = _mm_add_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
833 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
834#endif
835}
836
837template <>
838EIGEN_STRONG_INLINE Packet8f plset<Packet8f>(const float& a) {
839 return padd(pset1<Packet8f>(a), _mm256_set_ps(7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0));
840}
841template <>
842EIGEN_STRONG_INLINE Packet4d plset<Packet4d>(const double& a) {
843 return padd(pset1<Packet4d>(a), _mm256_set_pd(3.0, 2.0, 1.0, 0.0));
844}
845template <>
846EIGEN_STRONG_INLINE Packet8i plset<Packet8i>(const int& a) {
847 return padd(pset1<Packet8i>(a), (Packet8i)_mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0));
848}
849template <>
850EIGEN_STRONG_INLINE Packet8ui plset<Packet8ui>(const uint32_t& a) {
851 return padd(pset1<Packet8ui>(a), (Packet8ui)_mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0));
852}
853
854template <>
855EIGEN_STRONG_INLINE Packet8f psub<Packet8f>(const Packet8f& a, const Packet8f& b) {
856 return _mm256_sub_ps(a, b);
857}
858template <>
859EIGEN_STRONG_INLINE Packet4d psub<Packet4d>(const Packet4d& a, const Packet4d& b) {
860 return _mm256_sub_pd(a, b);
861}
862template <>
863EIGEN_STRONG_INLINE Packet8i psub<Packet8i>(const Packet8i& a, const Packet8i& b) {
864#ifdef EIGEN_VECTORIZE_AVX2
865 return _mm256_sub_epi32(a, b);
866#else
867 __m128i lo = _mm_sub_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
868 __m128i hi = _mm_sub_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
869 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
870#endif
871}
872template <>
873EIGEN_STRONG_INLINE Packet8ui psub<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
874#ifdef EIGEN_VECTORIZE_AVX2
875 return _mm256_sub_epi32(a, b);
876#else
877 __m128i lo = _mm_sub_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
878 __m128i hi = _mm_sub_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
879 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
880#endif
881}
882
883template <>
884EIGEN_STRONG_INLINE Packet8f pnegate(const Packet8f& a) {
885 const Packet8f mask = _mm256_castsi256_ps(_mm256_set1_epi32(0x80000000));
886 return _mm256_xor_ps(a, mask);
887}
888template <>
889EIGEN_STRONG_INLINE Packet4d pnegate(const Packet4d& a) {
890 const Packet4d mask = _mm256_castsi256_pd(_mm256_set1_epi64x(0x8000000000000000ULL));
891 return _mm256_xor_pd(a, mask);
892}
893template <>
894EIGEN_STRONG_INLINE Packet8i pnegate(const Packet8i& a) {
895 return psub(pzero(a), a);
896}
897
898template <>
899EIGEN_STRONG_INLINE Packet8f pconj(const Packet8f& a) {
900 return a;
901}
902template <>
903EIGEN_STRONG_INLINE Packet4d pconj(const Packet4d& a) {
904 return a;
905}
906template <>
907EIGEN_STRONG_INLINE Packet8i pconj(const Packet8i& a) {
908 return a;
909}
910
911template <>
912EIGEN_STRONG_INLINE Packet8f pmul<Packet8f>(const Packet8f& a, const Packet8f& b) {
913 return _mm256_mul_ps(a, b);
914}
915template <>
916EIGEN_STRONG_INLINE Packet4d pmul<Packet4d>(const Packet4d& a, const Packet4d& b) {
917 return _mm256_mul_pd(a, b);
918}
919template <>
920EIGEN_STRONG_INLINE Packet8i pmul<Packet8i>(const Packet8i& a, const Packet8i& b) {
921#ifdef EIGEN_VECTORIZE_AVX2
922 return _mm256_mullo_epi32(a, b);
923#else
924 const __m128i lo = _mm_mullo_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
925 const __m128i hi = _mm_mullo_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
926 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
927#endif
928}
929template <>
930EIGEN_STRONG_INLINE Packet8ui pmul<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
931#ifdef EIGEN_VECTORIZE_AVX2
932 return _mm256_mullo_epi32(a, b);
933#else
934 const __m128i lo = _mm_mullo_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
935 const __m128i hi = _mm_mullo_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
936 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
937#endif
938}
939
940template <>
941EIGEN_STRONG_INLINE Packet8f pdiv<Packet8f>(const Packet8f& a, const Packet8f& b) {
942 return _mm256_div_ps(a, b);
943}
944template <>
945EIGEN_STRONG_INLINE Packet4d pdiv<Packet4d>(const Packet4d& a, const Packet4d& b) {
946 return _mm256_div_pd(a, b);
947}
948
949template <>
950EIGEN_STRONG_INLINE Packet8i pdiv<Packet8i>(const Packet8i& a, const Packet8i& b) {
951#ifdef EIGEN_VECTORIZE_AVX512
952 return _mm512_cvttpd_epi32(_mm512_div_pd(_mm512_cvtepi32_pd(a), _mm512_cvtepi32_pd(b)));
953#else
954 Packet4i lo = pdiv<Packet4i>(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
955 Packet4i hi = pdiv<Packet4i>(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
956 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1);
957#endif
958}
959
960#ifdef EIGEN_VECTORIZE_FMA
961template <>
962EIGEN_STRONG_INLINE Packet8f pmadd(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
963 return _mm256_fmadd_ps(a, b, c);
964}
965template <>
966EIGEN_STRONG_INLINE Packet4d pmadd(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
967 return _mm256_fmadd_pd(a, b, c);
968}
969
970template <>
971EIGEN_STRONG_INLINE Packet8f pmsub(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
972 return _mm256_fmsub_ps(a, b, c);
973}
974
975template <>
976EIGEN_STRONG_INLINE Packet4d pmsub(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
977 return _mm256_fmsub_pd(a, b, c);
978}
979
980template <>
981EIGEN_STRONG_INLINE Packet8f pnmadd(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
982 return _mm256_fnmadd_ps(a, b, c);
983}
984
985template <>
986EIGEN_STRONG_INLINE Packet4d pnmadd(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
987 return _mm256_fnmadd_pd(a, b, c);
988}
989
990template <>
991EIGEN_STRONG_INLINE Packet8f pnmsub(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
992 return _mm256_fnmsub_ps(a, b, c);
993}
994
995template <>
996EIGEN_STRONG_INLINE Packet4d pnmsub(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
997 return _mm256_fnmsub_pd(a, b, c);
998}
999
1000#endif
1001
1002template <>
1003EIGEN_STRONG_INLINE Packet8f pcmp_le(const Packet8f& a, const Packet8f& b) {
1004 return _mm256_cmp_ps(a, b, _CMP_LE_OQ);
1005}
1006template <>
1007EIGEN_STRONG_INLINE Packet8f pcmp_lt(const Packet8f& a, const Packet8f& b) {
1008 return _mm256_cmp_ps(a, b, _CMP_LT_OQ);
1009}
1010template <>
1011EIGEN_STRONG_INLINE Packet8f pcmp_lt_or_nan(const Packet8f& a, const Packet8f& b) {
1012 return _mm256_cmp_ps(a, b, _CMP_NGE_UQ);
1013}
1014template <>
1015EIGEN_STRONG_INLINE Packet8f pcmp_eq(const Packet8f& a, const Packet8f& b) {
1016 return _mm256_cmp_ps(a, b, _CMP_EQ_OQ);
1017}
1018template <>
1019EIGEN_STRONG_INLINE Packet8f pisnan(const Packet8f& a) {
1020 return _mm256_cmp_ps(a, a, _CMP_UNORD_Q);
1021}
1022
1023template <>
1024EIGEN_STRONG_INLINE Packet4d pcmp_le(const Packet4d& a, const Packet4d& b) {
1025 return _mm256_cmp_pd(a, b, _CMP_LE_OQ);
1026}
1027template <>
1028EIGEN_STRONG_INLINE Packet4d pcmp_lt(const Packet4d& a, const Packet4d& b) {
1029 return _mm256_cmp_pd(a, b, _CMP_LT_OQ);
1030}
1031template <>
1032EIGEN_STRONG_INLINE Packet4d pcmp_lt_or_nan(const Packet4d& a, const Packet4d& b) {
1033 return _mm256_cmp_pd(a, b, _CMP_NGE_UQ);
1034}
1035template <>
1036EIGEN_STRONG_INLINE Packet4d pcmp_eq(const Packet4d& a, const Packet4d& b) {
1037 return _mm256_cmp_pd(a, b, _CMP_EQ_OQ);
1038}
1039
1040template <>
1041EIGEN_STRONG_INLINE Packet8i pcmp_le(const Packet8i& a, const Packet8i& b) {
1042#ifdef EIGEN_VECTORIZE_AVX2
1043 return _mm256_xor_si256(_mm256_cmpgt_epi32(a, b), _mm256_set1_epi32(-1));
1044#else
1045 __m128i lo = _mm_cmpgt_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1046 lo = _mm_xor_si128(lo, _mm_set1_epi32(-1));
1047 __m128i hi = _mm_cmpgt_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1048 hi = _mm_xor_si128(hi, _mm_set1_epi32(-1));
1049 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1050#endif
1051}
1052template <>
1053EIGEN_STRONG_INLINE Packet8i pcmp_lt(const Packet8i& a, const Packet8i& b) {
1054#ifdef EIGEN_VECTORIZE_AVX2
1055 return _mm256_cmpgt_epi32(b, a);
1056#else
1057 __m128i lo = _mm_cmpgt_epi32(_mm256_extractf128_si256(b, 0), _mm256_extractf128_si256(a, 0));
1058 __m128i hi = _mm_cmpgt_epi32(_mm256_extractf128_si256(b, 1), _mm256_extractf128_si256(a, 1));
1059 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1060#endif
1061}
1062template <>
1063EIGEN_STRONG_INLINE Packet8i pcmp_eq(const Packet8i& a, const Packet8i& b) {
1064#ifdef EIGEN_VECTORIZE_AVX2
1065 return _mm256_cmpeq_epi32(a, b);
1066#else
1067 __m128i lo = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1068 __m128i hi = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1069 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1070#endif
1071}
1072template <>
1073EIGEN_STRONG_INLINE Packet8ui pcmp_eq(const Packet8ui& a, const Packet8ui& b) {
1074#ifdef EIGEN_VECTORIZE_AVX2
1075 return _mm256_cmpeq_epi32(a, b);
1076#else
1077 __m128i lo = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1078 __m128i hi = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1079 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1080#endif
1081}
1082
1083template <>
1084EIGEN_STRONG_INLINE Packet8f pmin<Packet8f>(const Packet8f& a, const Packet8f& b) {
1085#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
1086 // There appears to be a bug in GCC, by which the optimizer may flip
1087 // the argument order in calls to _mm_min_ps/_mm_max_ps, so we have to
1088 // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
1089 // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
1090 Packet8f res;
1091 asm("vminps %[a], %[b], %[res]" : [res] "=x"(res) : [a] "x"(a), [b] "x"(b));
1092 return res;
1093#else
1094 // Arguments are swapped to match NaN propagation behavior of std::min.
1095 return _mm256_min_ps(b, a);
1096#endif
1097}
1098template <>
1099EIGEN_STRONG_INLINE Packet4d pmin<Packet4d>(const Packet4d& a, const Packet4d& b) {
1100#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
1101 // See pmin above
1102 Packet4d res;
1103 asm("vminpd %[a], %[b], %[res]" : [res] "=x"(res) : [a] "x"(a), [b] "x"(b));
1104 return res;
1105#else
1106 // Arguments are swapped to match NaN propagation behavior of std::min.
1107 return _mm256_min_pd(b, a);
1108#endif
1109}
1110template <>
1111EIGEN_STRONG_INLINE Packet8i pmin<Packet8i>(const Packet8i& a, const Packet8i& b) {
1112#ifdef EIGEN_VECTORIZE_AVX2
1113 return _mm256_min_epi32(a, b);
1114#else
1115 __m128i lo = _mm_min_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1116 __m128i hi = _mm_min_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1117 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1118#endif
1119}
1120template <>
1121EIGEN_STRONG_INLINE Packet8ui pmin<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
1122#ifdef EIGEN_VECTORIZE_AVX2
1123 return _mm256_min_epu32(a, b);
1124#else
1125 __m128i lo = _mm_min_epu32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1126 __m128i hi = _mm_min_epu32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1127 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1128#endif
1129}
1130
1131template <>
1132EIGEN_STRONG_INLINE Packet8f pmax<Packet8f>(const Packet8f& a, const Packet8f& b) {
1133#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
1134 // See pmin above
1135 Packet8f res;
1136 asm("vmaxps %[a], %[b], %[res]" : [res] "=x"(res) : [a] "x"(a), [b] "x"(b));
1137 return res;
1138#else
1139 // Arguments are swapped to match NaN propagation behavior of std::max.
1140 return _mm256_max_ps(b, a);
1141#endif
1142}
1143template <>
1144EIGEN_STRONG_INLINE Packet4d pmax<Packet4d>(const Packet4d& a, const Packet4d& b) {
1145#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
1146 // See pmin above
1147 Packet4d res;
1148 asm("vmaxpd %[a], %[b], %[res]" : [res] "=x"(res) : [a] "x"(a), [b] "x"(b));
1149 return res;
1150#else
1151 // Arguments are swapped to match NaN propagation behavior of std::max.
1152 return _mm256_max_pd(b, a);
1153#endif
1154}
1155template <>
1156EIGEN_STRONG_INLINE Packet8i pmax<Packet8i>(const Packet8i& a, const Packet8i& b) {
1157#ifdef EIGEN_VECTORIZE_AVX2
1158 return _mm256_max_epi32(a, b);
1159#else
1160 __m128i lo = _mm_max_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1161 __m128i hi = _mm_max_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1162 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1163#endif
1164}
1165template <>
1166EIGEN_STRONG_INLINE Packet8ui pmax<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
1167#ifdef EIGEN_VECTORIZE_AVX2
1168 return _mm256_max_epu32(a, b);
1169#else
1170 __m128i lo = _mm_max_epu32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
1171 __m128i hi = _mm_max_epu32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
1172 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1173#endif
1174}
1175
1176#ifdef EIGEN_VECTORIZE_AVX2
1177template <>
1178EIGEN_STRONG_INLINE Packet8i psign(const Packet8i& a) {
1179 return _mm256_sign_epi32(_mm256_set1_epi32(1), a);
1180}
1181#endif
1182
1183// Add specializations for min/max with prescribed NaN propagation.
1184template <>
1185EIGEN_STRONG_INLINE Packet8f pmin<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) {
1186 return pminmax_propagate_numbers(a, b, pmin<Packet8f>);
1187}
1188template <>
1189EIGEN_STRONG_INLINE Packet4d pmin<PropagateNumbers, Packet4d>(const Packet4d& a, const Packet4d& b) {
1190 return pminmax_propagate_numbers(a, b, pmin<Packet4d>);
1191}
1192template <>
1193EIGEN_STRONG_INLINE Packet8f pmax<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) {
1194 return pminmax_propagate_numbers(a, b, pmax<Packet8f>);
1195}
1196template <>
1197EIGEN_STRONG_INLINE Packet4d pmax<PropagateNumbers, Packet4d>(const Packet4d& a, const Packet4d& b) {
1198 return pminmax_propagate_numbers(a, b, pmax<Packet4d>);
1199}
1200template <>
1201EIGEN_STRONG_INLINE Packet8f pmin<PropagateNaN, Packet8f>(const Packet8f& a, const Packet8f& b) {
1202 return pminmax_propagate_nan(a, b, pmin<Packet8f>);
1203}
1204template <>
1205EIGEN_STRONG_INLINE Packet4d pmin<PropagateNaN, Packet4d>(const Packet4d& a, const Packet4d& b) {
1206 return pminmax_propagate_nan(a, b, pmin<Packet4d>);
1207}
1208template <>
1209EIGEN_STRONG_INLINE Packet8f pmax<PropagateNaN, Packet8f>(const Packet8f& a, const Packet8f& b) {
1210 return pminmax_propagate_nan(a, b, pmax<Packet8f>);
1211}
1212template <>
1213EIGEN_STRONG_INLINE Packet4d pmax<PropagateNaN, Packet4d>(const Packet4d& a, const Packet4d& b) {
1214 return pminmax_propagate_nan(a, b, pmax<Packet4d>);
1215}
1216
1217template <>
1218EIGEN_STRONG_INLINE Packet8f print<Packet8f>(const Packet8f& a) {
1219 return _mm256_round_ps(a, _MM_FROUND_CUR_DIRECTION);
1220}
1221template <>
1222EIGEN_STRONG_INLINE Packet4d print<Packet4d>(const Packet4d& a) {
1223 return _mm256_round_pd(a, _MM_FROUND_CUR_DIRECTION);
1224}
1225
1226template <>
1227EIGEN_STRONG_INLINE Packet8f pceil<Packet8f>(const Packet8f& a) {
1228 return _mm256_ceil_ps(a);
1229}
1230template <>
1231EIGEN_STRONG_INLINE Packet4d pceil<Packet4d>(const Packet4d& a) {
1232 return _mm256_ceil_pd(a);
1233}
1234
1235template <>
1236EIGEN_STRONG_INLINE Packet8f pfloor<Packet8f>(const Packet8f& a) {
1237 return _mm256_floor_ps(a);
1238}
1239template <>
1240EIGEN_STRONG_INLINE Packet4d pfloor<Packet4d>(const Packet4d& a) {
1241 return _mm256_floor_pd(a);
1242}
1243
1244template <>
1245EIGEN_STRONG_INLINE Packet8f ptrunc<Packet8f>(const Packet8f& a) {
1246 return _mm256_round_ps(a, _MM_FROUND_TRUNC);
1247}
1248template <>
1249EIGEN_STRONG_INLINE Packet4d ptrunc<Packet4d>(const Packet4d& a) {
1250 return _mm256_round_pd(a, _MM_FROUND_TRUNC);
1251}
1252
1253template <>
1254EIGEN_STRONG_INLINE Packet8i ptrue<Packet8i>(const Packet8i& a) {
1255#ifdef EIGEN_VECTORIZE_AVX2
1256 // vpcmpeqd has lower latency than the more general vcmpps
1257 return _mm256_cmpeq_epi32(a, a);
1258#else
1259 const __m256 b = _mm256_castsi256_ps(a);
1260 return _mm256_castps_si256(_mm256_cmp_ps(b, b, _CMP_TRUE_UQ));
1261#endif
1262}
1263
1264template <>
1265EIGEN_STRONG_INLINE Packet8f ptrue<Packet8f>(const Packet8f& a) {
1266#ifdef EIGEN_VECTORIZE_AVX2
1267 // vpcmpeqd has lower latency than the more general vcmpps
1268 const __m256i b = _mm256_castps_si256(a);
1269 return _mm256_castsi256_ps(_mm256_cmpeq_epi32(b, b));
1270#else
1271 return _mm256_cmp_ps(a, a, _CMP_TRUE_UQ);
1272#endif
1273}
1274
1275template <>
1276EIGEN_STRONG_INLINE Packet4d ptrue<Packet4d>(const Packet4d& a) {
1277#ifdef EIGEN_VECTORIZE_AVX2
1278 // vpcmpeqq has lower latency than the more general vcmppd
1279 const __m256i b = _mm256_castpd_si256(a);
1280 return _mm256_castsi256_pd(_mm256_cmpeq_epi64(b, b));
1281#else
1282 return _mm256_cmp_pd(a, a, _CMP_TRUE_UQ);
1283#endif
1284}
1285
1286template <>
1287EIGEN_STRONG_INLINE Packet8f pand<Packet8f>(const Packet8f& a, const Packet8f& b) {
1288 return _mm256_and_ps(a, b);
1289}
1290template <>
1291EIGEN_STRONG_INLINE Packet4d pand<Packet4d>(const Packet4d& a, const Packet4d& b) {
1292 return _mm256_and_pd(a, b);
1293}
1294template <>
1295EIGEN_STRONG_INLINE Packet8i pand<Packet8i>(const Packet8i& a, const Packet8i& b) {
1296#ifdef EIGEN_VECTORIZE_AVX2
1297 return _mm256_and_si256(a, b);
1298#else
1299 return _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
1300#endif
1301}
1302template <>
1303EIGEN_STRONG_INLINE Packet8ui pand<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
1304#ifdef EIGEN_VECTORIZE_AVX2
1305 return _mm256_and_si256(a, b);
1306#else
1307 return _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
1308#endif
1309}
1310
1311template <>
1312EIGEN_STRONG_INLINE Packet8f por<Packet8f>(const Packet8f& a, const Packet8f& b) {
1313 return _mm256_or_ps(a, b);
1314}
1315template <>
1316EIGEN_STRONG_INLINE Packet4d por<Packet4d>(const Packet4d& a, const Packet4d& b) {
1317 return _mm256_or_pd(a, b);
1318}
1319template <>
1320EIGEN_STRONG_INLINE Packet8i por<Packet8i>(const Packet8i& a, const Packet8i& b) {
1321#ifdef EIGEN_VECTORIZE_AVX2
1322 return _mm256_or_si256(a, b);
1323#else
1324 return _mm256_castps_si256(_mm256_or_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
1325#endif
1326}
1327template <>
1328EIGEN_STRONG_INLINE Packet8ui por<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
1329#ifdef EIGEN_VECTORIZE_AVX2
1330 return _mm256_or_si256(a, b);
1331#else
1332 return _mm256_castps_si256(_mm256_or_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
1333#endif
1334}
1335
1336template <>
1337EIGEN_STRONG_INLINE Packet8f pxor<Packet8f>(const Packet8f& a, const Packet8f& b) {
1338 return _mm256_xor_ps(a, b);
1339}
1340template <>
1341EIGEN_STRONG_INLINE Packet4d pxor<Packet4d>(const Packet4d& a, const Packet4d& b) {
1342 return _mm256_xor_pd(a, b);
1343}
1344template <>
1345EIGEN_STRONG_INLINE Packet8i pxor<Packet8i>(const Packet8i& a, const Packet8i& b) {
1346#ifdef EIGEN_VECTORIZE_AVX2
1347 return _mm256_xor_si256(a, b);
1348#else
1349 return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
1350#endif
1351}
1352template <>
1353EIGEN_STRONG_INLINE Packet8ui pxor<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
1354#ifdef EIGEN_VECTORIZE_AVX2
1355 return _mm256_xor_si256(a, b);
1356#else
1357 return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
1358#endif
1359}
1360
1361template <>
1362EIGEN_STRONG_INLINE Packet8f pandnot<Packet8f>(const Packet8f& a, const Packet8f& b) {
1363 return _mm256_andnot_ps(b, a);
1364}
1365template <>
1366EIGEN_STRONG_INLINE Packet4d pandnot<Packet4d>(const Packet4d& a, const Packet4d& b) {
1367 return _mm256_andnot_pd(b, a);
1368}
1369template <>
1370EIGEN_STRONG_INLINE Packet8i pandnot<Packet8i>(const Packet8i& a, const Packet8i& b) {
1371#ifdef EIGEN_VECTORIZE_AVX2
1372 return _mm256_andnot_si256(b, a);
1373#else
1374 return _mm256_castps_si256(_mm256_andnot_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(a)));
1375#endif
1376}
1377template <>
1378EIGEN_STRONG_INLINE Packet8ui pandnot<Packet8ui>(const Packet8ui& a, const Packet8ui& b) {
1379#ifdef EIGEN_VECTORIZE_AVX2
1380 return _mm256_andnot_si256(b, a);
1381#else
1382 return _mm256_castps_si256(_mm256_andnot_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(a)));
1383#endif
1384}
1385
1386template <>
1387EIGEN_STRONG_INLINE Packet8ui pcmp_lt(const Packet8ui& a, const Packet8ui& b) {
1388 return pxor(pcmp_eq(a, pmax(a, b)), ptrue(a));
1389}
1390template <>
1391EIGEN_STRONG_INLINE Packet8ui pcmp_le(const Packet8ui& a, const Packet8ui& b) {
1392 return pcmp_eq(a, pmin(a, b));
1393}
1394
1395template <>
1396EIGEN_STRONG_INLINE Packet8f pround<Packet8f>(const Packet8f& a) {
1397 const Packet8f mask = pset1frombits<Packet8f>(static_cast<numext::uint32_t>(0x80000000u));
1398 const Packet8f prev0dot5 = pset1frombits<Packet8f>(static_cast<numext::uint32_t>(0x3EFFFFFFu));
1399 return _mm256_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
1400}
1401template <>
1402EIGEN_STRONG_INLINE Packet4d pround<Packet4d>(const Packet4d& a) {
1403 const Packet4d mask = pset1frombits<Packet4d>(static_cast<numext::uint64_t>(0x8000000000000000ull));
1404 const Packet4d prev0dot5 = pset1frombits<Packet4d>(static_cast<numext::uint64_t>(0x3FDFFFFFFFFFFFFFull));
1405 return _mm256_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
1406}
1407
1408template <>
1409EIGEN_STRONG_INLINE Packet8f pselect<Packet8f>(const Packet8f& mask, const Packet8f& a, const Packet8f& b) {
1410 return _mm256_blendv_ps(b, a, mask);
1411}
1412template <>
1413EIGEN_STRONG_INLINE Packet8i pselect<Packet8i>(const Packet8i& mask, const Packet8i& a, const Packet8i& b) {
1414 return _mm256_castps_si256(
1415 _mm256_blendv_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(a), _mm256_castsi256_ps(mask)));
1416}
1417template <>
1418EIGEN_STRONG_INLINE Packet8ui pselect<Packet8ui>(const Packet8ui& mask, const Packet8ui& a, const Packet8ui& b) {
1419 return _mm256_castps_si256(
1420 _mm256_blendv_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(a), _mm256_castsi256_ps(mask)));
1421}
1422
1423template <>
1424EIGEN_STRONG_INLINE Packet4d pselect<Packet4d>(const Packet4d& mask, const Packet4d& a, const Packet4d& b) {
1425 return _mm256_blendv_pd(b, a, mask);
1426}
1427
1428template <int N>
1429EIGEN_STRONG_INLINE Packet8i parithmetic_shift_right(Packet8i a) {
1430#ifdef EIGEN_VECTORIZE_AVX2
1431 return _mm256_srai_epi32(a, N);
1432#else
1433 __m128i lo = _mm_srai_epi32(_mm256_extractf128_si256(a, 0), N);
1434 __m128i hi = _mm_srai_epi32(_mm256_extractf128_si256(a, 1), N);
1435 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1436#endif
1437}
1438
1439template <int N>
1440EIGEN_STRONG_INLINE Packet8i plogical_shift_right(Packet8i a) {
1441#ifdef EIGEN_VECTORIZE_AVX2
1442 return _mm256_srli_epi32(a, N);
1443#else
1444 __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(a, 0), N);
1445 __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(a, 1), N);
1446 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1447#endif
1448}
1449
1450template <int N>
1451EIGEN_STRONG_INLINE Packet8i plogical_shift_left(Packet8i a) {
1452#ifdef EIGEN_VECTORIZE_AVX2
1453 return _mm256_slli_epi32(a, N);
1454#else
1455 __m128i lo = _mm_slli_epi32(_mm256_extractf128_si256(a, 0), N);
1456 __m128i hi = _mm_slli_epi32(_mm256_extractf128_si256(a, 1), N);
1457 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1458#endif
1459}
1460
1461template <int N>
1462EIGEN_STRONG_INLINE Packet8ui parithmetic_shift_right(Packet8ui a) {
1463 return (Packet8ui)plogical_shift_right<N>((Packet8i)a);
1464}
1465template <int N>
1466EIGEN_STRONG_INLINE Packet8ui plogical_shift_right(Packet8ui a) {
1467 return (Packet8ui)plogical_shift_right<N>((Packet8i)a);
1468}
1469template <int N>
1470EIGEN_STRONG_INLINE Packet8ui plogical_shift_left(Packet8ui a) {
1471 return (Packet8ui)plogical_shift_left<N>((Packet8i)a);
1472}
1473
1474template <>
1475EIGEN_STRONG_INLINE Packet8f pload<Packet8f>(const float* from) {
1476 EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_ps(from);
1477}
1478template <>
1479EIGEN_STRONG_INLINE Packet4d pload<Packet4d>(const double* from) {
1480 EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_pd(from);
1481}
1482template <>
1483EIGEN_STRONG_INLINE Packet8i pload<Packet8i>(const int* from) {
1484 EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
1485}
1486template <>
1487EIGEN_STRONG_INLINE Packet8ui pload<Packet8ui>(const uint32_t* from) {
1488 EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
1489}
1490
1491template <>
1492EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from) {
1493 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_ps(from);
1494}
1495template <>
1496EIGEN_STRONG_INLINE Packet4d ploadu<Packet4d>(const double* from) {
1497 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_pd(from);
1498}
1499template <>
1500EIGEN_STRONG_INLINE Packet8i ploadu<Packet8i>(const int* from) {
1501 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
1502}
1503template <>
1504EIGEN_STRONG_INLINE Packet8ui ploadu<Packet8ui>(const uint32_t* from) {
1505 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
1506}
1507
1508template <>
1509EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from, uint8_t umask) {
1510#ifdef EIGEN_VECTORIZE_AVX512
1511 __mmask16 mask = static_cast<__mmask16>(umask & 0x00FF);
1512 EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_castps512_ps256(_mm512_maskz_loadu_ps(mask, from));
1513#else
1514 Packet8i mask = _mm256_set1_epi8(static_cast<char>(umask));
1515 const Packet8i bit_mask =
1516 _mm256_set_epi32(0xffffff7f, 0xffffffbf, 0xffffffdf, 0xffffffef, 0xfffffff7, 0xfffffffb, 0xfffffffd, 0xfffffffe);
1517 mask = por<Packet8i>(mask, bit_mask);
1518 mask = pcmp_eq<Packet8i>(mask, _mm256_set1_epi32(0xffffffff));
1519 EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_maskload_ps(from, mask);
1520#endif
1521}
1522
1523// Loads 4 floats from memory a returns the packet {a0, a0 a1, a1, a2, a2, a3, a3}
1524template <>
1525EIGEN_STRONG_INLINE Packet8f ploaddup<Packet8f>(const float* from) {
1526 // TODO try to find a way to avoid the need of a temporary register
1527 // Packet8f tmp = _mm256_castps128_ps256(_mm_loadu_ps(from));
1528 // tmp = _mm256_insertf128_ps(tmp, _mm_movehl_ps(_mm256_castps256_ps128(tmp),_mm256_castps256_ps128(tmp)), 1);
1529 // return _mm256_unpacklo_ps(tmp,tmp);
1530
1531 // _mm256_insertf128_ps is very slow on Haswell, thus:
1532 Packet8f tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
1533 // mimic an "inplace" permutation of the lower 128bits using a blend
1534 tmp = _mm256_blend_ps(
1535 tmp, _mm256_castps128_ps256(_mm_permute_ps(_mm256_castps256_ps128(tmp), _MM_SHUFFLE(1, 0, 1, 0))), 15);
1536 // then we can perform a consistent permutation on the global register to get everything in shape:
1537 return _mm256_permute_ps(tmp, _MM_SHUFFLE(3, 3, 2, 2));
1538}
1539// Loads 2 doubles from memory a returns the packet {a0, a0, a1, a1}
1540template <>
1541EIGEN_STRONG_INLINE Packet4d ploaddup<Packet4d>(const double* from) {
1542 Packet4d tmp = _mm256_broadcast_pd((const __m128d*)(const void*)from);
1543 return _mm256_permute_pd(tmp, 3 << 2);
1544}
1545// Loads 4 integers from memory a returns the packet {a0, a0, a1, a1, a2, a2, a3, a3}
1546template <>
1547EIGEN_STRONG_INLINE Packet8i ploaddup<Packet8i>(const int* from) {
1548#ifdef EIGEN_VECTORIZE_AVX2
1549 const Packet8i a = _mm256_castsi128_si256(ploadu<Packet4i>(from));
1550 return _mm256_permutevar8x32_epi32(a, _mm256_setr_epi32(0, 0, 1, 1, 2, 2, 3, 3));
1551#else
1552 __m256 tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
1553 // mimic an "inplace" permutation of the lower 128bits using a blend
1554 tmp = _mm256_blend_ps(
1555 tmp, _mm256_castps128_ps256(_mm_permute_ps(_mm256_castps256_ps128(tmp), _MM_SHUFFLE(1, 0, 1, 0))), 15);
1556 // then we can perform a consistent permutation on the global register to get everything in shape:
1557 return _mm256_castps_si256(_mm256_permute_ps(tmp, _MM_SHUFFLE(3, 3, 2, 2)));
1558#endif
1559}
1560template <>
1561EIGEN_STRONG_INLINE Packet8ui ploaddup<Packet8ui>(const uint32_t* from) {
1562#ifdef EIGEN_VECTORIZE_AVX2
1563 const Packet8ui a = _mm256_castsi128_si256(ploadu<Packet4ui>(from));
1564 return _mm256_permutevar8x32_epi32(a, _mm256_setr_epi32(0, 0, 1, 1, 2, 2, 3, 3));
1565#else
1566 __m256 tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
1567 // mimic an "inplace" permutation of the lower 128bits using a blend
1568 tmp = _mm256_blend_ps(
1569 tmp, _mm256_castps128_ps256(_mm_permute_ps(_mm256_castps256_ps128(tmp), _MM_SHUFFLE(1, 0, 1, 0))), 15);
1570 // then we can perform a consistent permutation on the global register to get
1571 // everything in shape:
1572 return _mm256_castps_si256(_mm256_permute_ps(tmp, _MM_SHUFFLE(3, 3, 2, 2)));
1573#endif
1574}
1575
1576// Loads 2 floats from memory a returns the packet {a0, a0 a0, a0, a1, a1, a1, a1}
1577template <>
1578EIGEN_STRONG_INLINE Packet8f ploadquad<Packet8f>(const float* from) {
1579 Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
1580 return _mm256_insertf128_ps(tmp, _mm_broadcast_ss(from + 1), 1);
1581}
1582template <>
1583EIGEN_STRONG_INLINE Packet8i ploadquad<Packet8i>(const int* from) {
1584 return _mm256_insertf128_si256(_mm256_set1_epi32(*from), _mm_set1_epi32(*(from + 1)), 1);
1585}
1586template <>
1587EIGEN_STRONG_INLINE Packet8ui ploadquad<Packet8ui>(const uint32_t* from) {
1588 return _mm256_insertf128_si256(_mm256_set1_epi32(*from), _mm_set1_epi32(*(from + 1)), 1);
1589}
1590
1591template <>
1592EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet8f& from) {
1593 EIGEN_DEBUG_ALIGNED_STORE _mm256_store_ps(to, from);
1594}
1595template <>
1596EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet4d& from) {
1597 EIGEN_DEBUG_ALIGNED_STORE _mm256_store_pd(to, from);
1598}
1599template <>
1600EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet8i& from) {
1601 EIGEN_DEBUG_ALIGNED_STORE _mm256_store_si256(reinterpret_cast<__m256i*>(to), from);
1602}
1603template <>
1604EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet8ui& from) {
1605 EIGEN_DEBUG_ALIGNED_STORE _mm256_store_si256(reinterpret_cast<__m256i*>(to), from);
1606}
1607
1608template <>
1609EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet8f& from) {
1610 EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_ps(to, from);
1611}
1612template <>
1613EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet4d& from) {
1614 EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_pd(to, from);
1615}
1616template <>
1617EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet8i& from) {
1618 EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from);
1619}
1620template <>
1621EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet8ui& from) {
1622 EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from);
1623}
1624
1625template <>
1626EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet8f& from, uint8_t umask) {
1627#ifdef EIGEN_VECTORIZE_AVX512
1628 __mmask16 mask = static_cast<__mmask16>(umask & 0x00FF);
1629 EIGEN_DEBUG_UNALIGNED_STORE _mm512_mask_storeu_ps(to, mask, _mm512_castps256_ps512(from));
1630#else
1631 Packet8i mask = _mm256_set1_epi8(static_cast<char>(umask));
1632 const Packet8i bit_mask =
1633 _mm256_set_epi32(0x7f7f7f7f, 0xbfbfbfbf, 0xdfdfdfdf, 0xefefefef, 0xf7f7f7f7, 0xfbfbfbfb, 0xfdfdfdfd, 0xfefefefe);
1634 mask = por<Packet8i>(mask, bit_mask);
1635 mask = pcmp_eq<Packet8i>(mask, _mm256_set1_epi32(0xffffffff));
1636#if EIGEN_COMP_MSVC
1637 // MSVC sometimes seems to use a bogus mask with maskstore.
1638 const __m256i ifrom = _mm256_castps_si256(from);
1639 EIGEN_DEBUG_UNALIGNED_STORE _mm_maskmoveu_si128(_mm256_extractf128_si256(ifrom, 0), _mm256_extractf128_si256(mask, 0),
1640 reinterpret_cast<char*>(to));
1641 EIGEN_DEBUG_UNALIGNED_STORE _mm_maskmoveu_si128(_mm256_extractf128_si256(ifrom, 1), _mm256_extractf128_si256(mask, 1),
1642 reinterpret_cast<char*>(to + 4));
1643#else
1644 EIGEN_DEBUG_UNALIGNED_STORE _mm256_maskstore_ps(to, mask, from);
1645#endif
1646#endif
1647}
1648
1649// NOTE: leverage _mm256_i32gather_ps and _mm256_i32gather_pd if AVX2 instructions are available
1650// NOTE: for the record the following seems to be slower: return _mm256_i32gather_ps(from, _mm256_set1_epi32(stride),
1651// 4);
1652template <>
1653EIGEN_DEVICE_FUNC inline Packet8f pgather<float, Packet8f>(const float* from, Index stride) {
1654 return _mm256_set_ps(from[7 * stride], from[6 * stride], from[5 * stride], from[4 * stride], from[3 * stride],
1655 from[2 * stride], from[1 * stride], from[0 * stride]);
1656}
1657template <>
1658EIGEN_DEVICE_FUNC inline Packet4d pgather<double, Packet4d>(const double* from, Index stride) {
1659 return _mm256_set_pd(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
1660}
1661template <>
1662EIGEN_DEVICE_FUNC inline Packet8i pgather<int, Packet8i>(const int* from, Index stride) {
1663 return _mm256_set_epi32(from[7 * stride], from[6 * stride], from[5 * stride], from[4 * stride], from[3 * stride],
1664 from[2 * stride], from[1 * stride], from[0 * stride]);
1665}
1666template <>
1667EIGEN_DEVICE_FUNC inline Packet8ui pgather<uint32_t, Packet8ui>(const uint32_t* from, Index stride) {
1668 return (Packet8ui)pgather<int, Packet8i>((int*)from, stride);
1669}
1670
1671template <>
1672EIGEN_DEVICE_FUNC inline void pscatter<float, Packet8f>(float* to, const Packet8f& from, Index stride) {
1673 __m128 low = _mm256_extractf128_ps(from, 0);
1674 to[stride * 0] = _mm_cvtss_f32(low);
1675 to[stride * 1] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1));
1676 to[stride * 2] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 2));
1677 to[stride * 3] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3));
1678
1679 __m128 high = _mm256_extractf128_ps(from, 1);
1680 to[stride * 4] = _mm_cvtss_f32(high);
1681 to[stride * 5] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1));
1682 to[stride * 6] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 2));
1683 to[stride * 7] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3));
1684}
1685template <>
1686EIGEN_DEVICE_FUNC inline void pscatter<double, Packet4d>(double* to, const Packet4d& from, Index stride) {
1687 __m128d low = _mm256_extractf128_pd(from, 0);
1688 to[stride * 0] = _mm_cvtsd_f64(low);
1689 to[stride * 1] = _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1));
1690 __m128d high = _mm256_extractf128_pd(from, 1);
1691 to[stride * 2] = _mm_cvtsd_f64(high);
1692 to[stride * 3] = _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1));
1693}
1694template <>
1695EIGEN_DEVICE_FUNC inline void pscatter<int, Packet8i>(int* to, const Packet8i& from, Index stride) {
1696 __m128i low = _mm256_extractf128_si256(from, 0);
1697 to[stride * 0] = _mm_extract_epi32(low, 0);
1698 to[stride * 1] = _mm_extract_epi32(low, 1);
1699 to[stride * 2] = _mm_extract_epi32(low, 2);
1700 to[stride * 3] = _mm_extract_epi32(low, 3);
1701
1702 __m128i high = _mm256_extractf128_si256(from, 1);
1703 to[stride * 4] = _mm_extract_epi32(high, 0);
1704 to[stride * 5] = _mm_extract_epi32(high, 1);
1705 to[stride * 6] = _mm_extract_epi32(high, 2);
1706 to[stride * 7] = _mm_extract_epi32(high, 3);
1707}
1708template <>
1709EIGEN_DEVICE_FUNC inline void pscatter<uint32_t, Packet8ui>(uint32_t* to, const Packet8ui& from, Index stride) {
1710 pscatter<int, Packet8i>((int*)to, (Packet8i)from, stride);
1711}
1712
1713template <>
1714EIGEN_STRONG_INLINE void pstore1<Packet8f>(float* to, const float& a) {
1715 Packet8f pa = pset1<Packet8f>(a);
1716 pstore(to, pa);
1717}
1718template <>
1719EIGEN_STRONG_INLINE void pstore1<Packet4d>(double* to, const double& a) {
1720 Packet4d pa = pset1<Packet4d>(a);
1721 pstore(to, pa);
1722}
1723template <>
1724EIGEN_STRONG_INLINE void pstore1<Packet8i>(int* to, const int& a) {
1725 Packet8i pa = pset1<Packet8i>(a);
1726 pstore(to, pa);
1727}
1728
1729#ifndef EIGEN_VECTORIZE_AVX512
1730template <>
1731EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) {
1732 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1733}
1734template <>
1735EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) {
1736 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1737}
1738template <>
1739EIGEN_STRONG_INLINE void prefetch<int>(const int* addr) {
1740 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1741}
1742template <>
1743EIGEN_STRONG_INLINE void prefetch<uint32_t>(const uint32_t* addr) {
1744 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1745}
1746#endif
1747
1748template <>
1749EIGEN_STRONG_INLINE float pfirst<Packet8f>(const Packet8f& a) {
1750 return _mm_cvtss_f32(_mm256_castps256_ps128(a));
1751}
1752template <>
1753EIGEN_STRONG_INLINE double pfirst<Packet4d>(const Packet4d& a) {
1754 return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));
1755}
1756template <>
1757EIGEN_STRONG_INLINE int pfirst<Packet8i>(const Packet8i& a) {
1758 return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
1759}
1760template <>
1761EIGEN_STRONG_INLINE uint32_t pfirst<Packet8ui>(const Packet8ui& a) {
1762 return numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(_mm256_castsi256_si128(a)));
1763}
1764
1765template <>
1766EIGEN_STRONG_INLINE Packet8f preverse(const Packet8f& a) {
1767 __m256 tmp = _mm256_shuffle_ps(a, a, 0x1b);
1768 return _mm256_permute2f128_ps(tmp, tmp, 1);
1769}
1770template <>
1771EIGEN_STRONG_INLINE Packet4d preverse(const Packet4d& a) {
1772 __m256d tmp = _mm256_shuffle_pd(a, a, 5);
1773 return _mm256_permute2f128_pd(tmp, tmp, 1);
1774#if 0
1775 // This version is unlikely to be faster as _mm256_shuffle_ps and _mm256_permute_pd
1776 // exhibit the same latency/throughput, but it is here for future reference/benchmarking...
1777 __m256d swap_halves = _mm256_permute2f128_pd(a,a,1);
1778 return _mm256_permute_pd(swap_halves,5);
1779#endif
1780}
1781template <>
1782EIGEN_STRONG_INLINE Packet8i preverse(const Packet8i& a) {
1783 return _mm256_castps_si256(preverse(_mm256_castsi256_ps(a)));
1784}
1785template <>
1786EIGEN_STRONG_INLINE Packet8ui preverse(const Packet8ui& a) {
1787 return _mm256_castps_si256(preverse(_mm256_castsi256_ps(a)));
1788}
1789
1790#ifdef EIGEN_VECTORIZE_AVX2
1791template <>
1792EIGEN_STRONG_INLINE Packet4l preverse(const Packet4l& a) {
1793 return _mm256_castpd_si256(preverse(_mm256_castsi256_pd(a)));
1794}
1795template <>
1796EIGEN_STRONG_INLINE Packet4ul preverse(const Packet4ul& a) {
1797 return _mm256_castpd_si256(preverse(_mm256_castsi256_pd(a)));
1798}
1799#endif
1800
1801// pabs should be ok
1802template <>
1803EIGEN_STRONG_INLINE Packet8f pabs(const Packet8f& a) {
1804 const Packet8f mask = _mm256_castsi256_ps(_mm256_set1_epi32(0x7FFFFFFF));
1805 return _mm256_and_ps(a, mask);
1806}
1807template <>
1808EIGEN_STRONG_INLINE Packet4d pabs(const Packet4d& a) {
1809 const Packet4d mask = _mm256_castsi256_pd(_mm256_set1_epi64x(0x7FFFFFFFFFFFFFFF));
1810 return _mm256_and_pd(a, mask);
1811}
1812template <>
1813EIGEN_STRONG_INLINE Packet8i pabs(const Packet8i& a) {
1814#ifdef EIGEN_VECTORIZE_AVX2
1815 return _mm256_abs_epi32(a);
1816#else
1817 __m128i lo = _mm_abs_epi32(_mm256_extractf128_si256(a, 0));
1818 __m128i hi = _mm_abs_epi32(_mm256_extractf128_si256(a, 1));
1819 return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
1820#endif
1821}
1822template <>
1823EIGEN_STRONG_INLINE Packet8ui pabs(const Packet8ui& a) {
1824 return a;
1825}
1826
1827#ifndef EIGEN_VECTORIZE_AVX512FP16
1828template <>
1829EIGEN_STRONG_INLINE Packet8h psignbit(const Packet8h& a) {
1830 return _mm_cmpgt_epi16(_mm_setzero_si128(), a);
1831}
1832#endif // EIGEN_VECTORIZE_AVX512FP16
1833
1834template <>
1835EIGEN_STRONG_INLINE Packet8bf psignbit(const Packet8bf& a) {
1836 return _mm_cmpgt_epi16(_mm_setzero_si128(), a);
1837}
1838template <>
1839EIGEN_STRONG_INLINE Packet8f psignbit(const Packet8f& a) {
1840#ifdef EIGEN_VECTORIZE_AVX2
1841 return _mm256_castsi256_ps(_mm256_cmpgt_epi32(_mm256_setzero_si256(), _mm256_castps_si256(a)));
1842#else
1843 return _mm256_castsi256_ps(parithmetic_shift_right<31>(Packet8i(_mm256_castps_si256(a))));
1844#endif
1845}
1846template <>
1847EIGEN_STRONG_INLINE Packet8ui psignbit(const Packet8ui& /*unused*/) {
1848 return _mm256_setzero_si256();
1849}
1850#ifdef EIGEN_VECTORIZE_AVX2
1851template <>
1852EIGEN_STRONG_INLINE Packet4d psignbit(const Packet4d& a) {
1853 return _mm256_castsi256_pd(_mm256_cmpgt_epi64(_mm256_setzero_si256(), _mm256_castpd_si256(a)));
1854}
1855template <>
1856EIGEN_STRONG_INLINE Packet4ul psignbit(const Packet4ul& /*unused*/) {
1857 return _mm256_setzero_si256();
1858}
1859#endif
1860
1861template <>
1862EIGEN_STRONG_INLINE Packet8f pfrexp<Packet8f>(const Packet8f& a, Packet8f& exponent) {
1863 return pfrexp_generic(a, exponent);
1864}
1865
1866// Extract exponent without existence of Packet4l.
1867template <>
1868EIGEN_STRONG_INLINE Packet4d pfrexp_generic_get_biased_exponent(const Packet4d& a) {
1869 const Packet4d cst_exp_mask = pset1frombits<Packet4d>(static_cast<uint64_t>(0x7ff0000000000000ull));
1870 __m256i a_expo = _mm256_castpd_si256(pand(a, cst_exp_mask));
1871#ifdef EIGEN_VECTORIZE_AVX2
1872 a_expo = _mm256_srli_epi64(a_expo, 52);
1873 __m128i lo = _mm256_extractf128_si256(a_expo, 0);
1874 __m128i hi = _mm256_extractf128_si256(a_expo, 1);
1875#else
1876 __m128i lo = _mm256_extractf128_si256(a_expo, 0);
1877 __m128i hi = _mm256_extractf128_si256(a_expo, 1);
1878 lo = _mm_srli_epi64(lo, 52);
1879 hi = _mm_srli_epi64(hi, 52);
1880#endif
1881 Packet2d exponent_lo = _mm_cvtepi32_pd(vec4i_swizzle1(lo, 0, 2, 1, 3));
1882 Packet2d exponent_hi = _mm_cvtepi32_pd(vec4i_swizzle1(hi, 0, 2, 1, 3));
1883 Packet4d exponent = _mm256_insertf128_pd(_mm256_setzero_pd(), exponent_lo, 0);
1884 exponent = _mm256_insertf128_pd(exponent, exponent_hi, 1);
1885 return exponent;
1886}
1887
1888template <>
1889EIGEN_STRONG_INLINE Packet4d pfrexp<Packet4d>(const Packet4d& a, Packet4d& exponent) {
1890 return pfrexp_generic(a, exponent);
1891}
1892
1893template <>
1894EIGEN_STRONG_INLINE Packet8f pldexp<Packet8f>(const Packet8f& a, const Packet8f& exponent) {
1895 return pldexp_generic(a, exponent);
1896}
1897
1898template <>
1899EIGEN_STRONG_INLINE Packet4d pldexp<Packet4d>(const Packet4d& a, const Packet4d& exponent) {
1900 // Clamp exponent to [-2099, 2099]
1901 const Packet4d max_exponent = pset1<Packet4d>(2099.0);
1902 const Packet4i e = _mm256_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
1903
1904 // Split 2^e into four factors and multiply.
1905 const Packet4i bias = pset1<Packet4i>(1023);
1906 Packet4i b = parithmetic_shift_right<2>(e); // floor(e/4)
1907
1908 // 2^b
1909 Packet4i hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
1910 Packet4i lo = _mm_slli_epi64(hi, 52);
1911 hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
1912 Packet4d c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
1913 Packet4d out = pmul(pmul(pmul(a, c), c), c); // a * 2^(3b)
1914
1915 // 2^(e - 3b)
1916 b = psub(psub(psub(e, b), b), b); // e - 3b
1917 hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
1918 lo = _mm_slli_epi64(hi, 52);
1919 hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
1920 c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
1921 out = pmul(out, c); // a * 2^e
1922 return out;
1923}
1924
1925template <>
1926EIGEN_STRONG_INLINE Packet4d pldexp_fast<Packet4d>(const Packet4d& a, const Packet4d& exponent) {
1927 // Clamp exponent to [-1024, 1024]
1928 const Packet4d min_exponent = pset1<Packet4d>(-1023.0);
1929 const Packet4d max_exponent = pset1<Packet4d>(1024.0);
1930 const Packet4i e = _mm256_cvtpd_epi32(pmin(pmax(exponent, min_exponent), max_exponent));
1931 const Packet4i bias = pset1<Packet4i>(1023);
1932
1933 // 2^e
1934 Packet4i hi = vec4i_swizzle1(padd(e, bias), 0, 2, 1, 3);
1935 const Packet4i lo = _mm_slli_epi64(hi, 52);
1936 hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
1937 const Packet4d c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
1938 return pmul(a, c); // a * 2^e
1939}
1940
1941template <>
1942EIGEN_STRONG_INLINE Packet4f predux_half_dowto4<Packet8f>(const Packet8f& a) {
1943 return _mm_add_ps(_mm256_castps256_ps128(a), _mm256_extractf128_ps(a, 1));
1944}
1945template <>
1946EIGEN_STRONG_INLINE Packet4i predux_half_dowto4<Packet8i>(const Packet8i& a) {
1947 return _mm_add_epi32(_mm256_castsi256_si128(a), _mm256_extractf128_si256(a, 1));
1948}
1949template <>
1950EIGEN_STRONG_INLINE Packet4ui predux_half_dowto4<Packet8ui>(const Packet8ui& a) {
1951 return _mm_add_epi32(_mm256_castsi256_si128(a), _mm256_extractf128_si256(a, 1));
1952}
1953
1954EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8f, 8>& kernel) {
1955 __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
1956 __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
1957 __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
1958 __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
1959 __m256 T4 = _mm256_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
1960 __m256 T5 = _mm256_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
1961 __m256 T6 = _mm256_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
1962 __m256 T7 = _mm256_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
1963 __m256 S0 = _mm256_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
1964 __m256 S1 = _mm256_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
1965 __m256 S2 = _mm256_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
1966 __m256 S3 = _mm256_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
1967 __m256 S4 = _mm256_shuffle_ps(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
1968 __m256 S5 = _mm256_shuffle_ps(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
1969 __m256 S6 = _mm256_shuffle_ps(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
1970 __m256 S7 = _mm256_shuffle_ps(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
1971 kernel.packet[0] = _mm256_permute2f128_ps(S0, S4, 0x20);
1972 kernel.packet[1] = _mm256_permute2f128_ps(S1, S5, 0x20);
1973 kernel.packet[2] = _mm256_permute2f128_ps(S2, S6, 0x20);
1974 kernel.packet[3] = _mm256_permute2f128_ps(S3, S7, 0x20);
1975 kernel.packet[4] = _mm256_permute2f128_ps(S0, S4, 0x31);
1976 kernel.packet[5] = _mm256_permute2f128_ps(S1, S5, 0x31);
1977 kernel.packet[6] = _mm256_permute2f128_ps(S2, S6, 0x31);
1978 kernel.packet[7] = _mm256_permute2f128_ps(S3, S7, 0x31);
1979}
1980
1981EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8f, 4>& kernel) {
1982 __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
1983 __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
1984 __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
1985 __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
1986
1987 __m256 S0 = _mm256_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
1988 __m256 S1 = _mm256_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
1989 __m256 S2 = _mm256_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
1990 __m256 S3 = _mm256_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
1991
1992 kernel.packet[0] = _mm256_permute2f128_ps(S0, S1, 0x20);
1993 kernel.packet[1] = _mm256_permute2f128_ps(S2, S3, 0x20);
1994 kernel.packet[2] = _mm256_permute2f128_ps(S0, S1, 0x31);
1995 kernel.packet[3] = _mm256_permute2f128_ps(S2, S3, 0x31);
1996}
1997
1998#define MM256_SHUFFLE_EPI32(A, B, M) \
1999 _mm256_castps_si256(_mm256_shuffle_ps(_mm256_castsi256_ps(A), _mm256_castsi256_ps(B), M))
2000
2001#ifndef EIGEN_VECTORIZE_AVX2
2002#define MM256_UNPACKLO_EPI32(A, B) \
2003 _mm256_castps_si256(_mm256_unpacklo_ps(_mm256_castsi256_ps(A), _mm256_castsi256_ps(B)))
2004#define MM256_UNPACKHI_EPI32(A, B) \
2005 _mm256_castps_si256(_mm256_unpackhi_ps(_mm256_castsi256_ps(A), _mm256_castsi256_ps(B)))
2006#else
2007#define MM256_UNPACKLO_EPI32(A, B) _mm256_unpacklo_epi32(A, B)
2008#define MM256_UNPACKHI_EPI32(A, B) _mm256_unpackhi_epi32(A, B)
2009#endif
2010
2011EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8i, 8>& kernel) {
2012 __m256i T0 = MM256_UNPACKLO_EPI32(kernel.packet[0], kernel.packet[1]);
2013 __m256i T1 = MM256_UNPACKHI_EPI32(kernel.packet[0], kernel.packet[1]);
2014 __m256i T2 = MM256_UNPACKLO_EPI32(kernel.packet[2], kernel.packet[3]);
2015 __m256i T3 = MM256_UNPACKHI_EPI32(kernel.packet[2], kernel.packet[3]);
2016 __m256i T4 = MM256_UNPACKLO_EPI32(kernel.packet[4], kernel.packet[5]);
2017 __m256i T5 = MM256_UNPACKHI_EPI32(kernel.packet[4], kernel.packet[5]);
2018 __m256i T6 = MM256_UNPACKLO_EPI32(kernel.packet[6], kernel.packet[7]);
2019 __m256i T7 = MM256_UNPACKHI_EPI32(kernel.packet[6], kernel.packet[7]);
2020 __m256i S0 = MM256_SHUFFLE_EPI32(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
2021 __m256i S1 = MM256_SHUFFLE_EPI32(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
2022 __m256i S2 = MM256_SHUFFLE_EPI32(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
2023 __m256i S3 = MM256_SHUFFLE_EPI32(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
2024 __m256i S4 = MM256_SHUFFLE_EPI32(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
2025 __m256i S5 = MM256_SHUFFLE_EPI32(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
2026 __m256i S6 = MM256_SHUFFLE_EPI32(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
2027 __m256i S7 = MM256_SHUFFLE_EPI32(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
2028 kernel.packet[0] = _mm256_permute2f128_si256(S0, S4, 0x20);
2029 kernel.packet[1] = _mm256_permute2f128_si256(S1, S5, 0x20);
2030 kernel.packet[2] = _mm256_permute2f128_si256(S2, S6, 0x20);
2031 kernel.packet[3] = _mm256_permute2f128_si256(S3, S7, 0x20);
2032 kernel.packet[4] = _mm256_permute2f128_si256(S0, S4, 0x31);
2033 kernel.packet[5] = _mm256_permute2f128_si256(S1, S5, 0x31);
2034 kernel.packet[6] = _mm256_permute2f128_si256(S2, S6, 0x31);
2035 kernel.packet[7] = _mm256_permute2f128_si256(S3, S7, 0x31);
2036}
2037EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8ui, 8>& kernel) {
2038 ptranspose((PacketBlock<Packet8i, 8>&)kernel);
2039}
2040
2041EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8i, 4>& kernel) {
2042 __m256i T0 = MM256_UNPACKLO_EPI32(kernel.packet[0], kernel.packet[1]);
2043 __m256i T1 = MM256_UNPACKHI_EPI32(kernel.packet[0], kernel.packet[1]);
2044 __m256i T2 = MM256_UNPACKLO_EPI32(kernel.packet[2], kernel.packet[3]);
2045 __m256i T3 = MM256_UNPACKHI_EPI32(kernel.packet[2], kernel.packet[3]);
2046
2047 __m256i S0 = MM256_SHUFFLE_EPI32(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
2048 __m256i S1 = MM256_SHUFFLE_EPI32(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
2049 __m256i S2 = MM256_SHUFFLE_EPI32(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
2050 __m256i S3 = MM256_SHUFFLE_EPI32(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
2051
2052 kernel.packet[0] = _mm256_permute2f128_si256(S0, S1, 0x20);
2053 kernel.packet[1] = _mm256_permute2f128_si256(S2, S3, 0x20);
2054 kernel.packet[2] = _mm256_permute2f128_si256(S0, S1, 0x31);
2055 kernel.packet[3] = _mm256_permute2f128_si256(S2, S3, 0x31);
2056}
2057EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8ui, 4>& kernel) {
2058 ptranspose((PacketBlock<Packet8i, 4>&)kernel);
2059}
2060
2061EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4d, 4>& kernel) {
2062 __m256d T0 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 15);
2063 __m256d T1 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
2064 __m256d T2 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 15);
2065 __m256d T3 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
2066
2067 kernel.packet[1] = _mm256_permute2f128_pd(T0, T2, 32);
2068 kernel.packet[3] = _mm256_permute2f128_pd(T0, T2, 49);
2069 kernel.packet[0] = _mm256_permute2f128_pd(T1, T3, 32);
2070 kernel.packet[2] = _mm256_permute2f128_pd(T1, T3, 49);
2071}
2072
2073EIGEN_STRONG_INLINE __m256i avx_blend_mask(const Selector<4>& ifPacket) {
2074 return _mm256_set_epi64x(0 - ifPacket.select[3], 0 - ifPacket.select[2], 0 - ifPacket.select[1],
2075 0 - ifPacket.select[0]);
2076}
2077
2078EIGEN_STRONG_INLINE __m256i avx_blend_mask(const Selector<8>& ifPacket) {
2079 return _mm256_set_epi32(0 - ifPacket.select[7], 0 - ifPacket.select[6], 0 - ifPacket.select[5],
2080 0 - ifPacket.select[4], 0 - ifPacket.select[3], 0 - ifPacket.select[2],
2081 0 - ifPacket.select[1], 0 - ifPacket.select[0]);
2082}
2083
2084template <>
2085EIGEN_STRONG_INLINE Packet8f pblend(const Selector<8>& ifPacket, const Packet8f& thenPacket,
2086 const Packet8f& elsePacket) {
2087 const __m256 true_mask = _mm256_castsi256_ps(avx_blend_mask(ifPacket));
2088 return pselect<Packet8f>(true_mask, thenPacket, elsePacket);
2089}
2090
2091template <>
2092EIGEN_STRONG_INLINE Packet4d pblend(const Selector<4>& ifPacket, const Packet4d& thenPacket,
2093 const Packet4d& elsePacket) {
2094 const __m256d true_mask = _mm256_castsi256_pd(avx_blend_mask(ifPacket));
2095 return pselect<Packet4d>(true_mask, thenPacket, elsePacket);
2096}
2097
2098// Packet math for Eigen::half
2099#ifndef EIGEN_VECTORIZE_AVX512FP16
2100template <>
2101struct unpacket_traits<Packet8h> {
2102 typedef Eigen::half type;
2103 enum {
2104 size = 8,
2105 alignment = Aligned16,
2106 vectorizable = true,
2107 masked_load_available = false,
2108 masked_store_available = false
2109 };
2110 typedef Packet8h half;
2111};
2112
2113template <>
2114EIGEN_STRONG_INLINE Packet8h pset1<Packet8h>(const Eigen::half& from) {
2115 return _mm_set1_epi16(numext::bit_cast<numext::uint16_t>(from));
2116}
2117
2118template <>
2119EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8h>(const Packet8h& from) {
2120 return numext::bit_cast<Eigen::half>(static_cast<numext::uint16_t>(_mm_extract_epi16(from, 0)));
2121}
2122
2123template <>
2124EIGEN_STRONG_INLINE Packet8h pload<Packet8h>(const Eigen::half* from) {
2125 return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
2126}
2127
2128template <>
2129EIGEN_STRONG_INLINE Packet8h ploadu<Packet8h>(const Eigen::half* from) {
2130 return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
2131}
2132
2133template <>
2134EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8h& from) {
2135 _mm_store_si128(reinterpret_cast<__m128i*>(to), from);
2136}
2137
2138template <>
2139EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8h& from) {
2140 _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from);
2141}
2142
2143template <>
2144EIGEN_STRONG_INLINE Packet8h ploaddup<Packet8h>(const Eigen::half* from) {
2145 const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
2146 const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
2147 const numext::uint16_t c = numext::bit_cast<numext::uint16_t>(from[2]);
2148 const numext::uint16_t d = numext::bit_cast<numext::uint16_t>(from[3]);
2149 return _mm_set_epi16(d, d, c, c, b, b, a, a);
2150}
2151
2152template <>
2153EIGEN_STRONG_INLINE Packet8h ploadquad<Packet8h>(const Eigen::half* from) {
2154 const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
2155 const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
2156 return _mm_set_epi16(b, b, b, b, a, a, a, a);
2157}
2158
2159template <>
2160EIGEN_STRONG_INLINE Packet8h ptrue(const Packet8h& a) {
2161 return _mm_cmpeq_epi32(a, a);
2162}
2163
2164template <>
2165EIGEN_STRONG_INLINE Packet8h pabs(const Packet8h& a) {
2166 const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
2167 return _mm_andnot_si128(sign_mask, a);
2168}
2169
2170EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
2171#ifdef EIGEN_HAS_FP16_C
2172 return _mm256_cvtph_ps(a);
2173#else
2174 Eigen::internal::Packet8f pp = _mm256_castsi256_ps(
2175 _mm256_insertf128_si256(_mm256_castsi128_si256(half2floatsse(a)), half2floatsse(_mm_srli_si128(a, 8)), 1));
2176 return pp;
2177#endif
2178}
2179
2180EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
2181#ifdef EIGEN_HAS_FP16_C
2182 return _mm256_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT);
2183#else
2184 __m128i lo = float2half(_mm256_extractf128_ps(a, 0));
2185 __m128i hi = float2half(_mm256_extractf128_ps(a, 1));
2186 return _mm_packus_epi32(lo, hi);
2187#endif
2188}
2189
2190template <>
2191EIGEN_STRONG_INLINE Packet8h pmin<Packet8h>(const Packet8h& a, const Packet8h& b) {
2192 return float2half(pmin<Packet8f>(half2float(a), half2float(b)));
2193}
2194
2195template <>
2196EIGEN_STRONG_INLINE Packet8h pmax<Packet8h>(const Packet8h& a, const Packet8h& b) {
2197 return float2half(pmax<Packet8f>(half2float(a), half2float(b)));
2198}
2199
2200template <>
2201EIGEN_STRONG_INLINE Packet8h plset<Packet8h>(const half& a) {
2202 return float2half(plset<Packet8f>(static_cast<float>(a)));
2203}
2204
2205template <>
2206EIGEN_STRONG_INLINE Packet8h por(const Packet8h& a, const Packet8h& b) {
2207 // in some cases Packet4i is a wrapper around __m128i, so we either need to
2208 // cast to Packet4i to directly call the intrinsics as below:
2209 return _mm_or_si128(a, b);
2210}
2211template <>
2212EIGEN_STRONG_INLINE Packet8h pxor(const Packet8h& a, const Packet8h& b) {
2213 return _mm_xor_si128(a, b);
2214}
2215template <>
2216EIGEN_STRONG_INLINE Packet8h pand(const Packet8h& a, const Packet8h& b) {
2217 return _mm_and_si128(a, b);
2218}
2219template <>
2220EIGEN_STRONG_INLINE Packet8h pandnot(const Packet8h& a, const Packet8h& b) {
2221 return _mm_andnot_si128(b, a);
2222}
2223
2224template <>
2225EIGEN_STRONG_INLINE Packet8h pselect(const Packet8h& mask, const Packet8h& a, const Packet8h& b) {
2226 return _mm_blendv_epi8(b, a, mask);
2227}
2228
2229template <>
2230EIGEN_STRONG_INLINE Packet8h pround<Packet8h>(const Packet8h& a) {
2231 return float2half(pround<Packet8f>(half2float(a)));
2232}
2233
2234template <>
2235EIGEN_STRONG_INLINE Packet8h print<Packet8h>(const Packet8h& a) {
2236 return float2half(print<Packet8f>(half2float(a)));
2237}
2238
2239template <>
2240EIGEN_STRONG_INLINE Packet8h pceil<Packet8h>(const Packet8h& a) {
2241 return float2half(pceil<Packet8f>(half2float(a)));
2242}
2243
2244template <>
2245EIGEN_STRONG_INLINE Packet8h pfloor<Packet8h>(const Packet8h& a) {
2246 return float2half(pfloor<Packet8f>(half2float(a)));
2247}
2248
2249template <>
2250EIGEN_STRONG_INLINE Packet8h ptrunc<Packet8h>(const Packet8h& a) {
2251 return float2half(ptrunc<Packet8f>(half2float(a)));
2252}
2253
2254template <>
2255EIGEN_STRONG_INLINE Packet8h pisinf<Packet8h>(const Packet8h& a) {
2256 constexpr uint16_t kInf = ((1 << 5) - 1) << 10;
2257 constexpr uint16_t kAbsMask = (1 << 15) - 1;
2258 return _mm_cmpeq_epi16(_mm_and_si128(a.m_val, _mm_set1_epi16(kAbsMask)), _mm_set1_epi16(kInf));
2259}
2260
2261template <>
2262EIGEN_STRONG_INLINE Packet8h pisnan<Packet8h>(const Packet8h& a) {
2263 constexpr uint16_t kInf = ((1 << 5) - 1) << 10;
2264 constexpr uint16_t kAbsMask = (1 << 15) - 1;
2265 return _mm_cmpgt_epi16(_mm_and_si128(a.m_val, _mm_set1_epi16(kAbsMask)), _mm_set1_epi16(kInf));
2266}
2267
2268// convert the sign-magnitude representation to two's complement
2269EIGEN_STRONG_INLINE __m128i pmaptosigned(const __m128i& a) {
2270 constexpr uint16_t kAbsMask = (1 << 15) - 1;
2271 // if 'a' has the sign bit set, clear the sign bit and negate the result as if it were an integer
2272 return _mm_sign_epi16(_mm_and_si128(a, _mm_set1_epi16(kAbsMask)), a);
2273}
2274
2275// return true if both `a` and `b` are not NaN
2276EIGEN_STRONG_INLINE Packet8h pisordered(const Packet8h& a, const Packet8h& b) {
2277 constexpr uint16_t kInf = ((1 << 5) - 1) << 10;
2278 constexpr uint16_t kAbsMask = (1 << 15) - 1;
2279 __m128i abs_a = _mm_and_si128(a.m_val, _mm_set1_epi16(kAbsMask));
2280 __m128i abs_b = _mm_and_si128(b.m_val, _mm_set1_epi16(kAbsMask));
2281 // check if both `abs_a <= kInf` and `abs_b <= kInf` by checking if max(abs_a, abs_b) <= kInf
2282 // SSE has no `lesser or equal` instruction for integers, but comparing against kInf + 1 accomplishes the same goal
2283 return _mm_cmplt_epi16(_mm_max_epu16(abs_a, abs_b), _mm_set1_epi16(kInf + 1));
2284}
2285
2286template <>
2287EIGEN_STRONG_INLINE Packet8h pcmp_eq(const Packet8h& a, const Packet8h& b) {
2288 __m128i isOrdered = pisordered(a, b);
2289 __m128i isEqual = _mm_cmpeq_epi16(pmaptosigned(a.m_val), pmaptosigned(b.m_val));
2290 return _mm_and_si128(isOrdered, isEqual);
2291}
2292
2293template <>
2294EIGEN_STRONG_INLINE Packet8h pcmp_le(const Packet8h& a, const Packet8h& b) {
2295 __m128i isOrdered = pisordered(a, b);
2296 __m128i isGreater = _mm_cmpgt_epi16(pmaptosigned(a.m_val), pmaptosigned(b.m_val));
2297 return _mm_andnot_si128(isGreater, isOrdered);
2298}
2299
2300template <>
2301EIGEN_STRONG_INLINE Packet8h pcmp_lt(const Packet8h& a, const Packet8h& b) {
2302 __m128i isOrdered = pisordered(a, b);
2303 __m128i isLess = _mm_cmplt_epi16(pmaptosigned(a.m_val), pmaptosigned(b.m_val));
2304 return _mm_and_si128(isOrdered, isLess);
2305}
2306
2307template <>
2308EIGEN_STRONG_INLINE Packet8h pcmp_lt_or_nan(const Packet8h& a, const Packet8h& b) {
2309 __m128i isUnordered = por(pisnan(a), pisnan(b));
2310 __m128i isLess = _mm_cmplt_epi16(pmaptosigned(a.m_val), pmaptosigned(b.m_val));
2311 return _mm_or_si128(isUnordered, isLess);
2312}
2313
2314template <>
2315EIGEN_STRONG_INLINE Packet8h pconj(const Packet8h& a) {
2316 return a;
2317}
2318
2319template <>
2320EIGEN_STRONG_INLINE Packet8h pnegate(const Packet8h& a) {
2321 Packet8h sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
2322 return _mm_xor_si128(a, sign_mask);
2323}
2324
2325#ifndef EIGEN_VECTORIZE_AVX512FP16
2326template <>
2327EIGEN_STRONG_INLINE Packet8h padd<Packet8h>(const Packet8h& a, const Packet8h& b) {
2328 Packet8f af = half2float(a);
2329 Packet8f bf = half2float(b);
2330 Packet8f rf = padd(af, bf);
2331 return float2half(rf);
2332}
2333
2334template <>
2335EIGEN_STRONG_INLINE Packet8h psub<Packet8h>(const Packet8h& a, const Packet8h& b) {
2336 Packet8f af = half2float(a);
2337 Packet8f bf = half2float(b);
2338 Packet8f rf = psub(af, bf);
2339 return float2half(rf);
2340}
2341
2342template <>
2343EIGEN_STRONG_INLINE Packet8h pmul<Packet8h>(const Packet8h& a, const Packet8h& b) {
2344 Packet8f af = half2float(a);
2345 Packet8f bf = half2float(b);
2346 Packet8f rf = pmul(af, bf);
2347 return float2half(rf);
2348}
2349
2350template <>
2351EIGEN_STRONG_INLINE Packet8h pmadd<Packet8h>(const Packet8h& a, const Packet8h& b, const Packet8h& c) {
2352 return float2half(pmadd(half2float(a), half2float(b), half2float(c)));
2353}
2354
2355template <>
2356EIGEN_STRONG_INLINE Packet8h pmsub<Packet8h>(const Packet8h& a, const Packet8h& b, const Packet8h& c) {
2357 return float2half(pmsub(half2float(a), half2float(b), half2float(c)));
2358}
2359
2360template <>
2361EIGEN_STRONG_INLINE Packet8h pnmadd<Packet8h>(const Packet8h& a, const Packet8h& b, const Packet8h& c) {
2362 return float2half(pnmadd(half2float(a), half2float(b), half2float(c)));
2363}
2364
2365template <>
2366EIGEN_STRONG_INLINE Packet8h pnmsub<Packet8h>(const Packet8h& a, const Packet8h& b, const Packet8h& c) {
2367 return float2half(pnmsub(half2float(a), half2float(b), half2float(c)));
2368}
2369
2370template <>
2371EIGEN_STRONG_INLINE Packet8h pdiv<Packet8h>(const Packet8h& a, const Packet8h& b) {
2372 Packet8f af = half2float(a);
2373 Packet8f bf = half2float(b);
2374 Packet8f rf = pdiv(af, bf);
2375 return float2half(rf);
2376}
2377#endif
2378
2379template <>
2380EIGEN_STRONG_INLINE Packet8h pgather<Eigen::half, Packet8h>(const Eigen::half* from, Index stride) {
2381 const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(from[0 * stride]);
2382 const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(from[1 * stride]);
2383 const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(from[2 * stride]);
2384 const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(from[3 * stride]);
2385 const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(from[4 * stride]);
2386 const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(from[5 * stride]);
2387 const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(from[6 * stride]);
2388 const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(from[7 * stride]);
2389 return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
2390}
2391
2392template <>
2393EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8h>(Eigen::half* to, const Packet8h& from, Index stride) {
2394 EIGEN_ALIGN32 Eigen::half aux[8];
2395 pstore(aux, from);
2396 to[stride * 0] = aux[0];
2397 to[stride * 1] = aux[1];
2398 to[stride * 2] = aux[2];
2399 to[stride * 3] = aux[3];
2400 to[stride * 4] = aux[4];
2401 to[stride * 5] = aux[5];
2402 to[stride * 6] = aux[6];
2403 to[stride * 7] = aux[7];
2404}
2405
2406template <>
2407EIGEN_STRONG_INLINE Packet8h preverse(const Packet8h& a) {
2408 __m128i m = _mm_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
2409 return _mm_shuffle_epi8(a, m);
2410}
2411
2412EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8h, 8>& kernel) {
2413 __m128i a = kernel.packet[0];
2414 __m128i b = kernel.packet[1];
2415 __m128i c = kernel.packet[2];
2416 __m128i d = kernel.packet[3];
2417 __m128i e = kernel.packet[4];
2418 __m128i f = kernel.packet[5];
2419 __m128i g = kernel.packet[6];
2420 __m128i h = kernel.packet[7];
2421
2422 __m128i a03b03 = _mm_unpacklo_epi16(a, b);
2423 __m128i c03d03 = _mm_unpacklo_epi16(c, d);
2424 __m128i e03f03 = _mm_unpacklo_epi16(e, f);
2425 __m128i g03h03 = _mm_unpacklo_epi16(g, h);
2426 __m128i a47b47 = _mm_unpackhi_epi16(a, b);
2427 __m128i c47d47 = _mm_unpackhi_epi16(c, d);
2428 __m128i e47f47 = _mm_unpackhi_epi16(e, f);
2429 __m128i g47h47 = _mm_unpackhi_epi16(g, h);
2430
2431 __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
2432 __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
2433 __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
2434 __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
2435 __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
2436 __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
2437 __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
2438 __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
2439
2440 __m128i a0b0c0d0e0f0g0h0 = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
2441 __m128i a1b1c1d1e1f1g1h1 = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
2442 __m128i a2b2c2d2e2f2g2h2 = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
2443 __m128i a3b3c3d3e3f3g3h3 = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
2444 __m128i a4b4c4d4e4f4g4h4 = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
2445 __m128i a5b5c5d5e5f5g5h5 = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
2446 __m128i a6b6c6d6e6f6g6h6 = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
2447 __m128i a7b7c7d7e7f7g7h7 = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
2448
2449 kernel.packet[0] = a0b0c0d0e0f0g0h0;
2450 kernel.packet[1] = a1b1c1d1e1f1g1h1;
2451 kernel.packet[2] = a2b2c2d2e2f2g2h2;
2452 kernel.packet[3] = a3b3c3d3e3f3g3h3;
2453 kernel.packet[4] = a4b4c4d4e4f4g4h4;
2454 kernel.packet[5] = a5b5c5d5e5f5g5h5;
2455 kernel.packet[6] = a6b6c6d6e6f6g6h6;
2456 kernel.packet[7] = a7b7c7d7e7f7g7h7;
2457}
2458
2459EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8h, 4>& kernel) {
2460 EIGEN_ALIGN32 Eigen::half in[4][8];
2461 pstore<Eigen::half>(in[0], kernel.packet[0]);
2462 pstore<Eigen::half>(in[1], kernel.packet[1]);
2463 pstore<Eigen::half>(in[2], kernel.packet[2]);
2464 pstore<Eigen::half>(in[3], kernel.packet[3]);
2465
2466 EIGEN_ALIGN32 Eigen::half out[4][8];
2467
2468 for (int i = 0; i < 4; ++i) {
2469 for (int j = 0; j < 4; ++j) {
2470 out[i][j] = in[j][2 * i];
2471 }
2472 for (int j = 0; j < 4; ++j) {
2473 out[i][j + 4] = in[j][2 * i + 1];
2474 }
2475 }
2476
2477 kernel.packet[0] = pload<Packet8h>(out[0]);
2478 kernel.packet[1] = pload<Packet8h>(out[1]);
2479 kernel.packet[2] = pload<Packet8h>(out[2]);
2480 kernel.packet[3] = pload<Packet8h>(out[3]);
2481}
2482
2483#endif
2484
2485// BFloat16 implementation.
2486
2487EIGEN_STRONG_INLINE Packet8f Bf16ToF32(const Packet8bf& a) {
2488#ifdef EIGEN_VECTORIZE_AVX2
2489 __m256i extend = _mm256_cvtepu16_epi32(a);
2490 return _mm256_castsi256_ps(_mm256_slli_epi32(extend, 16));
2491#else
2492 __m128i lo = _mm_cvtepu16_epi32(a);
2493 __m128i hi = _mm_cvtepu16_epi32(_mm_srli_si128(a, 8));
2494 __m128i lo_shift = _mm_slli_epi32(lo, 16);
2495 __m128i hi_shift = _mm_slli_epi32(hi, 16);
2496 return _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(lo_shift), hi_shift, 1));
2497#endif
2498}
2499
2500// Convert float to bfloat16 according to round-to-nearest-even/denormals algorithm.
2501EIGEN_STRONG_INLINE Packet8bf F32ToBf16(const Packet8f& a) {
2502 __m256i input = _mm256_castps_si256(a);
2503
2504#ifdef EIGEN_VECTORIZE_AVX2
2505 // uint32_t lsb = (input >> 16);
2506 __m256i t = _mm256_srli_epi32(input, 16);
2507 // uint32_t lsb = lsb & 1;
2508 t = _mm256_and_si256(t, _mm256_set1_epi32(1));
2509 // uint32_t rounding_bias = 0x7fff + lsb;
2510 t = _mm256_add_epi32(t, _mm256_set1_epi32(0x7fff));
2511 // input += rounding_bias;
2512 t = _mm256_add_epi32(t, input);
2513 // input = input >> 16;
2514 t = _mm256_srli_epi32(t, 16);
2515 // Check NaN before converting back to bf16
2516 __m256 mask = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
2517 __m256i nan = _mm256_set1_epi32(0x7fc0);
2518 t = _mm256_blendv_epi8(nan, t, _mm256_castps_si256(mask));
2519 // output = numext::bit_cast<uint16_t>(input);
2520 return _mm_packus_epi32(_mm256_extractf128_si256(t, 0), _mm256_extractf128_si256(t, 1));
2521#else
2522 // uint32_t lsb = (input >> 16);
2523 __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(input, 0), 16);
2524 __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(input, 1), 16);
2525 // uint32_t lsb = lsb & 1;
2526 lo = _mm_and_si128(lo, _mm_set1_epi32(1));
2527 hi = _mm_and_si128(hi, _mm_set1_epi32(1));
2528 // uint32_t rounding_bias = 0x7fff + lsb;
2529 lo = _mm_add_epi32(lo, _mm_set1_epi32(0x7fff));
2530 hi = _mm_add_epi32(hi, _mm_set1_epi32(0x7fff));
2531 // input += rounding_bias;
2532 lo = _mm_add_epi32(lo, _mm256_extractf128_si256(input, 0));
2533 hi = _mm_add_epi32(hi, _mm256_extractf128_si256(input, 1));
2534 // input = input >> 16;
2535 lo = _mm_srli_epi32(lo, 16);
2536 hi = _mm_srli_epi32(hi, 16);
2537 // Check NaN before converting back to bf16
2538 __m256 mask = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
2539 __m128i nan = _mm_set1_epi32(0x7fc0);
2540 lo = _mm_blendv_epi8(nan, lo, _mm_castps_si128(_mm256_castps256_ps128(mask)));
2541 hi = _mm_blendv_epi8(nan, hi, _mm_castps_si128(_mm256_extractf128_ps(mask, 1)));
2542 // output = numext::bit_cast<uint16_t>(input);
2543 return _mm_packus_epi32(lo, hi);
2544#endif
2545}
2546
2547template <>
2548EIGEN_STRONG_INLINE Packet8bf pset1<Packet8bf>(const bfloat16& from) {
2549 return _mm_set1_epi16(numext::bit_cast<numext::uint16_t>(from));
2550}
2551
2552template <>
2553EIGEN_STRONG_INLINE bfloat16 pfirst<Packet8bf>(const Packet8bf& from) {
2554 return numext::bit_cast<bfloat16>(static_cast<numext::uint16_t>(_mm_extract_epi16(from, 0)));
2555}
2556
2557template <>
2558EIGEN_STRONG_INLINE Packet8bf pload<Packet8bf>(const bfloat16* from) {
2559 return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
2560}
2561
2562template <>
2563EIGEN_STRONG_INLINE Packet8bf ploadu<Packet8bf>(const bfloat16* from) {
2564 return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
2565}
2566
2567template <>
2568EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to, const Packet8bf& from) {
2569 _mm_store_si128(reinterpret_cast<__m128i*>(to), from);
2570}
2571
2572template <>
2573EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to, const Packet8bf& from) {
2574 _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from);
2575}
2576
2577template <>
2578EIGEN_STRONG_INLINE Packet8bf ploaddup<Packet8bf>(const bfloat16* from) {
2579 const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
2580 const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
2581 const numext::uint16_t c = numext::bit_cast<numext::uint16_t>(from[2]);
2582 const numext::uint16_t d = numext::bit_cast<numext::uint16_t>(from[3]);
2583 return _mm_set_epi16(d, d, c, c, b, b, a, a);
2584}
2585
2586template <>
2587EIGEN_STRONG_INLINE Packet8bf ploadquad<Packet8bf>(const bfloat16* from) {
2588 const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
2589 const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
2590 return _mm_set_epi16(b, b, b, b, a, a, a, a);
2591}
2592
2593template <>
2594EIGEN_STRONG_INLINE Packet8bf ptrue(const Packet8bf& a) {
2595 return _mm_cmpeq_epi32(a, a);
2596}
2597
2598template <>
2599EIGEN_STRONG_INLINE Packet8bf pabs(const Packet8bf& a) {
2600 const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
2601 return _mm_andnot_si128(sign_mask, a);
2602}
2603
2604template <>
2605EIGEN_STRONG_INLINE Packet8bf pmin<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
2606 return F32ToBf16(pmin<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
2607}
2608
2609template <>
2610EIGEN_STRONG_INLINE Packet8bf pmax<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
2611 return F32ToBf16(pmax<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
2612}
2613
2614template <>
2615EIGEN_STRONG_INLINE Packet8bf plset<Packet8bf>(const bfloat16& a) {
2616 return F32ToBf16(plset<Packet8f>(static_cast<float>(a)));
2617}
2618
2619template <>
2620EIGEN_STRONG_INLINE Packet8bf por(const Packet8bf& a, const Packet8bf& b) {
2621 return _mm_or_si128(a, b);
2622}
2623template <>
2624EIGEN_STRONG_INLINE Packet8bf pxor(const Packet8bf& a, const Packet8bf& b) {
2625 return _mm_xor_si128(a, b);
2626}
2627template <>
2628EIGEN_STRONG_INLINE Packet8bf pand(const Packet8bf& a, const Packet8bf& b) {
2629 return _mm_and_si128(a, b);
2630}
2631template <>
2632EIGEN_STRONG_INLINE Packet8bf pandnot(const Packet8bf& a, const Packet8bf& b) {
2633 return _mm_andnot_si128(b, a);
2634}
2635
2636template <>
2637EIGEN_STRONG_INLINE Packet8bf pselect(const Packet8bf& mask, const Packet8bf& a, const Packet8bf& b) {
2638 return _mm_blendv_epi8(b, a, mask);
2639}
2640
2641template <>
2642EIGEN_STRONG_INLINE Packet8bf pround<Packet8bf>(const Packet8bf& a) {
2643 return F32ToBf16(pround<Packet8f>(Bf16ToF32(a)));
2644}
2645
2646template <>
2647EIGEN_STRONG_INLINE Packet8bf print<Packet8bf>(const Packet8bf& a) {
2648 return F32ToBf16(print<Packet8f>(Bf16ToF32(a)));
2649}
2650
2651template <>
2652EIGEN_STRONG_INLINE Packet8bf pceil<Packet8bf>(const Packet8bf& a) {
2653 return F32ToBf16(pceil<Packet8f>(Bf16ToF32(a)));
2654}
2655
2656template <>
2657EIGEN_STRONG_INLINE Packet8bf pfloor<Packet8bf>(const Packet8bf& a) {
2658 return F32ToBf16(pfloor<Packet8f>(Bf16ToF32(a)));
2659}
2660
2661template <>
2662EIGEN_STRONG_INLINE Packet8bf ptrunc<Packet8bf>(const Packet8bf& a) {
2663 return F32ToBf16(ptrunc<Packet8f>(Bf16ToF32(a)));
2664}
2665
2666template <>
2667EIGEN_STRONG_INLINE Packet8bf pcmp_eq(const Packet8bf& a, const Packet8bf& b) {
2668 return Pack16To8(pcmp_eq(Bf16ToF32(a), Bf16ToF32(b)));
2669}
2670
2671template <>
2672EIGEN_STRONG_INLINE Packet8bf pcmp_le(const Packet8bf& a, const Packet8bf& b) {
2673 return Pack16To8(pcmp_le(Bf16ToF32(a), Bf16ToF32(b)));
2674}
2675
2676template <>
2677EIGEN_STRONG_INLINE Packet8bf pcmp_lt(const Packet8bf& a, const Packet8bf& b) {
2678 return Pack16To8(pcmp_lt(Bf16ToF32(a), Bf16ToF32(b)));
2679}
2680
2681template <>
2682EIGEN_STRONG_INLINE Packet8bf pcmp_lt_or_nan(const Packet8bf& a, const Packet8bf& b) {
2683 return Pack16To8(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
2684}
2685
2686template <>
2687EIGEN_STRONG_INLINE Packet8bf pconj(const Packet8bf& a) {
2688 return a;
2689}
2690
2691template <>
2692EIGEN_STRONG_INLINE Packet8bf pnegate(const Packet8bf& a) {
2693 Packet8bf sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
2694 return _mm_xor_si128(a, sign_mask);
2695}
2696
2697template <>
2698EIGEN_STRONG_INLINE Packet8bf padd<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
2699 return F32ToBf16(padd<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
2700}
2701
2702template <>
2703EIGEN_STRONG_INLINE Packet8bf psub<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
2704 return F32ToBf16(psub<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
2705}
2706
2707template <>
2708EIGEN_STRONG_INLINE Packet8bf pmul<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
2709 return F32ToBf16(pmul<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
2710}
2711
2712template <>
2713EIGEN_STRONG_INLINE Packet8bf pmadd<Packet8bf>(const Packet8bf& a, const Packet8bf& b, const Packet8bf& c) {
2714 return F32ToBf16(pmadd(Bf16ToF32(a), Bf16ToF32(b), Bf16ToF32(c)));
2715}
2716
2717template <>
2718EIGEN_STRONG_INLINE Packet8bf pmsub<Packet8bf>(const Packet8bf& a, const Packet8bf& b, const Packet8bf& c) {
2719 return F32ToBf16(pmsub(Bf16ToF32(a), Bf16ToF32(b), Bf16ToF32(c)));
2720}
2721
2722template <>
2723EIGEN_STRONG_INLINE Packet8bf pnmadd<Packet8bf>(const Packet8bf& a, const Packet8bf& b, const Packet8bf& c) {
2724 return F32ToBf16(pnmadd(Bf16ToF32(a), Bf16ToF32(b), Bf16ToF32(c)));
2725}
2726
2727template <>
2728EIGEN_STRONG_INLINE Packet8bf pnmsub<Packet8bf>(const Packet8bf& a, const Packet8bf& b, const Packet8bf& c) {
2729 return F32ToBf16(pnmsub(Bf16ToF32(a), Bf16ToF32(b), Bf16ToF32(c)));
2730}
2731
2732template <>
2733EIGEN_STRONG_INLINE Packet8bf pdiv<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
2734 return F32ToBf16(pdiv<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
2735}
2736
2737template <>
2738EIGEN_STRONG_INLINE Packet8bf pgather<bfloat16, Packet8bf>(const bfloat16* from, Index stride) {
2739 const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(from[0 * stride]);
2740 const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(from[1 * stride]);
2741 const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(from[2 * stride]);
2742 const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(from[3 * stride]);
2743 const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(from[4 * stride]);
2744 const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(from[5 * stride]);
2745 const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(from[6 * stride]);
2746 const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(from[7 * stride]);
2747 return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
2748}
2749
2750template <>
2751EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet8bf>(bfloat16* to, const Packet8bf& from, Index stride) {
2752 EIGEN_ALIGN32 bfloat16 aux[8];
2753 pstore(aux, from);
2754 to[stride * 0] = aux[0];
2755 to[stride * 1] = aux[1];
2756 to[stride * 2] = aux[2];
2757 to[stride * 3] = aux[3];
2758 to[stride * 4] = aux[4];
2759 to[stride * 5] = aux[5];
2760 to[stride * 6] = aux[6];
2761 to[stride * 7] = aux[7];
2762}
2763
2764template <>
2765EIGEN_STRONG_INLINE Packet8bf preverse(const Packet8bf& a) {
2766 __m128i m = _mm_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
2767 return _mm_shuffle_epi8(a, m);
2768}
2769
2770EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8bf, 8>& kernel) {
2771 __m128i a = kernel.packet[0];
2772 __m128i b = kernel.packet[1];
2773 __m128i c = kernel.packet[2];
2774 __m128i d = kernel.packet[3];
2775 __m128i e = kernel.packet[4];
2776 __m128i f = kernel.packet[5];
2777 __m128i g = kernel.packet[6];
2778 __m128i h = kernel.packet[7];
2779
2780 __m128i a03b03 = _mm_unpacklo_epi16(a, b);
2781 __m128i c03d03 = _mm_unpacklo_epi16(c, d);
2782 __m128i e03f03 = _mm_unpacklo_epi16(e, f);
2783 __m128i g03h03 = _mm_unpacklo_epi16(g, h);
2784 __m128i a47b47 = _mm_unpackhi_epi16(a, b);
2785 __m128i c47d47 = _mm_unpackhi_epi16(c, d);
2786 __m128i e47f47 = _mm_unpackhi_epi16(e, f);
2787 __m128i g47h47 = _mm_unpackhi_epi16(g, h);
2788
2789 __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
2790 __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
2791 __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
2792 __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
2793 __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
2794 __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
2795 __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
2796 __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
2797
2798 kernel.packet[0] = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
2799 kernel.packet[1] = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
2800 kernel.packet[2] = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
2801 kernel.packet[3] = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
2802 kernel.packet[4] = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
2803 kernel.packet[5] = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
2804 kernel.packet[6] = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
2805 kernel.packet[7] = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
2806}
2807
2808EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8bf, 4>& kernel) {
2809 __m128i a = kernel.packet[0];
2810 __m128i b = kernel.packet[1];
2811 __m128i c = kernel.packet[2];
2812 __m128i d = kernel.packet[3];
2813
2814 __m128i ab_03 = _mm_unpacklo_epi16(a, b);
2815 __m128i cd_03 = _mm_unpacklo_epi16(c, d);
2816 __m128i ab_47 = _mm_unpackhi_epi16(a, b);
2817 __m128i cd_47 = _mm_unpackhi_epi16(c, d);
2818
2819 kernel.packet[0] = _mm_unpacklo_epi32(ab_03, cd_03);
2820 kernel.packet[1] = _mm_unpackhi_epi32(ab_03, cd_03);
2821 kernel.packet[2] = _mm_unpacklo_epi32(ab_47, cd_47);
2822 kernel.packet[3] = _mm_unpackhi_epi32(ab_47, cd_47);
2823}
2824
2825/*---------------- load/store segment support ----------------*/
2826
2827// returns a mask of 8-bit elements (at most 4) that are all 1's in the range [begin, begin + count) and 0 elsewhere.
2828inline __m128i segment_mask_4x8(Index begin, Index count) {
2829 eigen_assert(begin >= 0 && begin + count <= 4);
2830 long long mask = 1;
2831 mask <<= CHAR_BIT * count;
2832 mask--;
2833 mask <<= CHAR_BIT * begin;
2834#if !EIGEN_ARCH_x86_64
2835 return _mm_loadl_epi64(reinterpret_cast<const __m128i*>(&mask));
2836#else
2837 return _mm_cvtsi64_si128(mask);
2838#endif
2839}
2840
2841// returns a mask of 8-bit elements (at most 8) that are all 1's in the range [begin, begin + count) and 0 elsewhere.
2842inline __m128i segment_mask_8x8(Index begin, Index count) {
2843 eigen_assert(begin >= 0 && begin + count <= 8);
2844 long long mask = 1;
2845 // avoid UB when count == 8
2846 mask <<= (CHAR_BIT / 2) * count;
2847 mask <<= (CHAR_BIT / 2) * count;
2848 mask--;
2849 mask <<= CHAR_BIT * begin;
2850#if !EIGEN_ARCH_x86_64
2851 return _mm_loadl_epi64(reinterpret_cast<const __m128i*>(&mask));
2852#else
2853 return _mm_cvtsi64_si128(mask);
2854#endif
2855}
2856
2857// returns a mask of 32-bit elements (at most 4) that are all 1's in the range [begin, begin + count) and 0 elsewhere.
2858inline __m128i segment_mask_4x32(Index begin, Index count) {
2859 eigen_assert(begin >= 0 && begin + count <= 4);
2860 return _mm_cvtepi8_epi32(segment_mask_4x8(begin, count));
2861}
2862
2863// returns a mask of 64-bit elements (at most 2) that are all 1's in the range [begin, begin + count) and 0 elsewhere.
2864inline __m128i segment_mask_2x64(Index begin, Index count) {
2865 eigen_assert(begin >= 0 && begin + count <= 2);
2866 return _mm_cvtepi8_epi64(segment_mask_4x8(begin, count));
2867}
2868
2869// returns a mask of 32-bit elements (at most 8) that are all 1's in the range [begin, begin + count) and 0 elsewhere.
2870inline __m256i segment_mask_8x32(Index begin, Index count) {
2871 __m128i mask_epi8 = segment_mask_8x8(begin, count);
2872#ifdef EIGEN_VECTORIZE_AVX2
2873 __m256i mask_epi32 = _mm256_cvtepi8_epi32(mask_epi8);
2874#else
2875 __m128i mask_epi32_lo = _mm_cvtepi8_epi32(mask_epi8);
2876 __m128i mask_epi32_hi = _mm_cvtepi8_epi32(_mm_srli_epi64(mask_epi8, 32));
2877 __m256i mask_epi32 = _mm256_insertf128_si256(_mm256_castsi128_si256(mask_epi32_lo), mask_epi32_hi, 1);
2878#endif
2879 return mask_epi32;
2880}
2881
2882// returns a mask of 64-bit elements (at most 4) that are all 1's in the range [begin, begin + count) and 0 elsewhere.
2883inline __m256i segment_mask_4x64(Index begin, Index count) {
2884 __m128i mask_epi8 = segment_mask_4x8(begin, count);
2885#ifdef EIGEN_VECTORIZE_AVX2
2886 __m256i mask_epi64 = _mm256_cvtepi8_epi64(mask_epi8);
2887#else
2888 __m128i mask_epi64_lo = _mm_cvtepi8_epi64(mask_epi8);
2889 __m128i mask_epi64_hi = _mm_cvtepi8_epi64(_mm_srli_epi64(mask_epi8, 16));
2890 __m256i mask_epi64 = _mm256_insertf128_si256(_mm256_castsi128_si256(mask_epi64_lo), mask_epi64_hi, 1);
2891#endif
2892 return mask_epi64;
2893}
2894
2895/*---------------- float ----------------*/
2896
2897template <>
2898struct has_packet_segment<Packet4f> : std::true_type {};
2899
2900template <>
2901struct has_packet_segment<Packet8f> : std::true_type {};
2902
2903template <>
2904inline Packet4f ploaduSegment<Packet4f>(const float* from, Index begin, Index count) {
2905 return _mm_maskload_ps(from, segment_mask_4x32(begin, count));
2906}
2907
2908template <>
2909inline void pstoreuSegment<float, Packet4f>(float* to, const Packet4f& from, Index begin, Index count) {
2910 _mm_maskstore_ps(to, segment_mask_4x32(begin, count), from);
2911}
2912
2913template <>
2914inline Packet8f ploaduSegment<Packet8f>(const float* from, Index begin, Index count) {
2915 return _mm256_maskload_ps(from, segment_mask_8x32(begin, count));
2916}
2917
2918template <>
2919inline void pstoreuSegment<float, Packet8f>(float* to, const Packet8f& from, Index begin, Index count) {
2920 _mm256_maskstore_ps(to, segment_mask_8x32(begin, count), from);
2921}
2922
2923/*---------------- int32 ----------------*/
2924
2925template <>
2926struct has_packet_segment<Packet4i> : std::true_type {};
2927
2928template <>
2929struct has_packet_segment<Packet8i> : std::true_type {};
2930
2931#ifdef EIGEN_VECTORIZE_AVX2
2932
2933template <>
2934inline Packet4i ploaduSegment<Packet4i>(const int* from, Index begin, Index count) {
2935 return _mm_maskload_epi32(from, segment_mask_4x32(begin, count));
2936}
2937
2938template <>
2939inline void pstoreuSegment<int, Packet4i>(int* to, const Packet4i& from, Index begin, Index count) {
2940 _mm_maskstore_epi32(to, segment_mask_4x32(begin, count), from);
2941}
2942
2943template <>
2944inline Packet8i ploaduSegment<Packet8i>(const int* from, Index begin, Index count) {
2945 return _mm256_maskload_epi32(from, segment_mask_8x32(begin, count));
2946}
2947
2948template <>
2949inline void pstoreuSegment<int, Packet8i>(int* to, const Packet8i& from, Index begin, Index count) {
2950 _mm256_maskstore_epi32(to, segment_mask_8x32(begin, count), from);
2951}
2952
2953#else
2954
2955template <>
2956inline Packet4i ploaduSegment<Packet4i>(const int* from, Index begin, Index count) {
2957 return _mm_castps_si128(ploaduSegment<Packet4f>(reinterpret_cast<const float*>(from), begin, count));
2958}
2959
2960template <>
2961inline void pstoreuSegment<int, Packet4i>(int* to, const Packet4i& from, Index begin, Index count) {
2962 pstoreuSegment<float, Packet4f>(reinterpret_cast<float*>(to), _mm_castsi128_ps(from), begin, count);
2963}
2964
2965template <>
2966inline Packet8i ploaduSegment<Packet8i>(const int* from, Index begin, Index count) {
2967 return _mm256_castps_si256(ploaduSegment<Packet8f>(reinterpret_cast<const float*>(from), begin, count));
2968}
2969
2970template <>
2971inline void pstoreuSegment<int, Packet8i>(int* to, const Packet8i& from, Index begin, Index count) {
2972 pstoreuSegment<float, Packet8f>(reinterpret_cast<float*>(to), _mm256_castsi256_ps(from), begin, count);
2973}
2974
2975#endif
2976
2977/*---------------- uint32 ----------------*/
2978
2979template <>
2980struct has_packet_segment<Packet4ui> : std::true_type {};
2981
2982template <>
2983struct has_packet_segment<Packet8ui> : std::true_type {};
2984
2985template <>
2986inline Packet4ui ploaduSegment<Packet4ui>(const uint32_t* from, Index begin, Index count) {
2987 return Packet4ui(ploaduSegment<Packet4i>(reinterpret_cast<const int*>(from), begin, count));
2988}
2989
2990template <>
2991inline void pstoreuSegment<uint32_t, Packet4ui>(uint32_t* to, const Packet4ui& from, Index begin, Index count) {
2992 pstoreuSegment<int, Packet4i>(reinterpret_cast<int*>(to), Packet4i(from), begin, count);
2993}
2994
2995template <>
2996inline Packet8ui ploaduSegment<Packet8ui>(const uint32_t* from, Index begin, Index count) {
2997 return Packet8ui(ploaduSegment<Packet8i>(reinterpret_cast<const int*>(from), begin, count));
2998}
2999
3000template <>
3001inline void pstoreuSegment<uint32_t, Packet8ui>(uint32_t* to, const Packet8ui& from, Index begin, Index count) {
3002 pstoreuSegment<int, Packet8i>(reinterpret_cast<int*>(to), Packet8i(from), begin, count);
3003}
3004
3005/*---------------- double ----------------*/
3006
3007template <>
3008struct has_packet_segment<Packet2d> : std::true_type {};
3009
3010template <>
3011struct has_packet_segment<Packet4d> : std::true_type {};
3012
3013template <>
3014inline Packet2d ploaduSegment<Packet2d>(const double* from, Index begin, Index count) {
3015 return _mm_maskload_pd(from, segment_mask_2x64(begin, count));
3016}
3017
3018template <>
3019inline void pstoreuSegment<double, Packet2d>(double* to, const Packet2d& from, Index begin, Index count) {
3020 _mm_maskstore_pd(to, segment_mask_2x64(begin, count), from);
3021}
3022
3023template <>
3024inline Packet4d ploaduSegment<Packet4d>(const double* from, Index begin, Index count) {
3025 return _mm256_maskload_pd(from, segment_mask_4x64(begin, count));
3026}
3027
3028template <>
3029inline void pstoreuSegment<double, Packet4d>(double* to, const Packet4d& from, Index begin, Index count) {
3030 _mm256_maskstore_pd(to, segment_mask_4x64(begin, count), from);
3031}
3032
3033#ifdef EIGEN_VECTORIZE_AVX2
3034
3035/*---------------- int64_t ----------------*/
3036
3037template <>
3038struct has_packet_segment<Packet2l> : std::true_type {};
3039
3040template <>
3041struct has_packet_segment<Packet4l> : std::true_type {};
3042
3043template <>
3044inline Packet2l ploaduSegment<Packet2l>(const int64_t* from, Index begin, Index count) {
3045 return _mm_maskload_epi64(reinterpret_cast<const long long*>(from), segment_mask_2x64(begin, count));
3046}
3047template <>
3048inline void pstoreuSegment<int64_t, Packet2l>(int64_t* to, const Packet2l& from, Index begin, Index count) {
3049 _mm_maskstore_epi64(reinterpret_cast<long long*>(to), segment_mask_2x64(begin, count), from);
3050}
3051template <>
3052inline Packet4l ploaduSegment<Packet4l>(const int64_t* from, Index begin, Index count) {
3053 return _mm256_maskload_epi64(reinterpret_cast<const long long*>(from), segment_mask_4x64(begin, count));
3054}
3055template <>
3056inline void pstoreuSegment<int64_t, Packet4l>(int64_t* to, const Packet4l& from, Index begin, Index count) {
3057 _mm256_maskstore_epi64(reinterpret_cast<long long*>(to), segment_mask_4x64(begin, count), from);
3058}
3059
3060/*---------------- uint64_t ----------------*/
3061
3062template <>
3063struct has_packet_segment<Packet4ul> : std::true_type {};
3064
3065template <>
3066inline Packet4ul ploaduSegment<Packet4ul>(const uint64_t* from, Index begin, Index count) {
3067 return Packet4ul(ploaduSegment<Packet4l>(reinterpret_cast<const int64_t*>(from), begin, count));
3068}
3069template <>
3070inline void pstoreuSegment<uint64_t, Packet4ul>(uint64_t* to, const Packet4ul& from, Index begin, Index count) {
3071 pstoreuSegment<int64_t, Packet4l>(reinterpret_cast<int64_t*>(to), Packet4l(from), begin, count);
3072}
3073#endif
3074
3075/*---------------- end load/store segment support ----------------*/
3076
3077} // end namespace internal
3078
3079} // end namespace Eigen
3080
3081#endif // EIGEN_PACKET_MATH_AVX_H
Eigen::Aligned32
@ Aligned32
Definition Constants.h:238
Eigen::Aligned16
@ Aligned16
Definition Constants.h:237
Eigen
Namespace containing all symbols from the Eigen library.
Definition B01_Experimental.dox:1
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition Meta.h:82