1 /*
2 * Copyright (c) 2018, 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 jdk.incubator.vector.Vector;
27 import jdk.incubator.vector.Vector.Shape;
28 import jdk.incubator.vector.LongVector;
29
30 import java.util.concurrent.TimeUnit;
31 import java.util.function.BiFunction;
32 import java.util.function.IntFunction;
33
34 import org.openjdk.jmh.annotations.*;
35 import org.openjdk.jmh.infra.Blackhole;
36
37 @BenchmarkMode(Mode.Throughput)
38 @OutputTimeUnit(TimeUnit.MILLISECONDS)
39 @State(Scope.Benchmark)
40 @Warmup(iterations = 3, time = 1)
41 @Measurement(iterations = 5, time = 1)
42 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
43 public class LongMaxVector extends AbstractVectorBenchmark {
44 static final LongVector.LongSpecies SPECIES = LongVector.species(Shape.S_Max_BIT);
45
46 static final int INVOC_COUNT = 1; // get rid of outer loop
47
48 @Param("1024")
49 int size;
50
51 long[] fill(IntFunction<Long> f) {
52 long[] array = new long[size];
53 for (int i = 0; i < array.length; i++) {
54 array[i] = f.apply(i);
55 }
56 return array;
57 }
58
59 long[] a, b, c, r;
60 boolean[] m, rm;
61 int[] s;
62
63 @Setup
64 public void init() {
65 size += size % SPECIES.length(); // FIXME: add post-loops
66
67 a = fill(i -> (long)(2*i));
68 b = fill(i -> (long)(i+1));
69 c = fill(i -> (long)(i+5));
70 r = fill(i -> (long)0);
71
72 m = fillMask(size, i -> (i % 2) == 0);
73 rm = fillMask(size, i -> false);
74
75 s = fillInt(size, i -> RANDOM.nextInt(SPECIES.length()));
76 }
77
78 final IntFunction<long[]> fa = vl -> a;
79 final IntFunction<long[]> fb = vl -> b;
80 final IntFunction<long[]> fc = vl -> c;
81 final IntFunction<long[]> fr = vl -> r;
82 final IntFunction<boolean[]> fm = vl -> m;
83 final IntFunction<boolean[]> fmr = vl -> rm;
84 final BiFunction<Integer,Integer,int[]> fs = (i,j) -> s;
85
86
87 @Benchmark
88 public void add(Blackhole bh) {
89 long[] a = fa.apply(SPECIES.length());
90 long[] b = fb.apply(SPECIES.length());
91 long[] r = fr.apply(SPECIES.length());
92
93 for (int ic = 0; ic < INVOC_COUNT; ic++) {
94 for (int i = 0; i < a.length; i += SPECIES.length()) {
95 LongVector av = LongVector.fromArray(SPECIES, a, i);
96 LongVector bv = LongVector.fromArray(SPECIES, b, i);
97 av.add(bv).intoArray(r, i);
98 }
99 }
100
101 bh.consume(r);
102 }
103
104 @Benchmark
105 public void addMasked(Blackhole bh) {
106 long[] a = fa.apply(SPECIES.length());
107 long[] b = fb.apply(SPECIES.length());
108 long[] r = fr.apply(SPECIES.length());
109 boolean[] mask = fm.apply(SPECIES.length());
110 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
111
112 for (int ic = 0; ic < INVOC_COUNT; ic++) {
113 for (int i = 0; i < a.length; i += SPECIES.length()) {
114 LongVector av = LongVector.fromArray(SPECIES, a, i);
115 LongVector bv = LongVector.fromArray(SPECIES, b, i);
116 av.add(bv, vmask).intoArray(r, i);
117 }
118 }
119
120 bh.consume(r);
121 }
122
123 @Benchmark
124 public void sub(Blackhole bh) {
125 long[] a = fa.apply(SPECIES.length());
126 long[] b = fb.apply(SPECIES.length());
127 long[] r = fr.apply(SPECIES.length());
128
129 for (int ic = 0; ic < INVOC_COUNT; ic++) {
130 for (int i = 0; i < a.length; i += SPECIES.length()) {
131 LongVector av = LongVector.fromArray(SPECIES, a, i);
132 LongVector bv = LongVector.fromArray(SPECIES, b, i);
133 av.sub(bv).intoArray(r, i);
134 }
135 }
136
137 bh.consume(r);
138 }
139
140 @Benchmark
141 public void subMasked(Blackhole bh) {
142 long[] a = fa.apply(SPECIES.length());
143 long[] b = fb.apply(SPECIES.length());
144 long[] r = fr.apply(SPECIES.length());
145 boolean[] mask = fm.apply(SPECIES.length());
146 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
147
148 for (int ic = 0; ic < INVOC_COUNT; ic++) {
149 for (int i = 0; i < a.length; i += SPECIES.length()) {
150 LongVector av = LongVector.fromArray(SPECIES, a, i);
151 LongVector bv = LongVector.fromArray(SPECIES, b, i);
152 av.sub(bv, vmask).intoArray(r, i);
153 }
154 }
155
156 bh.consume(r);
157 }
158
159
160
161 @Benchmark
162 public void mul(Blackhole bh) {
163 long[] a = fa.apply(SPECIES.length());
164 long[] b = fb.apply(SPECIES.length());
165 long[] r = fr.apply(SPECIES.length());
166
167 for (int ic = 0; ic < INVOC_COUNT; ic++) {
168 for (int i = 0; i < a.length; i += SPECIES.length()) {
169 LongVector av = LongVector.fromArray(SPECIES, a, i);
170 LongVector bv = LongVector.fromArray(SPECIES, b, i);
171 av.mul(bv).intoArray(r, i);
172 }
173 }
174
175 bh.consume(r);
176 }
177
178 @Benchmark
179 public void mulMasked(Blackhole bh) {
180 long[] a = fa.apply(SPECIES.length());
181 long[] b = fb.apply(SPECIES.length());
182 long[] r = fr.apply(SPECIES.length());
183 boolean[] mask = fm.apply(SPECIES.length());
184 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
185
186 for (int ic = 0; ic < INVOC_COUNT; ic++) {
187 for (int i = 0; i < a.length; i += SPECIES.length()) {
188 LongVector av = LongVector.fromArray(SPECIES, a, i);
189 LongVector bv = LongVector.fromArray(SPECIES, b, i);
190 av.mul(bv, vmask).intoArray(r, i);
191 }
192 }
193
194 bh.consume(r);
195 }
196
197
198 @Benchmark
199 public void and(Blackhole bh) {
200 long[] a = fa.apply(SPECIES.length());
201 long[] b = fb.apply(SPECIES.length());
202 long[] r = fr.apply(SPECIES.length());
203
204 for (int ic = 0; ic < INVOC_COUNT; ic++) {
205 for (int i = 0; i < a.length; i += SPECIES.length()) {
206 LongVector av = LongVector.fromArray(SPECIES, a, i);
207 LongVector bv = LongVector.fromArray(SPECIES, b, i);
208 av.and(bv).intoArray(r, i);
209 }
210 }
211
212 bh.consume(r);
213 }
214
215
216
217 @Benchmark
218 public void andMasked(Blackhole bh) {
219 long[] a = fa.apply(SPECIES.length());
220 long[] b = fb.apply(SPECIES.length());
221 long[] r = fr.apply(SPECIES.length());
222 boolean[] mask = fm.apply(SPECIES.length());
223 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
224
225 for (int ic = 0; ic < INVOC_COUNT; ic++) {
226 for (int i = 0; i < a.length; i += SPECIES.length()) {
227 LongVector av = LongVector.fromArray(SPECIES, a, i);
228 LongVector bv = LongVector.fromArray(SPECIES, b, i);
229 av.and(bv, vmask).intoArray(r, i);
230 }
231 }
232
233 bh.consume(r);
234 }
235
236
237
238 @Benchmark
239 public void or(Blackhole bh) {
240 long[] a = fa.apply(SPECIES.length());
241 long[] b = fb.apply(SPECIES.length());
242 long[] r = fr.apply(SPECIES.length());
243
244 for (int ic = 0; ic < INVOC_COUNT; ic++) {
245 for (int i = 0; i < a.length; i += SPECIES.length()) {
246 LongVector av = LongVector.fromArray(SPECIES, a, i);
247 LongVector bv = LongVector.fromArray(SPECIES, b, i);
248 av.or(bv).intoArray(r, i);
249 }
250 }
251
252 bh.consume(r);
253 }
254
255
256
257 @Benchmark
258 public void orMasked(Blackhole bh) {
259 long[] a = fa.apply(SPECIES.length());
260 long[] b = fb.apply(SPECIES.length());
261 long[] r = fr.apply(SPECIES.length());
262 boolean[] mask = fm.apply(SPECIES.length());
263 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
264
265 for (int ic = 0; ic < INVOC_COUNT; ic++) {
266 for (int i = 0; i < a.length; i += SPECIES.length()) {
267 LongVector av = LongVector.fromArray(SPECIES, a, i);
268 LongVector bv = LongVector.fromArray(SPECIES, b, i);
269 av.or(bv, vmask).intoArray(r, i);
270 }
271 }
272
273 bh.consume(r);
274 }
275
276
277
278 @Benchmark
279 public void xor(Blackhole bh) {
280 long[] a = fa.apply(SPECIES.length());
281 long[] b = fb.apply(SPECIES.length());
282 long[] r = fr.apply(SPECIES.length());
283
284 for (int ic = 0; ic < INVOC_COUNT; ic++) {
285 for (int i = 0; i < a.length; i += SPECIES.length()) {
286 LongVector av = LongVector.fromArray(SPECIES, a, i);
287 LongVector bv = LongVector.fromArray(SPECIES, b, i);
288 av.xor(bv).intoArray(r, i);
289 }
290 }
291
292 bh.consume(r);
293 }
294
295
296
297 @Benchmark
298 public void xorMasked(Blackhole bh) {
299 long[] a = fa.apply(SPECIES.length());
300 long[] b = fb.apply(SPECIES.length());
301 long[] r = fr.apply(SPECIES.length());
302 boolean[] mask = fm.apply(SPECIES.length());
303 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
304
305 for (int ic = 0; ic < INVOC_COUNT; ic++) {
306 for (int i = 0; i < a.length; i += SPECIES.length()) {
307 LongVector av = LongVector.fromArray(SPECIES, a, i);
308 LongVector bv = LongVector.fromArray(SPECIES, b, i);
309 av.xor(bv, vmask).intoArray(r, i);
310 }
311 }
312
313 bh.consume(r);
314 }
315
316
317
318 @Benchmark
319 public void shiftR(Blackhole bh) {
320 long[] a = fa.apply(SPECIES.length());
321 long[] b = fb.apply(SPECIES.length());
322 long[] r = fr.apply(SPECIES.length());
323
324 for (int ic = 0; ic < INVOC_COUNT; ic++) {
325 for (int i = 0; i < a.length; i += SPECIES.length()) {
326 LongVector av = LongVector.fromArray(SPECIES, a, i);
327 LongVector bv = LongVector.fromArray(SPECIES, b, i);
328 av.shiftR(bv).intoArray(r, i);
329 }
330 }
331
332 bh.consume(r);
333 }
334
335
336
337 @Benchmark
338 public void shiftRMasked(Blackhole bh) {
339 long[] a = fa.apply(SPECIES.length());
340 long[] b = fb.apply(SPECIES.length());
341 long[] r = fr.apply(SPECIES.length());
342 boolean[] mask = fm.apply(SPECIES.length());
343 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
344
345 for (int ic = 0; ic < INVOC_COUNT; ic++) {
346 for (int i = 0; i < a.length; i += SPECIES.length()) {
347 LongVector av = LongVector.fromArray(SPECIES, a, i);
348 LongVector bv = LongVector.fromArray(SPECIES, b, i);
349 av.shiftR(bv, vmask).intoArray(r, i);
350 }
351 }
352
353 bh.consume(r);
354 }
355
356
357
358 @Benchmark
359 public void shiftL(Blackhole bh) {
360 long[] a = fa.apply(SPECIES.length());
361 long[] b = fb.apply(SPECIES.length());
362 long[] r = fr.apply(SPECIES.length());
363
364 for (int ic = 0; ic < INVOC_COUNT; ic++) {
365 for (int i = 0; i < a.length; i += SPECIES.length()) {
366 LongVector av = LongVector.fromArray(SPECIES, a, i);
367 LongVector bv = LongVector.fromArray(SPECIES, b, i);
368 av.shiftL(bv).intoArray(r, i);
369 }
370 }
371
372 bh.consume(r);
373 }
374
375
376
377 @Benchmark
378 public void shiftLMasked(Blackhole bh) {
379 long[] a = fa.apply(SPECIES.length());
380 long[] b = fb.apply(SPECIES.length());
381 long[] r = fr.apply(SPECIES.length());
382 boolean[] mask = fm.apply(SPECIES.length());
383 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
384
385 for (int ic = 0; ic < INVOC_COUNT; ic++) {
386 for (int i = 0; i < a.length; i += SPECIES.length()) {
387 LongVector av = LongVector.fromArray(SPECIES, a, i);
388 LongVector bv = LongVector.fromArray(SPECIES, b, i);
389 av.shiftL(bv, vmask).intoArray(r, i);
390 }
391 }
392
393 bh.consume(r);
394 }
395
396
397
398 @Benchmark
399 public void aShiftR(Blackhole bh) {
400 long[] a = fa.apply(SPECIES.length());
401 long[] b = fb.apply(SPECIES.length());
402 long[] r = fr.apply(SPECIES.length());
403
404 for (int ic = 0; ic < INVOC_COUNT; ic++) {
405 for (int i = 0; i < a.length; i += SPECIES.length()) {
406 LongVector av = LongVector.fromArray(SPECIES, a, i);
407 LongVector bv = LongVector.fromArray(SPECIES, b, i);
408 av.aShiftR(bv).intoArray(r, i);
409 }
410 }
411
412 bh.consume(r);
413 }
414
415
416
417 @Benchmark
418 public void aShiftRMasked(Blackhole bh) {
419 long[] a = fa.apply(SPECIES.length());
420 long[] b = fb.apply(SPECIES.length());
421 long[] r = fr.apply(SPECIES.length());
422 boolean[] mask = fm.apply(SPECIES.length());
423 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
424
425 for (int ic = 0; ic < INVOC_COUNT; ic++) {
426 for (int i = 0; i < a.length; i += SPECIES.length()) {
427 LongVector av = LongVector.fromArray(SPECIES, a, i);
428 LongVector bv = LongVector.fromArray(SPECIES, b, i);
429 av.aShiftR(bv, vmask).intoArray(r, i);
430 }
431 }
432
433 bh.consume(r);
434 }
435
436
437
438 @Benchmark
439 public void aShiftRShift(Blackhole bh) {
440 long[] a = fa.apply(SPECIES.length());
441 long[] b = fb.apply(SPECIES.length());
442 long[] r = fr.apply(SPECIES.length());
443
444 for (int ic = 0; ic < INVOC_COUNT; ic++) {
445 for (int i = 0; i < a.length; i += SPECIES.length()) {
446 LongVector av = LongVector.fromArray(SPECIES, a, i);
447 av.aShiftR((int)b[i]).intoArray(r, i);
448 }
449 }
450
451 bh.consume(r);
452 }
453
454
455
456 @Benchmark
457 public void aShiftRMaskedShift(Blackhole bh) {
458 long[] a = fa.apply(SPECIES.length());
459 long[] b = fb.apply(SPECIES.length());
460 long[] r = fr.apply(SPECIES.length());
461 boolean[] mask = fm.apply(SPECIES.length());
462 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
463
464 for (int ic = 0; ic < INVOC_COUNT; ic++) {
465 for (int i = 0; i < a.length; i += SPECIES.length()) {
466 LongVector av = LongVector.fromArray(SPECIES, a, i);
467 av.aShiftR((int)b[i], vmask).intoArray(r, i);
468 }
469 }
470
471 bh.consume(r);
472 }
473
474
475
476 @Benchmark
477 public void shiftRShift(Blackhole bh) {
478 long[] a = fa.apply(SPECIES.length());
479 long[] b = fb.apply(SPECIES.length());
480 long[] r = fr.apply(SPECIES.length());
481
482 for (int ic = 0; ic < INVOC_COUNT; ic++) {
483 for (int i = 0; i < a.length; i += SPECIES.length()) {
484 LongVector av = LongVector.fromArray(SPECIES, a, i);
485 av.shiftR((int)b[i]).intoArray(r, i);
486 }
487 }
488
489 bh.consume(r);
490 }
491
492
493
494 @Benchmark
495 public void shiftRMaskedShift(Blackhole bh) {
496 long[] a = fa.apply(SPECIES.length());
497 long[] b = fb.apply(SPECIES.length());
498 long[] r = fr.apply(SPECIES.length());
499 boolean[] mask = fm.apply(SPECIES.length());
500 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
501
502 for (int ic = 0; ic < INVOC_COUNT; ic++) {
503 for (int i = 0; i < a.length; i += SPECIES.length()) {
504 LongVector av = LongVector.fromArray(SPECIES, a, i);
505 av.shiftR((int)b[i], vmask).intoArray(r, i);
506 }
507 }
508
509 bh.consume(r);
510 }
511
512
513
514 @Benchmark
515 public void shiftLShift(Blackhole bh) {
516 long[] a = fa.apply(SPECIES.length());
517 long[] b = fb.apply(SPECIES.length());
518 long[] r = fr.apply(SPECIES.length());
519
520 for (int ic = 0; ic < INVOC_COUNT; ic++) {
521 for (int i = 0; i < a.length; i += SPECIES.length()) {
522 LongVector av = LongVector.fromArray(SPECIES, a, i);
523 av.shiftL((int)b[i]).intoArray(r, i);
524 }
525 }
526
527 bh.consume(r);
528 }
529
530
531
532 @Benchmark
533 public void shiftLMaskedShift(Blackhole bh) {
534 long[] a = fa.apply(SPECIES.length());
535 long[] b = fb.apply(SPECIES.length());
536 long[] r = fr.apply(SPECIES.length());
537 boolean[] mask = fm.apply(SPECIES.length());
538 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
539
540 for (int ic = 0; ic < INVOC_COUNT; ic++) {
541 for (int i = 0; i < a.length; i += SPECIES.length()) {
542 LongVector av = LongVector.fromArray(SPECIES, a, i);
543 av.shiftL((int)b[i], vmask).intoArray(r, i);
544 }
545 }
546
547 bh.consume(r);
548 }
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563 @Benchmark
564 public void max(Blackhole bh) {
565 long[] a = fa.apply(SPECIES.length());
566 long[] b = fb.apply(SPECIES.length());
567 long[] r = fr.apply(SPECIES.length());
568
569 for (int ic = 0; ic < INVOC_COUNT; ic++) {
570 for (int i = 0; i < a.length; i += SPECIES.length()) {
571 LongVector av = LongVector.fromArray(SPECIES, a, i);
572 LongVector bv = LongVector.fromArray(SPECIES, b, i);
573 av.max(bv).intoArray(r, i);
574 }
575 }
576
577 bh.consume(r);
578 }
579
580 @Benchmark
581 public void min(Blackhole bh) {
582 long[] a = fa.apply(SPECIES.length());
583 long[] b = fb.apply(SPECIES.length());
584 long[] r = fr.apply(SPECIES.length());
585
586 for (int ic = 0; ic < INVOC_COUNT; ic++) {
587 for (int i = 0; i < a.length; i += SPECIES.length()) {
588 LongVector av = LongVector.fromArray(SPECIES, a, i);
589 LongVector bv = LongVector.fromArray(SPECIES, b, i);
590 av.min(bv).intoArray(r, i);
591 }
592 }
593
594 bh.consume(r);
595 }
596
597
598 @Benchmark
599 public void andAll(Blackhole bh) {
600 long[] a = fa.apply(SPECIES.length());
601 long[] r = fr.apply(SPECIES.length());
602 long ra = -1;
603
604 for (int ic = 0; ic < INVOC_COUNT; ic++) {
605 for (int i = 0; i < a.length; i += SPECIES.length()) {
606 LongVector av = LongVector.fromArray(SPECIES, a, i);
607 r[i] = av.andAll();
608 }
609 }
610
611 for (int ic = 0; ic < INVOC_COUNT; ic++) {
612 ra = -1;
613 for (int i = 0; i < a.length; i += SPECIES.length()) {
614 LongVector av = LongVector.fromArray(SPECIES, a, i);
615 ra &= av.andAll();
616 }
617 }
618
619 bh.consume(ra);
620 bh.consume(r);
621 }
622
623
624
625 @Benchmark
626 public void orAll(Blackhole bh) {
627 long[] a = fa.apply(SPECIES.length());
628 long[] r = fr.apply(SPECIES.length());
629 long ra = 0;
630
631 for (int ic = 0; ic < INVOC_COUNT; ic++) {
632 for (int i = 0; i < a.length; i += SPECIES.length()) {
633 LongVector av = LongVector.fromArray(SPECIES, a, i);
634 r[i] = av.orAll();
635 }
636 }
637
638 for (int ic = 0; ic < INVOC_COUNT; ic++) {
639 ra = 0;
640 for (int i = 0; i < a.length; i += SPECIES.length()) {
641 LongVector av = LongVector.fromArray(SPECIES, a, i);
642 ra |= av.orAll();
643 }
644 }
645
646 bh.consume(ra);
647 bh.consume(r);
648 }
649
650
651
652 @Benchmark
653 public void xorAll(Blackhole bh) {
654 long[] a = fa.apply(SPECIES.length());
655 long[] r = fr.apply(SPECIES.length());
656 long ra = 0;
657
658 for (int ic = 0; ic < INVOC_COUNT; ic++) {
659 for (int i = 0; i < a.length; i += SPECIES.length()) {
660 LongVector av = LongVector.fromArray(SPECIES, a, i);
661 r[i] = av.xorAll();
662 }
663 }
664
665 for (int ic = 0; ic < INVOC_COUNT; ic++) {
666 ra = 0;
667 for (int i = 0; i < a.length; i += SPECIES.length()) {
668 LongVector av = LongVector.fromArray(SPECIES, a, i);
669 ra ^= av.xorAll();
670 }
671 }
672
673 bh.consume(ra);
674 bh.consume(r);
675 }
676
677
678 @Benchmark
679 public void addAll(Blackhole bh) {
680 long[] a = fa.apply(SPECIES.length());
681 long[] r = fr.apply(SPECIES.length());
682 long ra = 0;
683
684 for (int ic = 0; ic < INVOC_COUNT; ic++) {
685 for (int i = 0; i < a.length; i += SPECIES.length()) {
686 LongVector av = LongVector.fromArray(SPECIES, a, i);
687 r[i] = av.addAll();
688 }
689 }
690
691 for (int ic = 0; ic < INVOC_COUNT; ic++) {
692 ra = 0;
693 for (int i = 0; i < a.length; i += SPECIES.length()) {
694 LongVector av = LongVector.fromArray(SPECIES, a, i);
695 ra += av.addAll();
696 }
697 }
698
699 bh.consume(ra);
700 bh.consume(r);
701 }
702
703 @Benchmark
704 public void mulAll(Blackhole bh) {
705 long[] a = fa.apply(SPECIES.length());
706 long[] r = fr.apply(SPECIES.length());
707 long ra = 1;
708
709 for (int ic = 0; ic < INVOC_COUNT; ic++) {
710 for (int i = 0; i < a.length; i += SPECIES.length()) {
711 LongVector av = LongVector.fromArray(SPECIES, a, i);
712 r[i] = av.mulAll();
713 }
714 }
715
716 for (int ic = 0; ic < INVOC_COUNT; ic++) {
717 ra = 1;
718 for (int i = 0; i < a.length; i += SPECIES.length()) {
719 LongVector av = LongVector.fromArray(SPECIES, a, i);
720 ra *= av.mulAll();
721 }
722 }
723
724 bh.consume(ra);
725 bh.consume(r);
726 }
727
728 @Benchmark
729 public void minAll(Blackhole bh) {
730 long[] a = fa.apply(SPECIES.length());
731 long[] r = fr.apply(SPECIES.length());
732 long ra = Long.MAX_VALUE;
733
734 for (int ic = 0; ic < INVOC_COUNT; ic++) {
735 for (int i = 0; i < a.length; i += SPECIES.length()) {
736 LongVector av = LongVector.fromArray(SPECIES, a, i);
737 r[i] = av.minAll();
738 }
739 }
740
741 for (int ic = 0; ic < INVOC_COUNT; ic++) {
742 ra = Long.MAX_VALUE;
743 for (int i = 0; i < a.length; i += SPECIES.length()) {
744 LongVector av = LongVector.fromArray(SPECIES, a, i);
745 ra = (long)Math.min(ra, av.minAll());
746 }
747 }
748
749 bh.consume(ra);
750 bh.consume(r);
751 }
752
753 @Benchmark
754 public void maxAll(Blackhole bh) {
755 long[] a = fa.apply(SPECIES.length());
756 long[] r = fr.apply(SPECIES.length());
757 long ra = Long.MIN_VALUE;
758
759 for (int ic = 0; ic < INVOC_COUNT; ic++) {
760 for (int i = 0; i < a.length; i += SPECIES.length()) {
761 LongVector av = LongVector.fromArray(SPECIES, a, i);
762 r[i] = av.maxAll();
763 }
764 }
765
766 for (int ic = 0; ic < INVOC_COUNT; ic++) {
767 ra = Long.MIN_VALUE;
768 for (int i = 0; i < a.length; i += SPECIES.length()) {
769 LongVector av = LongVector.fromArray(SPECIES, a, i);
770 ra = (long)Math.max(ra, av.maxAll());
771 }
772 }
773
774 bh.consume(ra);
775 bh.consume(r);
776 }
777
778
779 @Benchmark
780 public void anyTrue(Blackhole bh) {
781 boolean[] mask = fm.apply(SPECIES.length());
782 boolean[] r = fmr.apply(SPECIES.length());
783
784 for (int ic = 0; ic < INVOC_COUNT; ic++) {
785 for (int i = 0; i < mask.length; i += SPECIES.length()) {
786 Vector.Mask<Long> vmask = LongVector.maskFromArray(SPECIES, mask, i);
787 r[i] = vmask.anyTrue();
788 }
789 }
790
791 bh.consume(r);
792 }
793
794
795
796 @Benchmark
797 public void allTrue(Blackhole bh) {
798 boolean[] mask = fm.apply(SPECIES.length());
799 boolean[] r = fmr.apply(SPECIES.length());
800
801 for (int ic = 0; ic < INVOC_COUNT; ic++) {
802 for (int i = 0; i < mask.length; i += SPECIES.length()) {
803 Vector.Mask<Long> vmask = LongVector.maskFromArray(SPECIES, mask, i);
804 r[i] = vmask.allTrue();
805 }
806 }
807
808 bh.consume(r);
809 }
810
811
812 @Benchmark
813 public void with(Blackhole bh) {
814 long[] a = fa.apply(SPECIES.length());
815 long[] r = fr.apply(SPECIES.length());
816
817 for (int ic = 0; ic < INVOC_COUNT; ic++) {
818 for (int i = 0; i < a.length; i += SPECIES.length()) {
819 LongVector av = LongVector.fromArray(SPECIES, a, i);
820 av.with(0, (long)4).intoArray(r, i);
821 }
822 }
823
824 bh.consume(r);
825 }
826
827 @Benchmark
828 public Object lessThan() {
829 long[] a = fa.apply(size);
830 long[] b = fb.apply(size);
831 boolean[] ms = fm.apply(size);
832 Vector.Mask<Long> m = LongVector.maskFromArray(SPECIES, ms, 0);
833
834 for (int ic = 0; ic < INVOC_COUNT; ic++) {
835 for (int i = 0; i < a.length; i += SPECIES.length()) {
836 LongVector av = LongVector.fromArray(SPECIES, a, i);
837 LongVector bv = LongVector.fromArray(SPECIES, b, i);
838 Vector.Mask<Long> mv = av.lessThan(bv);
839
840 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
841 }
842 }
843 return m;
844 }
845
846
847 @Benchmark
848 public Object greaterThan() {
849 long[] a = fa.apply(size);
850 long[] b = fb.apply(size);
851 boolean[] ms = fm.apply(size);
852 Vector.Mask<Long> m = LongVector.maskFromArray(SPECIES, ms, 0);
853
854 for (int ic = 0; ic < INVOC_COUNT; ic++) {
855 for (int i = 0; i < a.length; i += SPECIES.length()) {
856 LongVector av = LongVector.fromArray(SPECIES, a, i);
857 LongVector bv = LongVector.fromArray(SPECIES, b, i);
858 Vector.Mask<Long> mv = av.greaterThan(bv);
859
860 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
861 }
862 }
863 return m;
864 }
865
866
867 @Benchmark
868 public Object equal() {
869 long[] a = fa.apply(size);
870 long[] b = fb.apply(size);
871 boolean[] ms = fm.apply(size);
872 Vector.Mask<Long> m = LongVector.maskFromArray(SPECIES, ms, 0);
873
874 for (int ic = 0; ic < INVOC_COUNT; ic++) {
875 for (int i = 0; i < a.length; i += SPECIES.length()) {
876 LongVector av = LongVector.fromArray(SPECIES, a, i);
877 LongVector bv = LongVector.fromArray(SPECIES, b, i);
878 Vector.Mask<Long> mv = av.equal(bv);
879
880 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
881 }
882 }
883 return m;
884 }
885
886
887 @Benchmark
888 public Object notEqual() {
889 long[] a = fa.apply(size);
890 long[] b = fb.apply(size);
891 boolean[] ms = fm.apply(size);
892 Vector.Mask<Long> m = LongVector.maskFromArray(SPECIES, ms, 0);
893
894 for (int ic = 0; ic < INVOC_COUNT; ic++) {
895 for (int i = 0; i < a.length; i += SPECIES.length()) {
896 LongVector av = LongVector.fromArray(SPECIES, a, i);
897 LongVector bv = LongVector.fromArray(SPECIES, b, i);
898 Vector.Mask<Long> mv = av.notEqual(bv);
899
900 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
901 }
902 }
903 return m;
904 }
905
906
907 @Benchmark
908 public Object lessThanEq() {
909 long[] a = fa.apply(size);
910 long[] b = fb.apply(size);
911 boolean[] ms = fm.apply(size);
912 Vector.Mask<Long> m = LongVector.maskFromArray(SPECIES, ms, 0);
913
914 for (int ic = 0; ic < INVOC_COUNT; ic++) {
915 for (int i = 0; i < a.length; i += SPECIES.length()) {
916 LongVector av = LongVector.fromArray(SPECIES, a, i);
917 LongVector bv = LongVector.fromArray(SPECIES, b, i);
918 Vector.Mask<Long> mv = av.lessThanEq(bv);
919
920 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
921 }
922 }
923 return m;
924 }
925
926
927 @Benchmark
928 public Object greaterThanEq() {
929 long[] a = fa.apply(size);
930 long[] b = fb.apply(size);
931 boolean[] ms = fm.apply(size);
932 Vector.Mask<Long> m = LongVector.maskFromArray(SPECIES, ms, 0);
933
934 for (int ic = 0; ic < INVOC_COUNT; ic++) {
935 for (int i = 0; i < a.length; i += SPECIES.length()) {
936 LongVector av = LongVector.fromArray(SPECIES, a, i);
937 LongVector bv = LongVector.fromArray(SPECIES, b, i);
938 Vector.Mask<Long> mv = av.greaterThanEq(bv);
939
940 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
941 }
942 }
943 return m;
944 }
945
946
947 @Benchmark
948 public void blend(Blackhole bh) {
949 long[] a = fa.apply(SPECIES.length());
950 long[] b = fb.apply(SPECIES.length());
951 long[] r = fr.apply(SPECIES.length());
952 boolean[] mask = fm.apply(SPECIES.length());
953 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
954
955 for (int ic = 0; ic < INVOC_COUNT; ic++) {
956 for (int i = 0; i < a.length; i += SPECIES.length()) {
957 LongVector av = LongVector.fromArray(SPECIES, a, i);
958 LongVector bv = LongVector.fromArray(SPECIES, b, i);
959 av.blend(bv, vmask).intoArray(r, i);
960 }
961 }
962
963 bh.consume(r);
964 }
965
966 @Benchmark
967 public void rearrange(Blackhole bh) {
968 long[] a = fa.apply(SPECIES.length());
969 int[] order = fs.apply(a.length, SPECIES.length());
970 long[] r = fr.apply(SPECIES.length());
971
972 for (int ic = 0; ic < INVOC_COUNT; ic++) {
973 for (int i = 0; i < a.length; i += SPECIES.length()) {
974 LongVector av = LongVector.fromArray(SPECIES, a, i);
975 av.rearrange(LongVector.shuffleFromArray(SPECIES, order, i)).intoArray(r, i);
976 }
977 }
978
979 bh.consume(r);
980 }
981
982 @Benchmark
983 public void extract(Blackhole bh) {
984 long[] a = fa.apply(SPECIES.length());
985 long[] r = fr.apply(SPECIES.length());
986
987 for (int ic = 0; ic < INVOC_COUNT; ic++) {
988 for (int i = 0; i < a.length; i += SPECIES.length()) {
989 LongVector av = LongVector.fromArray(SPECIES, a, i);
990 int num_lanes = SPECIES.length();
991 // Manually unroll because full unroll happens after intrinsification.
992 // Unroll is needed because get intrinsic requires for index to be a known constant.
993 if (num_lanes == 1) {
994 r[i]=av.get(0);
995 } else if (num_lanes == 2) {
996 r[i]=av.get(0);
997 r[i+1]=av.get(1);
998 } else if (num_lanes == 4) {
999 r[i]=av.get(0);
1000 r[i+1]=av.get(1);
1001 r[i+2]=av.get(2);
1002 r[i+3]=av.get(3);
1003 } else if (num_lanes == 8) {
1004 r[i]=av.get(0);
1005 r[i+1]=av.get(1);
1006 r[i+2]=av.get(2);
1007 r[i+3]=av.get(3);
1008 r[i+4]=av.get(4);
1009 r[i+5]=av.get(5);
1010 r[i+6]=av.get(6);
1011 r[i+7]=av.get(7);
1012 } else if (num_lanes == 16) {
1013 r[i]=av.get(0);
1014 r[i+1]=av.get(1);
1015 r[i+2]=av.get(2);
1016 r[i+3]=av.get(3);
1017 r[i+4]=av.get(4);
1018 r[i+5]=av.get(5);
1019 r[i+6]=av.get(6);
1020 r[i+7]=av.get(7);
1021 r[i+8]=av.get(8);
1022 r[i+9]=av.get(9);
1023 r[i+10]=av.get(10);
1024 r[i+11]=av.get(11);
1025 r[i+12]=av.get(12);
1026 r[i+13]=av.get(13);
1027 r[i+14]=av.get(14);
1028 r[i+15]=av.get(15);
1029 } else if (num_lanes == 32) {
1030 r[i]=av.get(0);
1031 r[i+1]=av.get(1);
1032 r[i+2]=av.get(2);
1033 r[i+3]=av.get(3);
1034 r[i+4]=av.get(4);
1035 r[i+5]=av.get(5);
1036 r[i+6]=av.get(6);
1037 r[i+7]=av.get(7);
1038 r[i+8]=av.get(8);
1039 r[i+9]=av.get(9);
1040 r[i+10]=av.get(10);
1041 r[i+11]=av.get(11);
1042 r[i+12]=av.get(12);
1043 r[i+13]=av.get(13);
1044 r[i+14]=av.get(14);
1045 r[i+15]=av.get(15);
1046 r[i+16]=av.get(16);
1047 r[i+17]=av.get(17);
1048 r[i+18]=av.get(18);
1049 r[i+19]=av.get(19);
1050 r[i+20]=av.get(20);
1051 r[i+21]=av.get(21);
1052 r[i+22]=av.get(22);
1053 r[i+23]=av.get(23);
1054 r[i+24]=av.get(24);
1055 r[i+25]=av.get(25);
1056 r[i+26]=av.get(26);
1057 r[i+27]=av.get(27);
1058 r[i+28]=av.get(28);
1059 r[i+29]=av.get(29);
1060 r[i+30]=av.get(30);
1061 r[i+31]=av.get(31);
1062 } else if (num_lanes == 64) {
1063 r[i]=av.get(0);
1064 r[i+1]=av.get(1);
1065 r[i+2]=av.get(2);
1066 r[i+3]=av.get(3);
1067 r[i+4]=av.get(4);
1068 r[i+5]=av.get(5);
1069 r[i+6]=av.get(6);
1070 r[i+7]=av.get(7);
1071 r[i+8]=av.get(8);
1072 r[i+9]=av.get(9);
1073 r[i+10]=av.get(10);
1074 r[i+11]=av.get(11);
1075 r[i+12]=av.get(12);
1076 r[i+13]=av.get(13);
1077 r[i+14]=av.get(14);
1078 r[i+15]=av.get(15);
1079 r[i+16]=av.get(16);
1080 r[i+17]=av.get(17);
1081 r[i+18]=av.get(18);
1082 r[i+19]=av.get(19);
1083 r[i+20]=av.get(20);
1084 r[i+21]=av.get(21);
1085 r[i+22]=av.get(22);
1086 r[i+23]=av.get(23);
1087 r[i+24]=av.get(24);
1088 r[i+25]=av.get(25);
1089 r[i+26]=av.get(26);
1090 r[i+27]=av.get(27);
1091 r[i+28]=av.get(28);
1092 r[i+29]=av.get(29);
1093 r[i+30]=av.get(30);
1094 r[i+31]=av.get(31);
1095 r[i+32]=av.get(32);
1096 r[i+33]=av.get(33);
1097 r[i+34]=av.get(34);
1098 r[i+35]=av.get(35);
1099 r[i+36]=av.get(36);
1100 r[i+37]=av.get(37);
1101 r[i+38]=av.get(38);
1102 r[i+39]=av.get(39);
1103 r[i+40]=av.get(40);
1104 r[i+41]=av.get(41);
1105 r[i+42]=av.get(42);
1106 r[i+43]=av.get(43);
1107 r[i+44]=av.get(44);
1108 r[i+45]=av.get(45);
1109 r[i+46]=av.get(46);
1110 r[i+47]=av.get(47);
1111 r[i+48]=av.get(48);
1112 r[i+49]=av.get(49);
1113 r[i+50]=av.get(50);
1114 r[i+51]=av.get(51);
1115 r[i+52]=av.get(52);
1116 r[i+53]=av.get(53);
1117 r[i+54]=av.get(54);
1118 r[i+55]=av.get(55);
1119 r[i+56]=av.get(56);
1120 r[i+57]=av.get(57);
1121 r[i+58]=av.get(58);
1122 r[i+59]=av.get(59);
1123 r[i+60]=av.get(60);
1124 r[i+61]=av.get(61);
1125 r[i+62]=av.get(62);
1126 r[i+63]=av.get(63);
1127 } else {
1128 for (int j = 0; j < SPECIES.length(); j++) {
1129 r[i+j]=av.get(j);
1130 }
1131 }
1132 }
1133 }
1134
1135 bh.consume(r);
1136 }
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158 @Benchmark
1159 public void neg(Blackhole bh) {
1160 long[] a = fa.apply(SPECIES.length());
1161 long[] r = fr.apply(SPECIES.length());
1162
1163 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1164 for (int i = 0; i < a.length; i += SPECIES.length()) {
1165 LongVector av = LongVector.fromArray(SPECIES, a, i);
1166 av.neg().intoArray(r, i);
1167 }
1168 }
1169
1170 bh.consume(r);
1171 }
1172
1173 @Benchmark
1174 public void negMasked(Blackhole bh) {
1175 long[] a = fa.apply(SPECIES.length());
1176 long[] r = fr.apply(SPECIES.length());
1177 boolean[] mask = fm.apply(SPECIES.length());
1178 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
1179
1180 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1181 for (int i = 0; i < a.length; i += SPECIES.length()) {
1182 LongVector av = LongVector.fromArray(SPECIES, a, i);
1183 av.neg(vmask).intoArray(r, i);
1184 }
1185 }
1186
1187 bh.consume(r);
1188 }
1189
1190 @Benchmark
1191 public void abs(Blackhole bh) {
1192 long[] a = fa.apply(SPECIES.length());
1193 long[] r = fr.apply(SPECIES.length());
1194
1195 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1196 for (int i = 0; i < a.length; i += SPECIES.length()) {
1197 LongVector av = LongVector.fromArray(SPECIES, a, i);
1198 av.abs().intoArray(r, i);
1199 }
1200 }
1201
1202 bh.consume(r);
1203 }
1204
1205 @Benchmark
1206 public void absMasked(Blackhole bh) {
1207 long[] a = fa.apply(SPECIES.length());
1208 long[] r = fr.apply(SPECIES.length());
1209 boolean[] mask = fm.apply(SPECIES.length());
1210 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
1211
1212 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1213 for (int i = 0; i < a.length; i += SPECIES.length()) {
1214 LongVector av = LongVector.fromArray(SPECIES, a, i);
1215 av.abs(vmask).intoArray(r, i);
1216 }
1217 }
1218
1219 bh.consume(r);
1220 }
1221
1222
1223 @Benchmark
1224 public void not(Blackhole bh) {
1225 long[] a = fa.apply(SPECIES.length());
1226 long[] r = fr.apply(SPECIES.length());
1227
1228 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1229 for (int i = 0; i < a.length; i += SPECIES.length()) {
1230 LongVector av = LongVector.fromArray(SPECIES, a, i);
1231 av.not().intoArray(r, i);
1232 }
1233 }
1234
1235 bh.consume(r);
1236 }
1237
1238
1239
1240 @Benchmark
1241 public void notMasked(Blackhole bh) {
1242 long[] a = fa.apply(SPECIES.length());
1243 long[] r = fr.apply(SPECIES.length());
1244 boolean[] mask = fm.apply(SPECIES.length());
1245 Vector.Mask<Long> vmask = LongVector.maskFromValues(SPECIES, mask);
1246
1247 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1248 for (int i = 0; i < a.length; i += SPECIES.length()) {
1249 LongVector av = LongVector.fromArray(SPECIES, a, i);
1250 av.not(vmask).intoArray(r, i);
1251 }
1252 }
1253
1254 bh.consume(r);
1255 }
1256
1257
1258
1259
1260
1261 @Benchmark
1262 public void gather(Blackhole bh) {
1263 long[] a = fa.apply(SPECIES.length());
1264 int[] b = fs.apply(a.length * 2, SPECIES.length());
1265 long[] r = new long[a.length];
1266
1267 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1268 for (int i = 0; i < a.length; i += SPECIES.length()) {
1269 LongVector av = LongVector.fromArray(SPECIES, a, i, b, i);
1270 av.intoArray(r, i);
1271 }
1272 }
1273
1274 bh.consume(r);
1275 }
1276
1277
1278
1279 @Benchmark
1280 public void scatter(Blackhole bh) {
1281 long[] a = fa.apply(SPECIES.length());
1282 int[] b = fs.apply(a.length * 2, SPECIES.length());
1283 long[] r = new long[a.length];
1284
1285 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1286 for (int i = 0; i < a.length; i += SPECIES.length()) {
1287 LongVector av = LongVector.fromArray(SPECIES, a, i);
1288 av.intoArray(r, i, b, i);
1289 }
1290 }
1291
1292 bh.consume(r);
1293 }
1294
1295 }
1296