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.LongVector;
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 Long256Vector extends AbstractVectorBenchmark {
46 static final VectorSpecies<Long> SPECIES = LongVector.SPECIES_256;
301 long[] a = fa.apply(SPECIES.length());
302 long[] b = fb.apply(SPECIES.length());
303 long[] r = fr.apply(SPECIES.length());
304 boolean[] mask = fm.apply(SPECIES.length());
305 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
310 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
323 long[] b = fb.apply(SPECIES.length());
324 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
329 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
342 long[] b = fb.apply(SPECIES.length());
343 long[] r = fr.apply(SPECIES.length());
344 boolean[] mask = fm.apply(SPECIES.length());
345 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
350 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
363 long[] b = fb.apply(SPECIES.length());
364 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
369 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
382 long[] b = fb.apply(SPECIES.length());
383 long[] r = fr.apply(SPECIES.length());
384 boolean[] mask = fm.apply(SPECIES.length());
385 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
390 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
403 long[] b = fb.apply(SPECIES.length());
404 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
409 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
422 long[] b = fb.apply(SPECIES.length());
423 long[] r = fr.apply(SPECIES.length());
424 boolean[] mask = fm.apply(SPECIES.length());
425 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
430 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
443 long[] b = fb.apply(SPECIES.length());
444 long[] 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
461 long[] b = fb.apply(SPECIES.length());
462 long[] r = fr.apply(SPECIES.length());
463 boolean[] mask = fm.apply(SPECIES.length());
464 VectorMask<Long> 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
481 long[] b = fb.apply(SPECIES.length());
482 long[] 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
499 long[] b = fb.apply(SPECIES.length());
500 long[] r = fr.apply(SPECIES.length());
501 boolean[] mask = fm.apply(SPECIES.length());
502 VectorMask<Long> 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
519 long[] b = fb.apply(SPECIES.length());
520 long[] 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
537 long[] b = fb.apply(SPECIES.length());
538 long[] r = fr.apply(SPECIES.length());
539 boolean[] mask = fm.apply(SPECIES.length());
540 VectorMask<Long> 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
568 long[] b = fb.apply(SPECIES.length());
569 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
574 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
585 long[] b = fb.apply(SPECIES.length());
586 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
591 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
603 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
620 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
637 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
653 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
668 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
683 long ra = Long.MAX_VALUE;
684
685 for (int ic = 0; ic < INVOC_COUNT; ic++) {
686 ra = Long.MAX_VALUE;
687 for (int i = 0; i < a.length; i += SPECIES.length()) {
688 LongVector av = LongVector.fromArray(SPECIES, a, i);
689 ra = (long)Math.min(ra, av.minAll());
690 }
691 }
692 bh.consume(ra);
693 }
694
695 @Benchmark
696 public void maxAll(Blackhole bh) {
697 long[] a = fa.apply(SPECIES.length());
698 long ra = Long.MIN_VALUE;
699
700 for (int ic = 0; ic < INVOC_COUNT; ic++) {
701 ra = Long.MIN_VALUE;
702 for (int i = 0; i < a.length; i += SPECIES.length()) {
703 LongVector av = LongVector.fromArray(SPECIES, a, i);
704 ra = (long)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<Long> 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 long[] a = fa.apply(SPECIES.length());
747 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
752 av.with(0, (long)4).intoArray(r, i);
753 }
754 }
755
756 bh.consume(r);
757 }
758
759 @Benchmark
760 public Object lessThan() {
761 long[] a = fa.apply(size);
762 long[] b = fb.apply(size);
763 boolean[] ms = fm.apply(size);
764 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
769 LongVector bv = LongVector.fromArray(SPECIES, b, i);
770 VectorMask<Long> 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 long[] a = fa.apply(size);
782 long[] b = fb.apply(size);
783 boolean[] ms = fm.apply(size);
784 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
789 LongVector bv = LongVector.fromArray(SPECIES, b, i);
790 VectorMask<Long> 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 long[] a = fa.apply(size);
802 long[] b = fb.apply(size);
803 boolean[] ms = fm.apply(size);
804 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
809 LongVector bv = LongVector.fromArray(SPECIES, b, i);
810 VectorMask<Long> 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 long[] a = fa.apply(size);
822 long[] b = fb.apply(size);
823 boolean[] ms = fm.apply(size);
824 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
829 LongVector bv = LongVector.fromArray(SPECIES, b, i);
830 VectorMask<Long> 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 long[] a = fa.apply(size);
842 long[] b = fb.apply(size);
843 boolean[] ms = fm.apply(size);
844 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
849 LongVector bv = LongVector.fromArray(SPECIES, b, i);
850 VectorMask<Long> 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 long[] a = fa.apply(size);
862 long[] b = fb.apply(size);
863 boolean[] ms = fm.apply(size);
864 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
869 LongVector bv = LongVector.fromArray(SPECIES, b, i);
870 VectorMask<Long> 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 long[] a = fa.apply(SPECIES.length());
882 long[] b = fb.apply(SPECIES.length());
883 long[] 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.LongVector;
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 Long256Vector extends AbstractVectorBenchmark {
47 static final VectorSpecies<Long> SPECIES = LongVector.SPECIES_256;
302 long[] a = fa.apply(SPECIES.length());
303 long[] b = fb.apply(SPECIES.length());
304 long[] r = fr.apply(SPECIES.length());
305 boolean[] mask = fm.apply(SPECIES.length());
306 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
311 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
324 long[] b = fb.apply(SPECIES.length());
325 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
330 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
343 long[] b = fb.apply(SPECIES.length());
344 long[] r = fr.apply(SPECIES.length());
345 boolean[] mask = fm.apply(SPECIES.length());
346 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
351 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
368 long[] b = fb.apply(SPECIES.length());
369 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
374 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
387 long[] b = fb.apply(SPECIES.length());
388 long[] r = fr.apply(SPECIES.length());
389 boolean[] mask = fm.apply(SPECIES.length());
390 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
395 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
412 long[] b = fb.apply(SPECIES.length());
413 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
418 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
431 long[] b = fb.apply(SPECIES.length());
432 long[] r = fr.apply(SPECIES.length());
433 boolean[] mask = fm.apply(SPECIES.length());
434 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
439 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
456 long[] b = fb.apply(SPECIES.length());
457 long[] 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
474 long[] b = fb.apply(SPECIES.length());
475 long[] r = fr.apply(SPECIES.length());
476 boolean[] mask = fm.apply(SPECIES.length());
477 VectorMask<Long> 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
498 long[] b = fb.apply(SPECIES.length());
499 long[] 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
516 long[] b = fb.apply(SPECIES.length());
517 long[] r = fr.apply(SPECIES.length());
518 boolean[] mask = fm.apply(SPECIES.length());
519 VectorMask<Long> 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
540 long[] b = fb.apply(SPECIES.length());
541 long[] 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
558 long[] b = fb.apply(SPECIES.length());
559 long[] r = fr.apply(SPECIES.length());
560 boolean[] mask = fm.apply(SPECIES.length());
561 VectorMask<Long> 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
581 long[] b = fb.apply(SPECIES.length());
582 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
587 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
598 long[] b = fb.apply(SPECIES.length());
599 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
604 LongVector bv = LongVector.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 long[] a = fa.apply(SPECIES.length());
616 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
633 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
650 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
666 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
681 long 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 LongVector av = LongVector.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 long[] a = fa.apply(SPECIES.length());
696 long ra = Long.MAX_VALUE;
697
698 for (int ic = 0; ic < INVOC_COUNT; ic++) {
699 ra = Long.MAX_VALUE;
700 for (int i = 0; i < a.length; i += SPECIES.length()) {
701 LongVector av = LongVector.fromArray(SPECIES, a, i);
702 ra = (long)Math.min(ra, av.minLanes());
703 }
704 }
705 bh.consume(ra);
706 }
707
708 @Benchmark
709 public void maxLanes(Blackhole bh) {
710 long[] a = fa.apply(SPECIES.length());
711 long ra = Long.MIN_VALUE;
712
713 for (int ic = 0; ic < INVOC_COUNT; ic++) {
714 ra = Long.MIN_VALUE;
715 for (int i = 0; i < a.length; i += SPECIES.length()) {
716 LongVector av = LongVector.fromArray(SPECIES, a, i);
717 ra = (long)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<Long> 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 long[] a = fa.apply(SPECIES.length());
760 long[] 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
765 av.with(0, (long)4).intoArray(r, i);
766 }
767 }
768
769 bh.consume(r);
770 }
771
772 @Benchmark
773 public Object lessThan() {
774 long[] a = fa.apply(size);
775 long[] b = fb.apply(size);
776 boolean[] ms = fm.apply(size);
777 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
782 LongVector bv = LongVector.fromArray(SPECIES, b, i);
783 VectorMask<Long> 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 long[] a = fa.apply(size);
795 long[] b = fb.apply(size);
796 boolean[] ms = fm.apply(size);
797 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
802 LongVector bv = LongVector.fromArray(SPECIES, b, i);
803 VectorMask<Long> 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 long[] a = fa.apply(size);
815 long[] b = fb.apply(size);
816 boolean[] ms = fm.apply(size);
817 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
822 LongVector bv = LongVector.fromArray(SPECIES, b, i);
823 VectorMask<Long> 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 long[] a = fa.apply(size);
835 long[] b = fb.apply(size);
836 boolean[] ms = fm.apply(size);
837 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
842 LongVector bv = LongVector.fromArray(SPECIES, b, i);
843 VectorMask<Long> 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 long[] a = fa.apply(size);
855 long[] b = fb.apply(size);
856 boolean[] ms = fm.apply(size);
857 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
862 LongVector bv = LongVector.fromArray(SPECIES, b, i);
863 VectorMask<Long> 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 long[] a = fa.apply(size);
875 long[] b = fb.apply(size);
876 boolean[] ms = fm.apply(size);
877 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i);
882 LongVector bv = LongVector.fromArray(SPECIES, b, i);
883 VectorMask<Long> 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 long[] a = fa.apply(SPECIES.length());
895 long[] b = fb.apply(SPECIES.length());
896 long[] r = fr.apply(SPECIES.length());
897 boolean[] mask = fm.apply(SPECIES.length());
|