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.VectorShape;
28 import jdk.incubator.vector.VectorSpecies;
29 import jdk.incubator.vector.VectorShuffle;
30 import jdk.incubator.vector.IntVector;
31
32 import java.util.concurrent.TimeUnit;
33 import java.util.function.BiFunction;
34 import java.util.function.IntFunction;
35
36 import org.openjdk.jmh.annotations.*;
37 import org.openjdk.jmh.infra.Blackhole;
38
39 @BenchmarkMode(Mode.Throughput)
40 @OutputTimeUnit(TimeUnit.MILLISECONDS)
41 @State(Scope.Benchmark)
42 @Warmup(iterations = 3, time = 1)
43 @Measurement(iterations = 5, time = 1)
44 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
45 public class Int128Vector extends AbstractVectorBenchmark {
46 static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_128;
301 int[] a = fa.apply(SPECIES.length());
302 int[] b = fb.apply(SPECIES.length());
303 int[] r = fr.apply(SPECIES.length());
304 boolean[] mask = fm.apply(SPECIES.length());
305 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
306
307 for (int ic = 0; ic < INVOC_COUNT; ic++) {
308 for (int i = 0; i < a.length; i += SPECIES.length()) {
309 IntVector av = IntVector.fromArray(SPECIES, a, i);
310 IntVector bv = IntVector.fromArray(SPECIES, b, i);
311 av.xor(bv, vmask).intoArray(r, i);
312 }
313 }
314
315 bh.consume(r);
316 }
317
318
319
320 @Benchmark
321 public void shiftR(Blackhole bh) {
322 int[] a = fa.apply(SPECIES.length());
323 int[] b = fb.apply(SPECIES.length());
324 int[] r = fr.apply(SPECIES.length());
325
326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
327 for (int i = 0; i < a.length; i += SPECIES.length()) {
328 IntVector av = IntVector.fromArray(SPECIES, a, i);
329 IntVector bv = IntVector.fromArray(SPECIES, b, i);
330 av.shiftR(bv).intoArray(r, i);
331 }
332 }
333
334 bh.consume(r);
335 }
336
337
338
339 @Benchmark
340 public void shiftRMasked(Blackhole bh) {
341 int[] a = fa.apply(SPECIES.length());
342 int[] b = fb.apply(SPECIES.length());
343 int[] r = fr.apply(SPECIES.length());
344 boolean[] mask = fm.apply(SPECIES.length());
345 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
346
347 for (int ic = 0; ic < INVOC_COUNT; ic++) {
348 for (int i = 0; i < a.length; i += SPECIES.length()) {
349 IntVector av = IntVector.fromArray(SPECIES, a, i);
350 IntVector bv = IntVector.fromArray(SPECIES, b, i);
351 av.shiftR(bv, vmask).intoArray(r, i);
352 }
353 }
354
355 bh.consume(r);
356 }
357
358
359
360 @Benchmark
361 public void shiftL(Blackhole bh) {
362 int[] a = fa.apply(SPECIES.length());
363 int[] b = fb.apply(SPECIES.length());
364 int[] r = fr.apply(SPECIES.length());
365
366 for (int ic = 0; ic < INVOC_COUNT; ic++) {
367 for (int i = 0; i < a.length; i += SPECIES.length()) {
368 IntVector av = IntVector.fromArray(SPECIES, a, i);
369 IntVector bv = IntVector.fromArray(SPECIES, b, i);
370 av.shiftL(bv).intoArray(r, i);
371 }
372 }
373
374 bh.consume(r);
375 }
376
377
378
379 @Benchmark
380 public void shiftLMasked(Blackhole bh) {
381 int[] a = fa.apply(SPECIES.length());
382 int[] b = fb.apply(SPECIES.length());
383 int[] r = fr.apply(SPECIES.length());
384 boolean[] mask = fm.apply(SPECIES.length());
385 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
386
387 for (int ic = 0; ic < INVOC_COUNT; ic++) {
388 for (int i = 0; i < a.length; i += SPECIES.length()) {
389 IntVector av = IntVector.fromArray(SPECIES, a, i);
390 IntVector bv = IntVector.fromArray(SPECIES, b, i);
391 av.shiftL(bv, vmask).intoArray(r, i);
392 }
393 }
394
395 bh.consume(r);
396 }
397
398
399
400 @Benchmark
401 public void aShiftR(Blackhole bh) {
402 int[] a = fa.apply(SPECIES.length());
403 int[] b = fb.apply(SPECIES.length());
404 int[] r = fr.apply(SPECIES.length());
405
406 for (int ic = 0; ic < INVOC_COUNT; ic++) {
407 for (int i = 0; i < a.length; i += SPECIES.length()) {
408 IntVector av = IntVector.fromArray(SPECIES, a, i);
409 IntVector bv = IntVector.fromArray(SPECIES, b, i);
410 av.aShiftR(bv).intoArray(r, i);
411 }
412 }
413
414 bh.consume(r);
415 }
416
417
418
419 @Benchmark
420 public void aShiftRMasked(Blackhole bh) {
421 int[] a = fa.apply(SPECIES.length());
422 int[] b = fb.apply(SPECIES.length());
423 int[] r = fr.apply(SPECIES.length());
424 boolean[] mask = fm.apply(SPECIES.length());
425 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
426
427 for (int ic = 0; ic < INVOC_COUNT; ic++) {
428 for (int i = 0; i < a.length; i += SPECIES.length()) {
429 IntVector av = IntVector.fromArray(SPECIES, a, i);
430 IntVector bv = IntVector.fromArray(SPECIES, b, i);
431 av.aShiftR(bv, vmask).intoArray(r, i);
432 }
433 }
434
435 bh.consume(r);
436 }
437
438
439
440 @Benchmark
441 public void aShiftRShift(Blackhole bh) {
442 int[] a = fa.apply(SPECIES.length());
443 int[] b = fb.apply(SPECIES.length());
444 int[] r = fr.apply(SPECIES.length());
445
446 for (int ic = 0; ic < INVOC_COUNT; ic++) {
447 for (int i = 0; i < a.length; i += SPECIES.length()) {
448 IntVector av = IntVector.fromArray(SPECIES, a, i);
449 av.aShiftR((int)b[i]).intoArray(r, i);
450 }
451 }
452
453 bh.consume(r);
454 }
455
456
457
458 @Benchmark
459 public void aShiftRMaskedShift(Blackhole bh) {
460 int[] a = fa.apply(SPECIES.length());
461 int[] b = fb.apply(SPECIES.length());
462 int[] r = fr.apply(SPECIES.length());
463 boolean[] mask = fm.apply(SPECIES.length());
464 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
465
466 for (int ic = 0; ic < INVOC_COUNT; ic++) {
467 for (int i = 0; i < a.length; i += SPECIES.length()) {
468 IntVector av = IntVector.fromArray(SPECIES, a, i);
469 av.aShiftR((int)b[i], vmask).intoArray(r, i);
470 }
471 }
472
473 bh.consume(r);
474 }
475
476
477
478 @Benchmark
479 public void shiftRShift(Blackhole bh) {
480 int[] a = fa.apply(SPECIES.length());
481 int[] b = fb.apply(SPECIES.length());
482 int[] r = fr.apply(SPECIES.length());
483
484 for (int ic = 0; ic < INVOC_COUNT; ic++) {
485 for (int i = 0; i < a.length; i += SPECIES.length()) {
486 IntVector av = IntVector.fromArray(SPECIES, a, i);
487 av.shiftR((int)b[i]).intoArray(r, i);
488 }
489 }
490
491 bh.consume(r);
492 }
493
494
495
496 @Benchmark
497 public void shiftRMaskedShift(Blackhole bh) {
498 int[] a = fa.apply(SPECIES.length());
499 int[] b = fb.apply(SPECIES.length());
500 int[] r = fr.apply(SPECIES.length());
501 boolean[] mask = fm.apply(SPECIES.length());
502 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
503
504 for (int ic = 0; ic < INVOC_COUNT; ic++) {
505 for (int i = 0; i < a.length; i += SPECIES.length()) {
506 IntVector av = IntVector.fromArray(SPECIES, a, i);
507 av.shiftR((int)b[i], vmask).intoArray(r, i);
508 }
509 }
510
511 bh.consume(r);
512 }
513
514
515
516 @Benchmark
517 public void shiftLShift(Blackhole bh) {
518 int[] a = fa.apply(SPECIES.length());
519 int[] b = fb.apply(SPECIES.length());
520 int[] r = fr.apply(SPECIES.length());
521
522 for (int ic = 0; ic < INVOC_COUNT; ic++) {
523 for (int i = 0; i < a.length; i += SPECIES.length()) {
524 IntVector av = IntVector.fromArray(SPECIES, a, i);
525 av.shiftL((int)b[i]).intoArray(r, i);
526 }
527 }
528
529 bh.consume(r);
530 }
531
532
533
534 @Benchmark
535 public void shiftLMaskedShift(Blackhole bh) {
536 int[] a = fa.apply(SPECIES.length());
537 int[] b = fb.apply(SPECIES.length());
538 int[] r = fr.apply(SPECIES.length());
539 boolean[] mask = fm.apply(SPECIES.length());
540 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
541
542 for (int ic = 0; ic < INVOC_COUNT; ic++) {
543 for (int i = 0; i < a.length; i += SPECIES.length()) {
544 IntVector av = IntVector.fromArray(SPECIES, a, i);
545 av.shiftL((int)b[i], vmask).intoArray(r, i);
546 }
547 }
548
549 bh.consume(r);
550 }
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565 @Benchmark
566 public void max(Blackhole bh) {
567 int[] a = fa.apply(SPECIES.length());
568 int[] b = fb.apply(SPECIES.length());
569 int[] r = fr.apply(SPECIES.length());
570
571 for (int ic = 0; ic < INVOC_COUNT; ic++) {
572 for (int i = 0; i < a.length; i += SPECIES.length()) {
573 IntVector av = IntVector.fromArray(SPECIES, a, i);
574 IntVector bv = IntVector.fromArray(SPECIES, b, i);
575 av.max(bv).intoArray(r, i);
576 }
577 }
578
579 bh.consume(r);
580 }
581
582 @Benchmark
583 public void min(Blackhole bh) {
584 int[] a = fa.apply(SPECIES.length());
585 int[] b = fb.apply(SPECIES.length());
586 int[] r = fr.apply(SPECIES.length());
587
588 for (int ic = 0; ic < INVOC_COUNT; ic++) {
589 for (int i = 0; i < a.length; i += SPECIES.length()) {
590 IntVector av = IntVector.fromArray(SPECIES, a, i);
591 IntVector bv = IntVector.fromArray(SPECIES, b, i);
592 av.min(bv).intoArray(r, i);
593 }
594 }
595
596 bh.consume(r);
597 }
598
599
600 @Benchmark
601 public void andAll(Blackhole bh) {
602 int[] a = fa.apply(SPECIES.length());
603 int ra = -1;
604
605 for (int ic = 0; ic < INVOC_COUNT; ic++) {
606 ra = -1;
607 for (int i = 0; i < a.length; i += SPECIES.length()) {
608 IntVector av = IntVector.fromArray(SPECIES, a, i);
609 ra &= av.andAll();
610 }
611 }
612 bh.consume(ra);
613 }
614
615
616
617 @Benchmark
618 public void orAll(Blackhole bh) {
619 int[] a = fa.apply(SPECIES.length());
620 int ra = 0;
621
622 for (int ic = 0; ic < INVOC_COUNT; ic++) {
623 ra = 0;
624 for (int i = 0; i < a.length; i += SPECIES.length()) {
625 IntVector av = IntVector.fromArray(SPECIES, a, i);
626 ra |= av.orAll();
627 }
628 }
629 bh.consume(ra);
630 }
631
632
633
634 @Benchmark
635 public void xorAll(Blackhole bh) {
636 int[] a = fa.apply(SPECIES.length());
637 int ra = 0;
638
639 for (int ic = 0; ic < INVOC_COUNT; ic++) {
640 ra = 0;
641 for (int i = 0; i < a.length; i += SPECIES.length()) {
642 IntVector av = IntVector.fromArray(SPECIES, a, i);
643 ra ^= av.xorAll();
644 }
645 }
646 bh.consume(ra);
647 }
648
649
650 @Benchmark
651 public void addAll(Blackhole bh) {
652 int[] a = fa.apply(SPECIES.length());
653 int ra = 0;
654
655 for (int ic = 0; ic < INVOC_COUNT; ic++) {
656 ra = 0;
657 for (int i = 0; i < a.length; i += SPECIES.length()) {
658 IntVector av = IntVector.fromArray(SPECIES, a, i);
659 ra += av.addAll();
660 }
661 }
662 bh.consume(ra);
663 }
664
665 @Benchmark
666 public void mulAll(Blackhole bh) {
667 int[] a = fa.apply(SPECIES.length());
668 int ra = 1;
669
670 for (int ic = 0; ic < INVOC_COUNT; ic++) {
671 ra = 1;
672 for (int i = 0; i < a.length; i += SPECIES.length()) {
673 IntVector av = IntVector.fromArray(SPECIES, a, i);
674 ra *= av.mulAll();
675 }
676 }
677 bh.consume(ra);
678 }
679
680 @Benchmark
681 public void minAll(Blackhole bh) {
682 int[] a = fa.apply(SPECIES.length());
683 int ra = Integer.MAX_VALUE;
684
685 for (int ic = 0; ic < INVOC_COUNT; ic++) {
686 ra = Integer.MAX_VALUE;
687 for (int i = 0; i < a.length; i += SPECIES.length()) {
688 IntVector av = IntVector.fromArray(SPECIES, a, i);
689 ra = (int)Math.min(ra, av.minAll());
690 }
691 }
692 bh.consume(ra);
693 }
694
695 @Benchmark
696 public void maxAll(Blackhole bh) {
697 int[] a = fa.apply(SPECIES.length());
698 int ra = Integer.MIN_VALUE;
699
700 for (int ic = 0; ic < INVOC_COUNT; ic++) {
701 ra = Integer.MIN_VALUE;
702 for (int i = 0; i < a.length; i += SPECIES.length()) {
703 IntVector av = IntVector.fromArray(SPECIES, a, i);
704 ra = (int)Math.max(ra, av.maxAll());
705 }
706 }
707 bh.consume(ra);
708 }
709
710
711 @Benchmark
712 public void anyTrue(Blackhole bh) {
713 boolean[] mask = fm.apply(SPECIES.length());
714 boolean[] r = fmr.apply(SPECIES.length());
715
716 for (int ic = 0; ic < INVOC_COUNT; ic++) {
717 for (int i = 0; i < mask.length; i += SPECIES.length()) {
718 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
719 r[i] = vmask.anyTrue();
720 }
721 }
722
723 bh.consume(r);
724 }
744 @Benchmark
745 public void with(Blackhole bh) {
746 int[] a = fa.apply(SPECIES.length());
747 int[] r = fr.apply(SPECIES.length());
748
749 for (int ic = 0; ic < INVOC_COUNT; ic++) {
750 for (int i = 0; i < a.length; i += SPECIES.length()) {
751 IntVector av = IntVector.fromArray(SPECIES, a, i);
752 av.with(0, (int)4).intoArray(r, i);
753 }
754 }
755
756 bh.consume(r);
757 }
758
759 @Benchmark
760 public Object lessThan() {
761 int[] a = fa.apply(size);
762 int[] b = fb.apply(size);
763 boolean[] ms = fm.apply(size);
764 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
765
766 for (int ic = 0; ic < INVOC_COUNT; ic++) {
767 for (int i = 0; i < a.length; i += SPECIES.length()) {
768 IntVector av = IntVector.fromArray(SPECIES, a, i);
769 IntVector bv = IntVector.fromArray(SPECIES, b, i);
770 VectorMask<Integer> mv = av.lessThan(bv);
771
772 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
773 }
774 }
775 return m;
776 }
777
778
779 @Benchmark
780 public Object greaterThan() {
781 int[] a = fa.apply(size);
782 int[] b = fb.apply(size);
783 boolean[] ms = fm.apply(size);
784 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
785
786 for (int ic = 0; ic < INVOC_COUNT; ic++) {
787 for (int i = 0; i < a.length; i += SPECIES.length()) {
788 IntVector av = IntVector.fromArray(SPECIES, a, i);
789 IntVector bv = IntVector.fromArray(SPECIES, b, i);
790 VectorMask<Integer> mv = av.greaterThan(bv);
791
792 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
793 }
794 }
795 return m;
796 }
797
798
799 @Benchmark
800 public Object equal() {
801 int[] a = fa.apply(size);
802 int[] b = fb.apply(size);
803 boolean[] ms = fm.apply(size);
804 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
805
806 for (int ic = 0; ic < INVOC_COUNT; ic++) {
807 for (int i = 0; i < a.length; i += SPECIES.length()) {
808 IntVector av = IntVector.fromArray(SPECIES, a, i);
809 IntVector bv = IntVector.fromArray(SPECIES, b, i);
810 VectorMask<Integer> mv = av.equal(bv);
811
812 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
813 }
814 }
815 return m;
816 }
817
818
819 @Benchmark
820 public Object notEqual() {
821 int[] a = fa.apply(size);
822 int[] b = fb.apply(size);
823 boolean[] ms = fm.apply(size);
824 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
825
826 for (int ic = 0; ic < INVOC_COUNT; ic++) {
827 for (int i = 0; i < a.length; i += SPECIES.length()) {
828 IntVector av = IntVector.fromArray(SPECIES, a, i);
829 IntVector bv = IntVector.fromArray(SPECIES, b, i);
830 VectorMask<Integer> mv = av.notEqual(bv);
831
832 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
833 }
834 }
835 return m;
836 }
837
838
839 @Benchmark
840 public Object lessThanEq() {
841 int[] a = fa.apply(size);
842 int[] b = fb.apply(size);
843 boolean[] ms = fm.apply(size);
844 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
845
846 for (int ic = 0; ic < INVOC_COUNT; ic++) {
847 for (int i = 0; i < a.length; i += SPECIES.length()) {
848 IntVector av = IntVector.fromArray(SPECIES, a, i);
849 IntVector bv = IntVector.fromArray(SPECIES, b, i);
850 VectorMask<Integer> mv = av.lessThanEq(bv);
851
852 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
853 }
854 }
855 return m;
856 }
857
858
859 @Benchmark
860 public Object greaterThanEq() {
861 int[] a = fa.apply(size);
862 int[] b = fb.apply(size);
863 boolean[] ms = fm.apply(size);
864 VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
865
866 for (int ic = 0; ic < INVOC_COUNT; ic++) {
867 for (int i = 0; i < a.length; i += SPECIES.length()) {
868 IntVector av = IntVector.fromArray(SPECIES, a, i);
869 IntVector bv = IntVector.fromArray(SPECIES, b, i);
870 VectorMask<Integer> mv = av.greaterThanEq(bv);
871
872 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
873 }
874 }
875 return m;
876 }
877
878
879 @Benchmark
880 public void blend(Blackhole bh) {
881 int[] a = fa.apply(SPECIES.length());
882 int[] b = fb.apply(SPECIES.length());
883 int[] r = fr.apply(SPECIES.length());
884 boolean[] mask = fm.apply(SPECIES.length());
|
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.VectorMask;
28 import jdk.incubator.vector.VectorShape;
29 import jdk.incubator.vector.VectorSpecies;
30 import jdk.incubator.vector.VectorShuffle;
31 import jdk.incubator.vector.IntVector;
32
33 import java.util.concurrent.TimeUnit;
34 import java.util.function.BiFunction;
35 import java.util.function.IntFunction;
36
37 import org.openjdk.jmh.annotations.*;
38 import org.openjdk.jmh.infra.Blackhole;
39
40 @BenchmarkMode(Mode.Throughput)
41 @OutputTimeUnit(TimeUnit.MILLISECONDS)
42 @State(Scope.Benchmark)
43 @Warmup(iterations = 3, time = 1)
44 @Measurement(iterations = 5, time = 1)
45 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
46 public class Int128Vector extends AbstractVectorBenchmark {
47 static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_128;
302 int[] a = fa.apply(SPECIES.length());
303 int[] b = fb.apply(SPECIES.length());
304 int[] r = fr.apply(SPECIES.length());
305 boolean[] mask = fm.apply(SPECIES.length());
306 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
307
308 for (int ic = 0; ic < INVOC_COUNT; ic++) {
309 for (int i = 0; i < a.length; i += SPECIES.length()) {
310 IntVector av = IntVector.fromArray(SPECIES, a, i);
311 IntVector bv = IntVector.fromArray(SPECIES, b, i);
312 av.xor(bv, vmask).intoArray(r, i);
313 }
314 }
315
316 bh.consume(r);
317 }
318
319
320
321 @Benchmark
322 public void shiftLeft(Blackhole bh) {
323 int[] a = fa.apply(SPECIES.length());
324 int[] b = fb.apply(SPECIES.length());
325 int[] r = fr.apply(SPECIES.length());
326
327 for (int ic = 0; ic < INVOC_COUNT; ic++) {
328 for (int i = 0; i < a.length; i += SPECIES.length()) {
329 IntVector av = IntVector.fromArray(SPECIES, a, i);
330 IntVector bv = IntVector.fromArray(SPECIES, b, i);
331 av.shiftLeft(bv).intoArray(r, i);
332 }
333 }
334
335 bh.consume(r);
336 }
337
338
339
340 @Benchmark
341 public void shiftLeftMasked(Blackhole bh) {
342 int[] a = fa.apply(SPECIES.length());
343 int[] b = fb.apply(SPECIES.length());
344 int[] r = fr.apply(SPECIES.length());
345 boolean[] mask = fm.apply(SPECIES.length());
346 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
347
348 for (int ic = 0; ic < INVOC_COUNT; ic++) {
349 for (int i = 0; i < a.length; i += SPECIES.length()) {
350 IntVector av = IntVector.fromArray(SPECIES, a, i);
351 IntVector bv = IntVector.fromArray(SPECIES, b, i);
352 av.shiftLeft(bv, vmask).intoArray(r, i);
353 }
354 }
355
356 bh.consume(r);
357 }
358
359
360
361
362
363
364
365 @Benchmark
366 public void shiftRight(Blackhole bh) {
367 int[] a = fa.apply(SPECIES.length());
368 int[] b = fb.apply(SPECIES.length());
369 int[] r = fr.apply(SPECIES.length());
370
371 for (int ic = 0; ic < INVOC_COUNT; ic++) {
372 for (int i = 0; i < a.length; i += SPECIES.length()) {
373 IntVector av = IntVector.fromArray(SPECIES, a, i);
374 IntVector bv = IntVector.fromArray(SPECIES, b, i);
375 av.shiftRight(bv).intoArray(r, i);
376 }
377 }
378
379 bh.consume(r);
380 }
381
382
383
384 @Benchmark
385 public void shiftRightMasked(Blackhole bh) {
386 int[] a = fa.apply(SPECIES.length());
387 int[] b = fb.apply(SPECIES.length());
388 int[] r = fr.apply(SPECIES.length());
389 boolean[] mask = fm.apply(SPECIES.length());
390 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
391
392 for (int ic = 0; ic < INVOC_COUNT; ic++) {
393 for (int i = 0; i < a.length; i += SPECIES.length()) {
394 IntVector av = IntVector.fromArray(SPECIES, a, i);
395 IntVector bv = IntVector.fromArray(SPECIES, b, i);
396 av.shiftRight(bv, vmask).intoArray(r, i);
397 }
398 }
399
400 bh.consume(r);
401 }
402
403
404
405
406
407
408
409 @Benchmark
410 public void shiftArithmeticRight(Blackhole bh) {
411 int[] a = fa.apply(SPECIES.length());
412 int[] b = fb.apply(SPECIES.length());
413 int[] r = fr.apply(SPECIES.length());
414
415 for (int ic = 0; ic < INVOC_COUNT; ic++) {
416 for (int i = 0; i < a.length; i += SPECIES.length()) {
417 IntVector av = IntVector.fromArray(SPECIES, a, i);
418 IntVector bv = IntVector.fromArray(SPECIES, b, i);
419 av.shiftArithmeticRight(bv).intoArray(r, i);
420 }
421 }
422
423 bh.consume(r);
424 }
425
426
427
428 @Benchmark
429 public void shiftArithmeticRightMasked(Blackhole bh) {
430 int[] a = fa.apply(SPECIES.length());
431 int[] b = fb.apply(SPECIES.length());
432 int[] r = fr.apply(SPECIES.length());
433 boolean[] mask = fm.apply(SPECIES.length());
434 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
435
436 for (int ic = 0; ic < INVOC_COUNT; ic++) {
437 for (int i = 0; i < a.length; i += SPECIES.length()) {
438 IntVector av = IntVector.fromArray(SPECIES, a, i);
439 IntVector bv = IntVector.fromArray(SPECIES, b, i);
440 av.shiftArithmeticRight(bv, vmask).intoArray(r, i);
441 }
442 }
443
444 bh.consume(r);
445 }
446
447
448
449
450
451
452
453 @Benchmark
454 public void shiftLeftShift(Blackhole bh) {
455 int[] a = fa.apply(SPECIES.length());
456 int[] b = fb.apply(SPECIES.length());
457 int[] r = fr.apply(SPECIES.length());
458
459 for (int ic = 0; ic < INVOC_COUNT; ic++) {
460 for (int i = 0; i < a.length; i += SPECIES.length()) {
461 IntVector av = IntVector.fromArray(SPECIES, a, i);
462 av.shiftLeft((int)b[i]).intoArray(r, i);
463 }
464 }
465
466 bh.consume(r);
467 }
468
469
470
471 @Benchmark
472 public void shiftLeftMaskedShift(Blackhole bh) {
473 int[] a = fa.apply(SPECIES.length());
474 int[] b = fb.apply(SPECIES.length());
475 int[] r = fr.apply(SPECIES.length());
476 boolean[] mask = fm.apply(SPECIES.length());
477 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
478
479 for (int ic = 0; ic < INVOC_COUNT; ic++) {
480 for (int i = 0; i < a.length; i += SPECIES.length()) {
481 IntVector av = IntVector.fromArray(SPECIES, a, i);
482 av.shiftLeft((int)b[i], vmask).intoArray(r, i);
483 }
484 }
485
486 bh.consume(r);
487 }
488
489
490
491
492
493
494
495 @Benchmark
496 public void shiftRightShift(Blackhole bh) {
497 int[] a = fa.apply(SPECIES.length());
498 int[] b = fb.apply(SPECIES.length());
499 int[] r = fr.apply(SPECIES.length());
500
501 for (int ic = 0; ic < INVOC_COUNT; ic++) {
502 for (int i = 0; i < a.length; i += SPECIES.length()) {
503 IntVector av = IntVector.fromArray(SPECIES, a, i);
504 av.shiftRight((int)b[i]).intoArray(r, i);
505 }
506 }
507
508 bh.consume(r);
509 }
510
511
512
513 @Benchmark
514 public void shiftRightMaskedShift(Blackhole bh) {
515 int[] a = fa.apply(SPECIES.length());
516 int[] b = fb.apply(SPECIES.length());
517 int[] r = fr.apply(SPECIES.length());
518 boolean[] mask = fm.apply(SPECIES.length());
519 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
520
521 for (int ic = 0; ic < INVOC_COUNT; ic++) {
522 for (int i = 0; i < a.length; i += SPECIES.length()) {
523 IntVector av = IntVector.fromArray(SPECIES, a, i);
524 av.shiftRight((int)b[i], vmask).intoArray(r, i);
525 }
526 }
527
528 bh.consume(r);
529 }
530
531
532
533
534
535
536
537 @Benchmark
538 public void shiftArithmeticRightShift(Blackhole bh) {
539 int[] a = fa.apply(SPECIES.length());
540 int[] b = fb.apply(SPECIES.length());
541 int[] r = fr.apply(SPECIES.length());
542
543 for (int ic = 0; ic < INVOC_COUNT; ic++) {
544 for (int i = 0; i < a.length; i += SPECIES.length()) {
545 IntVector av = IntVector.fromArray(SPECIES, a, i);
546 av.shiftArithmeticRight((int)b[i]).intoArray(r, i);
547 }
548 }
549
550 bh.consume(r);
551 }
552
553
554
555 @Benchmark
556 public void shiftArithmeticRightMaskedShift(Blackhole bh) {
557 int[] a = fa.apply(SPECIES.length());
558 int[] b = fb.apply(SPECIES.length());
559 int[] r = fr.apply(SPECIES.length());
560 boolean[] mask = fm.apply(SPECIES.length());
561 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
562
563 for (int ic = 0; ic < INVOC_COUNT; ic++) {
564 for (int i = 0; i < a.length; i += SPECIES.length()) {
565 IntVector av = IntVector.fromArray(SPECIES, a, i);
566 av.shiftArithmeticRight((int)b[i], vmask).intoArray(r, i);
567 }
568 }
569
570 bh.consume(r);
571 }
572
573
574
575
576
577
578 @Benchmark
579 public void max(Blackhole bh) {
580 int[] a = fa.apply(SPECIES.length());
581 int[] b = fb.apply(SPECIES.length());
582 int[] r = fr.apply(SPECIES.length());
583
584 for (int ic = 0; ic < INVOC_COUNT; ic++) {
585 for (int i = 0; i < a.length; i += SPECIES.length()) {
586 IntVector av = IntVector.fromArray(SPECIES, a, i);
587 IntVector bv = IntVector.fromArray(SPECIES, b, i);
588 av.max(bv).intoArray(r, i);
589 }
590 }
591
592 bh.consume(r);
593 }
594
595 @Benchmark
596 public void min(Blackhole bh) {
597 int[] a = fa.apply(SPECIES.length());
598 int[] b = fb.apply(SPECIES.length());
599 int[] r = fr.apply(SPECIES.length());
600
601 for (int ic = 0; ic < INVOC_COUNT; ic++) {
602 for (int i = 0; i < a.length; i += SPECIES.length()) {
603 IntVector av = IntVector.fromArray(SPECIES, a, i);
604 IntVector bv = IntVector.fromArray(SPECIES, b, i);
605 av.min(bv).intoArray(r, i);
606 }
607 }
608
609 bh.consume(r);
610 }
611
612
613 @Benchmark
614 public void andLanes(Blackhole bh) {
615 int[] a = fa.apply(SPECIES.length());
616 int ra = -1;
617
618 for (int ic = 0; ic < INVOC_COUNT; ic++) {
619 ra = -1;
620 for (int i = 0; i < a.length; i += SPECIES.length()) {
621 IntVector av = IntVector.fromArray(SPECIES, a, i);
622 ra &= av.andLanes();
623 }
624 }
625 bh.consume(ra);
626 }
627
628
629
630 @Benchmark
631 public void orLanes(Blackhole bh) {
632 int[] a = fa.apply(SPECIES.length());
633 int ra = 0;
634
635 for (int ic = 0; ic < INVOC_COUNT; ic++) {
636 ra = 0;
637 for (int i = 0; i < a.length; i += SPECIES.length()) {
638 IntVector av = IntVector.fromArray(SPECIES, a, i);
639 ra |= av.orLanes();
640 }
641 }
642 bh.consume(ra);
643 }
644
645
646
647 @Benchmark
648 public void xorLanes(Blackhole bh) {
649 int[] a = fa.apply(SPECIES.length());
650 int ra = 0;
651
652 for (int ic = 0; ic < INVOC_COUNT; ic++) {
653 ra = 0;
654 for (int i = 0; i < a.length; i += SPECIES.length()) {
655 IntVector av = IntVector.fromArray(SPECIES, a, i);
656 ra ^= av.xorLanes();
657 }
658 }
659 bh.consume(ra);
660 }
661
662
663 @Benchmark
664 public void addLanes(Blackhole bh) {
665 int[] a = fa.apply(SPECIES.length());
666 int ra = 0;
667
668 for (int ic = 0; ic < INVOC_COUNT; ic++) {
669 ra = 0;
670 for (int i = 0; i < a.length; i += SPECIES.length()) {
671 IntVector av = IntVector.fromArray(SPECIES, a, i);
672 ra += av.addLanes();
673 }
674 }
675 bh.consume(ra);
676 }
677
678 @Benchmark
679 public void mulLanes(Blackhole bh) {
680 int[] a = fa.apply(SPECIES.length());
681 int ra = 1;
682
683 for (int ic = 0; ic < INVOC_COUNT; ic++) {
684 ra = 1;
685 for (int i = 0; i < a.length; i += SPECIES.length()) {
686 IntVector av = IntVector.fromArray(SPECIES, a, i);
687 ra *= av.mulLanes();
688 }
689 }
690 bh.consume(ra);
691 }
692
693 @Benchmark
694 public void minLanes(Blackhole bh) {
695 int[] a = fa.apply(SPECIES.length());
696 int ra = Integer.MAX_VALUE;
697
698 for (int ic = 0; ic < INVOC_COUNT; ic++) {
699 ra = Integer.MAX_VALUE;
700 for (int i = 0; i < a.length; i += SPECIES.length()) {
701 IntVector av = IntVector.fromArray(SPECIES, a, i);
702 ra = (int)Math.min(ra, av.minLanes());
703 }
704 }
705 bh.consume(ra);
706 }
707
708 @Benchmark
709 public void maxLanes(Blackhole bh) {
710 int[] a = fa.apply(SPECIES.length());
711 int ra = Integer.MIN_VALUE;
712
713 for (int ic = 0; ic < INVOC_COUNT; ic++) {
714 ra = Integer.MIN_VALUE;
715 for (int i = 0; i < a.length; i += SPECIES.length()) {
716 IntVector av = IntVector.fromArray(SPECIES, a, i);
717 ra = (int)Math.max(ra, av.maxLanes());
718 }
719 }
720 bh.consume(ra);
721 }
722
723
724 @Benchmark
725 public void anyTrue(Blackhole bh) {
726 boolean[] mask = fm.apply(SPECIES.length());
727 boolean[] r = fmr.apply(SPECIES.length());
728
729 for (int ic = 0; ic < INVOC_COUNT; ic++) {
730 for (int i = 0; i < mask.length; i += SPECIES.length()) {
731 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
732 r[i] = vmask.anyTrue();
733 }
734 }
735
736 bh.consume(r);
737 }
757 @Benchmark
758 public void with(Blackhole bh) {
759 int[] a = fa.apply(SPECIES.length());
760 int[] r = fr.apply(SPECIES.length());
761
762 for (int ic = 0; ic < INVOC_COUNT; ic++) {
763 for (int i = 0; i < a.length; i += SPECIES.length()) {
764 IntVector av = IntVector.fromArray(SPECIES, a, i);
765 av.with(0, (int)4).intoArray(r, i);
766 }
767 }
768
769 bh.consume(r);
770 }
771
772 @Benchmark
773 public Object lessThan() {
774 int[] a = fa.apply(size);
775 int[] b = fb.apply(size);
776 boolean[] ms = fm.apply(size);
777 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
778
779 for (int ic = 0; ic < INVOC_COUNT; ic++) {
780 for (int i = 0; i < a.length; i += SPECIES.length()) {
781 IntVector av = IntVector.fromArray(SPECIES, a, i);
782 IntVector bv = IntVector.fromArray(SPECIES, b, i);
783 VectorMask<Integer> mv = av.lessThan(bv);
784
785 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
786 }
787 }
788 return m;
789 }
790
791
792 @Benchmark
793 public Object greaterThan() {
794 int[] a = fa.apply(size);
795 int[] b = fb.apply(size);
796 boolean[] ms = fm.apply(size);
797 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
798
799 for (int ic = 0; ic < INVOC_COUNT; ic++) {
800 for (int i = 0; i < a.length; i += SPECIES.length()) {
801 IntVector av = IntVector.fromArray(SPECIES, a, i);
802 IntVector bv = IntVector.fromArray(SPECIES, b, i);
803 VectorMask<Integer> mv = av.greaterThan(bv);
804
805 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
806 }
807 }
808 return m;
809 }
810
811
812 @Benchmark
813 public Object equal() {
814 int[] a = fa.apply(size);
815 int[] b = fb.apply(size);
816 boolean[] ms = fm.apply(size);
817 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
818
819 for (int ic = 0; ic < INVOC_COUNT; ic++) {
820 for (int i = 0; i < a.length; i += SPECIES.length()) {
821 IntVector av = IntVector.fromArray(SPECIES, a, i);
822 IntVector bv = IntVector.fromArray(SPECIES, b, i);
823 VectorMask<Integer> mv = av.equal(bv);
824
825 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
826 }
827 }
828 return m;
829 }
830
831
832 @Benchmark
833 public Object notEqual() {
834 int[] a = fa.apply(size);
835 int[] b = fb.apply(size);
836 boolean[] ms = fm.apply(size);
837 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
838
839 for (int ic = 0; ic < INVOC_COUNT; ic++) {
840 for (int i = 0; i < a.length; i += SPECIES.length()) {
841 IntVector av = IntVector.fromArray(SPECIES, a, i);
842 IntVector bv = IntVector.fromArray(SPECIES, b, i);
843 VectorMask<Integer> mv = av.notEqual(bv);
844
845 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
846 }
847 }
848 return m;
849 }
850
851
852 @Benchmark
853 public Object lessThanEq() {
854 int[] a = fa.apply(size);
855 int[] b = fb.apply(size);
856 boolean[] ms = fm.apply(size);
857 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
858
859 for (int ic = 0; ic < INVOC_COUNT; ic++) {
860 for (int i = 0; i < a.length; i += SPECIES.length()) {
861 IntVector av = IntVector.fromArray(SPECIES, a, i);
862 IntVector bv = IntVector.fromArray(SPECIES, b, i);
863 VectorMask<Integer> mv = av.lessThanEq(bv);
864
865 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
866 }
867 }
868 return m;
869 }
870
871
872 @Benchmark
873 public Object greaterThanEq() {
874 int[] a = fa.apply(size);
875 int[] b = fb.apply(size);
876 boolean[] ms = fm.apply(size);
877 VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
878
879 for (int ic = 0; ic < INVOC_COUNT; ic++) {
880 for (int i = 0; i < a.length; i += SPECIES.length()) {
881 IntVector av = IntVector.fromArray(SPECIES, a, i);
882 IntVector bv = IntVector.fromArray(SPECIES, b, i);
883 VectorMask<Integer> mv = av.greaterThanEq(bv);
884
885 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
886 }
887 }
888 return m;
889 }
890
891
892 @Benchmark
893 public void blend(Blackhole bh) {
894 int[] a = fa.apply(SPECIES.length());
895 int[] b = fb.apply(SPECIES.length());
896 int[] r = fr.apply(SPECIES.length());
897 boolean[] mask = fm.apply(SPECIES.length());
|