10 #ifndef EIGEN_PACKET_MATH_ALTIVEC_H
11 #define EIGEN_PACKET_MATH_ALTIVEC_H
17 #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
18 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 4
21 #ifndef EIGEN_HAS_FUSE_CJMADD
22 #define EIGEN_HAS_FUSE_CJMADD 1
26 #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
27 #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
30 typedef __vector
float Packet4f;
31 typedef __vector
int Packet4i;
32 typedef __vector
unsigned int Packet4ui;
33 typedef __vector __bool
int Packet4bi;
34 typedef __vector
short int Packet8i;
35 typedef __vector
unsigned char Packet16uc;
40 #define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \
41 Packet4f p4f_##NAME = (Packet4f) vec_splat_s32(X)
43 #define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
44 Packet4i p4i_##NAME = vec_splat_s32(X)
46 #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
47 Packet4f p4f_##NAME = pset1<Packet4f>(X)
49 #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
50 Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int>(X))
52 #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
53 Packet4i p4i_##NAME = pset1<Packet4i>(X)
56 #define DST_CTRL(size, count, stride) (((size) << 24) | ((count) << 16) | (stride))
59 static Packet4f p4f_COUNTDOWN = { 3.0, 2.0, 1.0, 0.0 };
60 static Packet4i p4i_COUNTDOWN = { 3, 2, 1, 0 };
61 static Packet16uc p16uc_REVERSE = {12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3};
62 static Packet16uc p16uc_FORWARD = vec_lvsl(0, (
float*)0);
63 static Packet16uc p16uc_DUPLICATE = {0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7};
65 static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0);
66 static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0);
67 static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE,1);
68 static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS16,-16);
69 static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1);
70 static Packet4f p4f_ONE = vec_ctf(p4i_ONE, 0);
71 static Packet4f p4f_ZERO_ = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1);
73 template<>
struct packet_traits<float> : default_packet_traits
75 typedef Packet4f type;
89 template<>
struct packet_traits<int> : default_packet_traits
91 typedef Packet4i type;
100 template<>
struct unpacket_traits<Packet4f> {
typedef float type;
enum {size=4}; };
101 template<>
struct unpacket_traits<Packet4i> {
typedef int type;
enum {size=4}; };
147 template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(
const float& from) {
149 float EIGEN_ALIGN16 af[4];
151 Packet4f vc = vec_ld(0, af);
152 vc = vec_splat(vc, 0);
156 template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(
const int& from) {
157 int EIGEN_ALIGN16 ai[4];
159 Packet4i vc = vec_ld(0, ai);
160 vc = vec_splat(vc, 0);
164 template<> EIGEN_STRONG_INLINE Packet4f plset<float>(
const float& a) {
return vec_add(pset1<Packet4f>(a), p4f_COUNTDOWN); }
165 template<> EIGEN_STRONG_INLINE Packet4i plset<int>(
const int& a) {
return vec_add(pset1<Packet4i>(a), p4i_COUNTDOWN); }
167 template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_add(a,b); }
168 template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_add(a,b); }
170 template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_sub(a,b); }
171 template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_sub(a,b); }
173 template<> EIGEN_STRONG_INLINE Packet4f pnegate(
const Packet4f& a) {
return psub<Packet4f>(p4f_ZERO, a); }
174 template<> EIGEN_STRONG_INLINE Packet4i pnegate(
const Packet4i& a) {
return psub<Packet4i>(p4i_ZERO, a); }
176 template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_madd(a,b,p4f_ZERO); }
213 template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(
const Packet4f& a,
const Packet4f& b)
215 Packet4f t, y_0, y_1, res;
221 t = vec_nmsub(y_0, b, p4f_ONE);
222 y_1 = vec_madd(y_0, t, y_0);
224 res = vec_madd(a, y_1, p4f_ZERO);
228 template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(
const Packet4i& ,
const Packet4i& )
229 { eigen_assert(
false &&
"packet integer division are not supported by AltiVec");
230 return pset1<Packet4i>(0);
234 template<> EIGEN_STRONG_INLINE Packet4f pmadd(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
return vec_madd(a, b, c); }
235 template<> EIGEN_STRONG_INLINE Packet4i pmadd(
const Packet4i& a,
const Packet4i& b,
const Packet4i& c) {
return padd(pmul(a,b), c); }
237 template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_min(a, b); }
238 template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_min(a, b); }
240 template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_max(a, b); }
241 template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_max(a, b); }
244 template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_and(a, b); }
245 template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_and(a, b); }
247 template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_or(a, b); }
248 template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_or(a, b); }
250 template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_xor(a, b); }
251 template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_xor(a, b); }
253 template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
return vec_and(a, vec_nor(b, b)); }
254 template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
return vec_and(a, vec_nor(b, b)); }
256 template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(
const float* from) { EIGEN_DEBUG_ALIGNED_LOAD
return vec_ld(0, from); }
257 template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(
const int* from) { EIGEN_DEBUG_ALIGNED_LOAD
return vec_ld(0, from); }
259 template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(
const float* from)
261 EIGEN_DEBUG_ALIGNED_LOAD
265 MSQ = vec_ld(0, (
unsigned char *)from);
266 LSQ = vec_ld(15, (
unsigned char *)from);
267 mask = vec_lvsl(0, from);
268 return (Packet4f) vec_perm(MSQ, LSQ, mask);
271 template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(
const int* from)
273 EIGEN_DEBUG_ALIGNED_LOAD
277 MSQ = vec_ld(0, (
unsigned char *)from);
278 LSQ = vec_ld(15, (
unsigned char *)from);
279 mask = vec_lvsl(0, from);
280 return (Packet4i) vec_perm(MSQ, LSQ, mask);
283 template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(
const float* from)
286 if((ptrdiff_t(&from) % 16) == 0) p = pload<Packet4f>(from);
287 else p = ploadu<Packet4f>(from);
288 return vec_perm(p, p, p16uc_DUPLICATE);
290 template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(
const int* from)
293 if((ptrdiff_t(&from) % 16) == 0) p = pload<Packet4i>(from);
294 else p = ploadu<Packet4i>(from);
295 return vec_perm(p, p, p16uc_DUPLICATE);
298 template<> EIGEN_STRONG_INLINE
void pstore<float>(
float* to,
const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); }
299 template<> EIGEN_STRONG_INLINE
void pstore<int>(
int* to,
const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); }
301 template<> EIGEN_STRONG_INLINE
void pstoreu<float>(
float* to,
const Packet4f& from)
303 EIGEN_DEBUG_UNALIGNED_STORE
306 Packet16uc MSQ, LSQ, edges;
307 Packet16uc edgeAlign, align;
309 MSQ = vec_ld(0, (
unsigned char *)to);
310 LSQ = vec_ld(15, (
unsigned char *)to);
311 edgeAlign = vec_lvsl(0, to);
312 edges=vec_perm(LSQ,MSQ,edgeAlign);
313 align = vec_lvsr( 0, to );
314 MSQ = vec_perm(edges,(Packet16uc)from,align);
315 LSQ = vec_perm((Packet16uc)from,edges,align);
316 vec_st( LSQ, 15, (
unsigned char *)to );
317 vec_st( MSQ, 0, (
unsigned char *)to );
319 template<> EIGEN_STRONG_INLINE
void pstoreu<int>(
int* to,
const Packet4i& from)
321 EIGEN_DEBUG_UNALIGNED_STORE
324 Packet16uc MSQ, LSQ, edges;
325 Packet16uc edgeAlign, align;
327 MSQ = vec_ld(0, (
unsigned char *)to);
328 LSQ = vec_ld(15, (
unsigned char *)to);
329 edgeAlign = vec_lvsl(0, to);
330 edges=vec_perm(LSQ, MSQ, edgeAlign);
331 align = vec_lvsr( 0, to );
332 MSQ = vec_perm(edges, (Packet16uc) from, align);
333 LSQ = vec_perm((Packet16uc) from, edges, align);
334 vec_st( LSQ, 15, (
unsigned char *)to );
335 vec_st( MSQ, 0, (
unsigned char *)to );
338 template<> EIGEN_STRONG_INLINE
void prefetch<float>(
const float* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); }
339 template<> EIGEN_STRONG_INLINE
void prefetch<int>(
const int* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); }
341 template<> EIGEN_STRONG_INLINE
float pfirst<Packet4f>(
const Packet4f& a) {
float EIGEN_ALIGN16 x[4]; vec_st(a, 0, x);
return x[0]; }
342 template<> EIGEN_STRONG_INLINE
int pfirst<Packet4i>(
const Packet4i& a) {
int EIGEN_ALIGN16 x[4]; vec_st(a, 0, x);
return x[0]; }
344 template<> EIGEN_STRONG_INLINE Packet4f preverse(
const Packet4f& a) {
return (Packet4f)vec_perm((Packet16uc)a,(Packet16uc)a, p16uc_REVERSE); }
345 template<> EIGEN_STRONG_INLINE Packet4i preverse(
const Packet4i& a) {
return (Packet4i)vec_perm((Packet16uc)a,(Packet16uc)a, p16uc_REVERSE); }
347 template<> EIGEN_STRONG_INLINE Packet4f pabs(
const Packet4f& a) {
return vec_abs(a); }
348 template<> EIGEN_STRONG_INLINE Packet4i pabs(
const Packet4i& a) {
return vec_abs(a); }
350 template<> EIGEN_STRONG_INLINE
float predux<Packet4f>(
const Packet4f& a)
353 b = (Packet4f) vec_sld(a, a, 8);
355 b = (Packet4f) vec_sld(sum, sum, 4);
356 sum = vec_add(sum, b);
360 template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(
const Packet4f* vecs)
362 Packet4f v[4], sum[4];
367 v[0] = vec_mergeh(vecs[0], vecs[2]);
368 v[1] = vec_mergel(vecs[0], vecs[2]);
369 v[2] = vec_mergeh(vecs[1], vecs[3]);
370 v[3] = vec_mergel(vecs[1], vecs[3]);
372 sum[0] = vec_mergeh(v[0], v[2]);
373 sum[1] = vec_mergel(v[0], v[2]);
374 sum[2] = vec_mergeh(v[1], v[3]);
375 sum[3] = vec_mergel(v[1], v[3]);
379 sum[0] = vec_add(sum[0], sum[1]);
381 sum[1] = vec_add(sum[2], sum[3]);
383 sum[0] = vec_add(sum[0], sum[1]);
388 template<> EIGEN_STRONG_INLINE
int predux<Packet4i>(
const Packet4i& a)
391 sum = vec_sums(a, p4i_ZERO);
392 sum = vec_sld(sum, p4i_ZERO, 12);
396 template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(
const Packet4i* vecs)
398 Packet4i v[4], sum[4];
403 v[0] = vec_mergeh(vecs[0], vecs[2]);
404 v[1] = vec_mergel(vecs[0], vecs[2]);
405 v[2] = vec_mergeh(vecs[1], vecs[3]);
406 v[3] = vec_mergel(vecs[1], vecs[3]);
408 sum[0] = vec_mergeh(v[0], v[2]);
409 sum[1] = vec_mergel(v[0], v[2]);
410 sum[2] = vec_mergeh(v[1], v[3]);
411 sum[3] = vec_mergel(v[1], v[3]);
415 sum[0] = vec_add(sum[0], sum[1]);
417 sum[1] = vec_add(sum[2], sum[3]);
419 sum[0] = vec_add(sum[0], sum[1]);
426 template<> EIGEN_STRONG_INLINE
float predux_mul<Packet4f>(
const Packet4f& a)
429 prod = pmul(a, (Packet4f)vec_sld(a, a, 8));
430 return pfirst(pmul(prod, (Packet4f)vec_sld(prod, prod, 4)));
433 template<> EIGEN_STRONG_INLINE
int predux_mul<Packet4i>(
const Packet4i& a)
435 EIGEN_ALIGN16
int aux[4];
437 return aux[0] * aux[1] * aux[2] * aux[3];
441 template<> EIGEN_STRONG_INLINE
float predux_min<Packet4f>(
const Packet4f& a)
444 b = vec_min(a, vec_sld(a, a, 8));
445 res = vec_min(b, vec_sld(b, b, 4));
449 template<> EIGEN_STRONG_INLINE
int predux_min<Packet4i>(
const Packet4i& a)
452 b = vec_min(a, vec_sld(a, a, 8));
453 res = vec_min(b, vec_sld(b, b, 4));
458 template<> EIGEN_STRONG_INLINE
float predux_max<Packet4f>(
const Packet4f& a)
461 b = vec_max(a, vec_sld(a, a, 8));
462 res = vec_max(b, vec_sld(b, b, 4));
466 template<> EIGEN_STRONG_INLINE
int predux_max<Packet4i>(
const Packet4i& a)
469 b = vec_max(a, vec_sld(a, a, 8));
470 res = vec_max(b, vec_sld(b, b, 4));
475 struct palign_impl<Offset,Packet4f>
477 static EIGEN_STRONG_INLINE
void run(Packet4f& first,
const Packet4f& second)
480 first = vec_sld(first, second, Offset*4);
485 struct palign_impl<Offset,Packet4i>
487 static EIGEN_STRONG_INLINE
void run(Packet4i& first,
const Packet4i& second)
490 first = vec_sld(first, second, Offset*4);
498 #endif // EIGEN_PACKET_MATH_ALTIVEC_H