mirror of
https://gitlab.com/libeigen/eigen.git
synced 2024-12-21 07:19:46 +08:00
NEON: Added uint32_t packet math
This commit is contained in:
Joel Holdsworth
parent
eacf97f727
commit
d5d3cf9339
@ -168,6 +168,34 @@ struct packet_traits<int32_t> : default_packet_traits
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct packet_traits<uint32_t> : default_packet_traits
|
||||
{
|
||||
typedef Packet4ui type;
|
||||
typedef Packet2ui half;
|
||||
enum
|
||||
{
|
||||
Vectorizable = 1,
|
||||
AlignedOnScalar = 1,
|
||||
size = 4,
|
||||
HasHalfPacket = 1,
|
||||
|
||||
HasAdd = 1,
|
||||
HasSub = 1,
|
||||
HasMul = 1,
|
||||
HasNegate = 0,
|
||||
HasAbs = 0,
|
||||
HasArg = 0,
|
||||
HasAbs2 = 1,
|
||||
HasMin = 1,
|
||||
HasMax = 1,
|
||||
HasConj = 1,
|
||||
HasSetLinear = 0,
|
||||
HasBlend = 0,
|
||||
HasReduxp = 1
|
||||
};
|
||||
};
|
||||
|
||||
#if EIGEN_GNUC_AT_MOST(4, 4) && !EIGEN_COMP_LLVM
|
||||
// workaround gcc 4.2, 4.3 and 4.4 compilatin issue
|
||||
EIGEN_STRONG_INLINE float32x4_t vld1q_f32(const float* x) { return ::vld1q_f32((const float32_t*)x); }
|
||||
@ -231,11 +259,39 @@ template<> struct unpacket_traits<Packet4i>
|
||||
masked_store_available = false
|
||||
};
|
||||
};
|
||||
template<> struct unpacket_traits<Packet2ui>
|
||||
{
|
||||
typedef uint32_t type;
|
||||
typedef Packet2ui half;
|
||||
enum
|
||||
{
|
||||
size = 2,
|
||||
alignment = Aligned16,
|
||||
vectorizable = true,
|
||||
masked_load_available = false,
|
||||
masked_store_available = false
|
||||
};
|
||||
};
|
||||
template<> struct unpacket_traits<Packet4ui>
|
||||
{
|
||||
typedef uint32_t type;
|
||||
typedef Packet2ui half;
|
||||
enum
|
||||
{
|
||||
size = 4,
|
||||
alignment = Aligned16,
|
||||
vectorizable = true,
|
||||
masked_load_available = false,
|
||||
masked_store_available = false
|
||||
};
|
||||
};
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pset1<Packet2f>(const float& from) { return vdup_n_f32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return vdupq_n_f32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pset1<Packet2i>(const int32_t& from) { return vdup_n_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int32_t& from) { return vdupq_n_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pset1<Packet2ui>(const uint32_t& from) { return vdup_n_u32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pset1<Packet4ui>(const uint32_t& from) { return vdupq_n_u32(from); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pset1frombits<Packet2f>(unsigned int from)
|
||||
{ return vreinterpret_f32_u32(vdup_n_u32(from)); }
|
||||
@ -262,16 +318,30 @@ template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int32_t& a)
|
||||
const int32_t c[] = {0,1,2,3};
|
||||
return vaddq_s32(pset1<Packet4i>(a), vld1q_s32(c));
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui plset<Packet2ui>(const uint32_t& a)
|
||||
{
|
||||
const uint32_t c[] = {0,1};
|
||||
return vadd_u32(pset1<Packet2ui>(a), vld1_u32(c));
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui plset<Packet4ui>(const uint32_t& a)
|
||||
{
|
||||
const uint32_t c[] = {0,1,2,3};
|
||||
return vaddq_u32(pset1<Packet4ui>(a), vld1q_u32(c));
|
||||
}
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f padd<Packet2f>(const Packet2f& a, const Packet2f& b) { return vadd_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i padd<Packet2i>(const Packet2i& a, const Packet2i& b) { return vadd_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui padd<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vadd_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui padd<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vaddq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f psub<Packet2f>(const Packet2f& a, const Packet2f& b) { return vsub_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i psub<Packet2i>(const Packet2i& a, const Packet2i& b) { return vsub_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui psub<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vsub_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui psub<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vsubq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pnegate(const Packet2f& a) { return vneg_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); }
|
||||
@ -282,11 +352,15 @@ template<> EIGEN_STRONG_INLINE Packet2f pconj(const Packet2f& a) { return a; }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pconj(const Packet2i& a) { return a; }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pconj(const Packet2ui& a) { return a; }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pconj(const Packet4ui& a) { return a; }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pmul<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmul_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pmul<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmul_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pmul<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmul_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pmul<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vmulq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pdiv<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{
|
||||
@ -349,6 +423,16 @@ template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, co
|
||||
eigen_assert(false && "packet integer division are not supported by NEON");
|
||||
return pset1<Packet4i>(0);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pdiv<Packet2ui>(const Packet2ui& /*a*/, const Packet2ui& /*b*/)
|
||||
{
|
||||
eigen_assert(false && "packet integer division are not supported by NEON");
|
||||
return pset1<Packet2ui>(0);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pdiv<Packet4ui>(const Packet4ui& /*a*/, const Packet4ui& /*b*/)
|
||||
{
|
||||
eigen_assert(false && "packet integer division are not supported by NEON");
|
||||
return pset1<Packet4ui>(0);
|
||||
}
|
||||
|
||||
// Clang/ARM wrongly advertises __ARM_FEATURE_FMA even when it's not available,
|
||||
// then implements a slow software scalar fallback calling fmaf()!
|
||||
@ -393,16 +477,24 @@ template<> EIGEN_STRONG_INLINE Packet2i pmadd(const Packet2i& a, const Packet2i&
|
||||
{ return vmla_s32(c,a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c)
|
||||
{ return vmlaq_s32(c,a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pmadd(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c)
|
||||
{ return vmla_u32(c,a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pmadd(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c)
|
||||
{ return vmlaq_u32(c,a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pmin<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmin_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pmin<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmin_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pmin<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmin_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pmin<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vminq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pmax<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmax_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pmax<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmax_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pmax<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmax_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pmax<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vmaxq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pcmp_le<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(vcle_f32(a,b)); }
|
||||
@ -412,6 +504,10 @@ template<> EIGEN_STRONG_INLINE Packet2i pcmp_le<Packet2i>(const Packet2i& a, con
|
||||
{ return vreinterpret_s32_u32(vcle_s32(a,b)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pcmp_le<Packet4i>(const Packet4i& a, const Packet4i& b)
|
||||
{ return vreinterpretq_s32_u32(vcleq_s32(a,b)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pcmp_le<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return vcle_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pcmp_le<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return vcleq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pcmp_lt<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(vclt_f32(a,b)); }
|
||||
@ -421,6 +517,10 @@ template<> EIGEN_STRONG_INLINE Packet2i pcmp_lt<Packet2i>(const Packet2i& a, con
|
||||
{ return vreinterpret_s32_u32(vclt_s32(a,b)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt<Packet4i>(const Packet4i& a, const Packet4i& b)
|
||||
{ return vreinterpretq_s32_u32(vcltq_s32(a,b)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pcmp_lt<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return vclt_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pcmp_lt<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return vcltq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pcmp_eq<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(vceq_f32(a,b)); }
|
||||
@ -430,6 +530,10 @@ template<> EIGEN_STRONG_INLINE Packet2i pcmp_eq<Packet2i>(const Packet2i& a, con
|
||||
{ return vreinterpret_s32_u32(vceq_s32(a,b)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq<Packet4i>(const Packet4i& a, const Packet4i& b)
|
||||
{ return vreinterpretq_s32_u32(vceqq_s32(a,b)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pcmp_eq<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return vceq_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pcmp_eq<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return vceqq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pcmp_lt_or_nan<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(vmvn_u32(vcge_f32(a,b))); }
|
||||
@ -466,6 +570,10 @@ template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const
|
||||
{ return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pand<Packet2i>(const Packet2i& a, const Packet2i& b) { return vand_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pand<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return vand_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pand<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return vandq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f por<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(vorr_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
|
||||
@ -473,6 +581,10 @@ template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const P
|
||||
{ return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i por<Packet2i>(const Packet2i& a, const Packet2i& b) { return vorr_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui por<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return vorr_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui por<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return vorrq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pxor<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
|
||||
@ -480,6 +592,10 @@ template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const
|
||||
{ return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pxor<Packet2i>(const Packet2i& a, const Packet2i& b) { return veor_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pxor<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return veor_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pxor<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return veorq_u32(a,b); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pandnot<Packet2f>(const Packet2f& a, const Packet2f& b)
|
||||
{ return vreinterpret_f32_u32(vbic_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
|
||||
@ -489,12 +605,20 @@ template<> EIGEN_STRONG_INLINE Packet2i pandnot<Packet2i>(const Packet2i& a, con
|
||||
{ return vbic_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b)
|
||||
{ return vbicq_s32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pandnot<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
|
||||
{ return vbic_u32(a,b); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pandnot<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
|
||||
{ return vbicq_u32(a,b); }
|
||||
|
||||
template<int N> EIGEN_STRONG_INLINE Packet2i pshiftright(Packet2i a) { return vshr_n_s32(a,N); }
|
||||
template<int N> EIGEN_STRONG_INLINE Packet4i pshiftright(Packet4i a) { return vshrq_n_s32(a,N); }
|
||||
template<int N> EIGEN_STRONG_INLINE Packet2ui pshiftright(Packet2ui a) { return vshr_n_u32(a,N); }
|
||||
template<int N> EIGEN_STRONG_INLINE Packet4ui pshiftright(Packet4ui a) { return vshrq_n_u32(a,N); }
|
||||
|
||||
template<int N> EIGEN_STRONG_INLINE Packet2i pshiftleft(Packet2i a) { return vshl_n_s32(a,N); }
|
||||
template<int N> EIGEN_STRONG_INLINE Packet4i pshiftleft(Packet4i a) { return vshlq_n_s32(a,N); }
|
||||
template<int N> EIGEN_STRONG_INLINE Packet2ui pshiftleft(Packet2ui a) { return vshl_n_u32(a,N); }
|
||||
template<int N> EIGEN_STRONG_INLINE Packet4ui pshiftleft(Packet4ui a) { return vshlq_n_u32(a,N); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pload<Packet2f>(const float* from)
|
||||
{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_f32(from); }
|
||||
@ -504,6 +628,10 @@ template<> EIGEN_STRONG_INLINE Packet2i pload<Packet2i>(const int32_t* from)
|
||||
{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int32_t* from)
|
||||
{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pload<Packet2ui>(const uint32_t* from)
|
||||
{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pload<Packet4ui>(const uint32_t* from)
|
||||
{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u32(from); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f ploadu<Packet2f>(const float* from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f32(from); }
|
||||
@ -513,6 +641,10 @@ template<> EIGEN_STRONG_INLINE Packet2i ploadu<Packet2i>(const int32_t* from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int32_t* from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui ploadu<Packet2ui>(const uint32_t* from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui ploadu<Packet4ui>(const uint32_t* from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u32(from); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f ploaddup<Packet2f>(const float* from)
|
||||
{ return vld1_dup_f32(from); }
|
||||
@ -522,9 +654,14 @@ template<> EIGEN_STRONG_INLINE Packet2i ploaddup<Packet2i>(const int32_t* from)
|
||||
{ return vld1_dup_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int32_t* from)
|
||||
{ return vcombine_s32(vld1_dup_s32(from), vld1_dup_s32(from+1)); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui ploaddup<Packet2ui>(const uint32_t* from)
|
||||
{ return vld1_dup_u32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui ploaddup<Packet4ui>(const uint32_t* from)
|
||||
{ return vcombine_u32(vld1_dup_u32(from), vld1_dup_u32(from+1)); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet4f ploadquad<Packet4f>(const float* from) { return vld1q_dup_f32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i ploadquad<Packet4i>(const int32_t* from) { return vld1q_dup_s32(from); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui ploadquad<Packet4ui>(const uint32_t* from) { return vld1q_dup_u32(from); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet2f& from)
|
||||
{ EIGEN_DEBUG_ALIGNED_STORE vst1_f32(to,from); }
|
||||
@ -534,6 +671,10 @@ template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet2i&
|
||||
{ EIGEN_DEBUG_ALIGNED_STORE vst1_s32(to,from); }
|
||||
template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet4i& from)
|
||||
{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to,from); }
|
||||
template<> EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet2ui& from)
|
||||
{ EIGEN_DEBUG_ALIGNED_STORE vst1_u32(to,from); }
|
||||
template<> EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet4ui& from)
|
||||
{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u32(to,from); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet2f& from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_STORE vst1_f32(to,from); }
|
||||
@ -543,6 +684,10 @@ template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet2i
|
||||
{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s32(to,from); }
|
||||
template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet4i& from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to,from); }
|
||||
template<> EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet2ui& from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u32(to,from); }
|
||||
template<> EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet4ui& from)
|
||||
{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u32(to,from); }
|
||||
|
||||
template<> EIGEN_DEVICE_FUNC inline Packet2f pgather<float, Packet2f>(const float* from, Index stride)
|
||||
{
|
||||
@ -572,6 +717,20 @@ template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int32_t, Packet4i>(const in
|
||||
res = vld1q_lane_s32(from + 3*stride, res, 3);
|
||||
return res;
|
||||
}
|
||||
template<> EIGEN_DEVICE_FUNC inline Packet2ui pgather<uint32_t, Packet2ui>(const uint32_t* from, Index stride)
|
||||
{
|
||||
Packet2ui res = vld1_dup_u32(from);
|
||||
res = vld1_lane_u32(from + 1*stride, res, 1);
|
||||
return res;
|
||||
}
|
||||
template<> EIGEN_DEVICE_FUNC inline Packet4ui pgather<uint32_t, Packet4ui>(const uint32_t* from, Index stride)
|
||||
{
|
||||
Packet4ui res = vld1q_dup_u32(from);
|
||||
res = vld1q_lane_u32(from + 1*stride, res, 1);
|
||||
res = vld1q_lane_u32(from + 2*stride, res, 2);
|
||||
res = vld1q_lane_u32(from + 3*stride, res, 3);
|
||||
return res;
|
||||
}
|
||||
|
||||
template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet2f>(float* to, const Packet2f& from, Index stride)
|
||||
{
|
||||
@ -597,14 +756,29 @@ template<> EIGEN_DEVICE_FUNC inline void pscatter<int32_t, Packet4i>(int32_t* to
|
||||
vst1q_lane_s32(to + stride*2, from, 2);
|
||||
vst1q_lane_s32(to + stride*3, from, 3);
|
||||
}
|
||||
template<> EIGEN_DEVICE_FUNC inline void pscatter<uint32_t, Packet2ui>(uint32_t* to, const Packet2ui& from, Index stride)
|
||||
{
|
||||
vst1_lane_u32(to + stride*0, from, 0);
|
||||
vst1_lane_u32(to + stride*1, from, 1);
|
||||
}
|
||||
template<> EIGEN_DEVICE_FUNC inline void pscatter<uint32_t, Packet4ui>(uint32_t* to, const Packet4ui& from, Index stride)
|
||||
{
|
||||
vst1q_lane_u32(to + stride*0, from, 0);
|
||||
vst1q_lane_u32(to + stride*1, from, 1);
|
||||
vst1q_lane_u32(to + stride*2, from, 2);
|
||||
vst1q_lane_u32(to + stride*3, from, 3);
|
||||
}
|
||||
|
||||
template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { EIGEN_ARM_PREFETCH(addr); }
|
||||
template<> EIGEN_STRONG_INLINE void prefetch<int32_t>(const int32_t* addr) { EIGEN_ARM_PREFETCH(addr); }
|
||||
template<> EIGEN_STRONG_INLINE void prefetch<uint32_t>(const uint32_t* addr) { EIGEN_ARM_PREFETCH(addr); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE float pfirst<Packet2f>(const Packet2f& a) { return vget_lane_f32(a,0); }
|
||||
template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return vgetq_lane_f32(a,0); }
|
||||
template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet2i>(const Packet2i& a) { return vget_lane_s32(a,0); }
|
||||
template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet4i>(const Packet4i& a) { return vgetq_lane_s32(a,0); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t pfirst<Packet2ui>(const Packet2ui& a) { return vget_lane_u32(a,0); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(const Packet4ui& a) { return vgetq_lane_u32(a,0); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f preverse(const Packet2f& a) { return vrev64_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
|
||||
@ -618,6 +792,7 @@ template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
|
||||
const int32x4_t a_r64 = vrev64q_s32(a);
|
||||
return vcombine_s32(vget_high_s32(a_r64), vget_low_s32(a_r64));
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui preverse(const Packet2ui& a) { return vrev64_u32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui preverse(const Packet4ui& a)
|
||||
{
|
||||
const uint32x4_t a_r64 = vrev64q_u32(a);
|
||||
@ -628,6 +803,8 @@ template<> EIGEN_STRONG_INLINE Packet2f pabs(const Packet2f& a) { return vabs_f3
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pabs(const Packet2i& a) { return vabs_s32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pabs(const Packet2ui& a) { return a; }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pabs(const Packet4ui& a) { return a; }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pfrexp<Packet2f>(const Packet2f& a, Packet2f& exponent)
|
||||
{ return pfrexp_float(a,exponent); }
|
||||
@ -651,6 +828,12 @@ template<> EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a)
|
||||
const int32x2_t sum = vadd_s32(vget_low_s32(a), vget_high_s32(a));
|
||||
return vget_lane_s32(vpadd_s32(sum, sum), 0);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux<Packet2ui>(const Packet2ui& a) { return vget_lane_u32(vpadd_u32(a,a), 0); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux<Packet4ui>(const Packet4ui& a)
|
||||
{
|
||||
const uint32x2_t sum = vadd_u32(vget_low_u32(a), vget_high_u32(a));
|
||||
return vget_lane_u32(vpadd_u32(sum, sum), 0);
|
||||
}
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f preduxp<Packet2f>(const Packet2f* vecs)
|
||||
{
|
||||
@ -678,6 +861,30 @@ template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
|
||||
const int32x4x2_t res2 = vzipq_s32(vtrn1.val[1], vtrn2.val[1]);
|
||||
return vaddq_s32(vaddq_s32(res1.val[0], res1.val[1]), vaddq_s32(res2.val[0], res2.val[1]));
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui preduxp<Packet2ui>(const Packet2ui* vecs)
|
||||
{
|
||||
const uint32x2x2_t vtrn = vzip_u32(vecs[0], vecs[1]);
|
||||
return vadd_u32(vtrn.val[0], vtrn.val[1]);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui preduxp<Packet4ui>(const Packet4ui* vecs)
|
||||
{
|
||||
uint32x4x2_t vtrn1, vtrn2, res1, res2;
|
||||
Packet4ui sum1, sum2, sum;
|
||||
|
||||
// NEON zip performs interleaving of the supplied vectors.
|
||||
// We perform two interleaves in a row to acquire the transposed vector
|
||||
vtrn1 = vzipq_u32(vecs[0], vecs[2]);
|
||||
vtrn2 = vzipq_u32(vecs[1], vecs[3]);
|
||||
res1 = vzipq_u32(vtrn1.val[0], vtrn2.val[0]);
|
||||
res2 = vzipq_u32(vtrn1.val[1], vtrn2.val[1]);
|
||||
|
||||
// Do the addition of the resulting vectors
|
||||
sum1 = vaddq_u32(res1.val[0], res1.val[1]);
|
||||
sum2 = vaddq_u32(res2.val[0], res2.val[1]);
|
||||
sum = vaddq_u32(sum1, sum2);
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
// Other reduction functions:
|
||||
// mul
|
||||
@ -689,6 +896,10 @@ template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet2i>(const Packet2i& a)
|
||||
{ return vget_lane_s32(a, 0) * vget_lane_s32(a, 1); }
|
||||
template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet4i>(const Packet4i& a)
|
||||
{ return predux_mul(vmul_s32(vget_low_s32(a), vget_high_s32(a))); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux_mul<Packet2ui>(const Packet2ui& a)
|
||||
{ return vget_lane_u32(a, 0) * vget_lane_u32(a, 1); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux_mul<Packet4ui>(const Packet4ui& a)
|
||||
{ return predux_mul(vmul_u32(vget_low_u32(a), vget_high_u32(a))); }
|
||||
|
||||
// min
|
||||
template<> EIGEN_STRONG_INLINE float predux_min<Packet2f>(const Packet2f& a)
|
||||
@ -705,6 +916,13 @@ template<> EIGEN_STRONG_INLINE int32_t predux_min<Packet4i>(const Packet4i& a)
|
||||
const int32x2_t min = vmin_s32(vget_low_s32(a), vget_high_s32(a));
|
||||
return vget_lane_s32(vpmin_s32(min, min), 0);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux_min<Packet2ui>(const Packet2ui& a)
|
||||
{ return vget_lane_u32(vpmin_u32(a,a), 0); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux_min<Packet4ui>(const Packet4ui& a)
|
||||
{
|
||||
const uint32x2_t min = vmin_u32(vget_low_u32(a), vget_high_u32(a));
|
||||
return vget_lane_u32(vpmin_u32(min, min), 0);
|
||||
}
|
||||
|
||||
// max
|
||||
template<> EIGEN_STRONG_INLINE float predux_max<Packet2f>(const Packet2f& a)
|
||||
@ -721,6 +939,13 @@ template<> EIGEN_STRONG_INLINE int32_t predux_max<Packet4i>(const Packet4i& a)
|
||||
const int32x2_t max = vmax_s32(vget_low_s32(a), vget_high_s32(a));
|
||||
return vget_lane_s32(vpmax_s32(max, max), 0);
|
||||
}
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux_max<Packet2ui>(const Packet2ui& a)
|
||||
{ return vget_lane_u32(vpmax_u32(a,a), 0); }
|
||||
template<> EIGEN_STRONG_INLINE uint32_t predux_max<Packet4ui>(const Packet4ui& a)
|
||||
{
|
||||
const uint32x2_t max = vmax_u32(vget_low_u32(a), vget_high_u32(a));
|
||||
return vget_lane_u32(vpmax_u32(max, max), 0);
|
||||
}
|
||||
|
||||
template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
|
||||
{
|
||||
@ -758,6 +983,14 @@ PALIGN_NEON(1, Packet4i, vextq_s32)
|
||||
PALIGN_NEON(2, Packet4i, vextq_s32)
|
||||
PALIGN_NEON(3, Packet4i, vextq_s32)
|
||||
|
||||
PALIGN_NEON(0, Packet2ui, vext_u32)
|
||||
PALIGN_NEON(1, Packet2ui, vext_u32)
|
||||
|
||||
PALIGN_NEON(0, Packet4ui, vextq_u32)
|
||||
PALIGN_NEON(1, Packet4ui, vextq_u32)
|
||||
PALIGN_NEON(2, Packet4ui, vextq_u32)
|
||||
PALIGN_NEON(3, Packet4ui, vextq_u32)
|
||||
|
||||
#undef PALIGN_NEON
|
||||
|
||||
EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2f, 2>& kernel)
|
||||
@ -792,6 +1025,22 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4i, 4>& kernel)
|
||||
kernel.packet[2] = vcombine_s32(vget_low_s32(tmp1.val[1]), vget_low_s32(tmp2.val[1]));
|
||||
kernel.packet[3] = vcombine_s32(vget_high_s32(tmp1.val[1]), vget_high_s32(tmp2.val[1]));
|
||||
}
|
||||
EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2ui, 2>& kernel)
|
||||
{
|
||||
const uint32x2x2_t z = vzip_u32(kernel.packet[0], kernel.packet[1]);
|
||||
kernel.packet[0] = z.val[0];
|
||||
kernel.packet[1] = z.val[1];
|
||||
}
|
||||
EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4ui, 4>& kernel)
|
||||
{
|
||||
const uint32x4x2_t tmp1 = vzipq_u32(kernel.packet[0], kernel.packet[1]);
|
||||
const uint32x4x2_t tmp2 = vzipq_u32(kernel.packet[2], kernel.packet[3]);
|
||||
|
||||
kernel.packet[0] = vcombine_u32(vget_low_u32(tmp1.val[0]), vget_low_u32(tmp2.val[0]));
|
||||
kernel.packet[1] = vcombine_u32(vget_high_u32(tmp1.val[0]), vget_high_u32(tmp2.val[0]));
|
||||
kernel.packet[2] = vcombine_u32(vget_low_u32(tmp1.val[1]), vget_low_u32(tmp2.val[1]));
|
||||
kernel.packet[3] = vcombine_u32(vget_high_u32(tmp1.val[1]), vget_high_u32(tmp2.val[1]));
|
||||
}
|
||||
|
||||
//---------- double ----------
|
||||
|
||||
|
||||
@ -16,22 +16,38 @@ namespace internal {
|
||||
|
||||
template<> struct type_casting_traits<float,numext::int32_t>
|
||||
{ enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; };
|
||||
template<> struct type_casting_traits<float,numext::uint32_t>
|
||||
{ enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; };
|
||||
template<> struct type_casting_traits<numext::int32_t,float>
|
||||
{ enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; };
|
||||
template<> struct type_casting_traits<numext::uint32_t,float>
|
||||
{ enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; };
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pcast<Packet2i,Packet2f>(const Packet2i& a) { return vcvt_f32_s32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2f pcast<Packet2ui,Packet2f>(const Packet2ui& a) { return vcvt_f32_u32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4i,Packet4f>(const Packet4i& a) { return vcvtq_f32_s32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4ui,Packet4f>(const Packet4ui& a) { return vcvtq_f32_u32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i pcast<Packet2f,Packet2i>(const Packet2f& a) { return vcvt_s32_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i pcast<Packet4f,Packet4i>(const Packet4f& a) { return vcvtq_s32_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui pcast<Packet2f,Packet2ui>(const Packet2f& a) { return vcvt_u32_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui pcast<Packet4f,Packet4ui>(const Packet4f& a) { return vcvtq_u32_f32(a); }
|
||||
|
||||
template<> EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f,Packet2i>(const Packet2i& a)
|
||||
{ return vreinterpret_f32_s32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f,Packet2ui>(const Packet2ui& a)
|
||||
{ return vreinterpret_f32_u32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f,Packet4i>(const Packet4i& a)
|
||||
{ return vreinterpretq_f32_s32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f,Packet4ui>(const Packet4ui& a)
|
||||
{ return vreinterpretq_f32_u32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2i preinterpret<Packet2i,Packet2f>(const Packet2f& a)
|
||||
{ return vreinterpret_s32_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet4f>(const Packet4f& a)
|
||||
{ return vreinterpretq_s32_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet2ui preinterpret<Packet2ui,Packet2f>(const Packet2f& a)
|
||||
{ return vreinterpret_u32_f32(a); }
|
||||
template<> EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui,Packet4f>(const Packet4f& a)
|
||||
{ return vreinterpretq_u32_f32(a); }
|
||||
|
||||
} // end namespace internal
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user