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 /*
25 * @test
26 * @modules jdk.incubator.vector
27 * @run testng/othervm -ea -esa IntMaxVectorTests
28 */
29
30 import jdk.incubator.vector.Vector.Shape;
31 import jdk.incubator.vector.Vector.Species;
32 import jdk.incubator.vector.Vector;
33
34 import jdk.incubator.vector.IntVector;
35
36 import org.testng.Assert;
37 import org.testng.annotations.DataProvider;
38 import org.testng.annotations.Test;
39
40 import java.lang.Integer;
41 import java.util.List;
42 import java.util.Arrays;
43 import java.util.function.BiFunction;
44 import java.util.function.IntFunction;
45 import java.util.stream.Collectors;
46 import java.util.stream.Stream;
47
48 @Test
49 public class IntMaxVectorTests extends AbstractVectorTest {
50
51 static final Species<Integer> SPECIES =
52 IntVector.SPECIES_MAX;
53
54 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
55
56 static Shape getMaxBit() {
57 return Shape.S_Max_BIT;
58 }
59
60 interface FUnOp {
61 int apply(int a);
62 }
63
64 static void assertArraysEquals(int[] a, int[] r, FUnOp f) {
65 int i = 0;
66 try {
67 for (; i < a.length; i++) {
68 Assert.assertEquals(r[i], f.apply(a[i]));
69 }
70 } catch (AssertionError e) {
71 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
72 }
73 }
74
75 static void assertArraysEquals(int[] a, int[] r, boolean[] mask, FUnOp f) {
76 int i = 0;
77 try {
440 int[] r = fr.apply(SPECIES.length());
441
442 for (int ic = 0; ic < INVOC_COUNT; ic++) {
443 for (int i = 0; i < a.length; i += SPECIES.length()) {
444 IntVector av = IntVector.fromArray(SPECIES, a, i);
445 IntVector bv = IntVector.fromArray(SPECIES, b, i);
446 av.add(bv).intoArray(r, i);
447 }
448 }
449
450 assertArraysEquals(a, b, r, IntMaxVectorTests::add);
451 }
452
453 @Test(dataProvider = "intBinaryOpMaskProvider")
454 static void addIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
455 IntFunction<boolean[]> fm) {
456 int[] a = fa.apply(SPECIES.length());
457 int[] b = fb.apply(SPECIES.length());
458 int[] r = fr.apply(SPECIES.length());
459 boolean[] mask = fm.apply(SPECIES.length());
460 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
461
462 for (int ic = 0; ic < INVOC_COUNT; ic++) {
463 for (int i = 0; i < a.length; i += SPECIES.length()) {
464 IntVector av = IntVector.fromArray(SPECIES, a, i);
465 IntVector bv = IntVector.fromArray(SPECIES, b, i);
466 av.add(bv, vmask).intoArray(r, i);
467 }
468 }
469
470 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::add);
471 }
472 static int sub(int a, int b) {
473 return (int)(a - b);
474 }
475
476 @Test(dataProvider = "intBinaryOpProvider")
477 static void subIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
478 int[] a = fa.apply(SPECIES.length());
479 int[] b = fb.apply(SPECIES.length());
480 int[] 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 IntVector av = IntVector.fromArray(SPECIES, a, i);
485 IntVector bv = IntVector.fromArray(SPECIES, b, i);
486 av.sub(bv).intoArray(r, i);
487 }
488 }
489
490 assertArraysEquals(a, b, r, IntMaxVectorTests::sub);
491 }
492
493 @Test(dataProvider = "intBinaryOpMaskProvider")
494 static void subIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
495 IntFunction<boolean[]> fm) {
496 int[] a = fa.apply(SPECIES.length());
497 int[] b = fb.apply(SPECIES.length());
498 int[] r = fr.apply(SPECIES.length());
499 boolean[] mask = fm.apply(SPECIES.length());
500 Vector.Mask<Integer> vmask = IntVector.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 IntVector av = IntVector.fromArray(SPECIES, a, i);
505 IntVector bv = IntVector.fromArray(SPECIES, b, i);
506 av.sub(bv, vmask).intoArray(r, i);
507 }
508 }
509
510 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::sub);
511 }
512
513
514 static int mul(int a, int b) {
515 return (int)(a * b);
516 }
517
518 @Test(dataProvider = "intBinaryOpProvider")
519 static void mulIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
520 int[] a = fa.apply(SPECIES.length());
522 int[] r = fr.apply(SPECIES.length());
523
524 for (int ic = 0; ic < INVOC_COUNT; ic++) {
525 for (int i = 0; i < a.length; i += SPECIES.length()) {
526 IntVector av = IntVector.fromArray(SPECIES, a, i);
527 IntVector bv = IntVector.fromArray(SPECIES, b, i);
528 av.mul(bv).intoArray(r, i);
529 }
530 }
531
532 assertArraysEquals(a, b, r, IntMaxVectorTests::mul);
533 }
534
535 @Test(dataProvider = "intBinaryOpMaskProvider")
536 static void mulIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
537 IntFunction<boolean[]> fm) {
538 int[] a = fa.apply(SPECIES.length());
539 int[] b = fb.apply(SPECIES.length());
540 int[] r = fr.apply(SPECIES.length());
541 boolean[] mask = fm.apply(SPECIES.length());
542 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
543
544 for (int ic = 0; ic < INVOC_COUNT; ic++) {
545 for (int i = 0; i < a.length; i += SPECIES.length()) {
546 IntVector av = IntVector.fromArray(SPECIES, a, i);
547 IntVector bv = IntVector.fromArray(SPECIES, b, i);
548 av.mul(bv, vmask).intoArray(r, i);
549 }
550 }
551
552 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::mul);
553 }
554
555 static int and(int a, int b) {
556 return (int)(a & b);
557 }
558
559 @Test(dataProvider = "intBinaryOpProvider")
560 static void andIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
561 int[] a = fa.apply(SPECIES.length());
562 int[] b = fb.apply(SPECIES.length());
565 for (int ic = 0; ic < INVOC_COUNT; ic++) {
566 for (int i = 0; i < a.length; i += SPECIES.length()) {
567 IntVector av = IntVector.fromArray(SPECIES, a, i);
568 IntVector bv = IntVector.fromArray(SPECIES, b, i);
569 av.and(bv).intoArray(r, i);
570 }
571 }
572
573 assertArraysEquals(a, b, r, IntMaxVectorTests::and);
574 }
575
576
577
578 @Test(dataProvider = "intBinaryOpMaskProvider")
579 static void andIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
580 IntFunction<boolean[]> fm) {
581 int[] a = fa.apply(SPECIES.length());
582 int[] b = fb.apply(SPECIES.length());
583 int[] r = fr.apply(SPECIES.length());
584 boolean[] mask = fm.apply(SPECIES.length());
585 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
586
587 for (int ic = 0; ic < INVOC_COUNT; ic++) {
588 for (int i = 0; i < a.length; i += SPECIES.length()) {
589 IntVector av = IntVector.fromArray(SPECIES, a, i);
590 IntVector bv = IntVector.fromArray(SPECIES, b, i);
591 av.and(bv, vmask).intoArray(r, i);
592 }
593 }
594
595 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::and);
596 }
597
598
599 static int or(int a, int b) {
600 return (int)(a | b);
601 }
602
603 @Test(dataProvider = "intBinaryOpProvider")
604 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
605 int[] a = fa.apply(SPECIES.length());
609 for (int ic = 0; ic < INVOC_COUNT; ic++) {
610 for (int i = 0; i < a.length; i += SPECIES.length()) {
611 IntVector av = IntVector.fromArray(SPECIES, a, i);
612 IntVector bv = IntVector.fromArray(SPECIES, b, i);
613 av.or(bv).intoArray(r, i);
614 }
615 }
616
617 assertArraysEquals(a, b, r, IntMaxVectorTests::or);
618 }
619
620
621
622 @Test(dataProvider = "intBinaryOpMaskProvider")
623 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
624 IntFunction<boolean[]> fm) {
625 int[] a = fa.apply(SPECIES.length());
626 int[] b = fb.apply(SPECIES.length());
627 int[] r = fr.apply(SPECIES.length());
628 boolean[] mask = fm.apply(SPECIES.length());
629 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
630
631 for (int ic = 0; ic < INVOC_COUNT; ic++) {
632 for (int i = 0; i < a.length; i += SPECIES.length()) {
633 IntVector av = IntVector.fromArray(SPECIES, a, i);
634 IntVector bv = IntVector.fromArray(SPECIES, b, i);
635 av.or(bv, vmask).intoArray(r, i);
636 }
637 }
638
639 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::or);
640 }
641
642
643 static int xor(int a, int b) {
644 return (int)(a ^ b);
645 }
646
647 @Test(dataProvider = "intBinaryOpProvider")
648 static void xorIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
649 int[] a = fa.apply(SPECIES.length());
653 for (int ic = 0; ic < INVOC_COUNT; ic++) {
654 for (int i = 0; i < a.length; i += SPECIES.length()) {
655 IntVector av = IntVector.fromArray(SPECIES, a, i);
656 IntVector bv = IntVector.fromArray(SPECIES, b, i);
657 av.xor(bv).intoArray(r, i);
658 }
659 }
660
661 assertArraysEquals(a, b, r, IntMaxVectorTests::xor);
662 }
663
664
665
666 @Test(dataProvider = "intBinaryOpMaskProvider")
667 static void xorIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
668 IntFunction<boolean[]> fm) {
669 int[] a = fa.apply(SPECIES.length());
670 int[] b = fb.apply(SPECIES.length());
671 int[] r = fr.apply(SPECIES.length());
672 boolean[] mask = fm.apply(SPECIES.length());
673 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
674
675 for (int ic = 0; ic < INVOC_COUNT; ic++) {
676 for (int i = 0; i < a.length; i += SPECIES.length()) {
677 IntVector av = IntVector.fromArray(SPECIES, a, i);
678 IntVector bv = IntVector.fromArray(SPECIES, b, i);
679 av.xor(bv, vmask).intoArray(r, i);
680 }
681 }
682
683 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::xor);
684 }
685
686
687 static int shiftR(int a, int b) {
688 return (int)((a >>> b));
689 }
690
691 @Test(dataProvider = "intBinaryOpProvider")
692 static void shiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
693 int[] a = fa.apply(SPECIES.length());
697 for (int ic = 0; ic < INVOC_COUNT; ic++) {
698 for (int i = 0; i < a.length; i += SPECIES.length()) {
699 IntVector av = IntVector.fromArray(SPECIES, a, i);
700 IntVector bv = IntVector.fromArray(SPECIES, b, i);
701 av.shiftR(bv).intoArray(r, i);
702 }
703 }
704
705 assertArraysEquals(a, b, r, IntMaxVectorTests::shiftR);
706 }
707
708
709
710 @Test(dataProvider = "intBinaryOpMaskProvider")
711 static void shiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
712 IntFunction<boolean[]> fm) {
713 int[] a = fa.apply(SPECIES.length());
714 int[] b = fb.apply(SPECIES.length());
715 int[] r = fr.apply(SPECIES.length());
716 boolean[] mask = fm.apply(SPECIES.length());
717 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
718
719 for (int ic = 0; ic < INVOC_COUNT; ic++) {
720 for (int i = 0; i < a.length; i += SPECIES.length()) {
721 IntVector av = IntVector.fromArray(SPECIES, a, i);
722 IntVector bv = IntVector.fromArray(SPECIES, b, i);
723 av.shiftR(bv, vmask).intoArray(r, i);
724 }
725 }
726
727 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftR);
728 }
729
730
731 static int shiftL(int a, int b) {
732 return (int)((a << b));
733 }
734
735 @Test(dataProvider = "intBinaryOpProvider")
736 static void shiftLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
737 int[] a = fa.apply(SPECIES.length());
741 for (int ic = 0; ic < INVOC_COUNT; ic++) {
742 for (int i = 0; i < a.length; i += SPECIES.length()) {
743 IntVector av = IntVector.fromArray(SPECIES, a, i);
744 IntVector bv = IntVector.fromArray(SPECIES, b, i);
745 av.shiftL(bv).intoArray(r, i);
746 }
747 }
748
749 assertArraysEquals(a, b, r, IntMaxVectorTests::shiftL);
750 }
751
752
753
754 @Test(dataProvider = "intBinaryOpMaskProvider")
755 static void shiftLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
756 IntFunction<boolean[]> fm) {
757 int[] a = fa.apply(SPECIES.length());
758 int[] b = fb.apply(SPECIES.length());
759 int[] r = fr.apply(SPECIES.length());
760 boolean[] mask = fm.apply(SPECIES.length());
761 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
762
763 for (int ic = 0; ic < INVOC_COUNT; ic++) {
764 for (int i = 0; i < a.length; i += SPECIES.length()) {
765 IntVector av = IntVector.fromArray(SPECIES, a, i);
766 IntVector bv = IntVector.fromArray(SPECIES, b, i);
767 av.shiftL(bv, vmask).intoArray(r, i);
768 }
769 }
770
771 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftL);
772 }
773
774
775 static int aShiftR(int a, int b) {
776 return (int)((a >> b));
777 }
778
779 @Test(dataProvider = "intBinaryOpProvider")
780 static void aShiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
781 int[] a = fa.apply(SPECIES.length());
785 for (int ic = 0; ic < INVOC_COUNT; ic++) {
786 for (int i = 0; i < a.length; i += SPECIES.length()) {
787 IntVector av = IntVector.fromArray(SPECIES, a, i);
788 IntVector bv = IntVector.fromArray(SPECIES, b, i);
789 av.aShiftR(bv).intoArray(r, i);
790 }
791 }
792
793 assertArraysEquals(a, b, r, IntMaxVectorTests::aShiftR);
794 }
795
796
797
798 @Test(dataProvider = "intBinaryOpMaskProvider")
799 static void aShiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
800 IntFunction<boolean[]> fm) {
801 int[] a = fa.apply(SPECIES.length());
802 int[] b = fb.apply(SPECIES.length());
803 int[] r = fr.apply(SPECIES.length());
804 boolean[] mask = fm.apply(SPECIES.length());
805 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
806
807 for (int ic = 0; ic < INVOC_COUNT; ic++) {
808 for (int i = 0; i < a.length; i += SPECIES.length()) {
809 IntVector av = IntVector.fromArray(SPECIES, a, i);
810 IntVector bv = IntVector.fromArray(SPECIES, b, i);
811 av.aShiftR(bv, vmask).intoArray(r, i);
812 }
813 }
814
815 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::aShiftR);
816 }
817
818
819 static int aShiftR_unary(int a, int b) {
820 return (int)((a >> b));
821 }
822
823 @Test(dataProvider = "intBinaryOpProvider")
824 static void aShiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
825 int[] a = fa.apply(SPECIES.length());
828
829 for (int ic = 0; ic < INVOC_COUNT; ic++) {
830 for (int i = 0; i < a.length; i += SPECIES.length()) {
831 IntVector av = IntVector.fromArray(SPECIES, a, i);
832 av.aShiftR((int)b[i]).intoArray(r, i);
833 }
834 }
835
836 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::aShiftR_unary);
837 }
838
839
840
841 @Test(dataProvider = "intBinaryOpMaskProvider")
842 static void aShiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
843 IntFunction<boolean[]> fm) {
844 int[] a = fa.apply(SPECIES.length());
845 int[] b = fb.apply(SPECIES.length());
846 int[] r = fr.apply(SPECIES.length());
847 boolean[] mask = fm.apply(SPECIES.length());
848 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
849
850 for (int ic = 0; ic < INVOC_COUNT; ic++) {
851 for (int i = 0; i < a.length; i += SPECIES.length()) {
852 IntVector av = IntVector.fromArray(SPECIES, a, i);
853 av.aShiftR((int)b[i], vmask).intoArray(r, i);
854 }
855 }
856
857 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::aShiftR_unary);
858 }
859
860
861 static int shiftR_unary(int a, int b) {
862 return (int)((a >>> b));
863 }
864
865 @Test(dataProvider = "intBinaryOpProvider")
866 static void shiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
867 int[] a = fa.apply(SPECIES.length());
868 int[] b = fb.apply(SPECIES.length());
870
871 for (int ic = 0; ic < INVOC_COUNT; ic++) {
872 for (int i = 0; i < a.length; i += SPECIES.length()) {
873 IntVector av = IntVector.fromArray(SPECIES, a, i);
874 av.shiftR((int)b[i]).intoArray(r, i);
875 }
876 }
877
878 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::shiftR_unary);
879 }
880
881
882
883 @Test(dataProvider = "intBinaryOpMaskProvider")
884 static void shiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
885 IntFunction<boolean[]> fm) {
886 int[] a = fa.apply(SPECIES.length());
887 int[] b = fb.apply(SPECIES.length());
888 int[] r = fr.apply(SPECIES.length());
889 boolean[] mask = fm.apply(SPECIES.length());
890 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
891
892 for (int ic = 0; ic < INVOC_COUNT; ic++) {
893 for (int i = 0; i < a.length; i += SPECIES.length()) {
894 IntVector av = IntVector.fromArray(SPECIES, a, i);
895 av.shiftR((int)b[i], vmask).intoArray(r, i);
896 }
897 }
898
899 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftR_unary);
900 }
901
902
903 static int shiftL_unary(int a, int b) {
904 return (int)((a << b));
905 }
906
907 @Test(dataProvider = "intBinaryOpProvider")
908 static void shiftLIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
909 int[] a = fa.apply(SPECIES.length());
910 int[] b = fb.apply(SPECIES.length());
912
913 for (int ic = 0; ic < INVOC_COUNT; ic++) {
914 for (int i = 0; i < a.length; i += SPECIES.length()) {
915 IntVector av = IntVector.fromArray(SPECIES, a, i);
916 av.shiftL((int)b[i]).intoArray(r, i);
917 }
918 }
919
920 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::shiftL_unary);
921 }
922
923
924
925 @Test(dataProvider = "intBinaryOpMaskProvider")
926 static void shiftLIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
927 IntFunction<boolean[]> fm) {
928 int[] a = fa.apply(SPECIES.length());
929 int[] b = fb.apply(SPECIES.length());
930 int[] r = fr.apply(SPECIES.length());
931 boolean[] mask = fm.apply(SPECIES.length());
932 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
933
934 for (int ic = 0; ic < INVOC_COUNT; ic++) {
935 for (int i = 0; i < a.length; i += SPECIES.length()) {
936 IntVector av = IntVector.fromArray(SPECIES, a, i);
937 av.shiftL((int)b[i], vmask).intoArray(r, i);
938 }
939 }
940
941 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftL_unary);
942 }
943
944
945
946
947
948
949
950
951
952
1306 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::maxAll, IntMaxVectorTests::maxAll);
1307 }
1308
1309 static boolean anyTrue(boolean[] a, int idx) {
1310 boolean res = false;
1311 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1312 res |= a[i];
1313 }
1314
1315 return res;
1316 }
1317
1318
1319 @Test(dataProvider = "boolUnaryOpProvider")
1320 static void anyTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
1321 boolean[] mask = fm.apply(SPECIES.length());
1322 boolean[] r = fmr.apply(SPECIES.length());
1323
1324 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1325 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1326 Vector.Mask<Integer> vmask = IntVector.maskFromArray(SPECIES, mask, i);
1327 r[i] = vmask.anyTrue();
1328 }
1329 }
1330
1331 assertReductionBoolArraysEquals(mask, r, IntMaxVectorTests::anyTrue);
1332 }
1333
1334
1335 static boolean allTrue(boolean[] a, int idx) {
1336 boolean res = true;
1337 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1338 res &= a[i];
1339 }
1340
1341 return res;
1342 }
1343
1344
1345 @Test(dataProvider = "boolUnaryOpProvider")
1346 static void allTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
1347 boolean[] mask = fm.apply(SPECIES.length());
1348 boolean[] r = fmr.apply(SPECIES.length());
1349
1350 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1351 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1352 Vector.Mask<Integer> vmask = IntVector.maskFromArray(SPECIES, mask, i);
1353 r[i] = vmask.allTrue();
1354 }
1355 }
1356
1357 assertReductionBoolArraysEquals(mask, r, IntMaxVectorTests::allTrue);
1358 }
1359
1360
1361 @Test(dataProvider = "intUnaryOpProvider")
1362 static void withIntMaxVectorTests(IntFunction<int []> fa) {
1363 int[] a = fa.apply(SPECIES.length());
1364 int[] r = fr.apply(SPECIES.length());
1365
1366 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1367 for (int i = 0; i < a.length; i += SPECIES.length()) {
1368 IntVector av = IntVector.fromArray(SPECIES, a, i);
1369 av.with(0, (int)4).intoArray(r, i);
1370 }
1371 }
1372
1373 assertInsertArraysEquals(a, r, (int)4, 0);
1374 }
1375
1376 @Test(dataProvider = "intCompareOpProvider")
1377 static void lessThanIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1378 int[] a = fa.apply(SPECIES.length());
1379 int[] b = fb.apply(SPECIES.length());
1380
1381 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1382 for (int i = 0; i < a.length; i += SPECIES.length()) {
1383 IntVector av = IntVector.fromArray(SPECIES, a, i);
1384 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1385 Vector.Mask<Integer> mv = av.lessThan(bv);
1386
1387 // Check results as part of computation.
1388 for (int j = 0; j < SPECIES.length(); j++) {
1389 Assert.assertEquals(mv.getElement(j), a[i + j] < b[i + j]);
1390 }
1391 }
1392 }
1393 }
1394
1395
1396 @Test(dataProvider = "intCompareOpProvider")
1397 static void greaterThanIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1398 int[] a = fa.apply(SPECIES.length());
1399 int[] b = fb.apply(SPECIES.length());
1400
1401 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1402 for (int i = 0; i < a.length; i += SPECIES.length()) {
1403 IntVector av = IntVector.fromArray(SPECIES, a, i);
1404 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1405 Vector.Mask<Integer> mv = av.greaterThan(bv);
1406
1407 // Check results as part of computation.
1408 for (int j = 0; j < SPECIES.length(); j++) {
1409 Assert.assertEquals(mv.getElement(j), a[i + j] > b[i + j]);
1410 }
1411 }
1412 }
1413 }
1414
1415
1416 @Test(dataProvider = "intCompareOpProvider")
1417 static void equalIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1418 int[] a = fa.apply(SPECIES.length());
1419 int[] b = fb.apply(SPECIES.length());
1420
1421 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1422 for (int i = 0; i < a.length; i += SPECIES.length()) {
1423 IntVector av = IntVector.fromArray(SPECIES, a, i);
1424 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1425 Vector.Mask<Integer> mv = av.equal(bv);
1426
1427 // Check results as part of computation.
1428 for (int j = 0; j < SPECIES.length(); j++) {
1429 Assert.assertEquals(mv.getElement(j), a[i + j] == b[i + j]);
1430 }
1431 }
1432 }
1433 }
1434
1435
1436 @Test(dataProvider = "intCompareOpProvider")
1437 static void notEqualIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1438 int[] a = fa.apply(SPECIES.length());
1439 int[] b = fb.apply(SPECIES.length());
1440
1441 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1442 for (int i = 0; i < a.length; i += SPECIES.length()) {
1443 IntVector av = IntVector.fromArray(SPECIES, a, i);
1444 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1445 Vector.Mask<Integer> mv = av.notEqual(bv);
1446
1447 // Check results as part of computation.
1448 for (int j = 0; j < SPECIES.length(); j++) {
1449 Assert.assertEquals(mv.getElement(j), a[i + j] != b[i + j]);
1450 }
1451 }
1452 }
1453 }
1454
1455
1456 @Test(dataProvider = "intCompareOpProvider")
1457 static void lessThanEqIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1458 int[] a = fa.apply(SPECIES.length());
1459 int[] b = fb.apply(SPECIES.length());
1460
1461 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1462 for (int i = 0; i < a.length; i += SPECIES.length()) {
1463 IntVector av = IntVector.fromArray(SPECIES, a, i);
1464 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1465 Vector.Mask<Integer> mv = av.lessThanEq(bv);
1466
1467 // Check results as part of computation.
1468 for (int j = 0; j < SPECIES.length(); j++) {
1469 Assert.assertEquals(mv.getElement(j), a[i + j] <= b[i + j]);
1470 }
1471 }
1472 }
1473 }
1474
1475
1476 @Test(dataProvider = "intCompareOpProvider")
1477 static void greaterThanEqIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1478 int[] a = fa.apply(SPECIES.length());
1479 int[] b = fb.apply(SPECIES.length());
1480
1481 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1482 for (int i = 0; i < a.length; i += SPECIES.length()) {
1483 IntVector av = IntVector.fromArray(SPECIES, a, i);
1484 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1485 Vector.Mask<Integer> mv = av.greaterThanEq(bv);
1486
1487 // Check results as part of computation.
1488 for (int j = 0; j < SPECIES.length(); j++) {
1489 Assert.assertEquals(mv.getElement(j), a[i + j] >= b[i + j]);
1490 }
1491 }
1492 }
1493 }
1494
1495
1496 static int blend(int a, int b, boolean mask) {
1497 return mask ? b : a;
1498 }
1499
1500 @Test(dataProvider = "intBinaryOpMaskProvider")
1501 static void blendIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
1502 IntFunction<boolean[]> fm) {
1503 int[] a = fa.apply(SPECIES.length());
1504 int[] b = fb.apply(SPECIES.length());
1505 int[] r = fr.apply(SPECIES.length());
1506 boolean[] mask = fm.apply(SPECIES.length());
1507 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1508
1509 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1510 for (int i = 0; i < a.length; i += SPECIES.length()) {
1511 IntVector av = IntVector.fromArray(SPECIES, a, i);
1512 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1513 av.blend(bv, vmask).intoArray(r, i);
1514 }
1515 }
1516
1517 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::blend);
1518 }
1519
1520 @Test(dataProvider = "intUnaryOpShuffleProvider")
1521 static void RearrangeIntMaxVectorTests(IntFunction<int[]> fa,
1522 BiFunction<Integer,Integer,int[]> fs) {
1523 int[] a = fa.apply(SPECIES.length());
1524 int[] order = fs.apply(a.length, SPECIES.length());
1525 int[] r = fr.apply(SPECIES.length());
1526
1527 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1528 for (int i = 0; i < a.length; i += SPECIES.length()) {
1529 IntVector av = IntVector.fromArray(SPECIES, a, i);
1530 av.rearrange(IntVector.shuffleFromArray(SPECIES, order, i)).intoArray(r, i);
1531 }
1532 }
1533
1534 assertRearrangeArraysEquals(a, r, order, SPECIES.length());
1535 }
1536
1537
1538
1539
1540 @Test(dataProvider = "intUnaryOpProvider")
1541 static void getIntMaxVectorTests(IntFunction<int[]> fa) {
1542 int[] a = fa.apply(SPECIES.length());
1543 int[] r = fr.apply(SPECIES.length());
1544
1545 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1546 for (int i = 0; i < a.length; i += SPECIES.length()) {
1547 IntVector av = IntVector.fromArray(SPECIES, a, i);
1548 int num_lanes = SPECIES.length();
1549 // Manually unroll because full unroll happens after intrinsification.
1550 // Unroll is needed because get intrinsic requires for index to be a known constant.
1722 static void negIntMaxVectorTests(IntFunction<int[]> fa) {
1723 int[] a = fa.apply(SPECIES.length());
1724 int[] r = fr.apply(SPECIES.length());
1725
1726 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1727 for (int i = 0; i < a.length; i += SPECIES.length()) {
1728 IntVector av = IntVector.fromArray(SPECIES, a, i);
1729 av.neg().intoArray(r, i);
1730 }
1731 }
1732
1733 assertArraysEquals(a, r, IntMaxVectorTests::neg);
1734 }
1735
1736 @Test(dataProvider = "intUnaryOpMaskProvider")
1737 static void negMaskedIntMaxVectorTests(IntFunction<int[]> fa,
1738 IntFunction<boolean[]> fm) {
1739 int[] a = fa.apply(SPECIES.length());
1740 int[] r = fr.apply(SPECIES.length());
1741 boolean[] mask = fm.apply(SPECIES.length());
1742 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1743
1744 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1745 for (int i = 0; i < a.length; i += SPECIES.length()) {
1746 IntVector av = IntVector.fromArray(SPECIES, a, i);
1747 av.neg(vmask).intoArray(r, i);
1748 }
1749 }
1750
1751 assertArraysEquals(a, r, mask, IntMaxVectorTests::neg);
1752 }
1753
1754 static int abs(int a) {
1755 return (int)(Math.abs((int)a));
1756 }
1757
1758 @Test(dataProvider = "intUnaryOpProvider")
1759 static void absIntMaxVectorTests(IntFunction<int[]> fa) {
1760 int[] a = fa.apply(SPECIES.length());
1761 int[] r = fr.apply(SPECIES.length());
1762
1763 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1764 for (int i = 0; i < a.length; i += SPECIES.length()) {
1765 IntVector av = IntVector.fromArray(SPECIES, a, i);
1766 av.abs().intoArray(r, i);
1767 }
1768 }
1769
1770 assertArraysEquals(a, r, IntMaxVectorTests::abs);
1771 }
1772
1773 @Test(dataProvider = "intUnaryOpMaskProvider")
1774 static void absMaskedIntMaxVectorTests(IntFunction<int[]> fa,
1775 IntFunction<boolean[]> fm) {
1776 int[] a = fa.apply(SPECIES.length());
1777 int[] r = fr.apply(SPECIES.length());
1778 boolean[] mask = fm.apply(SPECIES.length());
1779 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1780
1781 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1782 for (int i = 0; i < a.length; i += SPECIES.length()) {
1783 IntVector av = IntVector.fromArray(SPECIES, a, i);
1784 av.abs(vmask).intoArray(r, i);
1785 }
1786 }
1787
1788 assertArraysEquals(a, r, mask, IntMaxVectorTests::abs);
1789 }
1790
1791
1792 static int not(int a) {
1793 return (int)(~((int)a));
1794 }
1795
1796
1797
1798 @Test(dataProvider = "intUnaryOpProvider")
1799 static void notIntMaxVectorTests(IntFunction<int[]> fa) {
1801 int[] r = fr.apply(SPECIES.length());
1802
1803 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1804 for (int i = 0; i < a.length; i += SPECIES.length()) {
1805 IntVector av = IntVector.fromArray(SPECIES, a, i);
1806 av.not().intoArray(r, i);
1807 }
1808 }
1809
1810 assertArraysEquals(a, r, IntMaxVectorTests::not);
1811 }
1812
1813
1814
1815 @Test(dataProvider = "intUnaryOpMaskProvider")
1816 static void notMaskedIntMaxVectorTests(IntFunction<int[]> fa,
1817 IntFunction<boolean[]> fm) {
1818 int[] a = fa.apply(SPECIES.length());
1819 int[] r = fr.apply(SPECIES.length());
1820 boolean[] mask = fm.apply(SPECIES.length());
1821 Vector.Mask<Integer> vmask = IntVector.maskFromValues(SPECIES, mask);
1822
1823 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1824 for (int i = 0; i < a.length; i += SPECIES.length()) {
1825 IntVector av = IntVector.fromArray(SPECIES, a, i);
1826 av.not(vmask).intoArray(r, i);
1827 }
1828 }
1829
1830 assertArraysEquals(a, r, mask, IntMaxVectorTests::not);
1831 }
1832
1833
1834
1835
1836
1837 static int[] gather(int a[], int ix, int[] b, int iy) {
1838 int[] res = new int[SPECIES.length()];
1839 for (int i = 0; i < SPECIES.length(); i++) {
1840 int bi = iy + i;
1841 res[i] = a[b[bi] + ix];
|
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 /*
25 * @test
26 * @modules jdk.incubator.vector
27 * @run testng/othervm -ea -esa IntMaxVectorTests
28 */
29
30 import jdk.incubator.vector.VectorShape;
31 import jdk.incubator.vector.VectorSpecies;
32 import jdk.incubator.vector.VectorShuffle;
33 import jdk.incubator.vector.VectorMask;
34 import jdk.incubator.vector.Vector;
35
36 import jdk.incubator.vector.IntVector;
37
38 import org.testng.Assert;
39 import org.testng.annotations.DataProvider;
40 import org.testng.annotations.Test;
41
42 import java.lang.Integer;
43 import java.util.List;
44 import java.util.Arrays;
45 import java.util.function.BiFunction;
46 import java.util.function.IntFunction;
47 import java.util.stream.Collectors;
48 import java.util.stream.Stream;
49
50 @Test
51 public class IntMaxVectorTests extends AbstractVectorTest {
52
53 static final VectorSpecies<Integer> SPECIES =
54 IntVector.SPECIES_MAX;
55
56 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
57
58 static VectorShape getMaxBit() {
59 return VectorShape.S_Max_BIT;
60 }
61
62 interface FUnOp {
63 int apply(int a);
64 }
65
66 static void assertArraysEquals(int[] a, int[] r, FUnOp f) {
67 int i = 0;
68 try {
69 for (; i < a.length; i++) {
70 Assert.assertEquals(r[i], f.apply(a[i]));
71 }
72 } catch (AssertionError e) {
73 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
74 }
75 }
76
77 static void assertArraysEquals(int[] a, int[] r, boolean[] mask, FUnOp f) {
78 int i = 0;
79 try {
442 int[] 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 IntVector av = IntVector.fromArray(SPECIES, a, i);
447 IntVector bv = IntVector.fromArray(SPECIES, b, i);
448 av.add(bv).intoArray(r, i);
449 }
450 }
451
452 assertArraysEquals(a, b, r, IntMaxVectorTests::add);
453 }
454
455 @Test(dataProvider = "intBinaryOpMaskProvider")
456 static void addIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
457 IntFunction<boolean[]> fm) {
458 int[] a = fa.apply(SPECIES.length());
459 int[] b = fb.apply(SPECIES.length());
460 int[] r = fr.apply(SPECIES.length());
461 boolean[] mask = fm.apply(SPECIES.length());
462 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
463
464 for (int ic = 0; ic < INVOC_COUNT; ic++) {
465 for (int i = 0; i < a.length; i += SPECIES.length()) {
466 IntVector av = IntVector.fromArray(SPECIES, a, i);
467 IntVector bv = IntVector.fromArray(SPECIES, b, i);
468 av.add(bv, vmask).intoArray(r, i);
469 }
470 }
471
472 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::add);
473 }
474 static int sub(int a, int b) {
475 return (int)(a - b);
476 }
477
478 @Test(dataProvider = "intBinaryOpProvider")
479 static void subIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
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 IntVector bv = IntVector.fromArray(SPECIES, b, i);
488 av.sub(bv).intoArray(r, i);
489 }
490 }
491
492 assertArraysEquals(a, b, r, IntMaxVectorTests::sub);
493 }
494
495 @Test(dataProvider = "intBinaryOpMaskProvider")
496 static void subIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
497 IntFunction<boolean[]> fm) {
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 IntVector bv = IntVector.fromArray(SPECIES, b, i);
508 av.sub(bv, vmask).intoArray(r, i);
509 }
510 }
511
512 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::sub);
513 }
514
515
516 static int mul(int a, int b) {
517 return (int)(a * b);
518 }
519
520 @Test(dataProvider = "intBinaryOpProvider")
521 static void mulIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
522 int[] a = fa.apply(SPECIES.length());
524 int[] r = fr.apply(SPECIES.length());
525
526 for (int ic = 0; ic < INVOC_COUNT; ic++) {
527 for (int i = 0; i < a.length; i += SPECIES.length()) {
528 IntVector av = IntVector.fromArray(SPECIES, a, i);
529 IntVector bv = IntVector.fromArray(SPECIES, b, i);
530 av.mul(bv).intoArray(r, i);
531 }
532 }
533
534 assertArraysEquals(a, b, r, IntMaxVectorTests::mul);
535 }
536
537 @Test(dataProvider = "intBinaryOpMaskProvider")
538 static void mulIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
539 IntFunction<boolean[]> fm) {
540 int[] a = fa.apply(SPECIES.length());
541 int[] b = fb.apply(SPECIES.length());
542 int[] r = fr.apply(SPECIES.length());
543 boolean[] mask = fm.apply(SPECIES.length());
544 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
545
546 for (int ic = 0; ic < INVOC_COUNT; ic++) {
547 for (int i = 0; i < a.length; i += SPECIES.length()) {
548 IntVector av = IntVector.fromArray(SPECIES, a, i);
549 IntVector bv = IntVector.fromArray(SPECIES, b, i);
550 av.mul(bv, vmask).intoArray(r, i);
551 }
552 }
553
554 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::mul);
555 }
556
557 static int and(int a, int b) {
558 return (int)(a & b);
559 }
560
561 @Test(dataProvider = "intBinaryOpProvider")
562 static void andIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
563 int[] a = fa.apply(SPECIES.length());
564 int[] b = fb.apply(SPECIES.length());
567 for (int ic = 0; ic < INVOC_COUNT; ic++) {
568 for (int i = 0; i < a.length; i += SPECIES.length()) {
569 IntVector av = IntVector.fromArray(SPECIES, a, i);
570 IntVector bv = IntVector.fromArray(SPECIES, b, i);
571 av.and(bv).intoArray(r, i);
572 }
573 }
574
575 assertArraysEquals(a, b, r, IntMaxVectorTests::and);
576 }
577
578
579
580 @Test(dataProvider = "intBinaryOpMaskProvider")
581 static void andIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
582 IntFunction<boolean[]> fm) {
583 int[] a = fa.apply(SPECIES.length());
584 int[] b = fb.apply(SPECIES.length());
585 int[] r = fr.apply(SPECIES.length());
586 boolean[] mask = fm.apply(SPECIES.length());
587 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
588
589 for (int ic = 0; ic < INVOC_COUNT; ic++) {
590 for (int i = 0; i < a.length; i += SPECIES.length()) {
591 IntVector av = IntVector.fromArray(SPECIES, a, i);
592 IntVector bv = IntVector.fromArray(SPECIES, b, i);
593 av.and(bv, vmask).intoArray(r, i);
594 }
595 }
596
597 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::and);
598 }
599
600
601 static int or(int a, int b) {
602 return (int)(a | b);
603 }
604
605 @Test(dataProvider = "intBinaryOpProvider")
606 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
607 int[] a = fa.apply(SPECIES.length());
611 for (int ic = 0; ic < INVOC_COUNT; ic++) {
612 for (int i = 0; i < a.length; i += SPECIES.length()) {
613 IntVector av = IntVector.fromArray(SPECIES, a, i);
614 IntVector bv = IntVector.fromArray(SPECIES, b, i);
615 av.or(bv).intoArray(r, i);
616 }
617 }
618
619 assertArraysEquals(a, b, r, IntMaxVectorTests::or);
620 }
621
622
623
624 @Test(dataProvider = "intBinaryOpMaskProvider")
625 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
626 IntFunction<boolean[]> fm) {
627 int[] a = fa.apply(SPECIES.length());
628 int[] b = fb.apply(SPECIES.length());
629 int[] r = fr.apply(SPECIES.length());
630 boolean[] mask = fm.apply(SPECIES.length());
631 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
632
633 for (int ic = 0; ic < INVOC_COUNT; ic++) {
634 for (int i = 0; i < a.length; i += SPECIES.length()) {
635 IntVector av = IntVector.fromArray(SPECIES, a, i);
636 IntVector bv = IntVector.fromArray(SPECIES, b, i);
637 av.or(bv, vmask).intoArray(r, i);
638 }
639 }
640
641 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::or);
642 }
643
644
645 static int xor(int a, int b) {
646 return (int)(a ^ b);
647 }
648
649 @Test(dataProvider = "intBinaryOpProvider")
650 static void xorIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
651 int[] a = fa.apply(SPECIES.length());
655 for (int ic = 0; ic < INVOC_COUNT; ic++) {
656 for (int i = 0; i < a.length; i += SPECIES.length()) {
657 IntVector av = IntVector.fromArray(SPECIES, a, i);
658 IntVector bv = IntVector.fromArray(SPECIES, b, i);
659 av.xor(bv).intoArray(r, i);
660 }
661 }
662
663 assertArraysEquals(a, b, r, IntMaxVectorTests::xor);
664 }
665
666
667
668 @Test(dataProvider = "intBinaryOpMaskProvider")
669 static void xorIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
670 IntFunction<boolean[]> fm) {
671 int[] a = fa.apply(SPECIES.length());
672 int[] b = fb.apply(SPECIES.length());
673 int[] r = fr.apply(SPECIES.length());
674 boolean[] mask = fm.apply(SPECIES.length());
675 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
676
677 for (int ic = 0; ic < INVOC_COUNT; ic++) {
678 for (int i = 0; i < a.length; i += SPECIES.length()) {
679 IntVector av = IntVector.fromArray(SPECIES, a, i);
680 IntVector bv = IntVector.fromArray(SPECIES, b, i);
681 av.xor(bv, vmask).intoArray(r, i);
682 }
683 }
684
685 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::xor);
686 }
687
688
689 static int shiftR(int a, int b) {
690 return (int)((a >>> b));
691 }
692
693 @Test(dataProvider = "intBinaryOpProvider")
694 static void shiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
695 int[] a = fa.apply(SPECIES.length());
699 for (int ic = 0; ic < INVOC_COUNT; ic++) {
700 for (int i = 0; i < a.length; i += SPECIES.length()) {
701 IntVector av = IntVector.fromArray(SPECIES, a, i);
702 IntVector bv = IntVector.fromArray(SPECIES, b, i);
703 av.shiftR(bv).intoArray(r, i);
704 }
705 }
706
707 assertArraysEquals(a, b, r, IntMaxVectorTests::shiftR);
708 }
709
710
711
712 @Test(dataProvider = "intBinaryOpMaskProvider")
713 static void shiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
714 IntFunction<boolean[]> fm) {
715 int[] a = fa.apply(SPECIES.length());
716 int[] b = fb.apply(SPECIES.length());
717 int[] r = fr.apply(SPECIES.length());
718 boolean[] mask = fm.apply(SPECIES.length());
719 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
720
721 for (int ic = 0; ic < INVOC_COUNT; ic++) {
722 for (int i = 0; i < a.length; i += SPECIES.length()) {
723 IntVector av = IntVector.fromArray(SPECIES, a, i);
724 IntVector bv = IntVector.fromArray(SPECIES, b, i);
725 av.shiftR(bv, vmask).intoArray(r, i);
726 }
727 }
728
729 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftR);
730 }
731
732
733 static int shiftL(int a, int b) {
734 return (int)((a << b));
735 }
736
737 @Test(dataProvider = "intBinaryOpProvider")
738 static void shiftLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
739 int[] a = fa.apply(SPECIES.length());
743 for (int ic = 0; ic < INVOC_COUNT; ic++) {
744 for (int i = 0; i < a.length; i += SPECIES.length()) {
745 IntVector av = IntVector.fromArray(SPECIES, a, i);
746 IntVector bv = IntVector.fromArray(SPECIES, b, i);
747 av.shiftL(bv).intoArray(r, i);
748 }
749 }
750
751 assertArraysEquals(a, b, r, IntMaxVectorTests::shiftL);
752 }
753
754
755
756 @Test(dataProvider = "intBinaryOpMaskProvider")
757 static void shiftLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
758 IntFunction<boolean[]> fm) {
759 int[] a = fa.apply(SPECIES.length());
760 int[] b = fb.apply(SPECIES.length());
761 int[] r = fr.apply(SPECIES.length());
762 boolean[] mask = fm.apply(SPECIES.length());
763 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
764
765 for (int ic = 0; ic < INVOC_COUNT; ic++) {
766 for (int i = 0; i < a.length; i += SPECIES.length()) {
767 IntVector av = IntVector.fromArray(SPECIES, a, i);
768 IntVector bv = IntVector.fromArray(SPECIES, b, i);
769 av.shiftL(bv, vmask).intoArray(r, i);
770 }
771 }
772
773 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftL);
774 }
775
776
777 static int aShiftR(int a, int b) {
778 return (int)((a >> b));
779 }
780
781 @Test(dataProvider = "intBinaryOpProvider")
782 static void aShiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
783 int[] a = fa.apply(SPECIES.length());
787 for (int ic = 0; ic < INVOC_COUNT; ic++) {
788 for (int i = 0; i < a.length; i += SPECIES.length()) {
789 IntVector av = IntVector.fromArray(SPECIES, a, i);
790 IntVector bv = IntVector.fromArray(SPECIES, b, i);
791 av.aShiftR(bv).intoArray(r, i);
792 }
793 }
794
795 assertArraysEquals(a, b, r, IntMaxVectorTests::aShiftR);
796 }
797
798
799
800 @Test(dataProvider = "intBinaryOpMaskProvider")
801 static void aShiftRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
802 IntFunction<boolean[]> fm) {
803 int[] a = fa.apply(SPECIES.length());
804 int[] b = fb.apply(SPECIES.length());
805 int[] r = fr.apply(SPECIES.length());
806 boolean[] mask = fm.apply(SPECIES.length());
807 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
808
809 for (int ic = 0; ic < INVOC_COUNT; ic++) {
810 for (int i = 0; i < a.length; i += SPECIES.length()) {
811 IntVector av = IntVector.fromArray(SPECIES, a, i);
812 IntVector bv = IntVector.fromArray(SPECIES, b, i);
813 av.aShiftR(bv, vmask).intoArray(r, i);
814 }
815 }
816
817 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::aShiftR);
818 }
819
820
821 static int aShiftR_unary(int a, int b) {
822 return (int)((a >> b));
823 }
824
825 @Test(dataProvider = "intBinaryOpProvider")
826 static void aShiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
827 int[] a = fa.apply(SPECIES.length());
830
831 for (int ic = 0; ic < INVOC_COUNT; ic++) {
832 for (int i = 0; i < a.length; i += SPECIES.length()) {
833 IntVector av = IntVector.fromArray(SPECIES, a, i);
834 av.aShiftR((int)b[i]).intoArray(r, i);
835 }
836 }
837
838 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::aShiftR_unary);
839 }
840
841
842
843 @Test(dataProvider = "intBinaryOpMaskProvider")
844 static void aShiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
845 IntFunction<boolean[]> fm) {
846 int[] a = fa.apply(SPECIES.length());
847 int[] b = fb.apply(SPECIES.length());
848 int[] r = fr.apply(SPECIES.length());
849 boolean[] mask = fm.apply(SPECIES.length());
850 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
851
852 for (int ic = 0; ic < INVOC_COUNT; ic++) {
853 for (int i = 0; i < a.length; i += SPECIES.length()) {
854 IntVector av = IntVector.fromArray(SPECIES, a, i);
855 av.aShiftR((int)b[i], vmask).intoArray(r, i);
856 }
857 }
858
859 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::aShiftR_unary);
860 }
861
862
863 static int shiftR_unary(int a, int b) {
864 return (int)((a >>> b));
865 }
866
867 @Test(dataProvider = "intBinaryOpProvider")
868 static void shiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
869 int[] a = fa.apply(SPECIES.length());
870 int[] b = fb.apply(SPECIES.length());
872
873 for (int ic = 0; ic < INVOC_COUNT; ic++) {
874 for (int i = 0; i < a.length; i += SPECIES.length()) {
875 IntVector av = IntVector.fromArray(SPECIES, a, i);
876 av.shiftR((int)b[i]).intoArray(r, i);
877 }
878 }
879
880 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::shiftR_unary);
881 }
882
883
884
885 @Test(dataProvider = "intBinaryOpMaskProvider")
886 static void shiftRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
887 IntFunction<boolean[]> fm) {
888 int[] a = fa.apply(SPECIES.length());
889 int[] b = fb.apply(SPECIES.length());
890 int[] r = fr.apply(SPECIES.length());
891 boolean[] mask = fm.apply(SPECIES.length());
892 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
893
894 for (int ic = 0; ic < INVOC_COUNT; ic++) {
895 for (int i = 0; i < a.length; i += SPECIES.length()) {
896 IntVector av = IntVector.fromArray(SPECIES, a, i);
897 av.shiftR((int)b[i], vmask).intoArray(r, i);
898 }
899 }
900
901 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftR_unary);
902 }
903
904
905 static int shiftL_unary(int a, int b) {
906 return (int)((a << b));
907 }
908
909 @Test(dataProvider = "intBinaryOpProvider")
910 static void shiftLIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
911 int[] a = fa.apply(SPECIES.length());
912 int[] b = fb.apply(SPECIES.length());
914
915 for (int ic = 0; ic < INVOC_COUNT; ic++) {
916 for (int i = 0; i < a.length; i += SPECIES.length()) {
917 IntVector av = IntVector.fromArray(SPECIES, a, i);
918 av.shiftL((int)b[i]).intoArray(r, i);
919 }
920 }
921
922 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::shiftL_unary);
923 }
924
925
926
927 @Test(dataProvider = "intBinaryOpMaskProvider")
928 static void shiftLIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
929 IntFunction<boolean[]> fm) {
930 int[] a = fa.apply(SPECIES.length());
931 int[] b = fb.apply(SPECIES.length());
932 int[] r = fr.apply(SPECIES.length());
933 boolean[] mask = fm.apply(SPECIES.length());
934 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
935
936 for (int ic = 0; ic < INVOC_COUNT; ic++) {
937 for (int i = 0; i < a.length; i += SPECIES.length()) {
938 IntVector av = IntVector.fromArray(SPECIES, a, i);
939 av.shiftL((int)b[i], vmask).intoArray(r, i);
940 }
941 }
942
943 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::shiftL_unary);
944 }
945
946
947
948
949
950
951
952
953
954
1308 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::maxAll, IntMaxVectorTests::maxAll);
1309 }
1310
1311 static boolean anyTrue(boolean[] a, int idx) {
1312 boolean res = false;
1313 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1314 res |= a[i];
1315 }
1316
1317 return res;
1318 }
1319
1320
1321 @Test(dataProvider = "boolUnaryOpProvider")
1322 static void anyTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
1323 boolean[] mask = fm.apply(SPECIES.length());
1324 boolean[] r = fmr.apply(SPECIES.length());
1325
1326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1327 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1328 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
1329 r[i] = vmask.anyTrue();
1330 }
1331 }
1332
1333 assertReductionBoolArraysEquals(mask, r, IntMaxVectorTests::anyTrue);
1334 }
1335
1336
1337 static boolean allTrue(boolean[] a, int idx) {
1338 boolean res = true;
1339 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1340 res &= a[i];
1341 }
1342
1343 return res;
1344 }
1345
1346
1347 @Test(dataProvider = "boolUnaryOpProvider")
1348 static void allTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
1349 boolean[] mask = fm.apply(SPECIES.length());
1350 boolean[] r = fmr.apply(SPECIES.length());
1351
1352 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1353 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1354 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
1355 r[i] = vmask.allTrue();
1356 }
1357 }
1358
1359 assertReductionBoolArraysEquals(mask, r, IntMaxVectorTests::allTrue);
1360 }
1361
1362
1363 @Test(dataProvider = "intUnaryOpProvider")
1364 static void withIntMaxVectorTests(IntFunction<int []> fa) {
1365 int[] a = fa.apply(SPECIES.length());
1366 int[] r = fr.apply(SPECIES.length());
1367
1368 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1369 for (int i = 0; i < a.length; i += SPECIES.length()) {
1370 IntVector av = IntVector.fromArray(SPECIES, a, i);
1371 av.with(0, (int)4).intoArray(r, i);
1372 }
1373 }
1374
1375 assertInsertArraysEquals(a, r, (int)4, 0);
1376 }
1377
1378 @Test(dataProvider = "intCompareOpProvider")
1379 static void lessThanIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1380 int[] a = fa.apply(SPECIES.length());
1381 int[] b = fb.apply(SPECIES.length());
1382
1383 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1384 for (int i = 0; i < a.length; i += SPECIES.length()) {
1385 IntVector av = IntVector.fromArray(SPECIES, a, i);
1386 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1387 VectorMask<Integer> mv = av.lessThan(bv);
1388
1389 // Check results as part of computation.
1390 for (int j = 0; j < SPECIES.length(); j++) {
1391 Assert.assertEquals(mv.getElement(j), a[i + j] < b[i + j]);
1392 }
1393 }
1394 }
1395 }
1396
1397
1398 @Test(dataProvider = "intCompareOpProvider")
1399 static void greaterThanIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1400 int[] a = fa.apply(SPECIES.length());
1401 int[] b = fb.apply(SPECIES.length());
1402
1403 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1404 for (int i = 0; i < a.length; i += SPECIES.length()) {
1405 IntVector av = IntVector.fromArray(SPECIES, a, i);
1406 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1407 VectorMask<Integer> mv = av.greaterThan(bv);
1408
1409 // Check results as part of computation.
1410 for (int j = 0; j < SPECIES.length(); j++) {
1411 Assert.assertEquals(mv.getElement(j), a[i + j] > b[i + j]);
1412 }
1413 }
1414 }
1415 }
1416
1417
1418 @Test(dataProvider = "intCompareOpProvider")
1419 static void equalIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1420 int[] a = fa.apply(SPECIES.length());
1421 int[] b = fb.apply(SPECIES.length());
1422
1423 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1424 for (int i = 0; i < a.length; i += SPECIES.length()) {
1425 IntVector av = IntVector.fromArray(SPECIES, a, i);
1426 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1427 VectorMask<Integer> mv = av.equal(bv);
1428
1429 // Check results as part of computation.
1430 for (int j = 0; j < SPECIES.length(); j++) {
1431 Assert.assertEquals(mv.getElement(j), a[i + j] == b[i + j]);
1432 }
1433 }
1434 }
1435 }
1436
1437
1438 @Test(dataProvider = "intCompareOpProvider")
1439 static void notEqualIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1440 int[] a = fa.apply(SPECIES.length());
1441 int[] b = fb.apply(SPECIES.length());
1442
1443 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1444 for (int i = 0; i < a.length; i += SPECIES.length()) {
1445 IntVector av = IntVector.fromArray(SPECIES, a, i);
1446 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1447 VectorMask<Integer> mv = av.notEqual(bv);
1448
1449 // Check results as part of computation.
1450 for (int j = 0; j < SPECIES.length(); j++) {
1451 Assert.assertEquals(mv.getElement(j), a[i + j] != b[i + j]);
1452 }
1453 }
1454 }
1455 }
1456
1457
1458 @Test(dataProvider = "intCompareOpProvider")
1459 static void lessThanEqIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1460 int[] a = fa.apply(SPECIES.length());
1461 int[] b = fb.apply(SPECIES.length());
1462
1463 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1464 for (int i = 0; i < a.length; i += SPECIES.length()) {
1465 IntVector av = IntVector.fromArray(SPECIES, a, i);
1466 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1467 VectorMask<Integer> mv = av.lessThanEq(bv);
1468
1469 // Check results as part of computation.
1470 for (int j = 0; j < SPECIES.length(); j++) {
1471 Assert.assertEquals(mv.getElement(j), a[i + j] <= b[i + j]);
1472 }
1473 }
1474 }
1475 }
1476
1477
1478 @Test(dataProvider = "intCompareOpProvider")
1479 static void greaterThanEqIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1480 int[] a = fa.apply(SPECIES.length());
1481 int[] b = fb.apply(SPECIES.length());
1482
1483 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1484 for (int i = 0; i < a.length; i += SPECIES.length()) {
1485 IntVector av = IntVector.fromArray(SPECIES, a, i);
1486 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1487 VectorMask<Integer> mv = av.greaterThanEq(bv);
1488
1489 // Check results as part of computation.
1490 for (int j = 0; j < SPECIES.length(); j++) {
1491 Assert.assertEquals(mv.getElement(j), a[i + j] >= b[i + j]);
1492 }
1493 }
1494 }
1495 }
1496
1497
1498 static int blend(int a, int b, boolean mask) {
1499 return mask ? b : a;
1500 }
1501
1502 @Test(dataProvider = "intBinaryOpMaskProvider")
1503 static void blendIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
1504 IntFunction<boolean[]> fm) {
1505 int[] a = fa.apply(SPECIES.length());
1506 int[] b = fb.apply(SPECIES.length());
1507 int[] r = fr.apply(SPECIES.length());
1508 boolean[] mask = fm.apply(SPECIES.length());
1509 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1510
1511 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1512 for (int i = 0; i < a.length; i += SPECIES.length()) {
1513 IntVector av = IntVector.fromArray(SPECIES, a, i);
1514 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1515 av.blend(bv, vmask).intoArray(r, i);
1516 }
1517 }
1518
1519 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::blend);
1520 }
1521
1522 @Test(dataProvider = "intUnaryOpShuffleProvider")
1523 static void RearrangeIntMaxVectorTests(IntFunction<int[]> fa,
1524 BiFunction<Integer,Integer,int[]> fs) {
1525 int[] a = fa.apply(SPECIES.length());
1526 int[] order = fs.apply(a.length, SPECIES.length());
1527 int[] r = fr.apply(SPECIES.length());
1528
1529 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1530 for (int i = 0; i < a.length; i += SPECIES.length()) {
1531 IntVector av = IntVector.fromArray(SPECIES, a, i);
1532 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
1533 }
1534 }
1535
1536 assertRearrangeArraysEquals(a, r, order, SPECIES.length());
1537 }
1538
1539
1540
1541
1542 @Test(dataProvider = "intUnaryOpProvider")
1543 static void getIntMaxVectorTests(IntFunction<int[]> fa) {
1544 int[] a = fa.apply(SPECIES.length());
1545 int[] r = fr.apply(SPECIES.length());
1546
1547 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1548 for (int i = 0; i < a.length; i += SPECIES.length()) {
1549 IntVector av = IntVector.fromArray(SPECIES, a, i);
1550 int num_lanes = SPECIES.length();
1551 // Manually unroll because full unroll happens after intrinsification.
1552 // Unroll is needed because get intrinsic requires for index to be a known constant.
1724 static void negIntMaxVectorTests(IntFunction<int[]> fa) {
1725 int[] a = fa.apply(SPECIES.length());
1726 int[] r = fr.apply(SPECIES.length());
1727
1728 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1729 for (int i = 0; i < a.length; i += SPECIES.length()) {
1730 IntVector av = IntVector.fromArray(SPECIES, a, i);
1731 av.neg().intoArray(r, i);
1732 }
1733 }
1734
1735 assertArraysEquals(a, r, IntMaxVectorTests::neg);
1736 }
1737
1738 @Test(dataProvider = "intUnaryOpMaskProvider")
1739 static void negMaskedIntMaxVectorTests(IntFunction<int[]> fa,
1740 IntFunction<boolean[]> fm) {
1741 int[] a = fa.apply(SPECIES.length());
1742 int[] r = fr.apply(SPECIES.length());
1743 boolean[] mask = fm.apply(SPECIES.length());
1744 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1745
1746 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1747 for (int i = 0; i < a.length; i += SPECIES.length()) {
1748 IntVector av = IntVector.fromArray(SPECIES, a, i);
1749 av.neg(vmask).intoArray(r, i);
1750 }
1751 }
1752
1753 assertArraysEquals(a, r, mask, IntMaxVectorTests::neg);
1754 }
1755
1756 static int abs(int a) {
1757 return (int)(Math.abs((int)a));
1758 }
1759
1760 @Test(dataProvider = "intUnaryOpProvider")
1761 static void absIntMaxVectorTests(IntFunction<int[]> fa) {
1762 int[] a = fa.apply(SPECIES.length());
1763 int[] r = fr.apply(SPECIES.length());
1764
1765 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1766 for (int i = 0; i < a.length; i += SPECIES.length()) {
1767 IntVector av = IntVector.fromArray(SPECIES, a, i);
1768 av.abs().intoArray(r, i);
1769 }
1770 }
1771
1772 assertArraysEquals(a, r, IntMaxVectorTests::abs);
1773 }
1774
1775 @Test(dataProvider = "intUnaryOpMaskProvider")
1776 static void absMaskedIntMaxVectorTests(IntFunction<int[]> fa,
1777 IntFunction<boolean[]> fm) {
1778 int[] a = fa.apply(SPECIES.length());
1779 int[] r = fr.apply(SPECIES.length());
1780 boolean[] mask = fm.apply(SPECIES.length());
1781 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1782
1783 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1784 for (int i = 0; i < a.length; i += SPECIES.length()) {
1785 IntVector av = IntVector.fromArray(SPECIES, a, i);
1786 av.abs(vmask).intoArray(r, i);
1787 }
1788 }
1789
1790 assertArraysEquals(a, r, mask, IntMaxVectorTests::abs);
1791 }
1792
1793
1794 static int not(int a) {
1795 return (int)(~((int)a));
1796 }
1797
1798
1799
1800 @Test(dataProvider = "intUnaryOpProvider")
1801 static void notIntMaxVectorTests(IntFunction<int[]> fa) {
1803 int[] r = fr.apply(SPECIES.length());
1804
1805 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1806 for (int i = 0; i < a.length; i += SPECIES.length()) {
1807 IntVector av = IntVector.fromArray(SPECIES, a, i);
1808 av.not().intoArray(r, i);
1809 }
1810 }
1811
1812 assertArraysEquals(a, r, IntMaxVectorTests::not);
1813 }
1814
1815
1816
1817 @Test(dataProvider = "intUnaryOpMaskProvider")
1818 static void notMaskedIntMaxVectorTests(IntFunction<int[]> fa,
1819 IntFunction<boolean[]> fm) {
1820 int[] a = fa.apply(SPECIES.length());
1821 int[] r = fr.apply(SPECIES.length());
1822 boolean[] mask = fm.apply(SPECIES.length());
1823 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1824
1825 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1826 for (int i = 0; i < a.length; i += SPECIES.length()) {
1827 IntVector av = IntVector.fromArray(SPECIES, a, i);
1828 av.not(vmask).intoArray(r, i);
1829 }
1830 }
1831
1832 assertArraysEquals(a, r, mask, IntMaxVectorTests::not);
1833 }
1834
1835
1836
1837
1838
1839 static int[] gather(int a[], int ix, int[] b, int iy) {
1840 int[] res = new int[SPECIES.length()];
1841 for (int i = 0; i < SPECIES.length(); i++) {
1842 int bi = iy + i;
1843 res[i] = a[b[bi] + ix];
|