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 @Benchmark
264 public void max(Blackhole bh) {
265 double[] as = fa.apply(size);
266 double[] bs = fb.apply(size);
267 double[] rs = fr.apply(size);
268
269 for (int ic = 0; ic < INVOC_COUNT; ic++) {
270 for (int i = 0; i < as.length; i++) {
271 double a = as[i];
272 double b = bs[i];
273 rs[i] = (double)(Math.max(a, b));
274 }
275 }
276
277 bh.consume(rs);
278 }
279
280 @Benchmark
281 public void min(Blackhole bh) {
282 double[] as = fa.apply(size);
283 double[] bs = fb.apply(size);
284 double[] rs = fr.apply(size);
285
286 for (int ic = 0; ic < INVOC_COUNT; ic++) {
287 for (int i = 0; i < as.length; i++) {
288 double a = as[i];
289 double b = bs[i];
290 rs[i] = (double)(Math.min(a, b));
291 }
292 }
293
294 bh.consume(rs);
295 }
296
297
298
299
300 @Benchmark
301 public void addAll(Blackhole bh) {
302 double[] as = fa.apply(size);
303 double r = 0;
304 for (int ic = 0; ic < INVOC_COUNT; ic++) {
305 r = 0;
306 for (int i = 0; i < as.length; i++) {
307 r += as[i];
308 }
309 }
310 bh.consume(r);
311 }
312
313 @Benchmark
314 public void mulAll(Blackhole bh) {
315 double[] as = fa.apply(size);
316 double r = 1;
317 for (int ic = 0; ic < INVOC_COUNT; ic++) {
318 r = 1;
319 for (int i = 0; i < as.length; i++) {
320 r *= as[i];
321 }
322 }
323 bh.consume(r);
324 }
325
326 @Benchmark
327 public void minAll(Blackhole bh) {
328 double[] as = fa.apply(size);
329 double r = Double.POSITIVE_INFINITY;
330 for (int ic = 0; ic < INVOC_COUNT; ic++) {
331 r = Double.POSITIVE_INFINITY;
332 for (int i = 0; i < as.length; i++) {
333 r = (double)Math.min(r, as[i]);
334 }
335 }
336 bh.consume(r);
337 }
338
339 @Benchmark
340 public void maxAll(Blackhole bh) {
341 double[] as = fa.apply(size);
342 double r = Double.NEGATIVE_INFINITY;
343 for (int ic = 0; ic < INVOC_COUNT; ic++) {
344 r = Double.NEGATIVE_INFINITY;
345 for (int i = 0; i < as.length; i++) {
346 r = (double)Math.max(r, as[i]);
347 }
348 }
349 bh.consume(r);
350 }
351
352
353
354 @Benchmark
355 public void lessThan(Blackhole bh) {
356 double[] as = fa.apply(size);
357 double[] bs = fb.apply(size);
358
359 boolean r = false;
360 for (int ic = 0; ic < INVOC_COUNT; ic++) {
361 r = false;
362 for (int i = 0; i < as.length; i++) {
363 boolean m = (as[i] < bs[i]);
364 r |= m; // accumulate so JIT can't eliminate the computation
365 }
366 }
367
368 bh.consume(r);
369 }
370
371 @Benchmark
372 public void greaterThan(Blackhole bh) {
373 double[] as = fa.apply(size);
374 double[] bs = fb.apply(size);
375
376 boolean r = false;
377 for (int ic = 0; ic < INVOC_COUNT; ic++) {
378 r = false;
379 for (int i = 0; i < as.length; i++) {
380 boolean m = (as[i] > bs[i]);
381 r |= m; // accumulate so JIT can't eliminate the computation
382 }
383 }
384
385 bh.consume(r);
386 }
387
388 @Benchmark
389 public void equal(Blackhole bh) {
390 double[] as = fa.apply(size);
391 double[] bs = fb.apply(size);
392
393 boolean r = false;
394 for (int ic = 0; ic < INVOC_COUNT; ic++) {
395 r = false;
396 for (int i = 0; i < as.length; i++) {
397 boolean m = (as[i] == bs[i]);
398 r |= m; // accumulate so JIT can't eliminate the computation
399 }
400 }
401
402 bh.consume(r);
403 }
404
405 @Benchmark
406 public void notEqual(Blackhole bh) {
407 double[] as = fa.apply(size);
408 double[] bs = fb.apply(size);
409
410 boolean r = false;
411 for (int ic = 0; ic < INVOC_COUNT; ic++) {
412 r = false;
413 for (int i = 0; i < as.length; i++) {
414 boolean m = (as[i] != bs[i]);
415 r |= m; // accumulate so JIT can't eliminate the computation
416 }
417 }
418
419 bh.consume(r);
420 }
421
422 @Benchmark
423 public void lessThanEq(Blackhole bh) {
424 double[] as = fa.apply(size);
425 double[] bs = fb.apply(size);
426
427 boolean r = false;
428 for (int ic = 0; ic < INVOC_COUNT; ic++) {
429 r = false;
430 for (int i = 0; i < as.length; i++) {
431 boolean m = (as[i] <= bs[i]);
432 r |= m; // accumulate so JIT can't eliminate the computation
433 }
434 }
435
436 bh.consume(r);
437 }
438
439 @Benchmark
440 public void greaterThanEq(Blackhole bh) {
441 double[] as = fa.apply(size);
442 double[] bs = fb.apply(size);
443
444 boolean r = false;
445 for (int ic = 0; ic < INVOC_COUNT; ic++) {
446 r = false;
447 for (int i = 0; i < as.length; i++) {
448 boolean m = (as[i] >= bs[i]);
449 r |= m; // accumulate so JIT can't eliminate the computation
450 }
451 }
452
453 bh.consume(r);
454 }
455
456 @Benchmark
457 public void blend(Blackhole bh) {
458 double[] as = fa.apply(size);
459 double[] bs = fb.apply(size);
460 double[] rs = fr.apply(size);
461 boolean[] ms = fm.apply(size);
462
463 for (int ic = 0; ic < INVOC_COUNT; ic++) {
464 for (int i = 0; i < as.length; i++) {
465 double a = as[i];
466 double b = bs[i];
467 boolean m = ms[i % ms.length];
468 rs[i] = (m ? b : a);
469 }
470 }
471
472 bh.consume(rs);
473 }
474 void rearrangeShared(int window, Blackhole bh) {
475 double[] as = fa.apply(size);
476 int[] order = fs.apply(size);
477 double[] rs = fr.apply(size);
478
479 for (int ic = 0; ic < INVOC_COUNT; ic++) {
480 for (int i = 0; i < as.length; i += window) {
481 for (int j = 0; j < window; j++) {
482 double a = as[i+j];
483 int pos = order[j];
484 rs[i + pos] = a;
485 }
486 }
487 }
488
489 bh.consume(rs);
490 }
491
492 @Benchmark
493 public void rearrange064(Blackhole bh) {
494 int window = 64 / Double.SIZE;
495 rearrangeShared(window, bh);
496 }
497
498 @Benchmark
499 public void rearrange128(Blackhole bh) {
500 int window = 128 / Double.SIZE;
501 rearrangeShared(window, bh);
502 }
503
504 @Benchmark
505 public void rearrange256(Blackhole bh) {
506 int window = 256 / Double.SIZE;
507 rearrangeShared(window, bh);
508 }
509
510 @Benchmark
511 public void rearrange512(Blackhole bh) {
512 int window = 512 / Double.SIZE;
513 rearrangeShared(window, bh);
514 }
515
516
517 @Benchmark
518 public void sin(Blackhole bh) {
519 double[] as = fa.apply(size);
520 double[] rs = fr.apply(size);
521
522 for (int ic = 0; ic < INVOC_COUNT; ic++) {
523 for (int i = 0; i < as.length; i++) {
524 double a = as[i];
525 rs[i] = (double)(Math.sin((double)a));
526 }
527 }
528
529 bh.consume(rs);
530 }
531
532
533
534 @Benchmark
535 public void exp(Blackhole bh) {
536 double[] as = fa.apply(size);
537 double[] rs = fr.apply(size);
538
539 for (int ic = 0; ic < INVOC_COUNT; ic++) {
540 for (int i = 0; i < as.length; i++) {
541 double a = as[i];
542 rs[i] = (double)(Math.exp((double)a));
543 }
544 }
545
546 bh.consume(rs);
547 }
548
549
550
551 @Benchmark
552 public void log1p(Blackhole bh) {
553 double[] as = fa.apply(size);
554 double[] rs = fr.apply(size);
555
556 for (int ic = 0; ic < INVOC_COUNT; ic++) {
557 for (int i = 0; i < as.length; i++) {
558 double a = as[i];
559 rs[i] = (double)(Math.log1p((double)a));
560 }
561 }
562
563 bh.consume(rs);
564 }
565
566
567
568 @Benchmark
569 public void log(Blackhole bh) {
570 double[] as = fa.apply(size);
571 double[] rs = fr.apply(size);
572
573 for (int ic = 0; ic < INVOC_COUNT; ic++) {
574 for (int i = 0; i < as.length; i++) {
575 double a = as[i];
576 rs[i] = (double)(Math.log((double)a));
577 }
578 }
579
580 bh.consume(rs);
581 }
582
583
584
585 @Benchmark
586 public void log10(Blackhole bh) {
587 double[] as = fa.apply(size);
588 double[] rs = fr.apply(size);
589
590 for (int ic = 0; ic < INVOC_COUNT; ic++) {
591 for (int i = 0; i < as.length; i++) {
592 double a = as[i];
593 rs[i] = (double)(Math.log10((double)a));
594 }
595 }
596
597 bh.consume(rs);
598 }
599
600
601
602 @Benchmark
603 public void expm1(Blackhole bh) {
604 double[] as = fa.apply(size);
605 double[] rs = fr.apply(size);
606
607 for (int ic = 0; ic < INVOC_COUNT; ic++) {
608 for (int i = 0; i < as.length; i++) {
609 double a = as[i];
610 rs[i] = (double)(Math.expm1((double)a));
611 }
612 }
613
614 bh.consume(rs);
615 }
616
617
618
619 @Benchmark
620 public void cos(Blackhole bh) {
621 double[] as = fa.apply(size);
622 double[] rs = fr.apply(size);
623
624 for (int ic = 0; ic < INVOC_COUNT; ic++) {
625 for (int i = 0; i < as.length; i++) {
626 double a = as[i];
627 rs[i] = (double)(Math.cos((double)a));
628 }
629 }
630
631 bh.consume(rs);
632 }
633
634
635
636 @Benchmark
637 public void tan(Blackhole bh) {
638 double[] as = fa.apply(size);
639 double[] rs = fr.apply(size);
640
641 for (int ic = 0; ic < INVOC_COUNT; ic++) {
642 for (int i = 0; i < as.length; i++) {
643 double a = as[i];
644 rs[i] = (double)(Math.tan((double)a));
645 }
646 }
647
648 bh.consume(rs);
649 }
650
651
652
653 @Benchmark
654 public void sinh(Blackhole bh) {
655 double[] as = fa.apply(size);
656 double[] rs = fr.apply(size);
657
658 for (int ic = 0; ic < INVOC_COUNT; ic++) {
659 for (int i = 0; i < as.length; i++) {
660 double a = as[i];
661 rs[i] = (double)(Math.sinh((double)a));
662 }
663 }
664
665 bh.consume(rs);
666 }
667
668
669
670 @Benchmark
671 public void cosh(Blackhole bh) {
672 double[] as = fa.apply(size);
673 double[] rs = fr.apply(size);
674
675 for (int ic = 0; ic < INVOC_COUNT; ic++) {
676 for (int i = 0; i < as.length; i++) {
677 double a = as[i];
678 rs[i] = (double)(Math.cosh((double)a));
679 }
680 }
681
682 bh.consume(rs);
683 }
684
685
686
687 @Benchmark
688 public void tanh(Blackhole bh) {
689 double[] as = fa.apply(size);
690 double[] rs = fr.apply(size);
691
692 for (int ic = 0; ic < INVOC_COUNT; ic++) {
693 for (int i = 0; i < as.length; i++) {
694 double a = as[i];
695 rs[i] = (double)(Math.tanh((double)a));
696 }
697 }
698
699 bh.consume(rs);
700 }
701
702
703
704 @Benchmark
705 public void asin(Blackhole bh) {
706 double[] as = fa.apply(size);
707 double[] rs = fr.apply(size);
708
709 for (int ic = 0; ic < INVOC_COUNT; ic++) {
710 for (int i = 0; i < as.length; i++) {
711 double a = as[i];
712 rs[i] = (double)(Math.asin((double)a));
713 }
714 }
715
716 bh.consume(rs);
717 }
718
719
720
721 @Benchmark
722 public void acos(Blackhole bh) {
723 double[] as = fa.apply(size);
724 double[] rs = fr.apply(size);
725
726 for (int ic = 0; ic < INVOC_COUNT; ic++) {
727 for (int i = 0; i < as.length; i++) {
728 double a = as[i];
729 rs[i] = (double)(Math.acos((double)a));
730 }
731 }
732
733 bh.consume(rs);
734 }
735
736
737
738 @Benchmark
739 public void atan(Blackhole bh) {
740 double[] as = fa.apply(size);
741 double[] rs = fr.apply(size);
742
743 for (int ic = 0; ic < INVOC_COUNT; ic++) {
744 for (int i = 0; i < as.length; i++) {
745 double a = as[i];
746 rs[i] = (double)(Math.atan((double)a));
747 }
748 }
749
750 bh.consume(rs);
751 }
752
753
754
755 @Benchmark
756 public void cbrt(Blackhole bh) {
757 double[] as = fa.apply(size);
758 double[] rs = fr.apply(size);
759
760 for (int ic = 0; ic < INVOC_COUNT; ic++) {
761 for (int i = 0; i < as.length; i++) {
762 double a = as[i];
763 rs[i] = (double)(Math.cbrt((double)a));
764 }
765 }
766
767 bh.consume(rs);
768 }
769
770
771
772 @Benchmark
773 public void hypot(Blackhole bh) {
774 double[] as = fa.apply(size);
775 double[] bs = fb.apply(size);
776 double[] rs = fr.apply(size);
777
778 for (int ic = 0; ic < INVOC_COUNT; ic++) {
779 for (int i = 0; i < as.length; i++) {
780 double a = as[i];
781 double b = bs[i];
782 rs[i] = (double)(Math.hypot((double)a, (double)b));
783 }
784 }
785
786 bh.consume(rs);
787 }
788
789
790
791 @Benchmark
792 public void pow(Blackhole bh) {
793 double[] as = fa.apply(size);
794 double[] bs = fb.apply(size);
795 double[] rs = fr.apply(size);
796
797 for (int ic = 0; ic < INVOC_COUNT; ic++) {
798 for (int i = 0; i < as.length; i++) {
799 double a = as[i];
800 double b = bs[i];
801 rs[i] = (double)(Math.pow((double)a, (double)b));
802 }
803 }
804
805 bh.consume(rs);
806 }
807
808
809
810 @Benchmark
811 public void atan2(Blackhole bh) {
812 double[] as = fa.apply(size);
813 double[] bs = fb.apply(size);
814 double[] rs = fr.apply(size);
815
816 for (int ic = 0; ic < INVOC_COUNT; ic++) {
817 for (int i = 0; i < as.length; i++) {
818 double a = as[i];
819 double b = bs[i];
820 rs[i] = (double)(Math.atan2((double)a, (double)b));
821 }
822 }
823
824 bh.consume(rs);
825 }
826
827
828
829 @Benchmark
830 public void fma(Blackhole bh) {
831 double[] as = fa.apply(size);
832 double[] bs = fb.apply(size);
833 double[] cs = fc.apply(size);
834 double[] rs = fr.apply(size);
835
836 for (int ic = 0; ic < INVOC_COUNT; ic++) {
837 for (int i = 0; i < as.length; i++) {
838 double a = as[i];
839 double b = bs[i];
840 double c = cs[i];
841 rs[i] = (double)(Math.fma(a, b, c));
842 }
843 }
844
845 bh.consume(rs);
846 }
847
848
849
850
851 @Benchmark
852 public void fmaMasked(Blackhole bh) {
853 double[] as = fa.apply(size);
854 double[] bs = fb.apply(size);
855 double[] cs = fc.apply(size);
856 double[] rs = fr.apply(size);
857 boolean[] ms = fm.apply(size);
858
859 for (int ic = 0; ic < INVOC_COUNT; ic++) {
860 for (int i = 0; i < as.length; i++) {
861 double a = as[i];
862 double b = bs[i];
863 double c = cs[i];
864 if (ms[i % ms.length]) {
865 rs[i] = (double)(Math.fma(a, b, c));
866 } else {
867 rs[i] = a;
868 }
869 }
870 }
871 bh.consume(rs);
872 }
873
874
875 @Benchmark
876 public void neg(Blackhole bh) {
877 double[] as = fa.apply(size);
878 double[] rs = fr.apply(size);
879
880 for (int ic = 0; ic < INVOC_COUNT; ic++) {
881 for (int i = 0; i < as.length; i++) {
882 double a = as[i];
883 rs[i] = (double)(-((double)a));
884 }
885 }
886
887 bh.consume(rs);
888 }
889
890 @Benchmark
891 public void negMasked(Blackhole bh) {
892 double[] as = fa.apply(size);
893 double[] rs = fr.apply(size);
894 boolean[] ms = fm.apply(size);
895
896 for (int ic = 0; ic < INVOC_COUNT; ic++) {
897 for (int i = 0; i < as.length; i++) {
898 double a = as[i];
899 boolean m = ms[i % ms.length];
900 rs[i] = (m ? (double)(-((double)a)) : a);
901 }
902 }
903
904 bh.consume(rs);
905 }
906
907 @Benchmark
908 public void abs(Blackhole bh) {
909 double[] as = fa.apply(size);
910 double[] rs = fr.apply(size);
911
912 for (int ic = 0; ic < INVOC_COUNT; ic++) {
913 for (int i = 0; i < as.length; i++) {
914 double a = as[i];
915 rs[i] = (double)(Math.abs((double)a));
916 }
917 }
918
919 bh.consume(rs);
920 }
921
922 @Benchmark
923 public void absMasked(Blackhole bh) {
924 double[] as = fa.apply(size);
925 double[] rs = fr.apply(size);
926 boolean[] ms = fm.apply(size);
927
928 for (int ic = 0; ic < INVOC_COUNT; ic++) {
929 for (int i = 0; i < as.length; i++) {
930 double a = as[i];
931 boolean m = ms[i % ms.length];
932 rs[i] = (m ? (double)(Math.abs((double)a)) : a);
933 }
934 }
935
936 bh.consume(rs);
937 }
938
939
940
941
942 @Benchmark
943 public void sqrt(Blackhole bh) {
944 double[] as = fa.apply(size);
945 double[] rs = fr.apply(size);
946
947 for (int ic = 0; ic < INVOC_COUNT; ic++) {
948 for (int i = 0; i < as.length; i++) {
949 double a = as[i];
950 rs[i] = (double)(Math.sqrt((double)a));
951 }
952 }
953
954 bh.consume(rs);
955 }
956
957
958
959 @Benchmark
960 public void sqrtMasked(Blackhole bh) {
961 double[] as = fa.apply(size);
962 double[] rs = fr.apply(size);
963 boolean[] ms = fm.apply(size);
964
965 for (int ic = 0; ic < INVOC_COUNT; ic++) {
966 for (int i = 0; i < as.length; i++) {
967 double a = as[i];
968 boolean m = ms[i % ms.length];
969 rs[i] = (m ? (double)(Math.sqrt((double)a)) : a);
970 }
971 }
972
973 bh.consume(rs);
974 }
975
976
977 @Benchmark
978 public void gatherBase0(Blackhole bh) {
979 double[] as = fa.apply(size);
980 int[] is = fs.apply(size);
981 double[] rs = fr.apply(size);
982
983 for (int ic = 0; ic < INVOC_COUNT; ic++) {
984 for (int i = 0; i < as.length; i++) {
985 int ix = 0 + is[i];
986 rs[i] = as[ix];
987 }
988 }
989
990 bh.consume(rs);
991 }
992
993
994 void gather(int window, Blackhole bh) {
995 double[] as = fa.apply(size);
996 int[] is = fs.apply(size);
997 double[] rs = fr.apply(size);
998
999 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1000 for (int i = 0; i < as.length; i += window) {
1001 for (int j = 0; j < window; j++) {
1002 int ix = i + is[i + j];
1003 rs[i + j] = as[ix];
1004 }
1005 }
1006 }
1007
1008 bh.consume(rs);
1009 }
1010
1011 @Benchmark
1012 public void gather064(Blackhole bh) {
1013 int window = 64 / Double.SIZE;
1014 gather(window, bh);
1015 }
1016
1017 @Benchmark
1018 public void gather128(Blackhole bh) {
1019 int window = 128 / Double.SIZE;
1020 gather(window, bh);
1021 }
1022
1023 @Benchmark
1024 public void gather256(Blackhole bh) {
1025 int window = 256 / Double.SIZE;
1026 gather(window, bh);
1027 }
1028
1029 @Benchmark
1030 public void gather512(Blackhole bh) {
1031 int window = 512 / Double.SIZE;
1032 gather(window, bh);
1033 }
1034
1035
1036
1037 @Benchmark
1038 public void scatterBase0(Blackhole bh) {
1039 double[] as = fa.apply(size);
1040 int[] is = fs.apply(size);
1041 double[] rs = fr.apply(size);
1042
1043 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1044 for (int i = 0; i < as.length; i++) {
1045 int ix = 0 + is[i];
1046 rs[ix] = as[i];
1047 }
1048 }
1049
1050 bh.consume(rs);
1051 }
1052
1053 void scatter(int window, Blackhole bh) {
1054 double[] as = fa.apply(size);
1055 int[] is = fs.apply(size);
1056 double[] rs = fr.apply(size);
1057
1058 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1059 for (int i = 0; i < as.length; i += window) {
1060 for (int j = 0; j < window; j++) {
1061 int ix = i + is[i + j];
1062 rs[ix] = as[i + j];
1063 }
1064 }
1065 }
1066
1067 bh.consume(rs);
1068 }
1069
1070 @Benchmark
1071 public void scatter064(Blackhole bh) {
1072 int window = 64 / Double.SIZE;
1073 scatter(window, bh);
1074 }
1075
1076 @Benchmark
1077 public void scatter128(Blackhole bh) {
1078 int window = 128 / Double.SIZE;
1079 scatter(window, bh);
1080 }
1081
1082 @Benchmark
1083 public void scatter256(Blackhole bh) {
1084 int window = 256 / Double.SIZE;
1085 scatter(window, bh);
1086 }
1087
1088 @Benchmark
1089 public void scatter512(Blackhole bh) {
1090 int window = 512 / Double.SIZE;
1091 scatter(window, bh);
1092 }
1093
1094 }
1095