Debian Codegraph @

packages/stk/stk_unit_tests/stk_simd_old/UnitTestStkSimdMathFloat.cpp

raw
1 #include <gtest/gtest.h>
2 #include <stk_simd/Simd.hpp>
3 #include <cmath>
4 #include <algorithm>
5 #include "SimdFixture.hpp"
6
7 constexpr float floatEpsilon = 5.e-7;
8
9 TEST(StkSimd, SimdAddSubtractMultDivideFloat)
10 {
11 int N = 400000;
12 double t0; // timing variable
13
14 std::vector<float> x(N);
15 std::vector<float> y(N);
16
17 std::vector<float> out1(N);
18 std::vector<float> out2(N);
19
20 for (int n=0; n < N; ++n) {
21 x[n] = 21*(rand()-0.5)/RAND_MAX;
22 y[n] = 26*(rand()-0.4)/RAND_MAX;
23 }
24
25 t0 = -stk::get_time_in_seconds();
26 for(int i=0; i<10; ++i) {
27 for (int n=0; n < N; n+=stk::simd::nfloats) {
28 const stk::simd::Float a = stk::simd::load(x.data() + n);
29 const stk::simd::Float b = stk::simd::load(y.data() + n);
30 const stk::simd::Float c = ( b*(a-b) )/a + 1;
31 stk::simd::store(out1.data() + n,c);
32 }
33 }
34 t0 += stk::get_time_in_seconds();
35 std::cout << "SIMD ADD,SUB,MUL,DIV took " << t0 << " seconds" << std::endl;
36
37 t0 = -stk::get_time_in_seconds();
38 for(int i=0; i<10; ++i) {
39 for (int n=0; n < N; ++n) {
40 const float a = x[n];
41 const float b = y[n];
42 out2[n] = ( b*(a-b) )/a + 1;
43 }
44 }
45 t0 += stk::get_time_in_seconds();
46 std::cout << "Real ADD,SUB,MUL,DIV took " << t0 << " seconds" << std::endl;
47
48 ASSERT_EQ( max_error(out1, out2), 0.0 );
49 }
50
51 TEST(StkSimd, SimdMiscSelfAddSubEtcFloat)
52 {
53 int N = 10000;
54
55 std::vector<float> x(N);
56 std::vector<float> y(N);
57
58 std::vector<float> out1(N);
59 std::vector<float> out2(N);
60
61 for (int n=0; n < N; ++n) {
62 x[n] = 21*(rand()-0.5)/RAND_MAX;
63 y[n] = 26*(rand()-0.4)/RAND_MAX;
64 }
65
66 // *= -a and traits
67
68 for (int n=0; n < N; n+=stk::simd::nfloats) {
69 const stk::simd::Float a = stk::simd::load(x.data() + n);
70 const stk::simd::Float b = stk::simd::load(y.data() + n);
71 stk::simd::Float c = 3.0f;
72 c *= -b + a + stk::Traits<stk::simd::Float>::TWO/5;
73 stk::simd::store(out1.data() + n,c);
74 }
75
76 for (int n=0; n < N; ++n) {
77 const float a = x[n];
78 const float b = y[n];
79 out2[n] = 3.0f;
80 out2[n] *= -b + a + stk::Traits<float>::TWO/5;
81 }
82
83 ASSERT_EQ( max_error(out1, out2), 0.0 );
84
85 for (int n=0; n < N; n+=stk::simd::nfloats) {
86 const stk::simd::Float a = stk::simd::load(x.data() + n);
87 const stk::simd::Float b = stk::simd::load(y.data() + n);
88 stk::simd::Float c = 3.2f;
89 c /= -b+a+5.6f*c;
90 stk::simd::store(out1.data() + n,c);
91 }
92
93 for (int n=0; n < N; ++n) {
94 const float a = x[n];
95 const float b = y[n];
96 out2[n] = 3.2f;
97 out2[n] /= -b+a+5.6f*out2[n];
98 }
99
100 ASSERT_EQ( max_error(out1, out2), 0.0 );
101
102 for (int n=0; n < N; n+=stk::simd::nfloats) {
103 const stk::simd::Float a = stk::simd::load(x.data() + n);
104 const stk::simd::Float b = stk::simd::load(y.data() + n);
105 stk::simd::Float c = stk::Traits<stk::simd::Float>::THIRD;
106 c += -(b/(1.0f-a)+(c+5.2f));
107 stk::simd::store(out1.data() + n,c);
108 }
109
110 for (int n=0; n < N; ++n) {
111 const float a = x[n];
112 const float b = y[n];
113 float c = 1.0/3.0;
114 c += -(b/(1.0f-a)+(c+5.2f));
115 out2[n] = c;
116 }
117
118 ASSERT_EQ( max_error(out1, out2), 0.0);
119
120 for (int n=0; n < N; n+=stk::simd::nfloats) {
121 const stk::simd::Float a = stk::simd::load(x.data() + n);
122 const stk::simd::Float b = stk::simd::load(y.data() + n);
123 stk::simd::Float c = stk::simd::Float(-0.5);
124 c -= 5.2f+(b/(a-5.4f)+3.5f/c);
125 stk::simd::store(out1.data() + n,c);
126 }
127
128 for (int n=0; n < N; ++n) {
129 const float a = x[n];
130 const float b = y[n];
131 out2[n] = -0.5f;
132 out2[n] -= 5.2f+(b/(a-5.4f)+3.5f/out2[n]);
133 }
134
135 ASSERT_EQ( max_error(out1, out2), 0.0 );
136
137 for (int n=0; n < N; n+=stk::simd::nfloats) {
138 const stk::simd::Float a = stk::simd::load(x.data() + n);
139 const stk::simd::Float b = stk::simd::load(y.data() + n);
140 const stk::simd::Float c = -0.3f;
141 const stk::simd::Float d = -c + 1.4f*a/b;
142 stk::simd::store(out1.data() + n,d);
143 }
144
145 for (int n=0; n < N; ++n) {
146 const float a = x[n];
147 const float b = y[n];
148 const float c = -0.3f;
149 out2[n] = -c + 1.4f*a/b;
150 }
151
152 ASSERT_EQ( max_error(out1, out2), 0.0 );
153 }
154
155 TEST(StkSimd, Simd_fmaddFloat)
156 {
157 int N = 400000;
158 double t0; // timing variable
159
160 std::vector<float> x(N);
161 std::vector<float> y(N);
162 std::vector<float> z(N);
163
164 std::vector<float> out1(N);
165 std::vector<float> out2(N);
166
167 for (int n=0; n < N; ++n) {
168 x[n] = 2.1*(rand()-0.5)/RAND_MAX;
169 y[n] = 6.0*(rand()-0.4)/RAND_MAX;
170 z[n] = 6.0*(rand()-0.4)/RAND_MAX;
171 }
172
173 t0 = -stk::get_time_in_seconds();
174 for (int n=0; n < N; n+=stk::simd::nfloats) {
175 const stk::simd::Float a = stk::simd::load(x.data() + n);
176 const stk::simd::Float b = stk::simd::load(y.data() + n);
177 const stk::simd::Float c = stk::simd::load(z.data() + n);
178 stk::simd::Float d = stk::math::fmadd(a,b,c);
179 stk::simd::store(out1.data() + n,d);
180 }
181 t0 += stk::get_time_in_seconds();
182 std::cout << "SIMD ADD,SUB,MUL,DIV took " << t0 << " seconds" << std::endl;
183
184 t0 = -stk::get_time_in_seconds();
185 #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
186 #pragma novector
187 #endif
188 for (int n=0; n < N; ++n) {
189 const float a = x[n];
190 const float b = y[n];
191 const float c = z[n];
192 out2[n] = a*b+c;
193 }
194 t0 += stk::get_time_in_seconds();
195 std::cout << "Real ADD,SUB,MUL,DIV took " << t0 << " seconds" << std::endl;
196
197 ASSERT_NEAR( max_error(out1, out2), 0.0, 1e-5 );
198 }
199
200 TEST(StkSimd, SimdSqrtFloat)
201 {
202 int N = 400000;
203 double t0; // timing variable
204
205 std::vector<float> x(N);
206
207 std::vector<float> out1(N);
208 std::vector<float> out2(N);
209
210 for (int n=0; n < N; ++n) {
211 x[n] = 21.0*(rand()+1)/RAND_MAX;
212 }
213
214 t0 = -stk::get_time_in_seconds();
215 for (int n=0; n < N; n+=stk::simd::nfloats) {
216 const stk::simd::Float a = stk::simd::load(x.data() + n);
217 const stk::simd::Float b = stk::math::sqrt(a);
218 stk::simd::store(out1.data() + n,b);
219 }
220 t0 += stk::get_time_in_seconds();
221 std::cout << "SIMD SQRT took " << t0 << " seconds" << std::endl;
222
223 t0 = -stk::get_time_in_seconds();
224 for (int n=0; n < N; ++n) {
225 const float a = x[n];
226 out2[n] = std::sqrt(a);
227 }
228 t0 += stk::get_time_in_seconds();
229 std::cout << "Real SQRT took " << t0 << " seconds" << std::endl;
230
231 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon );
232 }
233
234 TEST(StkSimd, SimdLogFloat)
235 {
236 int N = 400000;
237 double t0; // timing variable
238
239 std::vector<float> x(N);
240
241 std::vector<float> out1(N);
242 std::vector<float> out2(N);
243
244 for (int n=0; n < N; ++n) {
245 x[n] = 21.0*(rand()+1.0)/RAND_MAX+1.0;
246 }
247
248 t0 = -stk::get_time_in_seconds();
249 for (int n=0; n < N; n+=stk::simd::nfloats) {
250 const stk::simd::Float a = stk::simd::load(x.data() + n);
251 const stk::simd::Float b = stk::math::log(a);
252 stk::simd::store(out1.data() + n,b);
253 }
254 t0 += stk::get_time_in_seconds();
255 std::cout << "SIMD Log took " << t0 << " seconds" << std::endl;
256
257 t0 = -stk::get_time_in_seconds();
258 for (int n=0; n < N; ++n) {
259 const float a = x[n];
260 out2[n] = std::log(a);
261 }
262 t0 += stk::get_time_in_seconds();
263 std::cout << "Real Log took " << t0 << " seconds" << std::endl;
264
265 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon );
266 }
267
268 TEST(StkSimd, SimdExpFloat)
269 {
270 int N = 400000;
271
272 std::vector<float> x(N);
273
274 std::vector<float> out1(N);
275 std::vector<float> out2(N);
276
277 for (int n=0; n < N; ++n) {
278 x[n] = 5.4*(rand()/RAND_MAX-0.5);
279 }
280
281 double t0 = -stk::get_time_in_seconds();
282 for (int n=0; n < N; n+=stk::simd::nfloats) {
283 const stk::simd::Float a = stk::simd::load(x.data() + n);
284 const stk::simd::Float b = stk::math::exp(a);
285 stk::simd::store(out1.data() + n,b);
286 }
287 t0 += stk::get_time_in_seconds();
288 std::cout << "SIMD Exp took " << t0 << " seconds" << std::endl;
289
290 t0 = -stk::get_time_in_seconds();
291 for (int n=0; n < N; ++n) {
292 const float a = x[n];
293 out2[n] = std::exp(a);
294 }
295 t0 += stk::get_time_in_seconds();
296 std::cout << "Real Exp took " << t0 << " seconds" << std::endl;
297
298 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon );
299 }
300
301 TEST(StkSimd, SimdPowAFloat)
302 {
303 const int N = 2000;
304
305 std::vector<float> x(N);
306 std::vector<float> y(N/stk::simd::nfloats);
307
308 std::vector<float> out1(N);
309 std::vector<float> out2(N);
310
311 for (int n=0; n < N; ++n) {
312 x[n] = 5.4*(rand()/RAND_MAX-0.5)+0.002;
313 }
314 for (int n=0; n < N/stk::simd::nfloats; ++n) {
315 y[n] = 3.2*(rand()/RAND_MAX-0.5)+0.2;
316 }
317
318 double t0 = -stk::get_time_in_seconds();
319 for (int n=0; n < N; n+=stk::simd::nfloats) {
320 const stk::simd::Float a = stk::simd::load(x.data() + n);
321 const float b = y[n/stk::simd::nfloats];
322 const stk::simd::Float c = stk::math::pow(a,b);
323 stk::simd::store(out1.data() + n,c);
324 }
325 t0 += stk::get_time_in_seconds();
326 std::cout << "SIMD Pow took " << t0 << " seconds" << std::endl;
327
328 t0 = -stk::get_time_in_seconds();
329 for (int n=0; n < N/stk::simd::nfloats; ++n) {
330 float exp = y[n];
331 for (int i=0; i < stk::simd::nfloats; ++i) {
332 const float a = x[stk::simd::nfloats*n+i];
333 out2[stk::simd::nfloats*n+i] = stk::math::pow(a,exp);
334 }
335 }
336 t0 += stk::get_time_in_seconds();
337 std::cout << "Real Exp took " << t0 << " seconds" << std::endl;
338
339 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon );
340 }
341
342 TEST(StkSimd, SimdPowBFloat)
343 {
344 int N = 400000;
345
346 std::vector<float> x(N);
347 std::vector<float> y(N);
348
349 std::vector<float> out1(N);
350 std::vector<float> out2(N);
351
352 for (int n=0; n < N; ++n) {
353 x[n] = 5.4*(rand()/RAND_MAX-0.5)+0.001;
354 }
355 for (int n=0; n < N; ++n) {
356 y[n] = 3.2*(rand()/RAND_MAX-0.5)+0.1;
357 }
358
359 double t0 = -stk::get_time_in_seconds();
360 for (int n=0; n < N; n+=stk::simd::nfloats) {
361 const stk::simd::Float a = stk::simd::load(x.data() + n);
362 const stk::simd::Float b = stk::simd::load(y.data() + n);
363 const stk::simd::Float c = stk::math::pow(a,b);
364 stk::simd::store(out1.data() + n,c);
365 }
366 t0 += stk::get_time_in_seconds();
367 std::cout << "SIMD Pow took " << t0 << " seconds" << std::endl;
368
369 t0 = -stk::get_time_in_seconds();
370 for (int n=0; n < N; ++n) {
371 const float a = x[n];
372 const float b = y[n];
373 out2[n] = std::pow(a,b);
374 }
375 t0 += stk::get_time_in_seconds();
376 std::cout << "Real Pow took " << t0 << " seconds" << std::endl;
377
378 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon);
379 }
380
381 TEST(StkSimd, SimdPowCFloat)
382 {
383 int N = 100000;
384 double t0; // timing variable
385
386 std::vector<float> x(N);
387 std::vector<float> out1(N);
388 std::vector<float> out2(N);
389
390 for (int n=0; n < N; ++n) {
391 x[n] = 1.34*(rand()/RAND_MAX-0.5);
392 }
393
394 t0 = -stk::get_time_in_seconds();
395 for (int n=0; n < N; n+=stk::simd::nfloats) {
396 const stk::simd::Float a = stk::simd::load(x.data() + n);
397 const stk::simd::Float c = stk::math::pow(a,3);
398 stk::simd::store(out1.data() + n,c);
399 }
400 t0 += stk::get_time_in_seconds();
401 std::cout << "SIMD Exp took " << t0 << " seconds" << std::endl;
402
403 t0 = -stk::get_time_in_seconds();
404 for (int n=0; n < N; ++n) {
405 const float a = x[n];
406 out2[n] = std::pow(a,3);
407 }
408 t0 += stk::get_time_in_seconds();
409 std::cout << "Real Exp took " << t0 << " seconds" << std::endl;
410
411 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon);
412 }
413
414 TEST(StkSimd, SimdCbrtFloat)
415 {
416 int N = 800000;
417 double t0; // timing variable
418
419 std::vector<float> x(N);
420
421 std::vector<float> out1(N);
422 std::vector<float> out2(N);
423
424 for (int n=0; n < N; ++n) {
425 x[n] = 21.*(rand()-0.5)/RAND_MAX;
426 }
427
428 t0 = -stk::get_time_in_seconds();
429 for (int n=0; n < N; n+=stk::simd::nfloats) {
430 const stk::simd::Float xl = stk::simd::load(x.data() + n);
431 const stk::simd::Float d = stk::math::cbrt(xl);
432 stk::simd::store(out1.data() + n,d);
433 }
434 t0 += stk::get_time_in_seconds();
435 std::cout << "SIMD cbrt took " << t0 << " seconds" << std::endl;
436
437 t0 = -stk::get_time_in_seconds();
438 for (int n=0; n < N; ++n) {
439 out2[n] = stk::math::cbrt(x[n]);
440 }
441 t0 += stk::get_time_in_seconds();
442 std::cout << "Real cbrt took " << t0 << " seconds" << std::endl;
443
444 ASSERT_NEAR( max_error(out1, out2), 0.0, floatEpsilon );
445 }
446
447 TEST(StkSimd, SimdTimeLoadStoreDataLayoutFloat)
448 {
449 double t0;
450
451 const int N = 20000;
452 const int sz = 32;
453
454 std::vector<float,non_std::AlignedAllocator<float,64> > x(sz*N);
455 std::vector<float,non_std::AlignedAllocator<float,64> > y(sz*N);
456 std::vector<float,non_std::AlignedAllocator<float,64> > z(sz*N);
457 std::vector<float,non_std::AlignedAllocator<float,64> > w(sz*N);
458
459 for (int n=0; n < N; ++n) {
460 for (int i=0; i < sz; ++i) {
461 x[sz*n+i] = 1+std::sqrt(n+n*(i+1));
462 }
463 }
464
465 float* X = x.data();
466 float* Y = y.data();
467
468 stk::simd::Float a[sz];
469
470 t0 = -stk::get_time_in_seconds();
471 for (int n=0; n < N; n+=stk::simd::nfloats, X+=sz*stk::simd::nfloats, Y+=sz*stk::simd::nfloats) {
472 // load the slow way
473 for (int i=0; i < sz; ++i) a[i] = stk::simd::load( X+i, sz );
474 // store the slow way
475 for (int i=0; i < sz; ++i) stk::simd::store( Y+i, a[i]+stk::simd::Float(1.0), sz );
476 }
477
478 t0 += stk::get_time_in_seconds();
479 std::cout << "Method 1: Offset load/store, took " << t0 << " seconds" << std::endl;
480
481 // reorder the arrays...
482 const int ssz = sz*stk::simd::nfloats;
483 float tmp[ssz];
484
485 for (int n=0; n < N; n+=stk::simd::nfloats) {
486 for (int i=0; i < sz; ++i) {
487 for (int j=0; j < stk::simd::nfloats; ++j) {
488 tmp[sz*j+i] = x[sz*n+sz*j+i];
489 }
490 }
491 for (int i=0; i < sz; ++i) {
492 for (int j=0; j < stk::simd::nfloats; ++j) {
493 x[sz*n+stk::simd::nfloats*i+j] = tmp[sz*j+i];
494 }
495 }
496 }
497
498 X = x.data();
499 Y = z.data();
500
501 t0 = -stk::get_time_in_seconds();
502 for (int n=0; n < N; n+=stk::simd::nfloats, X+=sz*stk::simd::nfloats, Y+=sz*stk::simd::nfloats) {
503
504 for (int i=0; i < sz; ++i) {
505 a[i] = stk::simd::load( X+stk::simd::nfloats*i );
506 }
507
508 for (int i=0; i < sz; ++i) {
509 stk::simd::store( Y+stk::simd::nfloats*i, a[i]+stk::simd::Float(1.0) );
510 }
511
512 }
513 t0 += stk::get_time_in_seconds();
514 std::cout << "Method 2: Reordered load, took " << t0 << " seconds" << std::endl;
515
516 X = x.data();
517 Y = w.data();
518
519 stk::simd::Float* XX = stk::simd::simd_ptr_cast<float>(X);
520 stk::simd::Float* YY = stk::simd::simd_ptr_cast<float>(Y);
521
522 t0 = -stk::get_time_in_seconds();
523
524 for (int n=0,i=0; n < N; n+=stk::simd::nfloats) {
525 for (int j=0; j < sz; ++j,++i) {
526 YY[i] = XX[i] + stk::simd::Float(1.0);
527 }
528
529 }
530 t0 += stk::get_time_in_seconds();
531 std::cout << "Method 3: Load/Store in place, took " << t0 << " seconds" << std::endl;
532
533 //reorder back! (y and w)
534 for (int n=0; n < N; n+=stk::simd::nfloats) {
535 for (int i=0; i < sz; ++i) {
536 for (int j=0; j < stk::simd::nfloats; ++j) {
537 tmp[sz*j+i] = z[sz*n+stk::simd::nfloats*i+j];
538 }
539 }
540 for (int i=0; i < sz; ++i) {
541 for (int j=0; j < stk::simd::nfloats; ++j) {
542 z[sz*n+sz*j+i] = tmp[sz*j+i];
543 }
544 }
545 }
546
547 for (int n=0; n < N; n+=stk::simd::nfloats) {
548 for (int i=0; i < sz; ++i) {
549 for (int j=0; j < stk::simd::nfloats; ++j) {
550 tmp[sz*j+i] = w[sz*n+stk::simd::nfloats*i+j];
551 }
552 }
553 for (int i=0; i < sz; ++i) {
554 for (int j=0; j < stk::simd::nfloats; ++j) {
555 w[sz*n+sz*j+i] = tmp[sz*j+i];
556 }
557 }
558 }
559
560 // figure out error
561 ASSERT_NEAR( max_error(y, z), 0.0, floatEpsilon );
562 ASSERT_NEAR( max_error(y, w), 0.0, floatEpsilon );
563 }
564
565 TEST(StkSimd, SimdTimeLoadStoreInnerProductFloat)
566 {
567 double t0;
568
569 const int N = 20000;
570 const int sz = 32;
571
572 std::vector<float,non_std::AlignedAllocator<float,64> > x(sz*N);
573 std::vector<float,non_std::AlignedAllocator<float,64> > y(N);
574 std::vector<float,non_std::AlignedAllocator<float,64> > z(N);
575 std::vector<float,non_std::AlignedAllocator<float,64> > w(N);
576
577 for (int n=0; n < N; ++n) {
578 for (int i=0; i < sz; ++i) {
579 x[sz*n+i] = 1+std::sqrt(n+n*(i+1));
580 }
581 }
582
583 float* X = x.data();
584 float* Y = y.data();
585
586 t0 = -stk::get_time_in_seconds();
587 for (int n=0; n < N; n+=stk::simd::nfloats, X+=sz*stk::simd::nfloats, Y+=stk::simd::nfloats) {
588 // load the slow way
589 stk::simd::Float dot = stk::simd::Float(0.0);
590 for (int i=0; i < sz; ++i) {
591 stk::simd::Float tmp = stk::simd::load( X+i, sz );
592 dot += tmp*tmp;
593 }
594 stk::simd::store( Y, dot );
595 }
596
597 t0 += stk::get_time_in_seconds();
598 std::cout << "Method 1: Offset load/store, took " << t0 << " seconds" << std::endl;
599
600 // reorder the arrays...
601 const int ssz = sz*stk::simd::nfloats;
602 float tmp[ssz];
603
604 for (int n=0; n < N; n+=stk::simd::nfloats) {
605 for (int i=0; i < sz; ++i) {
606 for (int j=0; j < stk::simd::nfloats; ++j) {
607 tmp[sz*j+i] = x[sz*n+sz*j+i];
608 }
609 }
610 for (int i=0; i < sz; ++i) {
611 for (int j=0; j < stk::simd::nfloats; ++j) {
612 x[sz*n+stk::simd::nfloats*i+j] = tmp[sz*j+i];
613 }
614 }
615 }
616
617 X = x.data();
618 Y = z.data();
619
620 t0 = -stk::get_time_in_seconds();
621 for (int n=0; n < N; n+=stk::simd::nfloats, X+=sz*stk::simd::nfloats, Y+=stk::simd::nfloats) {
622 stk::simd::Float dot = stk::simd::Float(0.0);
623 for (int i=0; i < sz; ++i) {
624 const stk::simd::Float tmpFloats = stk::simd::load( X+stk::simd::nfloats*i );
625 dot += tmpFloats*tmpFloats;
626 }
627
628 stk::simd::store( Y, dot );
629
630 }
631 t0 += stk::get_time_in_seconds();
632 std::cout << "Method 2: Reordered load, took " << t0 << " seconds" << std::endl;
633
634 X = x.data();
635 Y = w.data();
636
637 const stk::simd::Float* XX = stk::simd::simd_ptr_cast<float>(X);
638 stk::simd::Float* YY = stk::simd::simd_ptr_cast<float>(Y);
639
640 t0 = -stk::get_time_in_seconds();
641
642 for (int n=0; n < N; n+=stk::simd::nfloats) {
643 stk::simd::Float dot = stk::simd::Float(0.0);
644 for (int i=0; i < sz; ++i) {
645 const stk::simd::Float tmpFloats = XX[i];
646 dot += tmpFloats*tmpFloats;
647 }
648 XX+=sz;
649 *(YY++) = dot;
650 }
651 t0 += stk::get_time_in_seconds();
652 std::cout << "Method 3: Load/Store in place, took " << t0 << " seconds" << std::endl;
653
654 //reorder back! (y and w)
655 for (int n=0; n < N; n+=stk::simd::nfloats) {
656 for (int i=0; i < 1; ++i) {
657 for (int j=0; j < stk::simd::nfloats; ++j) {
658 tmp[1*j+i] = z[1*n+stk::simd::nfloats*i+j];
659 }
660 }
661 for (int i=0; i < 1; ++i) {
662 for (int j=0; j < stk::simd::nfloats; ++j) {
663 z[1*n+1*j+i] = tmp[1*j+i];
664 }
665 }
666 }
667
668 for (int n=0; n < N; n+=stk::simd::nfloats) {
669 for (int i=0; i < 1; ++i) {
670 for (int j=0; j < stk::simd::nfloats; ++j) {
671 tmp[1*j+i] = w[1*n+stk::simd::nfloats*i+j];
672 }
673 }
674 for (int i=0; i < 1; ++i) {
675 for (int j=0; j < stk::simd::nfloats; ++j) {
676 w[1*n+1*j+i] = tmp[1*j+i];
677 }
678 }
679 }
680
681 // figure out error
682 ASSERT_NEAR( max_error(y,z), 0.0, floatEpsilon );
683 ASSERT_NEAR( max_error(y,w), 0.0, floatEpsilon );
684 }
685
686
687 TEST(StkSimd, SimdIfThenBoolFloat)
688 {
689 typedef stk::Traits<float>::bool_type float_bool;
690 typedef stk::Traits<stk::simd::Float>::bool_type Floats_bool;
691
692 ASSERT_TRUE( stk::simd::are_all( stk::Traits<stk::simd::Float>::TRUE_VAL ) );
693 ASSERT_TRUE( stk::Traits<float>::TRUE_VAL );
694
695 ASSERT_FALSE( stk::simd::are_all( stk::Traits<stk::simd::Float>::FALSE_VAL ) );
696 ASSERT_FALSE( stk::Traits<float>::FALSE_VAL );
697
698 const int N = 2000;
699 const float a = 5.1;
700 const float b = -3.2;
701
702 std::vector<float> x(N);
703 std::vector<float> y(N);
704 std::vector<float> x2(N);
705 std::vector<float> y2(N);
706 std::vector<float> z1(N);
707 std::vector<float> z2(N);
708 std::vector<float> z3(N);
709
710 for (int n=0; n < N; ++n) {
711 x[n] = (rand()-0.5)/RAND_MAX;
712 y[n] = rand()/RAND_MAX;
713 x2[n] = (rand()-0.1)/RAND_MAX;
714 y2[n] = (rand()+0.5)/RAND_MAX;
715 }
716
717 y[10] = x[10] = 5;
718 y[33] = x[33] = 6.4;
719 y[101]= x[101]= -3;
720
721 // less than
722
723 for (int n=0; n < N; n+=stk::simd::nfloats) {
724 for (int i=0; i < stk::simd::nfloats; ++i) {
725 z2[n+i] = x[n+i] < y[n+i] ? a : b;
726 float_bool tmp = x[n+i] < y[n+i];
727 z3[n+i] = stk::math::if_then_else(tmp,a,b);
728 }
729 const stk::simd::Float xl = stk::simd::load(x.data() + n);
730 const stk::simd::Float yl = stk::simd::load(y.data() + n);
731
732 stk::simd::Float zl = stk::math::if_then_else(xl < yl, stk::simd::Float(a), stk::simd::Float(b));
733 stk::simd::store(&z1[n],zl);
734 }
735
736 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
737
738 // less than equal
739
740 for (int n=0; n < N; n+=stk::simd::nfloats) {
741 for (int i=0; i < stk::simd::nfloats; ++i) {
742 z2[n+i] = x[n+i] <= y[n+i] ? a : b;
743 float_bool tmp = x[n+i] <= y[n+i];
744 z3[n+i] = stk::math::if_then_else(tmp,a,b);
745 }
746 const stk::simd::Float xl = stk::simd::load(x.data() + n);
747 const stk::simd::Float yl = stk::simd::load(y.data() + n);
748
749 stk::simd::Float zl = stk::math::if_then_else(xl <= yl, stk::simd::Float(a), stk::simd::Float(b));
750 stk::simd::store(&z1[n],zl);
751 }
752
753 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
754
755 // equal
756
757 for (int n=0; n < N; n+=stk::simd::nfloats) {
758 for (int i=0; i < stk::simd::nfloats; ++i) {
759 z2[n+i] = x[n+i] == y[n+i] ? a : b;
760 float_bool tmp = x[n+i] == y[n+i];
761 z3[n+i] = stk::math::if_then_else(tmp,a,b);
762 }
763 const stk::simd::Float xl = stk::simd::load(x.data() + n);
764 const stk::simd::Float yl = stk::simd::load(y.data() + n);
765
766 stk::simd::Float zl = stk::math::if_then_else(xl == yl, stk::simd::Float(a), stk::simd::Float(b));
767 stk::simd::store(&z1[n],zl);
768 }
769
770 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
771
772 // greater than equal
773
774 for (int n=0; n < N; n+=stk::simd::nfloats) {
775 for (int i=0; i < stk::simd::nfloats; ++i) {
776 z2[n+i] = x[n+i] >= y[n+i] ? a : b;
777 float_bool tmp = x[n+i] >= y[n+i];
778 z3[n+i] = stk::math::if_then_else(tmp,a,b);
779 }
780 const stk::simd::Float xl = stk::simd::load(x.data() + n);
781 const stk::simd::Float yl = stk::simd::load(y.data() + n);
782
783 stk::simd::Float zl = stk::math::if_then_else(xl >= yl, stk::simd::Float(a), stk::simd::Float(b));
784 stk::simd::store(&z1[n],zl);
785 }
786
787 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
788
789 // greater than
790
791 for (int n=0; n < N; n+=stk::simd::nfloats) {
792 for (int i=0; i < stk::simd::nfloats; ++i) {
793 z2[n+i] = x[n+i] > y[n+i] ? a : b;
794 float_bool tmp = x[n+i] > y[n+i];
795 z3[n+i] = stk::math::if_then_else(tmp,a,b);
796 }
797 const stk::simd::Float xl = stk::simd::load(x.data() + n);
798 const stk::simd::Float yl = stk::simd::load(y.data() + n);
799
800 stk::simd::Float zl = stk::math::if_then_else(xl > yl, stk::simd::Float(a), stk::simd::Float(b));
801 stk::simd::store(&z1[n],zl);
802 }
803
804 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
805
806 // not equal
807
808 for (int n=0; n < N; n+=stk::simd::nfloats) {
809 for (int i=0; i < stk::simd::nfloats; ++i) {
810 z2[n+i] = x[n+i] != y[n+i] ? a : b;
811 float_bool tmp = x[n+i] != y[n+i];
812 z3[n+i] = stk::math::if_then_else(tmp,a,b);
813 }
814 const stk::simd::Float xl = stk::simd::load(x.data() + n);
815 const stk::simd::Float yl = stk::simd::load(y.data() + n);
816
817 stk::simd::Float zl = stk::math::if_then_else(xl != yl, stk::simd::Float(a), stk::simd::Float(b));
818 stk::simd::store(&z1[n],zl);
819 }
820
821 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
822
823 // if then zero
824
825 for (int n=0; n < N; n+=stk::simd::nfloats) {
826 for (int i=0; i < stk::simd::nfloats; ++i) {
827 z2[n+i] = x[n+i] < y[n+i] ? a : 0;
828 float_bool tmp = x[n+i] < y[n+i];
829 z3[n+i] = stk::math::if_then_else_zero(tmp,a);
830 }
831 const stk::simd::Float xl = stk::simd::load(x.data() + n);
832 const stk::simd::Float yl = stk::simd::load(y.data() + n);
833
834 stk::simd::Float zl = stk::math::if_then_else_zero(xl < yl, stk::simd::Float(a));
835 stk::simd::store(&z1[n],zl);
836 }
837
838 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
839
840 // if ! then
841
842 for (int n=0; n < N; n+=stk::simd::nfloats) {
843 for (int i=0; i < stk::simd::nfloats; ++i) {
844 z2[n+i] = !(x[n+i] < y[n+i]) ? a : b;
845 float_bool tmp = x[n+i] < y[n+i];
846 z3[n+i] = stk::math::if_then_else(!tmp,a,b);
847 }
848 const stk::simd::Float xl = stk::simd::load(x.data() + n);
849 const stk::simd::Float yl = stk::simd::load(y.data() + n);
850 Floats_bool tmp = xl < yl;
851 stk::simd::Float zl = stk::math::if_then_else(!tmp, stk::simd::Float(a),stk::simd::Float(b));
852 stk::simd::store(&z1[n],zl);
853 }
854
855 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
856
857 // &&
858
859 for (int n=0; n < N; n+=stk::simd::nfloats) {
860 for (int i=0; i < stk::simd::nfloats; ++i) {
861 float_bool tmp = x[n+i] < y[n+i];
862 float_bool tmp2 = x2[n+i] > y2[n+i];
863 z2[n+i] = (tmp&tmp2) ? a : b;
864 z3[n+i] = stk::math::if_then_else(tmp&&tmp2,a,b);
865 }
866 const stk::simd::Float xl = stk::simd::load(x.data() + n);
867 const stk::simd::Float yl = stk::simd::load(y.data() + n);
868 const stk::simd::Float xl2 = stk::simd::load(x2.data() + n);
869 const stk::simd::Float yl2 = stk::simd::load(y2.data() + n);
870 Floats_bool tmp = xl < yl;
871 Floats_bool tmp2 = xl2 > yl2;
872 stk::simd::Float zl = stk::math::if_then_else(tmp&&tmp2, stk::simd::Float(a),stk::simd::Float(b));
873 stk::simd::store(&z1[n],zl);
874 }
875
876 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
877
878 // ||
879
880 for (int n=0; n < N; n+=stk::simd::nfloats) {
881 for (int i=0; i < stk::simd::nfloats; ++i) {
882 float_bool tmp = x[n+i] < y[n+i];
883 float_bool tmp2 = x2[n+i] > y2[n+i];
884 z2[n+i] = (tmp|tmp2) ? a : b;
885 z3[n+i] = stk::math::if_then_else(tmp||tmp2,a,b);
886 }
887 const stk::simd::Float xl = stk::simd::load(x.data() + n);
888 const stk::simd::Float yl = stk::simd::load(y.data() + n);
889 const stk::simd::Float xl2 = stk::simd::load(x2.data() + n);
890 const stk::simd::Float yl2 = stk::simd::load(y2.data() + n);
891 Floats_bool tmp = xl < yl;
892 Floats_bool tmp2 = xl2 > yl2;
893 stk::simd::Float zl = stk::math::if_then_else(tmp||tmp2,
894 stk::simd::Float(a),
895 stk::simd::Float(b));
896 stk::simd::store(&z1[n],zl);
897 }
898
899 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
900
901 // any
902
903 for (int n=0; n < N; n+=stk::simd::nfloats) {
904 bool anyl=false;
905 for (int i=0; i < stk::simd::nfloats; ++i) {
906 float_bool tmp = x[n+i] < y[n+i];
907 anyl = tmp|anyl;
908 }
909 const stk::simd::Float xl = stk::simd::load(x.data() + n);
910 const stk::simd::Float yl = stk::simd::load(y.data() + n);
911 Floats_bool tmp = xl < yl;
912 bool anyl_simd = stk::simd::are_any(tmp,stk::simd::nfloats);
913
914 ASSERT_TRUE(anyl_simd==anyl);
915
916 }
917
918 // all
919
920 for (int n=0; n < N; n+=stk::simd::nfloats) {
921 bool alll=true;
922 for (int i=0; i < stk::simd::nfloats; ++i) {
923 float_bool tmp = x[n+i] < y[n+i];
924 alll = tmp&alll;
925 }
926 const stk::simd::Float xl = stk::simd::load(x.data() + n);
927 const stk::simd::Float yl = stk::simd::load(y.data() + n);
928 Floats_bool tmp = xl < yl;
929 bool alll_simd = stk::simd::are_all(tmp,stk::simd::nfloats);
930
931 ASSERT_TRUE(alll_simd==alll);
932
933 }
934
935 #if defined(StkSimd_SIMD) // these don't make sense for non-simd
936
937 for (int n=0; n < N; n+=stk::simd::nfloats) {
938 bool anyl=false;
939 for (int i=0; i < stk::simd::nfloats-1; ++i) {
940 float_bool tmp = x[n+i] < y[n+i];
941 anyl = tmp|anyl;
942 }
943 const stk::simd::Float xl = stk::simd::load(x.data() + n);
944 const stk::simd::Float yl = stk::simd::load(y.data() + n);
945 Floats_bool tmp = xl < yl;
946 bool anyl_simd = stk::simd::are_any(tmp,stk::simd::nfloats-1);
947
948 ASSERT_TRUE(anyl_simd==anyl);
949
950 }
951
952 // all (partial)
953
954 for (int n=0; n < N; n+=stk::simd::nfloats) {
955 bool alll=true;
956 for (int i=0; i < stk::simd::nfloats-1; ++i) {
957 float_bool tmp = x[n+i] < y[n+i];
958 alll = tmp&alll;
959 }
960 const stk::simd::Float xl = stk::simd::load(x.data() + n);
961 const stk::simd::Float yl = stk::simd::load(y.data() + n);
962 Floats_bool tmp = xl < yl;
963 bool alll_simd = stk::simd::are_all(tmp,stk::simd::nfloats-1);
964
965 ASSERT_TRUE(alll_simd==alll);
966
967 }
968
969 #endif
970 }
971
972 TEST(StkSimd, SimdSpecialFunctionsFloat)
973 {
974 const int N = 2000;
975
976 std::vector<float> x(N);
977 std::vector<float> y(N);
978 std::vector<float> z1(N);
979 std::vector<float> z2(N);
980 std::vector<float> z3(N);
981
982 for (int n=0; n < N; ++n) {
983 x[n] = (rand()-0.5)/RAND_MAX;
984 y[n] = (rand()-0.5)/RAND_MAX;
985 }
986
987 // abs
988
989 for (int n=0; n < N; n+=stk::simd::nfloats) {
990 for (int i=0; i < stk::simd::nfloats; ++i) {
991 z2[n+i] = std::abs(x[n+i]);
992 z3[n+i] = stk::math::abs(x[n+i]);
993 }
994 const stk::simd::Float xl = stk::simd::load(x.data() + n);
995 stk::simd::Float zl = stk::math::abs(xl);
996 stk::simd::store(&z1[n],zl);
997 }
998
999 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
1000
1001 // max
1002
1003 for (int n=0; n < N; n+=stk::simd::nfloats) {
1004 for (int i=0; i < stk::simd::nfloats; ++i) {
1005 z2[n+i] = stk::math::max(x[n+i],y[n+i]);
1006 z3[n+i] = stk::math::max(x[n+i],y[n+i]);
1007 }
1008 const stk::simd::Float xl = stk::simd::load(x.data() + n);
1009 const stk::simd::Float yl = stk::simd::load(y.data() + n);
1010 stk::simd::Float zl = stk::math::max(xl,yl);
1011 stk::simd::store(&z1[n],zl);
1012 }
1013
1014 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
1015
1016 // min
1017
1018 for (int n=0; n < N; n+=stk::simd::nfloats) {
1019 for (int i=0; i < stk::simd::nfloats; ++i) {
1020 z2[n+i] = stk::math::min(x[n+i],y[n+i]);
1021 z3[n+i] = stk::math::min(x[n+i],y[n+i]);
1022 }
1023 const stk::simd::Float xl = stk::simd::load(x.data() + n);
1024 const stk::simd::Float yl = stk::simd::load(y.data() + n);
1025 stk::simd::Float zl = stk::math::min(xl,yl);
1026 stk::simd::store(&z1[n],zl);
1027 }
1028
1029 ASSERT_NEAR( max_error(z1, z2, z3), 0.0, floatEpsilon );
1030 }
1031
1032 TEST(StkSimd, SimdTimeSet1VsConstFloats)
1033 {
1034 int N = 1000000;
1035 double t0; // timing variable
1036
1037 std::vector<float> x(N);
1038
1039 std::vector<float> out1(N);
1040 std::vector<float> out2(N);
1041 std::vector<float> out3(N);
1042 std::vector<float> out4(N);
1043
1044 const float three = 3.0;
1045 const float two = 2.0;
1046
1047 for (int n=0; n < N; ++n) {
1048 x[n] = 21*(rand()-0.5)/RAND_MAX;
1049 }
1050
1051 t0 = -stk::get_time_in_seconds();
1052 for (int n=0; n < N; n+=stk::simd::nfloats) {
1053 const stk::simd::Float a = stk::simd::load(x.data() + n);
1054 stk::simd::store(out1.data() + n,stk::Traits<stk::simd::Float>::TWO+(a+stk::Traits<stk::simd::Float>::THREE));
1055 }
1056 t0 += stk::get_time_in_seconds();
1057 std::cout << "Adding a const Floats took " << t0 << " seconds" << std::endl;
1058
1059 t0 = -stk::get_time_in_seconds();
1060 for (int n=0; n < N; n+=stk::simd::nfloats) {
1061 const stk::simd::Float a = stk::simd::load(x.data() + n);
1062 stk::simd::store(out2.data() + n,stk::simd::Float(2.0)+(a+stk::simd::Float(3.0)));
1063 }
1064 t0 += stk::get_time_in_seconds();
1065 std::cout << "Adding a local const Floats took " << t0 << " seconds" << std::endl;
1066
1067 t0 = -stk::get_time_in_seconds();
1068 for (int n=0; n < N; n+=stk::simd::nfloats) {
1069 const stk::simd::Float a = stk::simd::load(x.data() + n);
1070 stk::simd::store(out3.data() + n,2.0f+(a+3.0f));
1071 }
1072 t0 += stk::get_time_in_seconds();
1073 std::cout << "Adding a 3.0 (with load1_pd) took " << t0 << " seconds" << std::endl;
1074 t0 = -stk::get_time_in_seconds();
1075 for (int n=0; n < N; ++n) {
1076 out4[n] = two+(x[n] + three);
1077 }
1078 t0 += stk::get_time_in_seconds();
1079 std::cout << "Non simd took " << t0 << " seconds" << std::endl;
1080
1081 ASSERT_NEAR( max_error(out1, out2, out3, out4), 0.0, floatEpsilon );
1082 }
1083
1084 template <typename REAL_TYPE>
1085 void negate_vec(REAL_TYPE * const in, REAL_TYPE * const out) {
1086 REAL_TYPE tmp[12];
1087 tmp[9] = -in[0];
1088 tmp[10] = -in[1];
1089 tmp[11] = -in[2];
1090
1091 out[0] = tmp[9];
1092 out[1] = tmp[10];
1093 out[2] = tmp[11];
1094 }
1095
1096 template <typename REAL_TYPE> static void negate_vec2(REAL_TYPE* const in, REAL_TYPE* const out) {
1097 static const REAL_TYPE ZERO(0.0);
1098 out[0] = ZERO - in[0];
1099 out[1] = ZERO - in[1];
1100 out[2] = ZERO - in[2];
1101 }
1102
1103
1104 TEST(StkSimd, NegatingAVectorFloat)
1105 {
1106 int N = 8000;
1107
1108 std::vector<float> x(3*N);
1109
1110 std::vector<float> out1(3*N);
1111 std::vector<float> out2(3*N);
1112 std::vector<float> out3(3*N);
1113
1114 for (int n=0; n < 3*N; ++n) {
1115 x[n] = 21.0*(rand()-0.5)/RAND_MAX;
1116 }
1117
1118 for (int n=0; n < N; ++n) {
1119 negate_vec(x.data() + 3*n, out1.data() + 3*n);
1120 }
1121
1122 stk::simd::Float a[3];
1123 stk::simd::Float b[3];
1124 for (int n=0; n < N; n+=stk::simd::nfloats) {
1125 stk::simd::load_array<3>(a,x.data() + 3*n);
1126 negate_vec(a,b);
1127 stk::simd::store_array<3>(out2.data() + 3*n,b);
1128 }
1129
1130 for (int n=0; n < N; n+=stk::simd::nfloats) {
1131 stk::simd::load_array<3>(a,x.data() + 3*n);
1132 negate_vec2(a,b);
1133 stk::simd::store_array<3>(out3.data() + 3*n,b);
1134 }
1135
1136 ASSERT_NEAR( max_error(out1, out2, out3), 0.0, floatEpsilon );
1137 }
1138
1139 TEST(StkSimd, SimdIsnanFloat)
1140 {
1141 const int N = stk::simd::nfloats;
1142
1143 std::vector<float> x(N);
1144 for (int i=0; i < stk::simd::nfloats; ++i) {
1145 x[i] = i;
1146 }
1147
1148 stk::simd::Float X = stk::simd::load(x.data());
1149 stk::simd::Float Y = stk::simd::Float(1.0)/X;
1150
1151 stk::simd::Boolf IsNaN = stk::math::isnan(Y);
1152
1153 ASSERT_FALSE( stk::simd::are_any(IsNaN) );
1154 ASSERT_FALSE( stk::simd::are_all(IsNaN) );
1155
1156 Y*= stk::simd::Float(0.0);
1157
1158 IsNaN = stk::math::isnan(Y);
1159
1160 ASSERT_TRUE( stk::simd::are_any(IsNaN) );
1161 ASSERT_TRUE( !stk::simd::are_all(IsNaN) || (stk::simd::nfloats==1) );
1162 }
1163
1164 TEST(StkSimd, SimdChooseFloat)
1165 {
1166 SIMD_NAMESPACE::simd<float, SIMD_NAMESPACE::simd_abi::native> one(1.0f);
1167 SIMD_NAMESPACE::simd<float, SIMD_NAMESPACE::simd_abi::native> zero(0.0f);
1168
1169 std::vector<float> maskVec(stk::simd::nfloats, 0.0f);
1170 maskVec[0] = 1.0f;
1171 SIMD_NAMESPACE::simd<float, SIMD_NAMESPACE::simd_abi::native> maskFloat(maskVec.data(), SIMD_NAMESPACE::element_aligned_tag());
1172 //SIMD_NAMESPACE::simd_mask<float, SIMD_NAMESPACE::simd_abi::native> mask(maskFloat.get());
1173 auto mask = (maskFloat == one);
1174
1175 SIMD_NAMESPACE::simd<float, SIMD_NAMESPACE::simd_abi::native> masked = SIMD_NAMESPACE::choose(mask, one, zero);
1176 std::vector<float> maskedVec(stk::simd::nfloats);
1177 masked.copy_to(maskedVec.data(), SIMD_NAMESPACE::element_aligned_tag());
1178
1179 ASSERT_EQ(maskVec, maskedVec);
1180 }