12 #ifndef EIGEN_PACKET_MATH_NEON_H 13 #define EIGEN_PACKET_MATH_NEON_H 19 #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 20 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8 23 #ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD 24 #define EIGEN_HAS_SINGLE_INSTRUCTION_MADD 27 #ifndef EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD 28 #define EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD 33 #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 34 #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16 37 typedef float32x2_t Packet2f;
38 typedef float32x4_t Packet4f;
39 typedef int32x4_t Packet4i;
40 typedef int32x2_t Packet2i;
41 typedef uint32x4_t Packet4ui;
43 #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \ 44 const Packet4f p4f_##NAME = pset1<Packet4f>(X) 46 #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ 47 const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int>(X)) 49 #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ 50 const Packet4i p4i_##NAME = pset1<Packet4i>(X) 52 #if EIGEN_COMP_LLVM && !EIGEN_COMP_CLANG 54 #define EIGEN_INIT_NEON_PACKET2(X, Y) {{X, Y}} 55 #define EIGEN_INIT_NEON_PACKET4(X, Y, Z, W) {{X, Y, Z, W}} 58 #define EIGEN_INIT_NEON_PACKET2(X, Y) {X, Y} 59 #define EIGEN_INIT_NEON_PACKET4(X, Y, Z, W) {X, Y, Z, W} 65 #if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC 66 #define EIGEN_ARM_PREFETCH(ADDR) __builtin_prefetch(ADDR); 68 #define EIGEN_ARM_PREFETCH(ADDR) __pld(ADDR) 69 #elif !EIGEN_ARCH_ARM64 70 #define EIGEN_ARM_PREFETCH(ADDR) __asm__ __volatile__ ( " pld [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" ); 73 #define EIGEN_ARM_PREFETCH(ADDR) 76 template<>
struct packet_traits<float> : default_packet_traits
78 typedef Packet4f type;
79 typedef Packet4f half;
95 template<>
struct packet_traits<int> : default_packet_traits
97 typedef Packet4i type;
98 typedef Packet4i half;
108 #if EIGEN_GNUC_AT_MOST(4,4) && !EIGEN_COMP_LLVM 110 EIGEN_STRONG_INLINE float32x4_t vld1q_f32(
const float* x) { return ::vld1q_f32((
const float32_t*)x); }
111 EIGEN_STRONG_INLINE float32x2_t vld1_f32 (
const float* x) { return ::vld1_f32 ((
const float32_t*)x); }
112 EIGEN_STRONG_INLINE float32x2_t vld1_dup_f32 (
const float* x) { return ::vld1_dup_f32 ((
const float32_t*)x); }
113 EIGEN_STRONG_INLINE
void vst1q_f32(
float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); }
114 EIGEN_STRONG_INLINE
void vst1_f32 (
float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); }
117 template<>
struct unpacket_traits<Packet4f> {
typedef float type;
enum {size=4, alignment=
Aligned16};
typedef Packet4f half; };
118 template<>
struct unpacket_traits<Packet4i> {
typedef int type;
enum {size=4, alignment=
Aligned16};
typedef Packet4i half; };
120 template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(
const float& from) {
return vdupq_n_f32(from); }
121 template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(
const int& from) {
return vdupq_n_s32(from); }
123 template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(
const float& a)
125 Packet4f countdown = EIGEN_INIT_NEON_PACKET4(0, 1, 2, 3);
126 return vaddq_f32(pset1<Packet4f>(a), countdown);
128 template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(
const int& a)
130 Packet4i countdown = EIGEN_INIT_NEON_PACKET4(0, 1, 2, 3);
131 return vaddq_s32(pset1<Packet4i>(a), countdown);
134 template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vaddq_f32(a,b); }
135 template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vaddq_s32(a,b); }
137 template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vsubq_f32(a,b); }
138 template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vsubq_s32(a,b); }
140 template<> EIGEN_STRONG_INLINE Packet4f pnegate(
const Packet4f& a) {
return vnegq_f32(a); }
141 template<> EIGEN_STRONG_INLINE Packet4i pnegate(
const Packet4i& a) {
return vnegq_s32(a); }
143 template<> EIGEN_STRONG_INLINE Packet4f pconj(
const Packet4f& a) {
return a; }
144 template<> EIGEN_STRONG_INLINE Packet4i pconj(
const Packet4i& a) {
return a; }
146 template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vmulq_f32(a,b); }
147 template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vmulq_s32(a,b); }
149 template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(
const Packet4f& a,
const Packet4f& b)
152 return vdivq_f32(a,b);
154 Packet4f inv, restep, div;
161 inv = vrecpeq_f32(b);
165 restep = vrecpsq_f32(b, inv);
166 inv = vmulq_f32(restep, inv);
169 div = vmulq_f32(a, inv);
175 template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(
const Packet4i& ,
const Packet4i& )
176 { eigen_assert(
false &&
"packet integer division are not supported by NEON");
177 return pset1<Packet4i>(0);
180 #ifdef __ARM_FEATURE_FMA 187 template<> EIGEN_STRONG_INLINE Packet4f pmadd(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
return vfmaq_f32(c,a,b); }
189 template<> EIGEN_STRONG_INLINE Packet4f pmadd(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
return vmlaq_f32(c,a,b); }
193 template<> EIGEN_STRONG_INLINE Packet4i pmadd(
const Packet4i& a,
const Packet4i& b,
const Packet4i& c) {
return vmlaq_s32(c,a,b); }
195 template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vminq_f32(a,b); }
196 template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vminq_s32(a,b); }
198 template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vmaxq_f32(a,b); }
199 template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vmaxq_s32(a,b); }
202 template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(
const Packet4f& a,
const Packet4f& b)
204 return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
206 template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vandq_s32(a,b); }
208 template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(
const Packet4f& a,
const Packet4f& b)
210 return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
212 template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vorrq_s32(a,b); }
214 template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(
const Packet4f& a,
const Packet4f& b)
216 return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
218 template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return veorq_s32(a,b); }
220 template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(
const Packet4f& a,
const Packet4f& b)
222 return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
224 template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vbicq_s32(a,b); }
226 template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(
const float* from) { EIGEN_DEBUG_ALIGNED_LOAD
return vld1q_f32(from); }
227 template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(
const int* from) { EIGEN_DEBUG_ALIGNED_LOAD
return vld1q_s32(from); }
229 template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(
const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD
return vld1q_f32(from); }
230 template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(
const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD
return vld1q_s32(from); }
232 template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(
const float* from)
235 lo = vld1_dup_f32(from);
236 hi = vld1_dup_f32(from+1);
237 return vcombine_f32(lo, hi);
239 template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(
const int* from)
242 lo = vld1_dup_s32(from);
243 hi = vld1_dup_s32(from+1);
244 return vcombine_s32(lo, hi);
247 template<> EIGEN_STRONG_INLINE
void pstore<float>(
float* to,
const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); }
248 template<> EIGEN_STRONG_INLINE
void pstore<int>(
int* to,
const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); }
250 template<> EIGEN_STRONG_INLINE
void pstoreu<float>(
float* to,
const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); }
251 template<> EIGEN_STRONG_INLINE
void pstoreu<int>(
int* to,
const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); }
253 template<> EIGEN_DEVICE_FUNC
inline Packet4f pgather<float, Packet4f>(
const float* from, Index stride)
255 Packet4f res = pset1<Packet4f>(0.f);
256 res = vsetq_lane_f32(from[0*stride], res, 0);
257 res = vsetq_lane_f32(from[1*stride], res, 1);
258 res = vsetq_lane_f32(from[2*stride], res, 2);
259 res = vsetq_lane_f32(from[3*stride], res, 3);
262 template<> EIGEN_DEVICE_FUNC
inline Packet4i pgather<int, Packet4i>(
const int* from, Index stride)
264 Packet4i res = pset1<Packet4i>(0);
265 res = vsetq_lane_s32(from[0*stride], res, 0);
266 res = vsetq_lane_s32(from[1*stride], res, 1);
267 res = vsetq_lane_s32(from[2*stride], res, 2);
268 res = vsetq_lane_s32(from[3*stride], res, 3);
272 template<> EIGEN_DEVICE_FUNC
inline void pscatter<float, Packet4f>(
float* to,
const Packet4f& from, Index stride)
274 to[stride*0] = vgetq_lane_f32(from, 0);
275 to[stride*1] = vgetq_lane_f32(from, 1);
276 to[stride*2] = vgetq_lane_f32(from, 2);
277 to[stride*3] = vgetq_lane_f32(from, 3);
279 template<> EIGEN_DEVICE_FUNC
inline void pscatter<int, Packet4i>(
int* to,
const Packet4i& from, Index stride)
281 to[stride*0] = vgetq_lane_s32(from, 0);
282 to[stride*1] = vgetq_lane_s32(from, 1);
283 to[stride*2] = vgetq_lane_s32(from, 2);
284 to[stride*3] = vgetq_lane_s32(from, 3);
287 template<> EIGEN_STRONG_INLINE
void prefetch<float>(
const float* addr) { EIGEN_ARM_PREFETCH(addr); }
288 template<> EIGEN_STRONG_INLINE
void prefetch<int>(
const int* addr) { EIGEN_ARM_PREFETCH(addr); }
291 template<> EIGEN_STRONG_INLINE
float pfirst<Packet4f>(
const Packet4f& a) {
float EIGEN_ALIGN16 x[4]; vst1q_f32(x, a);
return x[0]; }
292 template<> EIGEN_STRONG_INLINE
int pfirst<Packet4i>(
const Packet4i& a) {
int EIGEN_ALIGN16 x[4]; vst1q_s32(x, a);
return x[0]; }
294 template<> EIGEN_STRONG_INLINE Packet4f preverse(
const Packet4f& a) {
295 float32x2_t a_lo, a_hi;
298 a_r64 = vrev64q_f32(a);
299 a_lo = vget_low_f32(a_r64);
300 a_hi = vget_high_f32(a_r64);
301 return vcombine_f32(a_hi, a_lo);
303 template<> EIGEN_STRONG_INLINE Packet4i preverse(
const Packet4i& a) {
304 int32x2_t a_lo, a_hi;
307 a_r64 = vrev64q_s32(a);
308 a_lo = vget_low_s32(a_r64);
309 a_hi = vget_high_s32(a_r64);
310 return vcombine_s32(a_hi, a_lo);
313 template<
size_t offset>
314 struct protate_impl<offset, Packet4f>
316 static Packet4f run(
const Packet4f& a) {
317 return vextq_f32(a, a, offset);
321 template<
size_t offset>
322 struct protate_impl<offset, Packet4i>
324 static Packet4i run(
const Packet4i& a) {
325 return vextq_s32(a, a, offset);
329 template<> EIGEN_STRONG_INLINE Packet4f pabs(
const Packet4f& a) {
return vabsq_f32(a); }
330 template<> EIGEN_STRONG_INLINE Packet4i pabs(
const Packet4i& a) {
return vabsq_s32(a); }
332 template<> EIGEN_STRONG_INLINE
float predux<Packet4f>(
const Packet4f& a)
334 float32x2_t a_lo, a_hi, sum;
336 a_lo = vget_low_f32(a);
337 a_hi = vget_high_f32(a);
338 sum = vpadd_f32(a_lo, a_hi);
339 sum = vpadd_f32(sum, sum);
340 return vget_lane_f32(sum, 0);
343 template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(
const Packet4f* vecs)
345 float32x4x2_t vtrn1, vtrn2, res1, res2;
346 Packet4f sum1, sum2, sum;
350 vtrn1 = vzipq_f32(vecs[0], vecs[2]);
351 vtrn2 = vzipq_f32(vecs[1], vecs[3]);
352 res1 = vzipq_f32(vtrn1.val[0], vtrn2.val[0]);
353 res2 = vzipq_f32(vtrn1.val[1], vtrn2.val[1]);
356 sum1 = vaddq_f32(res1.val[0], res1.val[1]);
357 sum2 = vaddq_f32(res2.val[0], res2.val[1]);
358 sum = vaddq_f32(sum1, sum2);
363 template<> EIGEN_STRONG_INLINE
int predux<Packet4i>(
const Packet4i& a)
365 int32x2_t a_lo, a_hi, sum;
367 a_lo = vget_low_s32(a);
368 a_hi = vget_high_s32(a);
369 sum = vpadd_s32(a_lo, a_hi);
370 sum = vpadd_s32(sum, sum);
371 return vget_lane_s32(sum, 0);
374 template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(
const Packet4i* vecs)
376 int32x4x2_t vtrn1, vtrn2, res1, res2;
377 Packet4i sum1, sum2, sum;
381 vtrn1 = vzipq_s32(vecs[0], vecs[2]);
382 vtrn2 = vzipq_s32(vecs[1], vecs[3]);
383 res1 = vzipq_s32(vtrn1.val[0], vtrn2.val[0]);
384 res2 = vzipq_s32(vtrn1.val[1], vtrn2.val[1]);
387 sum1 = vaddq_s32(res1.val[0], res1.val[1]);
388 sum2 = vaddq_s32(res2.val[0], res2.val[1]);
389 sum = vaddq_s32(sum1, sum2);
396 template<> EIGEN_STRONG_INLINE
float predux_mul<Packet4f>(
const Packet4f& a)
398 float32x2_t a_lo, a_hi, prod;
401 a_lo = vget_low_f32(a);
402 a_hi = vget_high_f32(a);
404 prod = vmul_f32(a_lo, a_hi);
406 prod = vmul_f32(prod, vrev64_f32(prod));
408 return vget_lane_f32(prod, 0);
410 template<> EIGEN_STRONG_INLINE
int predux_mul<Packet4i>(
const Packet4i& a)
412 int32x2_t a_lo, a_hi, prod;
415 a_lo = vget_low_s32(a);
416 a_hi = vget_high_s32(a);
418 prod = vmul_s32(a_lo, a_hi);
420 prod = vmul_s32(prod, vrev64_s32(prod));
422 return vget_lane_s32(prod, 0);
426 template<> EIGEN_STRONG_INLINE
float predux_min<Packet4f>(
const Packet4f& a)
428 float32x2_t a_lo, a_hi, min;
430 a_lo = vget_low_f32(a);
431 a_hi = vget_high_f32(a);
432 min = vpmin_f32(a_lo, a_hi);
433 min = vpmin_f32(min, min);
435 return vget_lane_f32(min, 0);
438 template<> EIGEN_STRONG_INLINE
int predux_min<Packet4i>(
const Packet4i& a)
440 int32x2_t a_lo, a_hi, min;
442 a_lo = vget_low_s32(a);
443 a_hi = vget_high_s32(a);
444 min = vpmin_s32(a_lo, a_hi);
445 min = vpmin_s32(min, min);
447 return vget_lane_s32(min, 0);
451 template<> EIGEN_STRONG_INLINE
float predux_max<Packet4f>(
const Packet4f& a)
453 float32x2_t a_lo, a_hi, max;
455 a_lo = vget_low_f32(a);
456 a_hi = vget_high_f32(a);
457 max = vpmax_f32(a_lo, a_hi);
458 max = vpmax_f32(max, max);
460 return vget_lane_f32(max, 0);
463 template<> EIGEN_STRONG_INLINE
int predux_max<Packet4i>(
const Packet4i& a)
465 int32x2_t a_lo, a_hi, max;
467 a_lo = vget_low_s32(a);
468 a_hi = vget_high_s32(a);
469 max = vpmax_s32(a_lo, a_hi);
470 max = vpmax_s32(max, max);
472 return vget_lane_s32(max, 0);
477 #define PALIGN_NEON(Offset,Type,Command) \ 479 struct palign_impl<Offset,Type>\ 481 EIGEN_STRONG_INLINE static void run(Type& first, const Type& second)\ 484 first = Command(first, second, Offset);\ 488 PALIGN_NEON(0,Packet4f,vextq_f32)
489 PALIGN_NEON(1,Packet4f,vextq_f32)
490 PALIGN_NEON(2,Packet4f,vextq_f32)
491 PALIGN_NEON(3,Packet4f,vextq_f32)
492 PALIGN_NEON(0,Packet4i,vextq_s32)
493 PALIGN_NEON(1,Packet4i,vextq_s32)
494 PALIGN_NEON(2,Packet4i,vextq_s32)
495 PALIGN_NEON(3,Packet4i,vextq_s32)
499 EIGEN_DEVICE_FUNC
inline void 500 ptranspose(PacketBlock<Packet4f,4>& kernel) {
501 float32x4x2_t tmp1 = vzipq_f32(kernel.packet[0], kernel.packet[1]);
502 float32x4x2_t tmp2 = vzipq_f32(kernel.packet[2], kernel.packet[3]);
504 kernel.packet[0] = vcombine_f32(vget_low_f32(tmp1.val[0]), vget_low_f32(tmp2.val[0]));
505 kernel.packet[1] = vcombine_f32(vget_high_f32(tmp1.val[0]), vget_high_f32(tmp2.val[0]));
506 kernel.packet[2] = vcombine_f32(vget_low_f32(tmp1.val[1]), vget_low_f32(tmp2.val[1]));
507 kernel.packet[3] = vcombine_f32(vget_high_f32(tmp1.val[1]), vget_high_f32(tmp2.val[1]));
510 EIGEN_DEVICE_FUNC
inline void 511 ptranspose(PacketBlock<Packet4i,4>& kernel) {
512 int32x4x2_t tmp1 = vzipq_s32(kernel.packet[0], kernel.packet[1]);
513 int32x4x2_t tmp2 = vzipq_s32(kernel.packet[2], kernel.packet[3]);
514 kernel.packet[0] = vcombine_s32(vget_low_s32(tmp1.val[0]), vget_low_s32(tmp2.val[0]));
515 kernel.packet[1] = vcombine_s32(vget_high_s32(tmp1.val[0]), vget_high_s32(tmp2.val[0]));
516 kernel.packet[2] = vcombine_s32(vget_low_s32(tmp1.val[1]), vget_low_s32(tmp2.val[1]));
517 kernel.packet[3] = vcombine_s32(vget_high_s32(tmp1.val[1]), vget_high_s32(tmp2.val[1]));
524 #ifdef __apple_build_version__ 528 #define EIGEN_APPLE_DOUBLE_NEON_BUG (__apple_build_version__ < 6010000) 530 #define EIGEN_APPLE_DOUBLE_NEON_BUG 0 533 #if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG 535 #if (EIGEN_COMP_GNUC_STRICT && defined(__ANDROID__)) || defined(__apple_build_version__) 537 __extension__
static __inline uint64x2_t __attribute__ ((__always_inline__))
538 vreinterpretq_u64_f64 (float64x2_t __a)
540 return (uint64x2_t) __a;
543 __extension__
static __inline float64x2_t __attribute__ ((__always_inline__))
544 vreinterpretq_f64_u64 (uint64x2_t __a)
546 return (float64x2_t) __a;
550 typedef float64x2_t Packet2d;
551 typedef float64x1_t Packet1d;
553 template<>
struct packet_traits<double> : default_packet_traits
555 typedef Packet2d type;
556 typedef Packet2d half;
573 template<>
struct unpacket_traits<Packet2d> {
typedef double type;
enum {size=2, alignment=
Aligned16};
typedef Packet2d half; };
575 template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(
const double& from) {
return vdupq_n_f64(from); }
577 template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(
const double& a)
579 Packet2d countdown = EIGEN_INIT_NEON_PACKET2(0, 1);
580 return vaddq_f64(pset1<Packet2d>(a), countdown);
582 template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
return vaddq_f64(a,b); }
584 template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
return vsubq_f64(a,b); }
586 template<> EIGEN_STRONG_INLINE Packet2d pnegate(
const Packet2d& a) {
return vnegq_f64(a); }
588 template<> EIGEN_STRONG_INLINE Packet2d pconj(
const Packet2d& a) {
return a; }
590 template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
return vmulq_f64(a,b); }
592 template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
return vdivq_f64(a,b); }
594 #ifdef __ARM_FEATURE_FMA 596 template<> EIGEN_STRONG_INLINE Packet2d pmadd(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
return vfmaq_f64(c,a,b); }
598 template<> EIGEN_STRONG_INLINE Packet2d pmadd(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
return vmlaq_f64(c,a,b); }
601 template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
return vminq_f64(a,b); }
603 template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
return vmaxq_f64(a,b); }
606 template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(
const Packet2d& a,
const Packet2d& b)
608 return vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
611 template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(
const Packet2d& a,
const Packet2d& b)
613 return vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
616 template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(
const Packet2d& a,
const Packet2d& b)
618 return vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
621 template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(
const Packet2d& a,
const Packet2d& b)
623 return vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
626 template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(
const double* from) { EIGEN_DEBUG_ALIGNED_LOAD
return vld1q_f64(from); }
628 template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(
const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD
return vld1q_f64(from); }
630 template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(
const double* from)
632 return vld1q_dup_f64(from);
634 template<> EIGEN_STRONG_INLINE
void pstore<double>(
double* to,
const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f64(to, from); }
636 template<> EIGEN_STRONG_INLINE
void pstoreu<double>(
double* to,
const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f64(to, from); }
638 template<> EIGEN_DEVICE_FUNC
inline Packet2d pgather<double, Packet2d>(
const double* from, Index stride)
640 Packet2d res = pset1<Packet2d>(0.0);
641 res = vsetq_lane_f64(from[0*stride], res, 0);
642 res = vsetq_lane_f64(from[1*stride], res, 1);
645 template<> EIGEN_DEVICE_FUNC
inline void pscatter<double, Packet2d>(
double* to,
const Packet2d& from, Index stride)
647 to[stride*0] = vgetq_lane_f64(from, 0);
648 to[stride*1] = vgetq_lane_f64(from, 1);
650 template<> EIGEN_STRONG_INLINE
void prefetch<double>(
const double* addr) { EIGEN_ARM_PREFETCH(addr); }
653 template<> EIGEN_STRONG_INLINE
double pfirst<Packet2d>(
const Packet2d& a) {
return vgetq_lane_f64(a, 0); }
655 template<> EIGEN_STRONG_INLINE Packet2d preverse(
const Packet2d& a) {
return vcombine_f64(vget_high_f64(a), vget_low_f64(a)); }
657 template<
size_t offset>
658 struct protate_impl<offset, Packet2d>
660 static Packet2d run(
const Packet2d& a) {
661 return vextq_f64(a, a, offset);
665 template<> EIGEN_STRONG_INLINE Packet2d pabs(
const Packet2d& a) {
return vabsq_f64(a); }
667 #if EIGEN_COMP_CLANG && defined(__apple_build_version__) 669 template<> EIGEN_STRONG_INLINE
double predux<Packet2d>(
const Packet2d& a) {
return (vget_low_f64(a) + vget_high_f64(a))[0]; }
671 template<> EIGEN_STRONG_INLINE
double predux<Packet2d>(
const Packet2d& a) {
return vget_lane_f64(vget_low_f64(a) + vget_high_f64(a), 0); }
674 template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(
const Packet2d* vecs)
676 float64x2_t trn1, trn2;
680 trn1 = vzip1q_f64(vecs[0], vecs[1]);
681 trn2 = vzip2q_f64(vecs[0], vecs[1]);
684 return vaddq_f64(trn1, trn2);
688 #if EIGEN_COMP_CLANG && defined(__apple_build_version__) 689 template<> EIGEN_STRONG_INLINE
double predux_mul<Packet2d>(
const Packet2d& a) {
return (vget_low_f64(a) * vget_high_f64(a))[0]; }
691 template<> EIGEN_STRONG_INLINE
double predux_mul<Packet2d>(
const Packet2d& a) {
return vget_lane_f64(vget_low_f64(a) * vget_high_f64(a), 0); }
695 template<> EIGEN_STRONG_INLINE
double predux_min<Packet2d>(
const Packet2d& a) {
return vgetq_lane_f64(vpminq_f64(a, a), 0); }
698 template<> EIGEN_STRONG_INLINE
double predux_max<Packet2d>(
const Packet2d& a) {
return vgetq_lane_f64(vpmaxq_f64(a, a), 0); }
702 #define PALIGN_NEON(Offset,Type,Command) \ 704 struct palign_impl<Offset,Type>\ 706 EIGEN_STRONG_INLINE static void run(Type& first, const Type& second)\ 709 first = Command(first, second, Offset);\ 713 PALIGN_NEON(0,Packet2d,vextq_f64)
714 PALIGN_NEON(1,Packet2d,vextq_f64)
717 EIGEN_DEVICE_FUNC
inline void 718 ptranspose(PacketBlock<Packet2d,2>& kernel) {
719 float64x2_t trn1 = vzip1q_f64(kernel.packet[0], kernel.packet[1]);
720 float64x2_t trn2 = vzip2q_f64(kernel.packet[0], kernel.packet[1]);
722 kernel.packet[0] = trn1;
723 kernel.packet[1] = trn2;
725 #endif // EIGEN_ARCH_ARM64 731 #endif // EIGEN_PACKET_MATH_NEON_H Definition: Constants.h:230
Definition: Eigen_Colamd.h:54