Fixed segfault error with the information/statistics display
[mldemos:mldemos.git] / _AlgorithmsPlugins / KPCA / Eigen / src / Core / arch / NEON / PacketMath.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2010 Konstantinos Margaritis <markos@codex.gr>
6 // Heavily based on Gael's SSE version.
7 //
8 // Eigen is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 3 of the License, or (at your option) any later version.
12 //
13 // Alternatively, you can redistribute it and/or
14 // modify it under the terms of the GNU General Public License as
15 // published by the Free Software Foundation; either version 2 of
16 // the License, or (at your option) any later version.
17 //
18 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
19 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
21 // GNU General Public License for more details.
22 //
23 // You should have received a copy of the GNU Lesser General Public
24 // License and a copy of the GNU General Public License along with
25 // Eigen. If not, see <http://www.gnu.org/licenses/>.
26
27 #ifndef EIGEN_PACKET_MATH_NEON_H
28 #define EIGEN_PACKET_MATH_NEON_H
29
30 namespace internal {
31
32 #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
33 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
34 #endif
35
36 // FIXME NEON has 16 quad registers, but since the current register allocator
37 // is so bad, it is much better to reduce it to 8
38 #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
39 #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8
40 #endif
41
42 typedef float32x4_t Packet4f;
43 typedef int32x4_t   Packet4i;
44 typedef uint32x4_t  Packet4ui;
45
46 #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
47   const Packet4f p4f_##NAME = pset1<Packet4f>(X)
48
49 #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
50   const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int>(X))
51
52 #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
53   const Packet4i p4i_##NAME = pset1<Packet4i>(X)
54
55 #ifndef __pld
56 #define __pld(x) asm volatile ( "   pld [%[addr]]\n" :: [addr] "r" (x) : "cc" );
57 #endif
58
59 template<> struct packet_traits<float>  : default_packet_traits
60 {
61   typedef Packet4f type;
62   enum {
63     Vectorizable = 1,
64     AlignedOnScalar = 1,
65     size = 4,
66    
67     HasDiv  = 1,
68     // FIXME check the Has*
69     HasSin  = 0,
70     HasCos  = 0,
71     HasLog  = 0,
72     HasExp  = 0,
73     HasSqrt = 0
74   };
75 };
76 template<> struct packet_traits<int>    : default_packet_traits
77 {
78   typedef Packet4i type;
79   enum {
80     Vectorizable = 1,
81     AlignedOnScalar = 1,
82     size=4
83     // FIXME check the Has*
84   };
85 };
86
87 #if EIGEN_GNUC_AT_MOST(4,4)
88 // workaround gcc 4.2, 4.3 and 4.4 compilatin issue
89 EIGEN_STRONG_INLINE float32x4_t vld1q_f32(const float* x) { return ::vld1q_f32((const float32_t*)x); }
90 EIGEN_STRONG_INLINE float32x2_t vld1_f32 (const float* x) { return ::vld1_f32 ((const float32_t*)x); }
91 EIGEN_STRONG_INLINE void        vst1q_f32(float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); }
92 EIGEN_STRONG_INLINE void        vst1_f32 (float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); }
93 #endif
94
95 template<> struct unpacket_traits<Packet4f> { typedef float  type; enum {size=4}; };
96 template<> struct unpacket_traits<Packet4i> { typedef int    type; enum {size=4}; };
97
98 template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return vdupq_n_f32(from); }
99 template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)   { return vdupq_n_s32(from); }
100
101 template<> EIGEN_STRONG_INLINE Packet4f plset<float>(const float& a)
102 {
103   Packet4f countdown = { 3, 2, 1, 0 };
104   return vaddq_f32(pset1<Packet4f>(a), countdown);
105 }
106 template<> EIGEN_STRONG_INLINE Packet4i plset<int>(const int& a)
107 {
108   Packet4i countdown = { 3, 2, 1, 0 };
109   return vaddq_s32(pset1<Packet4i>(a), countdown);
110 }
111
112 template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); }
113 template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); }
114
115 template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); }
116 template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); }
117
118 template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); }
119 template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return vnegq_s32(a); }
120
121 template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); }
122 template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); }
123
124 template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
125 {
126   Packet4f inv, restep, div;
127
128   // NEON does not offer a divide instruction, we have to do a reciprocal approximation
129   // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
130   // a reciprocal estimate AND a reciprocal step -which saves a few instructions
131   // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
132   // Newton-Raphson and vrecpsq_f32()
133   inv = vrecpeq_f32(b);
134
135   // This returns a differential, by which we will have to multiply inv to get a better
136   // approximation of 1/b.
137   restep = vrecpsq_f32(b, inv);
138   inv = vmulq_f32(restep, inv);
139
140   // Finally, multiply a by 1/b and get the wanted result of the division.
141   div = vmulq_f32(a, inv);
142
143   return div;
144 }
145 template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
146 { eigen_assert(false && "packet integer division are not supported by NEON");
147   return pset1<Packet4i>(0);
148 }
149
150 // for some weird raisons, it has to be overloaded for packet of integers
151 template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); }
152
153 template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); }
154 template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); }
155
156 template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); }
157 template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); }
158
159 // Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
160 template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
161 {
162   return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
163 }
164 template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); }
165
166 template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
167 {
168   return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
169 }
170 template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); }
171
172 template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
173 {
174   return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
175 }
176 template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); }
177
178 template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
179 {
180   return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
181 }
182 template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vbicq_s32(a,b); }
183
184 template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); }
185 template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*   from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); }
186
187 template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); }
188 template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)   { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); }
189
190 template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
191 {
192   float32x2_t lo, hi;
193   lo = vdup_n_f32(*from);
194   hi = vdup_n_f32(*from);
195   return vcombine_f32(lo, hi);
196 }
197 template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
198 {
199   int32x2_t lo, hi;
200   lo = vdup_n_s32(*from);
201   hi = vdup_n_s32(*from);
202   return vcombine_s32(lo, hi);
203 }
204
205 template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); }
206 template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); }
207
208 template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); }
209 template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*      to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); }
210
211 template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { __pld(addr); }
212 template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*     addr) { __pld(addr); }
213
214 // FIXME only store the 2 first elements ?
215 template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; }
216 template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int   EIGEN_ALIGN16 x[4]; vst1q_s32(x, a); return x[0]; }
217
218 template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) {
219   float32x2_t a_lo, a_hi;
220   Packet4f a_r64;
221
222   a_r64 = vrev64q_f32(a);
223   a_lo = vget_low_f32(a_r64);
224   a_hi = vget_high_f32(a_r64);
225   return vcombine_f32(a_hi, a_lo);
226 }
227 template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) {
228   int32x2_t a_lo, a_hi;
229   Packet4i a_r64;
230
231   a_r64 = vrev64q_s32(a);
232   a_lo = vget_low_s32(a_r64);
233   a_hi = vget_high_s32(a_r64);
234   return vcombine_s32(a_hi, a_lo);
235 }
236 template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
237 template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
238
239 template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
240 {
241   float32x2_t a_lo, a_hi, sum;
242   float s[2];
243
244   a_lo = vget_low_f32(a);
245   a_hi = vget_high_f32(a);
246   sum = vpadd_f32(a_lo, a_hi);
247   sum = vpadd_f32(sum, sum);
248   vst1_f32(s, sum);
249
250   return s[0];
251 }
252
253 template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs)
254 {
255   float32x4x2_t vtrn1, vtrn2, res1, res2;
256   Packet4f sum1, sum2, sum;
257
258   // NEON zip performs interleaving of the supplied vectors.
259   // We perform two interleaves in a row to acquire the transposed vector
260   vtrn1 = vzipq_f32(vecs[0], vecs[2]);
261   vtrn2 = vzipq_f32(vecs[1], vecs[3]);
262   res1 = vzipq_f32(vtrn1.val[0], vtrn2.val[0]);
263   res2 = vzipq_f32(vtrn1.val[1], vtrn2.val[1]);
264
265   // Do the addition of the resulting vectors
266   sum1 = vaddq_f32(res1.val[0], res1.val[1]);
267   sum2 = vaddq_f32(res2.val[0], res2.val[1]);
268   sum = vaddq_f32(sum1, sum2);
269
270   return sum;
271 }
272
273 template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
274 {
275   int32x2_t a_lo, a_hi, sum;
276   int32_t s[2];
277
278   a_lo = vget_low_s32(a);
279   a_hi = vget_high_s32(a);
280   sum = vpadd_s32(a_lo, a_hi);
281   sum = vpadd_s32(sum, sum);
282   vst1_s32(s, sum);
283
284   return s[0];
285 }
286
287 template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
288 {
289   int32x4x2_t vtrn1, vtrn2, res1, res2;
290   Packet4i sum1, sum2, sum;
291
292   // NEON zip performs interleaving of the supplied vectors.
293   // We perform two interleaves in a row to acquire the transposed vector
294   vtrn1 = vzipq_s32(vecs[0], vecs[2]);
295   vtrn2 = vzipq_s32(vecs[1], vecs[3]);
296   res1 = vzipq_s32(vtrn1.val[0], vtrn2.val[0]);
297   res2 = vzipq_s32(vtrn1.val[1], vtrn2.val[1]);
298
299   // Do the addition of the resulting vectors
300   sum1 = vaddq_s32(res1.val[0], res1.val[1]);
301   sum2 = vaddq_s32(res2.val[0], res2.val[1]);
302   sum = vaddq_s32(sum1, sum2);
303
304   return sum;
305 }
306
307 // Other reduction functions:
308 // mul
309 template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
310 {
311   float32x2_t a_lo, a_hi, prod;
312   float s[2];
313
314   // Get a_lo = |a1|a2| and a_hi = |a3|a4|
315   a_lo = vget_low_f32(a);
316   a_hi = vget_high_f32(a);
317   // Get the product of a_lo * a_hi -> |a1*a3|a2*a4|
318   prod = vmul_f32(a_lo, a_hi);
319   // Multiply prod with its swapped value |a2*a4|a1*a3|
320   prod = vmul_f32(prod, vrev64_f32(prod));
321   vst1_f32(s, prod);
322
323   return s[0];
324 }
325 template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
326 {
327   int32x2_t a_lo, a_hi, prod;
328   int32_t s[2];
329
330   // Get a_lo = |a1|a2| and a_hi = |a3|a4|
331   a_lo = vget_low_s32(a);
332   a_hi = vget_high_s32(a);
333   // Get the product of a_lo * a_hi -> |a1*a3|a2*a4|
334   prod = vmul_s32(a_lo, a_hi);
335   // Multiply prod with its swapped value |a2*a4|a1*a3|
336   prod = vmul_s32(prod, vrev64_s32(prod));
337   vst1_s32(s, prod);
338
339   return s[0];
340 }
341
342 // min
343 template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
344 {
345   float32x2_t a_lo, a_hi, min;
346   float s[2];
347
348   a_lo = vget_low_f32(a);
349   a_hi = vget_high_f32(a);
350   min = vpmin_f32(a_lo, a_hi);
351   min = vpmin_f32(min, min);
352   vst1_f32(s, min);
353
354   return s[0];
355 }
356 template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
357 {
358   int32x2_t a_lo, a_hi, min;
359   int32_t s[2];
360
361   a_lo = vget_low_s32(a);
362   a_hi = vget_high_s32(a);
363   min = vpmin_s32(a_lo, a_hi);
364   min = vpmin_s32(min, min);
365   vst1_s32(s, min);
366
367   return s[0];
368 }
369
370 // max
371 template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
372 {
373   float32x2_t a_lo, a_hi, max;
374   float s[2];
375
376   a_lo = vget_low_f32(a);
377   a_hi = vget_high_f32(a);
378   max = vpmax_f32(a_lo, a_hi);
379   max = vpmax_f32(max, max);
380   vst1_f32(s, max);
381
382   return s[0];
383 }
384 template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
385 {
386   int32x2_t a_lo, a_hi, max;
387   int32_t s[2];
388
389   a_lo = vget_low_s32(a);
390   a_hi = vget_high_s32(a);
391   max = vpmax_s32(a_lo, a_hi);
392   max = vpmax_s32(max, max);
393   vst1_s32(s, max);
394
395   return s[0];
396 }
397
398 template<int Offset>
399 struct palign_impl<Offset,Packet4f>
400 {
401   EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second)
402   {
403     if (Offset!=0)
404       first = vextq_f32(first, second, Offset);
405   }
406 };
407
408 template<int Offset>
409 struct palign_impl<Offset,Packet4i>
410 {
411   EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second)
412   {
413     if (Offset!=0)
414       first = vextq_s32(first, second, Offset);
415   }
416 };
417
418 } // end namespace internal
419
420 #endif // EIGEN_PACKET_MATH_NEON_H