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 LongScalar extends AbstractVectorBenchmark {
39 static final int INVOC_COUNT = 1; // To align with vector benchmarks.
40
41 @Param("1024")
42 int size;
43
44 long[] fill(IntFunction<Long> f) {
45 long[] array = new long[size];
46 for (int i = 0; i < array.length; i++) {
47 array[i] = f.apply(i);
48 }
49 return array;
50 }
51
52 long[] as, bs, cs, rs;
53 boolean[] ms, rms;
54 int[] ss;
55
56 @Setup
57 public void init() {
58 as = fill(i -> (long)(2*i));
59 bs = fill(i -> (long)(i+1));
60 cs = fill(i -> (long)(i+5));
61 rs = fill(i -> (long)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<long[]> fa = vl -> as;
69 final IntFunction<long[]> fb = vl -> bs;
70 final IntFunction<long[]> fc = vl -> cs;
71 final IntFunction<long[]> 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 long[] as = fa.apply(size);
80 long[] bs = fb.apply(size);
81 long[] rs = fr.apply(size);
82
83 for (int ic = 0; ic < INVOC_COUNT; ic++) {
84 for (int i = 0; i < as.length; i++) {
85 long a = as[i];
86 long b = bs[i];
87 rs[i] = (long)(a + b);
88 }
89 }
90
91 bh.consume(rs);
92 }
93
94 @Benchmark
95 public void addMasked(Blackhole bh) {
96 long[] as = fa.apply(size);
97 long[] bs = fb.apply(size);
98 long[] 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 long a = as[i];
104 long b = bs[i];
105 if (ms[i % ms.length]) {
106 rs[i] = (long)(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 long[] as = fa.apply(size);
118 long[] bs = fb.apply(size);
119 long[] rs = fr.apply(size);
120
121 for (int ic = 0; ic < INVOC_COUNT; ic++) {
122 for (int i = 0; i < as.length; i++) {
123 long a = as[i];
124 long b = bs[i];
125 rs[i] = (long)(a - b);
126 }
127 }
128
129 bh.consume(rs);
130 }
131
132 @Benchmark
133 public void subMasked(Blackhole bh) {
134 long[] as = fa.apply(size);
135 long[] bs = fb.apply(size);
136 long[] 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 long a = as[i];
142 long b = bs[i];
143 if (ms[i % ms.length]) {
144 rs[i] = (long)(a - b);
145 } else {
146 rs[i] = a;
147 }
148 }
149 }
150 bh.consume(rs);
151 }
152
153
154
155 @Benchmark
156 public void mul(Blackhole bh) {
157 long[] as = fa.apply(size);
158 long[] bs = fb.apply(size);
159 long[] rs = fr.apply(size);
160
161 for (int ic = 0; ic < INVOC_COUNT; ic++) {
162 for (int i = 0; i < as.length; i++) {
163 long a = as[i];
164 long b = bs[i];
165 rs[i] = (long)(a * b);
166 }
167 }
168
169 bh.consume(rs);
170 }
171
172 @Benchmark
173 public void mulMasked(Blackhole bh) {
174 long[] as = fa.apply(size);
175 long[] bs = fb.apply(size);
176 long[] rs = fr.apply(size);
177 boolean[] ms = fm.apply(size);
178
179 for (int ic = 0; ic < INVOC_COUNT; ic++) {
180 for (int i = 0; i < as.length; i++) {
181 long a = as[i];
182 long b = bs[i];
183 if (ms[i % ms.length]) {
184 rs[i] = (long)(a * b);
185 } else {
186 rs[i] = a;
187 }
188 }
189 }
190 bh.consume(rs);
191 }
192
193
194 @Benchmark
195 public void and(Blackhole bh) {
196 long[] as = fa.apply(size);
197 long[] bs = fb.apply(size);
198 long[] rs = fr.apply(size);
199
200 for (int ic = 0; ic < INVOC_COUNT; ic++) {
201 for (int i = 0; i < as.length; i++) {
202 long a = as[i];
203 long b = bs[i];
204 rs[i] = (long)(a & b);
205 }
206 }
207
208 bh.consume(rs);
209 }
210
211
212
213 @Benchmark
214 public void andMasked(Blackhole bh) {
215 long[] as = fa.apply(size);
216 long[] bs = fb.apply(size);
217 long[] rs = fr.apply(size);
218 boolean[] ms = fm.apply(size);
219
220 for (int ic = 0; ic < INVOC_COUNT; ic++) {
221 for (int i = 0; i < as.length; i++) {
222 long a = as[i];
223 long b = bs[i];
224 if (ms[i % ms.length]) {
225 rs[i] = (long)(a & b);
226 } else {
227 rs[i] = a;
228 }
229 }
230 }
231 bh.consume(rs);
232 }
233
234
235
236 @Benchmark
237 public void or(Blackhole bh) {
238 long[] as = fa.apply(size);
239 long[] bs = fb.apply(size);
240 long[] rs = fr.apply(size);
241
242 for (int ic = 0; ic < INVOC_COUNT; ic++) {
243 for (int i = 0; i < as.length; i++) {
244 long a = as[i];
245 long b = bs[i];
246 rs[i] = (long)(a | b);
247 }
248 }
249
250 bh.consume(rs);
251 }
252
253
254
255 @Benchmark
256 public void orMasked(Blackhole bh) {
257 long[] as = fa.apply(size);
258 long[] bs = fb.apply(size);
259 long[] rs = fr.apply(size);
260 boolean[] ms = fm.apply(size);
261
262 for (int ic = 0; ic < INVOC_COUNT; ic++) {
263 for (int i = 0; i < as.length; i++) {
264 long a = as[i];
265 long b = bs[i];
266 if (ms[i % ms.length]) {
267 rs[i] = (long)(a | b);
268 } else {
269 rs[i] = a;
270 }
271 }
272 }
273 bh.consume(rs);
274 }
275
276
277
278 @Benchmark
279 public void xor(Blackhole bh) {
280 long[] as = fa.apply(size);
281 long[] bs = fb.apply(size);
282 long[] rs = fr.apply(size);
283
284 for (int ic = 0; ic < INVOC_COUNT; ic++) {
285 for (int i = 0; i < as.length; i++) {
286 long a = as[i];
287 long b = bs[i];
288 rs[i] = (long)(a ^ b);
289 }
290 }
291
292 bh.consume(rs);
293 }
294
295
296
297 @Benchmark
298 public void xorMasked(Blackhole bh) {
299 long[] as = fa.apply(size);
300 long[] bs = fb.apply(size);
301 long[] rs = fr.apply(size);
302 boolean[] ms = fm.apply(size);
303
304 for (int ic = 0; ic < INVOC_COUNT; ic++) {
305 for (int i = 0; i < as.length; i++) {
306 long a = as[i];
307 long b = bs[i];
308 if (ms[i % ms.length]) {
309 rs[i] = (long)(a ^ b);
310 } else {
311 rs[i] = a;
312 }
313 }
314 }
315 bh.consume(rs);
316 }
317
318
319
320 @Benchmark
321 public void shiftR(Blackhole bh) {
322 long[] as = fa.apply(size);
323 long[] bs = fb.apply(size);
324 long[] rs = fr.apply(size);
325
326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
327 for (int i = 0; i < as.length; i++) {
328 long a = as[i];
329 long b = bs[i];
330 rs[i] = (long)((a >>> b));
331 }
332 }
333
334 bh.consume(rs);
335 }
336
337
338
339 @Benchmark
340 public void shiftRMasked(Blackhole bh) {
341 long[] as = fa.apply(size);
342 long[] bs = fb.apply(size);
343 long[] rs = fr.apply(size);
344 boolean[] ms = fm.apply(size);
345
346 for (int ic = 0; ic < INVOC_COUNT; ic++) {
347 for (int i = 0; i < as.length; i++) {
348 long a = as[i];
349 long b = bs[i];
350 if (ms[i % ms.length]) {
351 rs[i] = (long)((a >>> b));
352 } else {
353 rs[i] = a;
354 }
355 }
356 }
357 bh.consume(rs);
358 }
359
360
361
362 @Benchmark
363 public void shiftL(Blackhole bh) {
364 long[] as = fa.apply(size);
365 long[] bs = fb.apply(size);
366 long[] rs = fr.apply(size);
367
368 for (int ic = 0; ic < INVOC_COUNT; ic++) {
369 for (int i = 0; i < as.length; i++) {
370 long a = as[i];
371 long b = bs[i];
372 rs[i] = (long)((a << b));
373 }
374 }
375
376 bh.consume(rs);
377 }
378
379
380
381 @Benchmark
382 public void shiftLMasked(Blackhole bh) {
383 long[] as = fa.apply(size);
384 long[] bs = fb.apply(size);
385 long[] rs = fr.apply(size);
386 boolean[] ms = fm.apply(size);
387
388 for (int ic = 0; ic < INVOC_COUNT; ic++) {
389 for (int i = 0; i < as.length; i++) {
390 long a = as[i];
391 long b = bs[i];
392 if (ms[i % ms.length]) {
393 rs[i] = (long)((a << b));
394 } else {
395 rs[i] = a;
396 }
397 }
398 }
399 bh.consume(rs);
400 }
401
402
403
404 @Benchmark
405 public void aShiftR(Blackhole bh) {
406 long[] as = fa.apply(size);
407 long[] bs = fb.apply(size);
408 long[] rs = fr.apply(size);
409
410 for (int ic = 0; ic < INVOC_COUNT; ic++) {
411 for (int i = 0; i < as.length; i++) {
412 long a = as[i];
413 long b = bs[i];
414 rs[i] = (long)((a >> b));
415 }
416 }
417
418 bh.consume(rs);
419 }
420
421
422
423 @Benchmark
424 public void aShiftRMasked(Blackhole bh) {
425 long[] as = fa.apply(size);
426 long[] bs = fb.apply(size);
427 long[] rs = fr.apply(size);
428 boolean[] ms = fm.apply(size);
429
430 for (int ic = 0; ic < INVOC_COUNT; ic++) {
431 for (int i = 0; i < as.length; i++) {
432 long a = as[i];
433 long b = bs[i];
434 if (ms[i % ms.length]) {
435 rs[i] = (long)((a >> b));
436 } else {
437 rs[i] = a;
438 }
439 }
440 }
441 bh.consume(rs);
442 }
443
444
445
446 @Benchmark
447 public void aShiftRShift(Blackhole bh) {
448 long[] as = fa.apply(size);
449 long[] bs = fb.apply(size);
450 long[] rs = fr.apply(size);
451
452 for (int ic = 0; ic < INVOC_COUNT; ic++) {
453 for (int i = 0; i < as.length; i++) {
454 long a = as[i];
455 long b = bs[i];
456 rs[i] = (long)((a >> b));
457 }
458 }
459
460 bh.consume(rs);
461 }
462
463
464
465 @Benchmark
466 public void aShiftRMaskedShift(Blackhole bh) {
467 long[] as = fa.apply(size);
468 long[] bs = fb.apply(size);
469 long[] rs = fr.apply(size);
470 boolean[] ms = fm.apply(size);
471
472 for (int ic = 0; ic < INVOC_COUNT; ic++) {
473 for (int i = 0; i < as.length; i++) {
474 long a = as[i];
475 long b = bs[i];
476 boolean m = ms[i % ms.length];
477 rs[i] = (m ? (long)((a >> b)) : a);
478 }
479 }
480
481 bh.consume(rs);
482 }
483
484
485
486 @Benchmark
487 public void shiftRShift(Blackhole bh) {
488 long[] as = fa.apply(size);
489 long[] bs = fb.apply(size);
490 long[] rs = fr.apply(size);
491
492 for (int ic = 0; ic < INVOC_COUNT; ic++) {
493 for (int i = 0; i < as.length; i++) {
494 long a = as[i];
495 long b = bs[i];
496 rs[i] = (long)((a >>> b));
497 }
498 }
499
500 bh.consume(rs);
501 }
502
503
504
505 @Benchmark
506 public void shiftRMaskedShift(Blackhole bh) {
507 long[] as = fa.apply(size);
508 long[] bs = fb.apply(size);
509 long[] rs = fr.apply(size);
510 boolean[] ms = fm.apply(size);
511
512 for (int ic = 0; ic < INVOC_COUNT; ic++) {
513 for (int i = 0; i < as.length; i++) {
514 long a = as[i];
515 long b = bs[i];
516 boolean m = ms[i % ms.length];
517 rs[i] = (m ? (long)((a >>> b)) : a);
518 }
519 }
520
521 bh.consume(rs);
522 }
523
524
525
526 @Benchmark
527 public void shiftLShift(Blackhole bh) {
528 long[] as = fa.apply(size);
529 long[] bs = fb.apply(size);
530 long[] rs = fr.apply(size);
531
532 for (int ic = 0; ic < INVOC_COUNT; ic++) {
533 for (int i = 0; i < as.length; i++) {
534 long a = as[i];
535 long b = bs[i];
536 rs[i] = (long)((a << b));
537 }
538 }
539
540 bh.consume(rs);
541 }
542
543
544
545 @Benchmark
546 public void shiftLMaskedShift(Blackhole bh) {
547 long[] as = fa.apply(size);
548 long[] bs = fb.apply(size);
549 long[] rs = fr.apply(size);
550 boolean[] ms = fm.apply(size);
551
552 for (int ic = 0; ic < INVOC_COUNT; ic++) {
553 for (int i = 0; i < as.length; i++) {
554 long a = as[i];
555 long b = bs[i];
556 boolean m = ms[i % ms.length];
557 rs[i] = (m ? (long)((a << b)) : a);
558 }
559 }
560
561 bh.consume(rs);
562 }
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577 @Benchmark
578 public void max(Blackhole bh) {
579 long[] as = fa.apply(size);
580 long[] bs = fb.apply(size);
581 long[] rs = fr.apply(size);
582
583 for (int ic = 0; ic < INVOC_COUNT; ic++) {
584 for (int i = 0; i < as.length; i++) {
585 long a = as[i];
586 long b = bs[i];
587 rs[i] = (long)(Math.max(a, b));
588 }
589 }
590
591 bh.consume(rs);
592 }
593
594 @Benchmark
595 public void min(Blackhole bh) {
596 long[] as = fa.apply(size);
597 long[] bs = fb.apply(size);
598 long[] rs = fr.apply(size);
599
600 for (int ic = 0; ic < INVOC_COUNT; ic++) {
601 for (int i = 0; i < as.length; i++) {
602 long a = as[i];
603 long b = bs[i];
604 rs[i] = (long)(Math.min(a, b));
605 }
606 }
607
608 bh.consume(rs);
609 }
610
611
612 @Benchmark
613 public void andAll(Blackhole bh) {
614 long[] as = fa.apply(size);
615 long r = -1;
616 for (int ic = 0; ic < INVOC_COUNT; ic++) {
617 r = -1;
618 for (int i = 0; i < as.length; i++) {
619 r &= as[i];
620 }
621 }
622 bh.consume(r);
623 }
624
625
626
627 @Benchmark
628 public void orAll(Blackhole bh) {
629 long[] as = fa.apply(size);
630 long r = 0;
631 for (int ic = 0; ic < INVOC_COUNT; ic++) {
632 r = 0;
633 for (int i = 0; i < as.length; i++) {
634 r |= as[i];
635 }
636 }
637 bh.consume(r);
638 }
639
640
641
642 @Benchmark
643 public void xorAll(Blackhole bh) {
644 long[] as = fa.apply(size);
645 long r = 0;
646 for (int ic = 0; ic < INVOC_COUNT; ic++) {
647 r = 0;
648 for (int i = 0; i < as.length; i++) {
649 r ^= as[i];
650 }
651 }
652 bh.consume(r);
653 }
654
655
656 @Benchmark
657 public void addAll(Blackhole bh) {
658 long[] as = fa.apply(size);
659 long r = 0;
660 for (int ic = 0; ic < INVOC_COUNT; ic++) {
661 r = 0;
662 for (int i = 0; i < as.length; i++) {
663 r += as[i];
664 }
665 }
666 bh.consume(r);
667 }
668
669 @Benchmark
670 public void mulAll(Blackhole bh) {
671 long[] as = fa.apply(size);
672 long r = 1;
673 for (int ic = 0; ic < INVOC_COUNT; ic++) {
674 r = 1;
675 for (int i = 0; i < as.length; i++) {
676 r *= as[i];
677 }
678 }
679 bh.consume(r);
680 }
681
682 @Benchmark
683 public void minAll(Blackhole bh) {
684 long[] as = fa.apply(size);
685 long r = Long.MAX_VALUE;
686 for (int ic = 0; ic < INVOC_COUNT; ic++) {
687 r = Long.MAX_VALUE;
688 for (int i = 0; i < as.length; i++) {
689 r = (long)Math.min(r, as[i]);
690 }
691 }
692 bh.consume(r);
693 }
694
695 @Benchmark
696 public void maxAll(Blackhole bh) {
697 long[] as = fa.apply(size);
698 long r = Long.MIN_VALUE;
699 for (int ic = 0; ic < INVOC_COUNT; ic++) {
700 r = Long.MIN_VALUE;
701 for (int i = 0; i < as.length; i++) {
702 r = (long)Math.max(r, as[i]);
703 }
704 }
705 bh.consume(r);
706 }
707
708
709 @Benchmark
710 public void anyTrue(Blackhole bh) {
711 boolean[] ms = fm.apply(size);
712 boolean r = false;
713 for (int ic = 0; ic < INVOC_COUNT; ic++) {
714 r = false;
715 for (int i = 0; i < ms.length; i++) {
716 r |= ms[i];
717 }
718 }
719 bh.consume(r);
720 }
721
722
723
724 @Benchmark
725 public void allTrue(Blackhole bh) {
726 boolean[] ms = fm.apply(size);
727 boolean r = true;
728 for (int ic = 0; ic < INVOC_COUNT; ic++) {
729 r = true;
730 for (int i = 0; i < ms.length; i++) {
731 r &= ms[i];
732 }
733 }
734 bh.consume(r);
735 }
736
737
738 @Benchmark
739 public void lessThan(Blackhole bh) {
740 long[] as = fa.apply(size);
741 long[] bs = fb.apply(size);
742
743 boolean r = false;
744 for (int ic = 0; ic < INVOC_COUNT; ic++) {
745 r = false;
746 for (int i = 0; i < as.length; i++) {
747 boolean m = (as[i] < bs[i]);
748 r |= m; // accumulate so JIT can't eliminate the computation
749 }
750 }
751
752 bh.consume(r);
753 }
754
755 @Benchmark
756 public void greaterThan(Blackhole bh) {
757 long[] as = fa.apply(size);
758 long[] bs = fb.apply(size);
759
760 boolean r = false;
761 for (int ic = 0; ic < INVOC_COUNT; ic++) {
762 r = false;
763 for (int i = 0; i < as.length; i++) {
764 boolean m = (as[i] > bs[i]);
765 r |= m; // accumulate so JIT can't eliminate the computation
766 }
767 }
768
769 bh.consume(r);
770 }
771
772 @Benchmark
773 public void equal(Blackhole bh) {
774 long[] as = fa.apply(size);
775 long[] bs = fb.apply(size);
776
777 boolean r = false;
778 for (int ic = 0; ic < INVOC_COUNT; ic++) {
779 r = false;
780 for (int i = 0; i < as.length; i++) {
781 boolean m = (as[i] == bs[i]);
782 r |= m; // accumulate so JIT can't eliminate the computation
783 }
784 }
785
786 bh.consume(r);
787 }
788
789 @Benchmark
790 public void notEqual(Blackhole bh) {
791 long[] as = fa.apply(size);
792 long[] bs = fb.apply(size);
793
794 boolean r = false;
795 for (int ic = 0; ic < INVOC_COUNT; ic++) {
796 r = false;
797 for (int i = 0; i < as.length; i++) {
798 boolean m = (as[i] != bs[i]);
799 r |= m; // accumulate so JIT can't eliminate the computation
800 }
801 }
802
803 bh.consume(r);
804 }
805
806 @Benchmark
807 public void lessThanEq(Blackhole bh) {
808 long[] as = fa.apply(size);
809 long[] bs = fb.apply(size);
810
811 boolean r = false;
812 for (int ic = 0; ic < INVOC_COUNT; ic++) {
813 r = false;
814 for (int i = 0; i < as.length; i++) {
815 boolean m = (as[i] <= bs[i]);
816 r |= m; // accumulate so JIT can't eliminate the computation
817 }
818 }
819
820 bh.consume(r);
821 }
822
823 @Benchmark
824 public void greaterThanEq(Blackhole bh) {
825 long[] as = fa.apply(size);
826 long[] bs = fb.apply(size);
827
828 boolean r = false;
829 for (int ic = 0; ic < INVOC_COUNT; ic++) {
830 r = false;
831 for (int i = 0; i < as.length; i++) {
832 boolean m = (as[i] >= bs[i]);
833 r |= m; // accumulate so JIT can't eliminate the computation
834 }
835 }
836
837 bh.consume(r);
838 }
839
840 @Benchmark
841 public void blend(Blackhole bh) {
842 long[] as = fa.apply(size);
843 long[] bs = fb.apply(size);
844 long[] rs = fr.apply(size);
845 boolean[] ms = fm.apply(size);
846
847 for (int ic = 0; ic < INVOC_COUNT; ic++) {
848 for (int i = 0; i < as.length; i++) {
849 long a = as[i];
850 long b = bs[i];
851 boolean m = ms[i % ms.length];
852 rs[i] = (m ? b : a);
853 }
854 }
855
856 bh.consume(rs);
857 }
858 void rearrangeShared(int window, Blackhole bh) {
859 long[] as = fa.apply(size);
860 int[] order = fs.apply(size);
861 long[] rs = fr.apply(size);
862
863 for (int ic = 0; ic < INVOC_COUNT; ic++) {
864 for (int i = 0; i < as.length; i += window) {
865 for (int j = 0; j < window; j++) {
866 long a = as[i+j];
867 int pos = order[j];
868 rs[i + pos] = a;
869 }
870 }
871 }
872
873 bh.consume(rs);
874 }
875
876 @Benchmark
877 public void rearrange064(Blackhole bh) {
878 int window = 64 / Long.SIZE;
879 rearrangeShared(window, bh);
880 }
881
882 @Benchmark
883 public void rearrange128(Blackhole bh) {
884 int window = 128 / Long.SIZE;
885 rearrangeShared(window, bh);
886 }
887
888 @Benchmark
889 public void rearrange256(Blackhole bh) {
890 int window = 256 / Long.SIZE;
891 rearrangeShared(window, bh);
892 }
893
894 @Benchmark
895 public void rearrange512(Blackhole bh) {
896 int window = 512 / Long.SIZE;
897 rearrangeShared(window, bh);
898 }
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920 @Benchmark
921 public void neg(Blackhole bh) {
922 long[] as = fa.apply(size);
923 long[] rs = fr.apply(size);
924
925 for (int ic = 0; ic < INVOC_COUNT; ic++) {
926 for (int i = 0; i < as.length; i++) {
927 long a = as[i];
928 rs[i] = (long)(-((long)a));
929 }
930 }
931
932 bh.consume(rs);
933 }
934
935 @Benchmark
936 public void negMasked(Blackhole bh) {
937 long[] as = fa.apply(size);
938 long[] rs = fr.apply(size);
939 boolean[] ms = fm.apply(size);
940
941 for (int ic = 0; ic < INVOC_COUNT; ic++) {
942 for (int i = 0; i < as.length; i++) {
943 long a = as[i];
944 boolean m = ms[i % ms.length];
945 rs[i] = (m ? (long)(-((long)a)) : a);
946 }
947 }
948
949 bh.consume(rs);
950 }
951
952 @Benchmark
953 public void abs(Blackhole bh) {
954 long[] as = fa.apply(size);
955 long[] rs = fr.apply(size);
956
957 for (int ic = 0; ic < INVOC_COUNT; ic++) {
958 for (int i = 0; i < as.length; i++) {
959 long a = as[i];
960 rs[i] = (long)(Math.abs((long)a));
961 }
962 }
963
964 bh.consume(rs);
965 }
966
967 @Benchmark
968 public void absMasked(Blackhole bh) {
969 long[] as = fa.apply(size);
970 long[] rs = fr.apply(size);
971 boolean[] ms = fm.apply(size);
972
973 for (int ic = 0; ic < INVOC_COUNT; ic++) {
974 for (int i = 0; i < as.length; i++) {
975 long a = as[i];
976 boolean m = ms[i % ms.length];
977 rs[i] = (m ? (long)(Math.abs((long)a)) : a);
978 }
979 }
980
981 bh.consume(rs);
982 }
983
984
985 @Benchmark
986 public void not(Blackhole bh) {
987 long[] as = fa.apply(size);
988 long[] rs = fr.apply(size);
989
990 for (int ic = 0; ic < INVOC_COUNT; ic++) {
991 for (int i = 0; i < as.length; i++) {
992 long a = as[i];
993 rs[i] = (long)(~((long)a));
994 }
995 }
996
997 bh.consume(rs);
998 }
999
1000
1001
1002 @Benchmark
1003 public void notMasked(Blackhole bh) {
1004 long[] as = fa.apply(size);
1005 long[] rs = fr.apply(size);
1006 boolean[] ms = fm.apply(size);
1007
1008 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1009 for (int i = 0; i < as.length; i++) {
1010 long a = as[i];
1011 boolean m = ms[i % ms.length];
1012 rs[i] = (m ? (long)(~((long)a)) : a);
1013 }
1014 }
1015
1016 bh.consume(rs);
1017 }
1018
1019
1020
1021
1022 @Benchmark
1023 public void gatherBase0(Blackhole bh) {
1024 long[] as = fa.apply(size);
1025 int[] is = fs.apply(size);
1026 long[] rs = fr.apply(size);
1027
1028 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1029 for (int i = 0; i < as.length; i++) {
1030 int ix = 0 + is[i];
1031 rs[i] = as[ix];
1032 }
1033 }
1034
1035 bh.consume(rs);
1036 }
1037
1038
1039 void gather(int window, Blackhole bh) {
1040 long[] as = fa.apply(size);
1041 int[] is = fs.apply(size);
1042 long[] rs = fr.apply(size);
1043
1044 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1045 for (int i = 0; i < as.length; i += window) {
1046 for (int j = 0; j < window; j++) {
1047 int ix = i + is[i + j];
1048 rs[i + j] = as[ix];
1049 }
1050 }
1051 }
1052
1053 bh.consume(rs);
1054 }
1055
1056 @Benchmark
1057 public void gather064(Blackhole bh) {
1058 int window = 64 / Long.SIZE;
1059 gather(window, bh);
1060 }
1061
1062 @Benchmark
1063 public void gather128(Blackhole bh) {
1064 int window = 128 / Long.SIZE;
1065 gather(window, bh);
1066 }
1067
1068 @Benchmark
1069 public void gather256(Blackhole bh) {
1070 int window = 256 / Long.SIZE;
1071 gather(window, bh);
1072 }
1073
1074 @Benchmark
1075 public void gather512(Blackhole bh) {
1076 int window = 512 / Long.SIZE;
1077 gather(window, bh);
1078 }
1079
1080
1081
1082 @Benchmark
1083 public void scatterBase0(Blackhole bh) {
1084 long[] as = fa.apply(size);
1085 int[] is = fs.apply(size);
1086 long[] rs = fr.apply(size);
1087
1088 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1089 for (int i = 0; i < as.length; i++) {
1090 int ix = 0 + is[i];
1091 rs[ix] = as[i];
1092 }
1093 }
1094
1095 bh.consume(rs);
1096 }
1097
1098 void scatter(int window, Blackhole bh) {
1099 long[] as = fa.apply(size);
1100 int[] is = fs.apply(size);
1101 long[] rs = fr.apply(size);
1102
1103 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1104 for (int i = 0; i < as.length; i += window) {
1105 for (int j = 0; j < window; j++) {
1106 int ix = i + is[i + j];
1107 rs[ix] = as[i + j];
1108 }
1109 }
1110 }
1111
1112 bh.consume(rs);
1113 }
1114
1115 @Benchmark
1116 public void scatter064(Blackhole bh) {
1117 int window = 64 / Long.SIZE;
1118 scatter(window, bh);
1119 }
1120
1121 @Benchmark
1122 public void scatter128(Blackhole bh) {
1123 int window = 128 / Long.SIZE;
1124 scatter(window, bh);
1125 }
1126
1127 @Benchmark
1128 public void scatter256(Blackhole bh) {
1129 int window = 256 / Long.SIZE;
1130 scatter(window, bh);
1131 }
1132
1133 @Benchmark
1134 public void scatter512(Blackhole bh) {
1135 int window = 512 / Long.SIZE;
1136 scatter(window, bh);
1137 }
1138
1139 }
1140