1 /*
2 * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have
21 * questions.
22 */
23
24 package benchmark.jdk.incubator.vector;
25
26 import java.util.concurrent.TimeUnit;
27 import java.util.function.IntFunction;
28
29 import org.openjdk.jmh.annotations.*;
30 import org.openjdk.jmh.infra.Blackhole;
31
32 @BenchmarkMode(Mode.Throughput)
33 @OutputTimeUnit(TimeUnit.MILLISECONDS)
34 @State(Scope.Benchmark)
35 @Warmup(iterations = 3, time = 1)
36 @Measurement(iterations = 5, time = 1)
37 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
38 public class DoubleScalar extends AbstractVectorBenchmark {
39 static final int INVOC_COUNT = 1; // To align with vector benchmarks.
40
41 @Param("1024")
42 int size;
43
44 double[] fill(IntFunction<Double> f) {
45 double[] array = new double[size];
46 for (int i = 0; i < array.length; i++) {
47 array[i] = f.apply(i);
48 }
49 return array;
50 }
51
52 double[] as, bs, cs, rs;
53 boolean[] ms, rms;
54 int[] ss;
55
56 @Setup
57 public void init() {
58 as = fill(i -> (double)(2*i));
59 bs = fill(i -> (double)(i+1));
60 cs = fill(i -> (double)(i+5));
61 rs = fill(i -> (double)0);
62 ms = fillMask(size, i -> (i % 2) == 0);
63 rms = fillMask(size, i -> false);
64
65 ss = fillInt(size, i -> RANDOM.nextInt(Math.max(i,1)));
66 }
67
68 final IntFunction<double[]> fa = vl -> as;
69 final IntFunction<double[]> fb = vl -> bs;
70 final IntFunction<double[]> fc = vl -> cs;
71 final IntFunction<double[]> fr = vl -> rs;
72 final IntFunction<boolean[]> fm = vl -> ms;
73 final IntFunction<boolean[]> fmr = vl -> rms;
74 final IntFunction<int[]> fs = vl -> ss;
75
76
77 @Benchmark
78 public void add(Blackhole bh) {
79 double[] as = fa.apply(size);
80 double[] bs = fb.apply(size);
81 double[] rs = fr.apply(size);
82
83 for (int ic = 0; ic < INVOC_COUNT; ic++) {
84 for (int i = 0; i < as.length; i++) {
85 double a = as[i];
86 double b = bs[i];
87 rs[i] = (double)(a + b);
88 }
89 }
90
91 bh.consume(rs);
92 }
93
94 @Benchmark
95 public void addMasked(Blackhole bh) {
96 double[] as = fa.apply(size);
97 double[] bs = fb.apply(size);
98 double[] rs = fr.apply(size);
99 boolean[] ms = fm.apply(size);
100
101 for (int ic = 0; ic < INVOC_COUNT; ic++) {
102 for (int i = 0; i < as.length; i++) {
103 double a = as[i];
104 double b = bs[i];
105 if (ms[i % ms.length]) {
106 rs[i] = (double)(a + b);
107 } else {
108 rs[i] = a;
109 }
110 }
111 }
112 bh.consume(rs);
113 }
114
115 @Benchmark
116 public void sub(Blackhole bh) {
117 double[] as = fa.apply(size);
118 double[] bs = fb.apply(size);
119 double[] rs = fr.apply(size);
120
121 for (int ic = 0; ic < INVOC_COUNT; ic++) {
122 for (int i = 0; i < as.length; i++) {
123 double a = as[i];
124 double b = bs[i];
125 rs[i] = (double)(a - b);
126 }
127 }
128
129 bh.consume(rs);
130 }
131
132 @Benchmark
133 public void subMasked(Blackhole bh) {
134 double[] as = fa.apply(size);
135 double[] bs = fb.apply(size);
136 double[] rs = fr.apply(size);
137 boolean[] ms = fm.apply(size);
138
139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
140 for (int i = 0; i < as.length; i++) {
141 double a = as[i];
142 double b = bs[i];
143 if (ms[i % ms.length]) {
144 rs[i] = (double)(a - b);
145 } else {
146 rs[i] = a;
147 }
148 }
149 }
150 bh.consume(rs);
151 }
152
153
154 @Benchmark
155 public void div(Blackhole bh) {
156 double[] as = fa.apply(size);
157 double[] bs = fb.apply(size);
158 double[] rs = fr.apply(size);
159
160 for (int ic = 0; ic < INVOC_COUNT; ic++) {
161 for (int i = 0; i < as.length; i++) {
162 double a = as[i];
163 double b = bs[i];
164 rs[i] = (double)(a / b);
165 }
166 }
167
168 bh.consume(rs);
169 }
170
171
172
173 @Benchmark
174 public void divMasked(Blackhole bh) {
175 double[] as = fa.apply(size);
176 double[] bs = fb.apply(size);
177 double[] rs = fr.apply(size);
178 boolean[] ms = fm.apply(size);
179
180 for (int ic = 0; ic < INVOC_COUNT; ic++) {
181 for (int i = 0; i < as.length; i++) {
182 double a = as[i];
183 double b = bs[i];
184 if (ms[i % ms.length]) {
185 rs[i] = (double)(a / b);
186 } else {
187 rs[i] = a;
188 }
189 }
190 }
191 bh.consume(rs);
192 }
193
194
195 @Benchmark
196 public void mul(Blackhole bh) {
197 double[] as = fa.apply(size);
198 double[] bs = fb.apply(size);
199 double[] rs = fr.apply(size);
200
201 for (int ic = 0; ic < INVOC_COUNT; ic++) {
202 for (int i = 0; i < as.length; i++) {
203 double a = as[i];
204 double b = bs[i];
205 rs[i] = (double)(a * b);
206 }
207 }
208
209 bh.consume(rs);
210 }
211
212 @Benchmark
213 public void mulMasked(Blackhole bh) {
214 double[] as = fa.apply(size);
215 double[] bs = fb.apply(size);
216 double[] rs = fr.apply(size);
217 boolean[] ms = fm.apply(size);
218
219 for (int ic = 0; ic < INVOC_COUNT; ic++) {
220 for (int i = 0; i < as.length; i++) {
221 double a = as[i];
222 double b = bs[i];
223 if (ms[i % ms.length]) {
224 rs[i] = (double)(a * b);
225 } else {
226 rs[i] = a;
227 }
228 }
229 }
230 bh.consume(rs);
231 }
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275 @Benchmark
276 public void max(Blackhole bh) {
277 double[] as = fa.apply(size);
278 double[] bs = fb.apply(size);
279 double[] rs = fr.apply(size);
280
281 for (int ic = 0; ic < INVOC_COUNT; ic++) {
282 for (int i = 0; i < as.length; i++) {
283 double a = as[i];
284 double b = bs[i];
285 rs[i] = (double)(Math.max(a, b));
286 }
287 }
288
289 bh.consume(rs);
290 }
291
292 @Benchmark
293 public void min(Blackhole bh) {
294 double[] as = fa.apply(size);
295 double[] bs = fb.apply(size);
296 double[] rs = fr.apply(size);
297
298 for (int ic = 0; ic < INVOC_COUNT; ic++) {
299 for (int i = 0; i < as.length; i++) {
300 double a = as[i];
301 double b = bs[i];
302 rs[i] = (double)(Math.min(a, b));
303 }
304 }
305
306 bh.consume(rs);
307 }
308
309
310
311
312 @Benchmark
313 public void addLanes(Blackhole bh) {
314 double[] as = fa.apply(size);
315 double r = 0;
316 for (int ic = 0; ic < INVOC_COUNT; ic++) {
317 r = 0;
318 for (int i = 0; i < as.length; i++) {
319 r += as[i];
320 }
321 }
322 bh.consume(r);
323 }
324
325 @Benchmark
326 public void mulLanes(Blackhole bh) {
327 double[] as = fa.apply(size);
328 double r = 1;
329 for (int ic = 0; ic < INVOC_COUNT; ic++) {
330 r = 1;
331 for (int i = 0; i < as.length; i++) {
332 r *= as[i];
333 }
334 }
335 bh.consume(r);
336 }
337
338 @Benchmark
339 public void minLanes(Blackhole bh) {
340 double[] as = fa.apply(size);
341 double r = Double.POSITIVE_INFINITY;
342 for (int ic = 0; ic < INVOC_COUNT; ic++) {
343 r = Double.POSITIVE_INFINITY;
344 for (int i = 0; i < as.length; i++) {
345 r = (double)Math.min(r, as[i]);
346 }
347 }
348 bh.consume(r);
349 }
350
351 @Benchmark
352 public void maxLanes(Blackhole bh) {
353 double[] as = fa.apply(size);
354 double r = Double.NEGATIVE_INFINITY;
355 for (int ic = 0; ic < INVOC_COUNT; ic++) {
356 r = Double.NEGATIVE_INFINITY;
357 for (int i = 0; i < as.length; i++) {
358 r = (double)Math.max(r, as[i]);
359 }
360 }
361 bh.consume(r);
362 }
363
364
365
366 @Benchmark
367 public void lessThan(Blackhole bh) {
368 double[] as = fa.apply(size);
369 double[] bs = fb.apply(size);
370
371 boolean r = false;
372 for (int ic = 0; ic < INVOC_COUNT; ic++) {
373 r = false;
374 for (int i = 0; i < as.length; i++) {
375 boolean m = (as[i] < bs[i]);
376 r |= m; // accumulate so JIT can't eliminate the computation
377 }
378 }
379
380 bh.consume(r);
381 }
382
383 @Benchmark
384 public void greaterThan(Blackhole bh) {
385 double[] as = fa.apply(size);
386 double[] bs = fb.apply(size);
387
388 boolean r = false;
389 for (int ic = 0; ic < INVOC_COUNT; ic++) {
390 r = false;
391 for (int i = 0; i < as.length; i++) {
392 boolean m = (as[i] > bs[i]);
393 r |= m; // accumulate so JIT can't eliminate the computation
394 }
395 }
396
397 bh.consume(r);
398 }
399
400 @Benchmark
401 public void equal(Blackhole bh) {
402 double[] as = fa.apply(size);
403 double[] bs = fb.apply(size);
404
405 boolean r = false;
406 for (int ic = 0; ic < INVOC_COUNT; ic++) {
407 r = false;
408 for (int i = 0; i < as.length; i++) {
409 boolean m = (as[i] == bs[i]);
410 r |= m; // accumulate so JIT can't eliminate the computation
411 }
412 }
413
414 bh.consume(r);
415 }
416
417 @Benchmark
418 public void notEqual(Blackhole bh) {
419 double[] as = fa.apply(size);
420 double[] bs = fb.apply(size);
421
422 boolean r = false;
423 for (int ic = 0; ic < INVOC_COUNT; ic++) {
424 r = false;
425 for (int i = 0; i < as.length; i++) {
426 boolean m = (as[i] != bs[i]);
427 r |= m; // accumulate so JIT can't eliminate the computation
428 }
429 }
430
431 bh.consume(r);
432 }
433
434 @Benchmark
435 public void lessThanEq(Blackhole bh) {
436 double[] as = fa.apply(size);
437 double[] bs = fb.apply(size);
438
439 boolean r = false;
440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
441 r = false;
442 for (int i = 0; i < as.length; i++) {
443 boolean m = (as[i] <= bs[i]);
444 r |= m; // accumulate so JIT can't eliminate the computation
445 }
446 }
447
448 bh.consume(r);
449 }
450
451 @Benchmark
452 public void greaterThanEq(Blackhole bh) {
453 double[] as = fa.apply(size);
454 double[] bs = fb.apply(size);
455
456 boolean r = false;
457 for (int ic = 0; ic < INVOC_COUNT; ic++) {
458 r = false;
459 for (int i = 0; i < as.length; i++) {
460 boolean m = (as[i] >= bs[i]);
461 r |= m; // accumulate so JIT can't eliminate the computation
462 }
463 }
464
465 bh.consume(r);
466 }
467
468 @Benchmark
469 public void blend(Blackhole bh) {
470 double[] as = fa.apply(size);
471 double[] bs = fb.apply(size);
472 double[] rs = fr.apply(size);
473 boolean[] ms = fm.apply(size);
474
475 for (int ic = 0; ic < INVOC_COUNT; ic++) {
476 for (int i = 0; i < as.length; i++) {
477 double a = as[i];
478 double b = bs[i];
479 boolean m = ms[i % ms.length];
480 rs[i] = (m ? b : a);
481 }
482 }
483
484 bh.consume(rs);
485 }
486 void rearrangeShared(int window, Blackhole bh) {
487 double[] as = fa.apply(size);
488 int[] order = fs.apply(size);
489 double[] rs = fr.apply(size);
490
491 for (int ic = 0; ic < INVOC_COUNT; ic++) {
492 for (int i = 0; i < as.length; i += window) {
493 for (int j = 0; j < window; j++) {
494 double a = as[i+j];
495 int pos = order[j];
496 rs[i + pos] = a;
497 }
498 }
499 }
500
501 bh.consume(rs);
502 }
503
504 @Benchmark
505 public void rearrange064(Blackhole bh) {
506 int window = 64 / Double.SIZE;
507 rearrangeShared(window, bh);
508 }
509
510 @Benchmark
511 public void rearrange128(Blackhole bh) {
512 int window = 128 / Double.SIZE;
513 rearrangeShared(window, bh);
514 }
515
516 @Benchmark
517 public void rearrange256(Blackhole bh) {
518 int window = 256 / Double.SIZE;
519 rearrangeShared(window, bh);
520 }
521
522 @Benchmark
523 public void rearrange512(Blackhole bh) {
524 int window = 512 / Double.SIZE;
525 rearrangeShared(window, bh);
526 }
527
528
529 @Benchmark
530 public void sin(Blackhole bh) {
531 double[] as = fa.apply(size);
532 double[] rs = fr.apply(size);
533
534 for (int ic = 0; ic < INVOC_COUNT; ic++) {
535 for (int i = 0; i < as.length; i++) {
536 double a = as[i];
537 rs[i] = (double)(Math.sin((double)a));
538 }
539 }
540
541 bh.consume(rs);
542 }
543
544
545
546 @Benchmark
547 public void exp(Blackhole bh) {
548 double[] as = fa.apply(size);
549 double[] rs = fr.apply(size);
550
551 for (int ic = 0; ic < INVOC_COUNT; ic++) {
552 for (int i = 0; i < as.length; i++) {
553 double a = as[i];
554 rs[i] = (double)(Math.exp((double)a));
555 }
556 }
557
558 bh.consume(rs);
559 }
560
561
562
563 @Benchmark
564 public void log1p(Blackhole bh) {
565 double[] as = fa.apply(size);
566 double[] rs = fr.apply(size);
567
568 for (int ic = 0; ic < INVOC_COUNT; ic++) {
569 for (int i = 0; i < as.length; i++) {
570 double a = as[i];
571 rs[i] = (double)(Math.log1p((double)a));
572 }
573 }
574
575 bh.consume(rs);
576 }
577
578
579
580 @Benchmark
581 public void log(Blackhole bh) {
582 double[] as = fa.apply(size);
583 double[] rs = fr.apply(size);
584
585 for (int ic = 0; ic < INVOC_COUNT; ic++) {
586 for (int i = 0; i < as.length; i++) {
587 double a = as[i];
588 rs[i] = (double)(Math.log((double)a));
589 }
590 }
591
592 bh.consume(rs);
593 }
594
595
596
597 @Benchmark
598 public void log10(Blackhole bh) {
599 double[] as = fa.apply(size);
600 double[] rs = fr.apply(size);
601
602 for (int ic = 0; ic < INVOC_COUNT; ic++) {
603 for (int i = 0; i < as.length; i++) {
604 double a = as[i];
605 rs[i] = (double)(Math.log10((double)a));
606 }
607 }
608
609 bh.consume(rs);
610 }
611
612
613
614 @Benchmark
615 public void expm1(Blackhole bh) {
616 double[] as = fa.apply(size);
617 double[] rs = fr.apply(size);
618
619 for (int ic = 0; ic < INVOC_COUNT; ic++) {
620 for (int i = 0; i < as.length; i++) {
621 double a = as[i];
622 rs[i] = (double)(Math.expm1((double)a));
623 }
624 }
625
626 bh.consume(rs);
627 }
628
629
630
631 @Benchmark
632 public void cos(Blackhole bh) {
633 double[] as = fa.apply(size);
634 double[] rs = fr.apply(size);
635
636 for (int ic = 0; ic < INVOC_COUNT; ic++) {
637 for (int i = 0; i < as.length; i++) {
638 double a = as[i];
639 rs[i] = (double)(Math.cos((double)a));
640 }
641 }
642
643 bh.consume(rs);
644 }
645
646
647
648 @Benchmark
649 public void tan(Blackhole bh) {
650 double[] as = fa.apply(size);
651 double[] rs = fr.apply(size);
652
653 for (int ic = 0; ic < INVOC_COUNT; ic++) {
654 for (int i = 0; i < as.length; i++) {
655 double a = as[i];
656 rs[i] = (double)(Math.tan((double)a));
657 }
658 }
659
660 bh.consume(rs);
661 }
662
663
664
665 @Benchmark
666 public void sinh(Blackhole bh) {
667 double[] as = fa.apply(size);
668 double[] rs = fr.apply(size);
669
670 for (int ic = 0; ic < INVOC_COUNT; ic++) {
671 for (int i = 0; i < as.length; i++) {
672 double a = as[i];
673 rs[i] = (double)(Math.sinh((double)a));
674 }
675 }
676
677 bh.consume(rs);
678 }
679
680
681
682 @Benchmark
683 public void cosh(Blackhole bh) {
684 double[] as = fa.apply(size);
685 double[] rs = fr.apply(size);
686
687 for (int ic = 0; ic < INVOC_COUNT; ic++) {
688 for (int i = 0; i < as.length; i++) {
689 double a = as[i];
690 rs[i] = (double)(Math.cosh((double)a));
691 }
692 }
693
694 bh.consume(rs);
695 }
696
697
698
699 @Benchmark
700 public void tanh(Blackhole bh) {
701 double[] as = fa.apply(size);
702 double[] rs = fr.apply(size);
703
704 for (int ic = 0; ic < INVOC_COUNT; ic++) {
705 for (int i = 0; i < as.length; i++) {
706 double a = as[i];
707 rs[i] = (double)(Math.tanh((double)a));
708 }
709 }
710
711 bh.consume(rs);
712 }
713
714
715
716 @Benchmark
717 public void asin(Blackhole bh) {
718 double[] as = fa.apply(size);
719 double[] rs = fr.apply(size);
720
721 for (int ic = 0; ic < INVOC_COUNT; ic++) {
722 for (int i = 0; i < as.length; i++) {
723 double a = as[i];
724 rs[i] = (double)(Math.asin((double)a));
725 }
726 }
727
728 bh.consume(rs);
729 }
730
731
732
733 @Benchmark
734 public void acos(Blackhole bh) {
735 double[] as = fa.apply(size);
736 double[] rs = fr.apply(size);
737
738 for (int ic = 0; ic < INVOC_COUNT; ic++) {
739 for (int i = 0; i < as.length; i++) {
740 double a = as[i];
741 rs[i] = (double)(Math.acos((double)a));
742 }
743 }
744
745 bh.consume(rs);
746 }
747
748
749
750 @Benchmark
751 public void atan(Blackhole bh) {
752 double[] as = fa.apply(size);
753 double[] rs = fr.apply(size);
754
755 for (int ic = 0; ic < INVOC_COUNT; ic++) {
756 for (int i = 0; i < as.length; i++) {
757 double a = as[i];
758 rs[i] = (double)(Math.atan((double)a));
759 }
760 }
761
762 bh.consume(rs);
763 }
764
765
766
767 @Benchmark
768 public void cbrt(Blackhole bh) {
769 double[] as = fa.apply(size);
770 double[] rs = fr.apply(size);
771
772 for (int ic = 0; ic < INVOC_COUNT; ic++) {
773 for (int i = 0; i < as.length; i++) {
774 double a = as[i];
775 rs[i] = (double)(Math.cbrt((double)a));
776 }
777 }
778
779 bh.consume(rs);
780 }
781
782
783
784 @Benchmark
785 public void hypot(Blackhole bh) {
786 double[] as = fa.apply(size);
787 double[] bs = fb.apply(size);
788 double[] rs = fr.apply(size);
789
790 for (int ic = 0; ic < INVOC_COUNT; ic++) {
791 for (int i = 0; i < as.length; i++) {
792 double a = as[i];
793 double b = bs[i];
794 rs[i] = (double)(Math.hypot((double)a, (double)b));
795 }
796 }
797
798 bh.consume(rs);
799 }
800
801
802
803 @Benchmark
804 public void pow(Blackhole bh) {
805 double[] as = fa.apply(size);
806 double[] bs = fb.apply(size);
807 double[] rs = fr.apply(size);
808
809 for (int ic = 0; ic < INVOC_COUNT; ic++) {
810 for (int i = 0; i < as.length; i++) {
811 double a = as[i];
812 double b = bs[i];
813 rs[i] = (double)(Math.pow((double)a, (double)b));
814 }
815 }
816
817 bh.consume(rs);
818 }
819
820
821
822 @Benchmark
823 public void atan2(Blackhole bh) {
824 double[] as = fa.apply(size);
825 double[] bs = fb.apply(size);
826 double[] rs = fr.apply(size);
827
828 for (int ic = 0; ic < INVOC_COUNT; ic++) {
829 for (int i = 0; i < as.length; i++) {
830 double a = as[i];
831 double b = bs[i];
832 rs[i] = (double)(Math.atan2((double)a, (double)b));
833 }
834 }
835
836 bh.consume(rs);
837 }
838
839
840
841 @Benchmark
842 public void fma(Blackhole bh) {
843 double[] as = fa.apply(size);
844 double[] bs = fb.apply(size);
845 double[] cs = fc.apply(size);
846 double[] rs = fr.apply(size);
847
848 for (int ic = 0; ic < INVOC_COUNT; ic++) {
849 for (int i = 0; i < as.length; i++) {
850 double a = as[i];
851 double b = bs[i];
852 double c = cs[i];
853 rs[i] = (double)(Math.fma(a, b, c));
854 }
855 }
856
857 bh.consume(rs);
858 }
859
860
861
862
863 @Benchmark
864 public void fmaMasked(Blackhole bh) {
865 double[] as = fa.apply(size);
866 double[] bs = fb.apply(size);
867 double[] cs = fc.apply(size);
868 double[] rs = fr.apply(size);
869 boolean[] ms = fm.apply(size);
870
871 for (int ic = 0; ic < INVOC_COUNT; ic++) {
872 for (int i = 0; i < as.length; i++) {
873 double a = as[i];
874 double b = bs[i];
875 double c = cs[i];
876 if (ms[i % ms.length]) {
877 rs[i] = (double)(Math.fma(a, b, c));
878 } else {
879 rs[i] = a;
880 }
881 }
882 }
883 bh.consume(rs);
884 }
885
886
887 @Benchmark
888 public void neg(Blackhole bh) {
889 double[] as = fa.apply(size);
890 double[] rs = fr.apply(size);
891
892 for (int ic = 0; ic < INVOC_COUNT; ic++) {
893 for (int i = 0; i < as.length; i++) {
894 double a = as[i];
895 rs[i] = (double)(-((double)a));
896 }
897 }
898
899 bh.consume(rs);
900 }
901
902 @Benchmark
903 public void negMasked(Blackhole bh) {
904 double[] as = fa.apply(size);
905 double[] rs = fr.apply(size);
906 boolean[] ms = fm.apply(size);
907
908 for (int ic = 0; ic < INVOC_COUNT; ic++) {
909 for (int i = 0; i < as.length; i++) {
910 double a = as[i];
911 boolean m = ms[i % ms.length];
912 rs[i] = (m ? (double)(-((double)a)) : a);
913 }
914 }
915
916 bh.consume(rs);
917 }
918
919 @Benchmark
920 public void abs(Blackhole bh) {
921 double[] as = fa.apply(size);
922 double[] rs = fr.apply(size);
923
924 for (int ic = 0; ic < INVOC_COUNT; ic++) {
925 for (int i = 0; i < as.length; i++) {
926 double a = as[i];
927 rs[i] = (double)(Math.abs((double)a));
928 }
929 }
930
931 bh.consume(rs);
932 }
933
934 @Benchmark
935 public void absMasked(Blackhole bh) {
936 double[] as = fa.apply(size);
937 double[] rs = fr.apply(size);
938 boolean[] ms = fm.apply(size);
939
940 for (int ic = 0; ic < INVOC_COUNT; ic++) {
941 for (int i = 0; i < as.length; i++) {
942 double a = as[i];
943 boolean m = ms[i % ms.length];
944 rs[i] = (m ? (double)(Math.abs((double)a)) : a);
945 }
946 }
947
948 bh.consume(rs);
949 }
950
951
952
953
954 @Benchmark
955 public void sqrt(Blackhole bh) {
956 double[] as = fa.apply(size);
957 double[] rs = fr.apply(size);
958
959 for (int ic = 0; ic < INVOC_COUNT; ic++) {
960 for (int i = 0; i < as.length; i++) {
961 double a = as[i];
962 rs[i] = (double)(Math.sqrt((double)a));
963 }
964 }
965
966 bh.consume(rs);
967 }
968
969
970
971 @Benchmark
972 public void sqrtMasked(Blackhole bh) {
973 double[] as = fa.apply(size);
974 double[] rs = fr.apply(size);
975 boolean[] ms = fm.apply(size);
976
977 for (int ic = 0; ic < INVOC_COUNT; ic++) {
978 for (int i = 0; i < as.length; i++) {
979 double a = as[i];
980 boolean m = ms[i % ms.length];
981 rs[i] = (m ? (double)(Math.sqrt((double)a)) : a);
982 }
983 }
984
985 bh.consume(rs);
986 }
987
988
989 @Benchmark
990 public void gatherBase0(Blackhole bh) {
991 double[] as = fa.apply(size);
992 int[] is = fs.apply(size);
993 double[] rs = fr.apply(size);
994
995 for (int ic = 0; ic < INVOC_COUNT; ic++) {
996 for (int i = 0; i < as.length; i++) {
997 int ix = 0 + is[i];
998 rs[i] = as[ix];
999 }
1000 }
1001
1002 bh.consume(rs);
1003 }
1004
1005
1006 void gather(int window, Blackhole bh) {
1007 double[] as = fa.apply(size);
1008 int[] is = fs.apply(size);
1009 double[] rs = fr.apply(size);
1010
1011 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1012 for (int i = 0; i < as.length; i += window) {
1013 for (int j = 0; j < window; j++) {
1014 int ix = i + is[i + j];
1015 rs[i + j] = as[ix];
1016 }
1017 }
1018 }
1019
1020 bh.consume(rs);
1021 }
1022
1023 @Benchmark
1024 public void gather064(Blackhole bh) {
1025 int window = 64 / Double.SIZE;
1026 gather(window, bh);
1027 }
1028
1029 @Benchmark
1030 public void gather128(Blackhole bh) {
1031 int window = 128 / Double.SIZE;
1032 gather(window, bh);
1033 }
1034
1035 @Benchmark
1036 public void gather256(Blackhole bh) {
1037 int window = 256 / Double.SIZE;
1038 gather(window, bh);
1039 }
1040
1041 @Benchmark
1042 public void gather512(Blackhole bh) {
1043 int window = 512 / Double.SIZE;
1044 gather(window, bh);
1045 }
1046
1047
1048
1049 @Benchmark
1050 public void scatterBase0(Blackhole bh) {
1051 double[] as = fa.apply(size);
1052 int[] is = fs.apply(size);
1053 double[] rs = fr.apply(size);
1054
1055 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1056 for (int i = 0; i < as.length; i++) {
1057 int ix = 0 + is[i];
1058 rs[ix] = as[i];
1059 }
1060 }
1061
1062 bh.consume(rs);
1063 }
1064
1065 void scatter(int window, Blackhole bh) {
1066 double[] as = fa.apply(size);
1067 int[] is = fs.apply(size);
1068 double[] rs = fr.apply(size);
1069
1070 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1071 for (int i = 0; i < as.length; i += window) {
1072 for (int j = 0; j < window; j++) {
1073 int ix = i + is[i + j];
1074 rs[ix] = as[i + j];
1075 }
1076 }
1077 }
1078
1079 bh.consume(rs);
1080 }
1081
1082 @Benchmark
1083 public void scatter064(Blackhole bh) {
1084 int window = 64 / Double.SIZE;
1085 scatter(window, bh);
1086 }
1087
1088 @Benchmark
1089 public void scatter128(Blackhole bh) {
1090 int window = 128 / Double.SIZE;
1091 scatter(window, bh);
1092 }
1093
1094 @Benchmark
1095 public void scatter256(Blackhole bh) {
1096 int window = 256 / Double.SIZE;
1097 scatter(window, bh);
1098 }
1099
1100 @Benchmark
1101 public void scatter512(Blackhole bh) {
1102 int window = 512 / Double.SIZE;
1103 scatter(window, bh);
1104 }
1105
1106 }
1107