1 /*
2 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have
21 * questions.
22 */
23
24 /*
25 * @test
26 * @modules jdk.incubator.vector
27 * @run testng/othervm -ea -esa Int128VectorTests
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 Int128VectorTests extends AbstractVectorTest {
52
53 static final VectorSpecies<Integer> SPECIES =
54 IntVector.SPECIES_128;
55
56 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
57
58 interface FUnOp {
59 int apply(int a);
60 }
61
62 static void assertArraysEquals(int[] a, int[] r, FUnOp f) {
63 int i = 0;
64 try {
65 for (; i < a.length; i++) {
66 Assert.assertEquals(r[i], f.apply(a[i]));
67 }
68 } catch (AssertionError e) {
69 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
70 }
71 }
72
73 static void assertArraysEquals(int[] a, int[] r, boolean[] mask, FUnOp f) {
74 int i = 0;
75 try {
76 for (; i < a.length; i++) {
77 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
78 }
79 } catch (AssertionError e) {
80 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
81 }
82 }
83
84 interface FReductionOp {
85 int apply(int[] a, int idx);
86 }
87
88 interface FReductionAllOp {
89 int apply(int[] a);
90 }
91
92 static void assertReductionArraysEquals(int[] a, int[] b, int c,
93 FReductionOp f, FReductionAllOp fa) {
94 int i = 0;
95 try {
96 Assert.assertEquals(c, fa.apply(a));
97 for (; i < a.length; i += SPECIES.length()) {
98 Assert.assertEquals(b[i], f.apply(a, i));
99 }
100 } catch (AssertionError e) {
101 Assert.assertEquals(c, fa.apply(a), "Final result is incorrect!");
102 Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
103 }
104 }
105
106 interface FBoolReductionOp {
107 boolean apply(boolean[] a, int idx);
108 }
109
110 static void assertReductionBoolArraysEquals(boolean[] a, boolean[] b, FBoolReductionOp f) {
111 int i = 0;
112 try {
113 for (; i < a.length; i += SPECIES.length()) {
114 Assert.assertEquals(f.apply(a, i), b[i]);
115 }
116 } catch (AssertionError e) {
117 Assert.assertEquals(f.apply(a, i), b[i], "at index #" + i);
118 }
119 }
120
121 static void assertInsertArraysEquals(int[] a, int[] b, int element, int index) {
122 int i = 0;
123 try {
124 for (; i < a.length; i += 1) {
125 if(i%SPECIES.length() == index) {
126 Assert.assertEquals(b[i], element);
127 } else {
128 Assert.assertEquals(b[i], a[i]);
129 }
130 }
131 } catch (AssertionError e) {
132 if (i%SPECIES.length() == index) {
133 Assert.assertEquals(b[i], element, "at index #" + i);
134 } else {
135 Assert.assertEquals(b[i], a[i], "at index #" + i);
136 }
137 }
138 }
139
140 static void assertRearrangeArraysEquals(int[] a, int[] r, int[] order, int vector_len) {
141 int i = 0, j = 0;
142 try {
143 for (; i < a.length; i += vector_len) {
144 for (j = 0; j < vector_len; j++) {
145 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
146 }
147 }
148 } catch (AssertionError e) {
149 int idx = i + j;
150 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
151 }
152 }
153
154 interface FBinOp {
155 int apply(int a, int b);
156 }
157
158 interface FBinMaskOp {
159 int apply(int a, int b, boolean m);
160
161 static FBinMaskOp lift(FBinOp f) {
162 return (a, b, m) -> m ? f.apply(a, b) : a;
163 }
164 }
165
166 static void assertArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
167 int i = 0;
168 try {
169 for (; i < a.length; i++) {
170 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
171 }
172 } catch (AssertionError e) {
173 Assert.assertEquals(f.apply(a[i], b[i]), r[i], "(" + a[i] + ", " + b[i] + ") at index #" + i);
174 }
175 }
176
177 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
178 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
179 }
180
181 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
182 int i = 0;
183 try {
184 for (; i < a.length; i++) {
185 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
186 }
187 } catch (AssertionError err) {
188 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
189 }
190 }
191
192 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
193 int i = 0;
194 int j = 0;
195 try {
196 for (; j < a.length; j += SPECIES.length()) {
197 for (i = 0; i < SPECIES.length(); i++) {
198 Assert.assertEquals(f.apply(a[i+j], b[j]), r[i+j]);
199 }
200 }
201 } catch (AssertionError e) {
202 Assert.assertEquals(f.apply(a[i+j], b[j]), r[i+j], "at index #" + i + ", " + j);
203 }
204 }
205
206 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
207 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
208 }
209
210 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
211 int i = 0;
212 int j = 0;
213 try {
214 for (; j < a.length; j += SPECIES.length()) {
215 for (i = 0; i < SPECIES.length(); i++) {
216 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
217 }
218 }
219 } catch (AssertionError err) {
220 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
221 }
222 }
223
224
225 interface FBinArrayOp {
226 int apply(int[] a, int b);
227 }
228
229 static void assertArraysEquals(int[] a, int[] r, FBinArrayOp f) {
230 int i = 0;
231 try {
232 for (; i < a.length; i++) {
233 Assert.assertEquals(f.apply(a, i), r[i]);
234 }
235 } catch (AssertionError e) {
236 Assert.assertEquals(f.apply(a,i), r[i], "at index #" + i);
237 }
238 }
239 interface FGatherScatterOp {
240 int[] apply(int[] a, int ix, int[] b, int iy);
241 }
242
243 static void assertArraysEquals(int[] a, int[] b, int[] r, FGatherScatterOp f) {
244 int i = 0;
245 try {
246 for (; i < a.length; i += SPECIES.length()) {
247 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
248 f.apply(a, i, b, i));
249 }
250 } catch (AssertionError e) {
251 int[] ref = f.apply(a, i, b, i);
252 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
253 Assert.assertEquals(ref, res,
254 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
255 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
256 + ", b: "
257 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
258 + " at index #" + i);
259 }
260 }
261
262
263 static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
264 withToString("int[-i * 5]", (int s) -> {
265 return fill(s * 1000,
266 i -> (int)(-i * 5));
267 }),
268 withToString("int[i * 5]", (int s) -> {
269 return fill(s * 1000,
270 i -> (int)(i * 5));
271 }),
272 withToString("int[i + 1]", (int s) -> {
273 return fill(s * 1000,
274 i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
275 }),
276 withToString("int[cornerCaseValue(i)]", (int s) -> {
277 return fill(s * 1000,
278 i -> cornerCaseValue(i));
279 })
280 );
281
282 // Create combinations of pairs
283 // @@@ Might be sensitive to order e.g. div by 0
284 static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
285 Stream.of(INT_GENERATORS.get(0)).
286 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
287 collect(Collectors.toList());
288
289 @DataProvider
290 public Object[][] boolUnaryOpProvider() {
291 return BOOL_ARRAY_GENERATORS.stream().
292 map(f -> new Object[]{f}).
293 toArray(Object[][]::new);
294 }
295
296
297 @DataProvider
298 public Object[][] intBinaryOpProvider() {
299 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
300 toArray(Object[][]::new);
301 }
302
303 @DataProvider
304 public Object[][] intIndexedOpProvider() {
305 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
306 toArray(Object[][]::new);
307 }
308
309 @DataProvider
310 public Object[][] intBinaryOpMaskProvider() {
311 return BOOLEAN_MASK_GENERATORS.stream().
312 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
313 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
314 })).
315 toArray(Object[][]::new);
316 }
317
318
319 @DataProvider
320 public Object[][] intUnaryOpProvider() {
321 return INT_GENERATORS.stream().
322 map(f -> new Object[]{f}).
323 toArray(Object[][]::new);
324 }
325
326 @DataProvider
327 public Object[][] intUnaryOpMaskProvider() {
328 return BOOLEAN_MASK_GENERATORS.stream().
329 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
330 return new Object[] {fa, fm};
331 })).
332 toArray(Object[][]::new);
333 }
334
335 @DataProvider
336 public Object[][] intUnaryOpShuffleProvider() {
337 return INT_SHUFFLE_GENERATORS.stream().
338 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
339 return new Object[] {fa, fs};
340 })).
341 toArray(Object[][]::new);
342 }
343
344 @DataProvider
345 public Object[][] intUnaryOpIndexProvider() {
346 return INT_INDEX_GENERATORS.stream().
347 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
348 return new Object[] {fa, fs};
349 })).
350 toArray(Object[][]::new);
351 }
352
353
354 static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
355 withToString("int[i]", (int s) -> {
356 return fill(s * 1000,
357 i -> (int)i);
358 }),
359 withToString("int[i + 1]", (int s) -> {
360 return fill(s * 1000,
361 i -> (int)(i + 1));
362 }),
363 withToString("int[i - 2]", (int s) -> {
364 return fill(s * 1000,
365 i -> (int)(i - 2));
366 }),
367 withToString("int[zigZag(i)]", (int s) -> {
368 return fill(s * 1000,
369 i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
370 }),
371 withToString("int[cornerCaseValue(i)]", (int s) -> {
372 return fill(s * 1000,
373 i -> cornerCaseValue(i));
374 })
375 );
376
377 static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
378 INT_COMPARE_GENERATORS.stream().
379 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
380 collect(Collectors.toList());
381
382 @DataProvider
383 public Object[][] intCompareOpProvider() {
384 return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
385 toArray(Object[][]::new);
386 }
387
388 interface ToIntF {
389 int apply(int i);
390 }
391
392 static int[] fill(int s , ToIntF f) {
393 return fill(new int[s], f);
394 }
395
396 static int[] fill(int[] a, ToIntF f) {
397 for (int i = 0; i < a.length; i++) {
398 a[i] = f.apply(i);
399 }
400 return a;
401 }
402
403 static int cornerCaseValue(int i) {
404 switch(i % 5) {
405 case 0:
406 return Integer.MAX_VALUE;
407 case 1:
408 return Integer.MIN_VALUE;
409 case 2:
410 return Integer.MIN_VALUE;
411 case 3:
412 return Integer.MAX_VALUE;
413 default:
414 return (int)0;
415 }
416 }
417 static int get(int[] a, int i) {
418 return (int) a[i];
419 }
420
421 static final IntFunction<int[]> fr = (vl) -> {
422 int length = 1000 * vl;
423 return new int[length];
424 };
425
426 static final IntFunction<boolean[]> fmr = (vl) -> {
427 int length = 1000 * vl;
428 return new boolean[length];
429 };
430 static int add(int a, int b) {
431 return (int)(a + b);
432 }
433
434 @Test(dataProvider = "intBinaryOpProvider")
435 static void addInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
436 int[] a = fa.apply(SPECIES.length());
437 int[] b = fb.apply(SPECIES.length());
438 int[] r = fr.apply(SPECIES.length());
439
440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
441 for (int i = 0; i < a.length; i += SPECIES.length()) {
442 IntVector av = IntVector.fromArray(SPECIES, a, i);
443 IntVector bv = IntVector.fromArray(SPECIES, b, i);
444 av.add(bv).intoArray(r, i);
445 }
446 }
447
448 assertArraysEquals(a, b, r, Int128VectorTests::add);
449 }
450
451 @Test(dataProvider = "intBinaryOpMaskProvider")
452 static void addInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
453 IntFunction<boolean[]> fm) {
454 int[] a = fa.apply(SPECIES.length());
455 int[] b = fb.apply(SPECIES.length());
456 int[] r = fr.apply(SPECIES.length());
457 boolean[] mask = fm.apply(SPECIES.length());
458 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
459
460 for (int ic = 0; ic < INVOC_COUNT; ic++) {
461 for (int i = 0; i < a.length; i += SPECIES.length()) {
462 IntVector av = IntVector.fromArray(SPECIES, a, i);
463 IntVector bv = IntVector.fromArray(SPECIES, b, i);
464 av.add(bv, vmask).intoArray(r, i);
465 }
466 }
467
468 assertArraysEquals(a, b, r, mask, Int128VectorTests::add);
469 }
470 static int sub(int a, int b) {
471 return (int)(a - b);
472 }
473
474 @Test(dataProvider = "intBinaryOpProvider")
475 static void subInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
476 int[] a = fa.apply(SPECIES.length());
477 int[] b = fb.apply(SPECIES.length());
478 int[] r = fr.apply(SPECIES.length());
479
480 for (int ic = 0; ic < INVOC_COUNT; ic++) {
481 for (int i = 0; i < a.length; i += SPECIES.length()) {
482 IntVector av = IntVector.fromArray(SPECIES, a, i);
483 IntVector bv = IntVector.fromArray(SPECIES, b, i);
484 av.sub(bv).intoArray(r, i);
485 }
486 }
487
488 assertArraysEquals(a, b, r, Int128VectorTests::sub);
489 }
490
491 @Test(dataProvider = "intBinaryOpMaskProvider")
492 static void subInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
493 IntFunction<boolean[]> fm) {
494 int[] a = fa.apply(SPECIES.length());
495 int[] b = fb.apply(SPECIES.length());
496 int[] r = fr.apply(SPECIES.length());
497 boolean[] mask = fm.apply(SPECIES.length());
498 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
499
500 for (int ic = 0; ic < INVOC_COUNT; ic++) {
501 for (int i = 0; i < a.length; i += SPECIES.length()) {
502 IntVector av = IntVector.fromArray(SPECIES, a, i);
503 IntVector bv = IntVector.fromArray(SPECIES, b, i);
504 av.sub(bv, vmask).intoArray(r, i);
505 }
506 }
507
508 assertArraysEquals(a, b, r, mask, Int128VectorTests::sub);
509 }
510
511
512 static int mul(int a, int b) {
513 return (int)(a * b);
514 }
515
516 @Test(dataProvider = "intBinaryOpProvider")
517 static void mulInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
518 int[] a = fa.apply(SPECIES.length());
519 int[] b = fb.apply(SPECIES.length());
520 int[] r = fr.apply(SPECIES.length());
521
522 for (int ic = 0; ic < INVOC_COUNT; ic++) {
523 for (int i = 0; i < a.length; i += SPECIES.length()) {
524 IntVector av = IntVector.fromArray(SPECIES, a, i);
525 IntVector bv = IntVector.fromArray(SPECIES, b, i);
526 av.mul(bv).intoArray(r, i);
527 }
528 }
529
530 assertArraysEquals(a, b, r, Int128VectorTests::mul);
531 }
532
533 @Test(dataProvider = "intBinaryOpMaskProvider")
534 static void mulInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
535 IntFunction<boolean[]> fm) {
536 int[] a = fa.apply(SPECIES.length());
537 int[] b = fb.apply(SPECIES.length());
538 int[] r = fr.apply(SPECIES.length());
539 boolean[] mask = fm.apply(SPECIES.length());
540 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
541
542 for (int ic = 0; ic < INVOC_COUNT; ic++) {
543 for (int i = 0; i < a.length; i += SPECIES.length()) {
544 IntVector av = IntVector.fromArray(SPECIES, a, i);
545 IntVector bv = IntVector.fromArray(SPECIES, b, i);
546 av.mul(bv, vmask).intoArray(r, i);
547 }
548 }
549
550 assertArraysEquals(a, b, r, mask, Int128VectorTests::mul);
551 }
552
553 static int and(int a, int b) {
554 return (int)(a & b);
555 }
556
557 @Test(dataProvider = "intBinaryOpProvider")
558 static void andInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
559 int[] a = fa.apply(SPECIES.length());
560 int[] b = fb.apply(SPECIES.length());
561 int[] r = fr.apply(SPECIES.length());
562
563 for (int ic = 0; ic < INVOC_COUNT; ic++) {
564 for (int i = 0; i < a.length; i += SPECIES.length()) {
565 IntVector av = IntVector.fromArray(SPECIES, a, i);
566 IntVector bv = IntVector.fromArray(SPECIES, b, i);
567 av.and(bv).intoArray(r, i);
568 }
569 }
570
571 assertArraysEquals(a, b, r, Int128VectorTests::and);
572 }
573
574
575
576 @Test(dataProvider = "intBinaryOpMaskProvider")
577 static void andInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
578 IntFunction<boolean[]> fm) {
579 int[] a = fa.apply(SPECIES.length());
580 int[] b = fb.apply(SPECIES.length());
581 int[] r = fr.apply(SPECIES.length());
582 boolean[] mask = fm.apply(SPECIES.length());
583 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
584
585 for (int ic = 0; ic < INVOC_COUNT; ic++) {
586 for (int i = 0; i < a.length; i += SPECIES.length()) {
587 IntVector av = IntVector.fromArray(SPECIES, a, i);
588 IntVector bv = IntVector.fromArray(SPECIES, b, i);
589 av.and(bv, vmask).intoArray(r, i);
590 }
591 }
592
593 assertArraysEquals(a, b, r, mask, Int128VectorTests::and);
594 }
595
596
597 static int or(int a, int b) {
598 return (int)(a | b);
599 }
600
601 @Test(dataProvider = "intBinaryOpProvider")
602 static void orInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
603 int[] a = fa.apply(SPECIES.length());
604 int[] b = fb.apply(SPECIES.length());
605 int[] r = fr.apply(SPECIES.length());
606
607 for (int ic = 0; ic < INVOC_COUNT; ic++) {
608 for (int i = 0; i < a.length; i += SPECIES.length()) {
609 IntVector av = IntVector.fromArray(SPECIES, a, i);
610 IntVector bv = IntVector.fromArray(SPECIES, b, i);
611 av.or(bv).intoArray(r, i);
612 }
613 }
614
615 assertArraysEquals(a, b, r, Int128VectorTests::or);
616 }
617
618
619
620 @Test(dataProvider = "intBinaryOpMaskProvider")
621 static void orInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
622 IntFunction<boolean[]> fm) {
623 int[] a = fa.apply(SPECIES.length());
624 int[] b = fb.apply(SPECIES.length());
625 int[] r = fr.apply(SPECIES.length());
626 boolean[] mask = fm.apply(SPECIES.length());
627 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
628
629 for (int ic = 0; ic < INVOC_COUNT; ic++) {
630 for (int i = 0; i < a.length; i += SPECIES.length()) {
631 IntVector av = IntVector.fromArray(SPECIES, a, i);
632 IntVector bv = IntVector.fromArray(SPECIES, b, i);
633 av.or(bv, vmask).intoArray(r, i);
634 }
635 }
636
637 assertArraysEquals(a, b, r, mask, Int128VectorTests::or);
638 }
639
640
641 static int xor(int a, int b) {
642 return (int)(a ^ b);
643 }
644
645 @Test(dataProvider = "intBinaryOpProvider")
646 static void xorInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
647 int[] a = fa.apply(SPECIES.length());
648 int[] b = fb.apply(SPECIES.length());
649 int[] r = fr.apply(SPECIES.length());
650
651 for (int ic = 0; ic < INVOC_COUNT; ic++) {
652 for (int i = 0; i < a.length; i += SPECIES.length()) {
653 IntVector av = IntVector.fromArray(SPECIES, a, i);
654 IntVector bv = IntVector.fromArray(SPECIES, b, i);
655 av.xor(bv).intoArray(r, i);
656 }
657 }
658
659 assertArraysEquals(a, b, r, Int128VectorTests::xor);
660 }
661
662
663
664 @Test(dataProvider = "intBinaryOpMaskProvider")
665 static void xorInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
666 IntFunction<boolean[]> fm) {
667 int[] a = fa.apply(SPECIES.length());
668 int[] b = fb.apply(SPECIES.length());
669 int[] r = fr.apply(SPECIES.length());
670 boolean[] mask = fm.apply(SPECIES.length());
671 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
672
673 for (int ic = 0; ic < INVOC_COUNT; ic++) {
674 for (int i = 0; i < a.length; i += SPECIES.length()) {
675 IntVector av = IntVector.fromArray(SPECIES, a, i);
676 IntVector bv = IntVector.fromArray(SPECIES, b, i);
677 av.xor(bv, vmask).intoArray(r, i);
678 }
679 }
680
681 assertArraysEquals(a, b, r, mask, Int128VectorTests::xor);
682 }
683
684
685 static int shiftR(int a, int b) {
686 return (int)((a >>> b));
687 }
688
689 @Test(dataProvider = "intBinaryOpProvider")
690 static void shiftRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
691 int[] a = fa.apply(SPECIES.length());
692 int[] b = fb.apply(SPECIES.length());
693 int[] r = fr.apply(SPECIES.length());
694
695 for (int ic = 0; ic < INVOC_COUNT; ic++) {
696 for (int i = 0; i < a.length; i += SPECIES.length()) {
697 IntVector av = IntVector.fromArray(SPECIES, a, i);
698 IntVector bv = IntVector.fromArray(SPECIES, b, i);
699 av.shiftR(bv).intoArray(r, i);
700 }
701 }
702
703 assertArraysEquals(a, b, r, Int128VectorTests::shiftR);
704 }
705
706
707
708 @Test(dataProvider = "intBinaryOpMaskProvider")
709 static void shiftRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
710 IntFunction<boolean[]> fm) {
711 int[] a = fa.apply(SPECIES.length());
712 int[] b = fb.apply(SPECIES.length());
713 int[] r = fr.apply(SPECIES.length());
714 boolean[] mask = fm.apply(SPECIES.length());
715 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
716
717 for (int ic = 0; ic < INVOC_COUNT; ic++) {
718 for (int i = 0; i < a.length; i += SPECIES.length()) {
719 IntVector av = IntVector.fromArray(SPECIES, a, i);
720 IntVector bv = IntVector.fromArray(SPECIES, b, i);
721 av.shiftR(bv, vmask).intoArray(r, i);
722 }
723 }
724
725 assertArraysEquals(a, b, r, mask, Int128VectorTests::shiftR);
726 }
727
728
729 static int shiftL(int a, int b) {
730 return (int)((a << b));
731 }
732
733 @Test(dataProvider = "intBinaryOpProvider")
734 static void shiftLInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
735 int[] a = fa.apply(SPECIES.length());
736 int[] b = fb.apply(SPECIES.length());
737 int[] r = fr.apply(SPECIES.length());
738
739 for (int ic = 0; ic < INVOC_COUNT; ic++) {
740 for (int i = 0; i < a.length; i += SPECIES.length()) {
741 IntVector av = IntVector.fromArray(SPECIES, a, i);
742 IntVector bv = IntVector.fromArray(SPECIES, b, i);
743 av.shiftL(bv).intoArray(r, i);
744 }
745 }
746
747 assertArraysEquals(a, b, r, Int128VectorTests::shiftL);
748 }
749
750
751
752 @Test(dataProvider = "intBinaryOpMaskProvider")
753 static void shiftLInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
754 IntFunction<boolean[]> fm) {
755 int[] a = fa.apply(SPECIES.length());
756 int[] b = fb.apply(SPECIES.length());
757 int[] r = fr.apply(SPECIES.length());
758 boolean[] mask = fm.apply(SPECIES.length());
759 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
760
761 for (int ic = 0; ic < INVOC_COUNT; ic++) {
762 for (int i = 0; i < a.length; i += SPECIES.length()) {
763 IntVector av = IntVector.fromArray(SPECIES, a, i);
764 IntVector bv = IntVector.fromArray(SPECIES, b, i);
765 av.shiftL(bv, vmask).intoArray(r, i);
766 }
767 }
768
769 assertArraysEquals(a, b, r, mask, Int128VectorTests::shiftL);
770 }
771
772
773 static int aShiftR(int a, int b) {
774 return (int)((a >> b));
775 }
776
777 @Test(dataProvider = "intBinaryOpProvider")
778 static void aShiftRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
779 int[] a = fa.apply(SPECIES.length());
780 int[] b = fb.apply(SPECIES.length());
781 int[] r = fr.apply(SPECIES.length());
782
783 for (int ic = 0; ic < INVOC_COUNT; ic++) {
784 for (int i = 0; i < a.length; i += SPECIES.length()) {
785 IntVector av = IntVector.fromArray(SPECIES, a, i);
786 IntVector bv = IntVector.fromArray(SPECIES, b, i);
787 av.aShiftR(bv).intoArray(r, i);
788 }
789 }
790
791 assertArraysEquals(a, b, r, Int128VectorTests::aShiftR);
792 }
793
794
795
796 @Test(dataProvider = "intBinaryOpMaskProvider")
797 static void aShiftRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
798 IntFunction<boolean[]> fm) {
799 int[] a = fa.apply(SPECIES.length());
800 int[] b = fb.apply(SPECIES.length());
801 int[] r = fr.apply(SPECIES.length());
802 boolean[] mask = fm.apply(SPECIES.length());
803 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
804
805 for (int ic = 0; ic < INVOC_COUNT; ic++) {
806 for (int i = 0; i < a.length; i += SPECIES.length()) {
807 IntVector av = IntVector.fromArray(SPECIES, a, i);
808 IntVector bv = IntVector.fromArray(SPECIES, b, i);
809 av.aShiftR(bv, vmask).intoArray(r, i);
810 }
811 }
812
813 assertArraysEquals(a, b, r, mask, Int128VectorTests::aShiftR);
814 }
815
816
817 static int aShiftR_unary(int a, int b) {
818 return (int)((a >> b));
819 }
820
821 @Test(dataProvider = "intBinaryOpProvider")
822 static void aShiftRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
823 int[] a = fa.apply(SPECIES.length());
824 int[] b = fb.apply(SPECIES.length());
825 int[] r = fr.apply(SPECIES.length());
826
827 for (int ic = 0; ic < INVOC_COUNT; ic++) {
828 for (int i = 0; i < a.length; i += SPECIES.length()) {
829 IntVector av = IntVector.fromArray(SPECIES, a, i);
830 av.aShiftR((int)b[i]).intoArray(r, i);
831 }
832 }
833
834 assertShiftArraysEquals(a, b, r, Int128VectorTests::aShiftR_unary);
835 }
836
837
838
839 @Test(dataProvider = "intBinaryOpMaskProvider")
840 static void aShiftRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
841 IntFunction<boolean[]> fm) {
842 int[] a = fa.apply(SPECIES.length());
843 int[] b = fb.apply(SPECIES.length());
844 int[] r = fr.apply(SPECIES.length());
845 boolean[] mask = fm.apply(SPECIES.length());
846 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
847
848 for (int ic = 0; ic < INVOC_COUNT; ic++) {
849 for (int i = 0; i < a.length; i += SPECIES.length()) {
850 IntVector av = IntVector.fromArray(SPECIES, a, i);
851 av.aShiftR((int)b[i], vmask).intoArray(r, i);
852 }
853 }
854
855 assertShiftArraysEquals(a, b, r, mask, Int128VectorTests::aShiftR_unary);
856 }
857
858
859 static int shiftR_unary(int a, int b) {
860 return (int)((a >>> b));
861 }
862
863 @Test(dataProvider = "intBinaryOpProvider")
864 static void shiftRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
865 int[] a = fa.apply(SPECIES.length());
866 int[] b = fb.apply(SPECIES.length());
867 int[] r = fr.apply(SPECIES.length());
868
869 for (int ic = 0; ic < INVOC_COUNT; ic++) {
870 for (int i = 0; i < a.length; i += SPECIES.length()) {
871 IntVector av = IntVector.fromArray(SPECIES, a, i);
872 av.shiftR((int)b[i]).intoArray(r, i);
873 }
874 }
875
876 assertShiftArraysEquals(a, b, r, Int128VectorTests::shiftR_unary);
877 }
878
879
880
881 @Test(dataProvider = "intBinaryOpMaskProvider")
882 static void shiftRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
883 IntFunction<boolean[]> fm) {
884 int[] a = fa.apply(SPECIES.length());
885 int[] b = fb.apply(SPECIES.length());
886 int[] r = fr.apply(SPECIES.length());
887 boolean[] mask = fm.apply(SPECIES.length());
888 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
889
890 for (int ic = 0; ic < INVOC_COUNT; ic++) {
891 for (int i = 0; i < a.length; i += SPECIES.length()) {
892 IntVector av = IntVector.fromArray(SPECIES, a, i);
893 av.shiftR((int)b[i], vmask).intoArray(r, i);
894 }
895 }
896
897 assertShiftArraysEquals(a, b, r, mask, Int128VectorTests::shiftR_unary);
898 }
899
900
901 static int shiftL_unary(int a, int b) {
902 return (int)((a << b));
903 }
904
905 @Test(dataProvider = "intBinaryOpProvider")
906 static void shiftLInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
907 int[] a = fa.apply(SPECIES.length());
908 int[] b = fb.apply(SPECIES.length());
909 int[] r = fr.apply(SPECIES.length());
910
911 for (int ic = 0; ic < INVOC_COUNT; ic++) {
912 for (int i = 0; i < a.length; i += SPECIES.length()) {
913 IntVector av = IntVector.fromArray(SPECIES, a, i);
914 av.shiftL((int)b[i]).intoArray(r, i);
915 }
916 }
917
918 assertShiftArraysEquals(a, b, r, Int128VectorTests::shiftL_unary);
919 }
920
921
922
923 @Test(dataProvider = "intBinaryOpMaskProvider")
924 static void shiftLInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
925 IntFunction<boolean[]> fm) {
926 int[] a = fa.apply(SPECIES.length());
927 int[] b = fb.apply(SPECIES.length());
928 int[] r = fr.apply(SPECIES.length());
929 boolean[] mask = fm.apply(SPECIES.length());
930 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
931
932 for (int ic = 0; ic < INVOC_COUNT; ic++) {
933 for (int i = 0; i < a.length; i += SPECIES.length()) {
934 IntVector av = IntVector.fromArray(SPECIES, a, i);
935 av.shiftL((int)b[i], vmask).intoArray(r, i);
936 }
937 }
938
939 assertShiftArraysEquals(a, b, r, mask, Int128VectorTests::shiftL_unary);
940 }
941
942
943
944
945
946
947
948
949
950
951
952
953
954 static int max(int a, int b) {
955 return (int)(Math.max(a, b));
956 }
957
958 @Test(dataProvider = "intBinaryOpProvider")
959 static void maxInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
960 int[] a = fa.apply(SPECIES.length());
961 int[] b = fb.apply(SPECIES.length());
962 int[] r = fr.apply(SPECIES.length());
963
964 for (int ic = 0; ic < INVOC_COUNT; ic++) {
965 for (int i = 0; i < a.length; i += SPECIES.length()) {
966 IntVector av = IntVector.fromArray(SPECIES, a, i);
967 IntVector bv = IntVector.fromArray(SPECIES, b, i);
968 av.max(bv).intoArray(r, i);
969 }
970 }
971
972 assertArraysEquals(a, b, r, Int128VectorTests::max);
973 }
974 static int min(int a, int b) {
975 return (int)(Math.min(a, b));
976 }
977
978 @Test(dataProvider = "intBinaryOpProvider")
979 static void minInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
980 int[] a = fa.apply(SPECIES.length());
981 int[] b = fb.apply(SPECIES.length());
982 int[] r = fr.apply(SPECIES.length());
983
984 for (int ic = 0; ic < INVOC_COUNT; ic++) {
985 for (int i = 0; i < a.length; i += SPECIES.length()) {
986 IntVector av = IntVector.fromArray(SPECIES, a, i);
987 IntVector bv = IntVector.fromArray(SPECIES, b, i);
988 av.min(bv).intoArray(r, i);
989 }
990 }
991
992 assertArraysEquals(a, b, r, Int128VectorTests::min);
993 }
994
995 static int andAll(int[] a, int idx) {
996 int res = -1;
997 for (int i = idx; i < (idx + SPECIES.length()); i++) {
998 res &= a[i];
999 }
1000
1001 return res;
1002 }
1003
1004 static int andAll(int[] a) {
1005 int res = -1;
1006 for (int i = 0; i < a.length; i += SPECIES.length()) {
1007 int tmp = -1;
1008 for (int j = 0; j < SPECIES.length(); j++) {
1009 tmp &= a[i + j];
1010 }
1011 res &= tmp;
1012 }
1013
1014 return res;
1015 }
1016
1017
1018 @Test(dataProvider = "intUnaryOpProvider")
1019 static void andAllInt128VectorTests(IntFunction<int[]> fa) {
1020 int[] a = fa.apply(SPECIES.length());
1021 int[] r = fr.apply(SPECIES.length());
1022 int ra = -1;
1023
1024 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1025 for (int i = 0; i < a.length; i += SPECIES.length()) {
1026 IntVector av = IntVector.fromArray(SPECIES, a, i);
1027 r[i] = av.andAll();
1028 }
1029 }
1030
1031 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1032 ra = -1;
1033 for (int i = 0; i < a.length; i += SPECIES.length()) {
1034 IntVector av = IntVector.fromArray(SPECIES, a, i);
1035 ra &= av.andAll();
1036 }
1037 }
1038
1039 assertReductionArraysEquals(a, r, ra, Int128VectorTests::andAll, Int128VectorTests::andAll);
1040 }
1041
1042
1043 static int orAll(int[] a, int idx) {
1044 int res = 0;
1045 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1046 res |= a[i];
1047 }
1048
1049 return res;
1050 }
1051
1052 static int orAll(int[] a) {
1053 int res = 0;
1054 for (int i = 0; i < a.length; i += SPECIES.length()) {
1055 int tmp = 0;
1056 for (int j = 0; j < SPECIES.length(); j++) {
1057 tmp |= a[i + j];
1058 }
1059 res |= tmp;
1060 }
1061
1062 return res;
1063 }
1064
1065
1066 @Test(dataProvider = "intUnaryOpProvider")
1067 static void orAllInt128VectorTests(IntFunction<int[]> fa) {
1068 int[] a = fa.apply(SPECIES.length());
1069 int[] r = fr.apply(SPECIES.length());
1070 int ra = 0;
1071
1072 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1073 for (int i = 0; i < a.length; i += SPECIES.length()) {
1074 IntVector av = IntVector.fromArray(SPECIES, a, i);
1075 r[i] = av.orAll();
1076 }
1077 }
1078
1079 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1080 ra = 0;
1081 for (int i = 0; i < a.length; i += SPECIES.length()) {
1082 IntVector av = IntVector.fromArray(SPECIES, a, i);
1083 ra |= av.orAll();
1084 }
1085 }
1086
1087 assertReductionArraysEquals(a, r, ra, Int128VectorTests::orAll, Int128VectorTests::orAll);
1088 }
1089
1090
1091 static int xorAll(int[] a, int idx) {
1092 int res = 0;
1093 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1094 res ^= a[i];
1095 }
1096
1097 return res;
1098 }
1099
1100 static int xorAll(int[] a) {
1101 int res = 0;
1102 for (int i = 0; i < a.length; i += SPECIES.length()) {
1103 int tmp = 0;
1104 for (int j = 0; j < SPECIES.length(); j++) {
1105 tmp ^= a[i + j];
1106 }
1107 res ^= tmp;
1108 }
1109
1110 return res;
1111 }
1112
1113
1114 @Test(dataProvider = "intUnaryOpProvider")
1115 static void xorAllInt128VectorTests(IntFunction<int[]> fa) {
1116 int[] a = fa.apply(SPECIES.length());
1117 int[] r = fr.apply(SPECIES.length());
1118 int ra = 0;
1119
1120 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1121 for (int i = 0; i < a.length; i += SPECIES.length()) {
1122 IntVector av = IntVector.fromArray(SPECIES, a, i);
1123 r[i] = av.xorAll();
1124 }
1125 }
1126
1127 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1128 ra = 0;
1129 for (int i = 0; i < a.length; i += SPECIES.length()) {
1130 IntVector av = IntVector.fromArray(SPECIES, a, i);
1131 ra ^= av.xorAll();
1132 }
1133 }
1134
1135 assertReductionArraysEquals(a, r, ra, Int128VectorTests::xorAll, Int128VectorTests::xorAll);
1136 }
1137
1138 static int addAll(int[] a, int idx) {
1139 int res = 0;
1140 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1141 res += a[i];
1142 }
1143
1144 return res;
1145 }
1146
1147 static int addAll(int[] a) {
1148 int res = 0;
1149 for (int i = 0; i < a.length; i += SPECIES.length()) {
1150 int tmp = 0;
1151 for (int j = 0; j < SPECIES.length(); j++) {
1152 tmp += a[i + j];
1153 }
1154 res += tmp;
1155 }
1156
1157 return res;
1158 }
1159 @Test(dataProvider = "intUnaryOpProvider")
1160 static void addAllInt128VectorTests(IntFunction<int[]> fa) {
1161 int[] a = fa.apply(SPECIES.length());
1162 int[] r = fr.apply(SPECIES.length());
1163 int ra = 0;
1164
1165 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1166 for (int i = 0; i < a.length; i += SPECIES.length()) {
1167 IntVector av = IntVector.fromArray(SPECIES, a, i);
1168 r[i] = av.addAll();
1169 }
1170 }
1171
1172 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1173 ra = 0;
1174 for (int i = 0; i < a.length; i += SPECIES.length()) {
1175 IntVector av = IntVector.fromArray(SPECIES, a, i);
1176 ra += av.addAll();
1177 }
1178 }
1179
1180 assertReductionArraysEquals(a, r, ra, Int128VectorTests::addAll, Int128VectorTests::addAll);
1181 }
1182 static int mulAll(int[] a, int idx) {
1183 int res = 1;
1184 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1185 res *= a[i];
1186 }
1187
1188 return res;
1189 }
1190
1191 static int mulAll(int[] a) {
1192 int res = 1;
1193 for (int i = 0; i < a.length; i += SPECIES.length()) {
1194 int tmp = 1;
1195 for (int j = 0; j < SPECIES.length(); j++) {
1196 tmp *= a[i + j];
1197 }
1198 res *= tmp;
1199 }
1200
1201 return res;
1202 }
1203 @Test(dataProvider = "intUnaryOpProvider")
1204 static void mulAllInt128VectorTests(IntFunction<int[]> fa) {
1205 int[] a = fa.apply(SPECIES.length());
1206 int[] r = fr.apply(SPECIES.length());
1207 int ra = 1;
1208
1209 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1210 for (int i = 0; i < a.length; i += SPECIES.length()) {
1211 IntVector av = IntVector.fromArray(SPECIES, a, i);
1212 r[i] = av.mulAll();
1213 }
1214 }
1215
1216 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1217 ra = 1;
1218 for (int i = 0; i < a.length; i += SPECIES.length()) {
1219 IntVector av = IntVector.fromArray(SPECIES, a, i);
1220 ra *= av.mulAll();
1221 }
1222 }
1223
1224 assertReductionArraysEquals(a, r, ra, Int128VectorTests::mulAll, Int128VectorTests::mulAll);
1225 }
1226 static int minAll(int[] a, int idx) {
1227 int res = Integer.MAX_VALUE;
1228 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1229 res = (int)Math.min(res, a[i]);
1230 }
1231
1232 return res;
1233 }
1234
1235 static int minAll(int[] a) {
1236 int res = Integer.MAX_VALUE;
1237 for (int i = 0; i < a.length; i++) {
1238 res = (int)Math.min(res, a[i]);
1239 }
1240
1241 return res;
1242 }
1243 @Test(dataProvider = "intUnaryOpProvider")
1244 static void minAllInt128VectorTests(IntFunction<int[]> fa) {
1245 int[] a = fa.apply(SPECIES.length());
1246 int[] r = fr.apply(SPECIES.length());
1247 int ra = Integer.MAX_VALUE;
1248
1249 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1250 for (int i = 0; i < a.length; i += SPECIES.length()) {
1251 IntVector av = IntVector.fromArray(SPECIES, a, i);
1252 r[i] = av.minAll();
1253 }
1254 }
1255
1256 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1257 ra = Integer.MAX_VALUE;
1258 for (int i = 0; i < a.length; i += SPECIES.length()) {
1259 IntVector av = IntVector.fromArray(SPECIES, a, i);
1260 ra = (int)Math.min(ra, av.minAll());
1261 }
1262 }
1263
1264 assertReductionArraysEquals(a, r, ra, Int128VectorTests::minAll, Int128VectorTests::minAll);
1265 }
1266 static int maxAll(int[] a, int idx) {
1267 int res = Integer.MIN_VALUE;
1268 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1269 res = (int)Math.max(res, a[i]);
1270 }
1271
1272 return res;
1273 }
1274
1275 static int maxAll(int[] a) {
1276 int res = Integer.MIN_VALUE;
1277 for (int i = 0; i < a.length; i++) {
1278 res = (int)Math.max(res, a[i]);
1279 }
1280
1281 return res;
1282 }
1283 @Test(dataProvider = "intUnaryOpProvider")
1284 static void maxAllInt128VectorTests(IntFunction<int[]> fa) {
1285 int[] a = fa.apply(SPECIES.length());
1286 int[] r = fr.apply(SPECIES.length());
1287 int ra = Integer.MIN_VALUE;
1288
1289 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1290 for (int i = 0; i < a.length; i += SPECIES.length()) {
1291 IntVector av = IntVector.fromArray(SPECIES, a, i);
1292 r[i] = av.maxAll();
1293 }
1294 }
1295
1296 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1297 ra = Integer.MIN_VALUE;
1298 for (int i = 0; i < a.length; i += SPECIES.length()) {
1299 IntVector av = IntVector.fromArray(SPECIES, a, i);
1300 ra = (int)Math.max(ra, av.maxAll());
1301 }
1302 }
1303
1304 assertReductionArraysEquals(a, r, ra, Int128VectorTests::maxAll, Int128VectorTests::maxAll);
1305 }
1306
1307 static boolean anyTrue(boolean[] a, int idx) {
1308 boolean res = false;
1309 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1310 res |= a[i];
1311 }
1312
1313 return res;
1314 }
1315
1316
1317 @Test(dataProvider = "boolUnaryOpProvider")
1318 static void anyTrueInt128VectorTests(IntFunction<boolean[]> fm) {
1319 boolean[] mask = fm.apply(SPECIES.length());
1320 boolean[] r = fmr.apply(SPECIES.length());
1321
1322 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1323 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1324 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
1325 r[i] = vmask.anyTrue();
1326 }
1327 }
1328
1329 assertReductionBoolArraysEquals(mask, r, Int128VectorTests::anyTrue);
1330 }
1331
1332
1333 static boolean allTrue(boolean[] a, int idx) {
1334 boolean res = true;
1335 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1336 res &= a[i];
1337 }
1338
1339 return res;
1340 }
1341
1342
1343 @Test(dataProvider = "boolUnaryOpProvider")
1344 static void allTrueInt128VectorTests(IntFunction<boolean[]> fm) {
1345 boolean[] mask = fm.apply(SPECIES.length());
1346 boolean[] r = fmr.apply(SPECIES.length());
1347
1348 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1349 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1350 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
1351 r[i] = vmask.allTrue();
1352 }
1353 }
1354
1355 assertReductionBoolArraysEquals(mask, r, Int128VectorTests::allTrue);
1356 }
1357
1358
1359 @Test(dataProvider = "intUnaryOpProvider")
1360 static void withInt128VectorTests(IntFunction<int []> fa) {
1361 int[] a = fa.apply(SPECIES.length());
1362 int[] r = fr.apply(SPECIES.length());
1363
1364 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1365 for (int i = 0; i < a.length; i += SPECIES.length()) {
1366 IntVector av = IntVector.fromArray(SPECIES, a, i);
1367 av.with(0, (int)4).intoArray(r, i);
1368 }
1369 }
1370
1371 assertInsertArraysEquals(a, r, (int)4, 0);
1372 }
1373
1374 @Test(dataProvider = "intCompareOpProvider")
1375 static void lessThanInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1376 int[] a = fa.apply(SPECIES.length());
1377 int[] b = fb.apply(SPECIES.length());
1378
1379 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1380 for (int i = 0; i < a.length; i += SPECIES.length()) {
1381 IntVector av = IntVector.fromArray(SPECIES, a, i);
1382 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1383 VectorMask<Integer> mv = av.lessThan(bv);
1384
1385 // Check results as part of computation.
1386 for (int j = 0; j < SPECIES.length(); j++) {
1387 Assert.assertEquals(mv.lane(j), a[i + j] < b[i + j]);
1388 }
1389 }
1390 }
1391 }
1392
1393
1394 @Test(dataProvider = "intCompareOpProvider")
1395 static void greaterThanInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1396 int[] a = fa.apply(SPECIES.length());
1397 int[] b = fb.apply(SPECIES.length());
1398
1399 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1400 for (int i = 0; i < a.length; i += SPECIES.length()) {
1401 IntVector av = IntVector.fromArray(SPECIES, a, i);
1402 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1403 VectorMask<Integer> mv = av.greaterThan(bv);
1404
1405 // Check results as part of computation.
1406 for (int j = 0; j < SPECIES.length(); j++) {
1407 Assert.assertEquals(mv.lane(j), a[i + j] > b[i + j]);
1408 }
1409 }
1410 }
1411 }
1412
1413
1414 @Test(dataProvider = "intCompareOpProvider")
1415 static void equalInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1416 int[] a = fa.apply(SPECIES.length());
1417 int[] b = fb.apply(SPECIES.length());
1418
1419 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1420 for (int i = 0; i < a.length; i += SPECIES.length()) {
1421 IntVector av = IntVector.fromArray(SPECIES, a, i);
1422 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1423 VectorMask<Integer> mv = av.equal(bv);
1424
1425 // Check results as part of computation.
1426 for (int j = 0; j < SPECIES.length(); j++) {
1427 Assert.assertEquals(mv.lane(j), a[i + j] == b[i + j]);
1428 }
1429 }
1430 }
1431 }
1432
1433
1434 @Test(dataProvider = "intCompareOpProvider")
1435 static void notEqualInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1436 int[] a = fa.apply(SPECIES.length());
1437 int[] b = fb.apply(SPECIES.length());
1438
1439 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1440 for (int i = 0; i < a.length; i += SPECIES.length()) {
1441 IntVector av = IntVector.fromArray(SPECIES, a, i);
1442 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1443 VectorMask<Integer> mv = av.notEqual(bv);
1444
1445 // Check results as part of computation.
1446 for (int j = 0; j < SPECIES.length(); j++) {
1447 Assert.assertEquals(mv.lane(j), a[i + j] != b[i + j]);
1448 }
1449 }
1450 }
1451 }
1452
1453
1454 @Test(dataProvider = "intCompareOpProvider")
1455 static void lessThanEqInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1456 int[] a = fa.apply(SPECIES.length());
1457 int[] b = fb.apply(SPECIES.length());
1458
1459 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1460 for (int i = 0; i < a.length; i += SPECIES.length()) {
1461 IntVector av = IntVector.fromArray(SPECIES, a, i);
1462 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1463 VectorMask<Integer> mv = av.lessThanEq(bv);
1464
1465 // Check results as part of computation.
1466 for (int j = 0; j < SPECIES.length(); j++) {
1467 Assert.assertEquals(mv.lane(j), a[i + j] <= b[i + j]);
1468 }
1469 }
1470 }
1471 }
1472
1473
1474 @Test(dataProvider = "intCompareOpProvider")
1475 static void greaterThanEqInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1476 int[] a = fa.apply(SPECIES.length());
1477 int[] b = fb.apply(SPECIES.length());
1478
1479 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1480 for (int i = 0; i < a.length; i += SPECIES.length()) {
1481 IntVector av = IntVector.fromArray(SPECIES, a, i);
1482 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1483 VectorMask<Integer> mv = av.greaterThanEq(bv);
1484
1485 // Check results as part of computation.
1486 for (int j = 0; j < SPECIES.length(); j++) {
1487 Assert.assertEquals(mv.lane(j), a[i + j] >= b[i + j]);
1488 }
1489 }
1490 }
1491 }
1492
1493
1494 static int blend(int a, int b, boolean mask) {
1495 return mask ? b : a;
1496 }
1497
1498 @Test(dataProvider = "intBinaryOpMaskProvider")
1499 static void blendInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
1500 IntFunction<boolean[]> fm) {
1501 int[] a = fa.apply(SPECIES.length());
1502 int[] b = fb.apply(SPECIES.length());
1503 int[] r = fr.apply(SPECIES.length());
1504 boolean[] mask = fm.apply(SPECIES.length());
1505 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1506
1507 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1508 for (int i = 0; i < a.length; i += SPECIES.length()) {
1509 IntVector av = IntVector.fromArray(SPECIES, a, i);
1510 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1511 av.blend(bv, vmask).intoArray(r, i);
1512 }
1513 }
1514
1515 assertArraysEquals(a, b, r, mask, Int128VectorTests::blend);
1516 }
1517
1518 @Test(dataProvider = "intUnaryOpShuffleProvider")
1519 static void RearrangeInt128VectorTests(IntFunction<int[]> fa,
1520 BiFunction<Integer,Integer,int[]> fs) {
1521 int[] a = fa.apply(SPECIES.length());
1522 int[] order = fs.apply(a.length, SPECIES.length());
1523 int[] r = fr.apply(SPECIES.length());
1524
1525 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1526 for (int i = 0; i < a.length; i += SPECIES.length()) {
1527 IntVector av = IntVector.fromArray(SPECIES, a, i);
1528 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
1529 }
1530 }
1531
1532 assertRearrangeArraysEquals(a, r, order, SPECIES.length());
1533 }
1534
1535
1536
1537
1538 @Test(dataProvider = "intUnaryOpProvider")
1539 static void getInt128VectorTests(IntFunction<int[]> fa) {
1540 int[] a = fa.apply(SPECIES.length());
1541 int[] r = fr.apply(SPECIES.length());
1542
1543 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1544 for (int i = 0; i < a.length; i += SPECIES.length()) {
1545 IntVector av = IntVector.fromArray(SPECIES, a, i);
1546 int num_lanes = SPECIES.length();
1547 // Manually unroll because full unroll happens after intrinsification.
1548 // Unroll is needed because get intrinsic requires for index to be a known constant.
1549 if (num_lanes == 1) {
1550 r[i]=av.lane(0);
1551 } else if (num_lanes == 2) {
1552 r[i]=av.lane(0);
1553 r[i+1]=av.lane(1);
1554 } else if (num_lanes == 4) {
1555 r[i]=av.lane(0);
1556 r[i+1]=av.lane(1);
1557 r[i+2]=av.lane(2);
1558 r[i+3]=av.lane(3);
1559 } else if (num_lanes == 8) {
1560 r[i]=av.lane(0);
1561 r[i+1]=av.lane(1);
1562 r[i+2]=av.lane(2);
1563 r[i+3]=av.lane(3);
1564 r[i+4]=av.lane(4);
1565 r[i+5]=av.lane(5);
1566 r[i+6]=av.lane(6);
1567 r[i+7]=av.lane(7);
1568 } else if (num_lanes == 16) {
1569 r[i]=av.lane(0);
1570 r[i+1]=av.lane(1);
1571 r[i+2]=av.lane(2);
1572 r[i+3]=av.lane(3);
1573 r[i+4]=av.lane(4);
1574 r[i+5]=av.lane(5);
1575 r[i+6]=av.lane(6);
1576 r[i+7]=av.lane(7);
1577 r[i+8]=av.lane(8);
1578 r[i+9]=av.lane(9);
1579 r[i+10]=av.lane(10);
1580 r[i+11]=av.lane(11);
1581 r[i+12]=av.lane(12);
1582 r[i+13]=av.lane(13);
1583 r[i+14]=av.lane(14);
1584 r[i+15]=av.lane(15);
1585 } else if (num_lanes == 32) {
1586 r[i]=av.lane(0);
1587 r[i+1]=av.lane(1);
1588 r[i+2]=av.lane(2);
1589 r[i+3]=av.lane(3);
1590 r[i+4]=av.lane(4);
1591 r[i+5]=av.lane(5);
1592 r[i+6]=av.lane(6);
1593 r[i+7]=av.lane(7);
1594 r[i+8]=av.lane(8);
1595 r[i+9]=av.lane(9);
1596 r[i+10]=av.lane(10);
1597 r[i+11]=av.lane(11);
1598 r[i+12]=av.lane(12);
1599 r[i+13]=av.lane(13);
1600 r[i+14]=av.lane(14);
1601 r[i+15]=av.lane(15);
1602 r[i+16]=av.lane(16);
1603 r[i+17]=av.lane(17);
1604 r[i+18]=av.lane(18);
1605 r[i+19]=av.lane(19);
1606 r[i+20]=av.lane(20);
1607 r[i+21]=av.lane(21);
1608 r[i+22]=av.lane(22);
1609 r[i+23]=av.lane(23);
1610 r[i+24]=av.lane(24);
1611 r[i+25]=av.lane(25);
1612 r[i+26]=av.lane(26);
1613 r[i+27]=av.lane(27);
1614 r[i+28]=av.lane(28);
1615 r[i+29]=av.lane(29);
1616 r[i+30]=av.lane(30);
1617 r[i+31]=av.lane(31);
1618 } else if (num_lanes == 64) {
1619 r[i]=av.lane(0);
1620 r[i+1]=av.lane(1);
1621 r[i+2]=av.lane(2);
1622 r[i+3]=av.lane(3);
1623 r[i+4]=av.lane(4);
1624 r[i+5]=av.lane(5);
1625 r[i+6]=av.lane(6);
1626 r[i+7]=av.lane(7);
1627 r[i+8]=av.lane(8);
1628 r[i+9]=av.lane(9);
1629 r[i+10]=av.lane(10);
1630 r[i+11]=av.lane(11);
1631 r[i+12]=av.lane(12);
1632 r[i+13]=av.lane(13);
1633 r[i+14]=av.lane(14);
1634 r[i+15]=av.lane(15);
1635 r[i+16]=av.lane(16);
1636 r[i+17]=av.lane(17);
1637 r[i+18]=av.lane(18);
1638 r[i+19]=av.lane(19);
1639 r[i+20]=av.lane(20);
1640 r[i+21]=av.lane(21);
1641 r[i+22]=av.lane(22);
1642 r[i+23]=av.lane(23);
1643 r[i+24]=av.lane(24);
1644 r[i+25]=av.lane(25);
1645 r[i+26]=av.lane(26);
1646 r[i+27]=av.lane(27);
1647 r[i+28]=av.lane(28);
1648 r[i+29]=av.lane(29);
1649 r[i+30]=av.lane(30);
1650 r[i+31]=av.lane(31);
1651 r[i+32]=av.lane(32);
1652 r[i+33]=av.lane(33);
1653 r[i+34]=av.lane(34);
1654 r[i+35]=av.lane(35);
1655 r[i+36]=av.lane(36);
1656 r[i+37]=av.lane(37);
1657 r[i+38]=av.lane(38);
1658 r[i+39]=av.lane(39);
1659 r[i+40]=av.lane(40);
1660 r[i+41]=av.lane(41);
1661 r[i+42]=av.lane(42);
1662 r[i+43]=av.lane(43);
1663 r[i+44]=av.lane(44);
1664 r[i+45]=av.lane(45);
1665 r[i+46]=av.lane(46);
1666 r[i+47]=av.lane(47);
1667 r[i+48]=av.lane(48);
1668 r[i+49]=av.lane(49);
1669 r[i+50]=av.lane(50);
1670 r[i+51]=av.lane(51);
1671 r[i+52]=av.lane(52);
1672 r[i+53]=av.lane(53);
1673 r[i+54]=av.lane(54);
1674 r[i+55]=av.lane(55);
1675 r[i+56]=av.lane(56);
1676 r[i+57]=av.lane(57);
1677 r[i+58]=av.lane(58);
1678 r[i+59]=av.lane(59);
1679 r[i+60]=av.lane(60);
1680 r[i+61]=av.lane(61);
1681 r[i+62]=av.lane(62);
1682 r[i+63]=av.lane(63);
1683 } else {
1684 for (int j = 0; j < SPECIES.length(); j++) {
1685 r[i+j]=av.lane(j);
1686 }
1687 }
1688 }
1689 }
1690
1691 assertArraysEquals(a, r, Int128VectorTests::get);
1692 }
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715 static int neg(int a) {
1716 return (int)(-((int)a));
1717 }
1718
1719 @Test(dataProvider = "intUnaryOpProvider")
1720 static void negInt128VectorTests(IntFunction<int[]> fa) {
1721 int[] a = fa.apply(SPECIES.length());
1722 int[] r = fr.apply(SPECIES.length());
1723
1724 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1725 for (int i = 0; i < a.length; i += SPECIES.length()) {
1726 IntVector av = IntVector.fromArray(SPECIES, a, i);
1727 av.neg().intoArray(r, i);
1728 }
1729 }
1730
1731 assertArraysEquals(a, r, Int128VectorTests::neg);
1732 }
1733
1734 @Test(dataProvider = "intUnaryOpMaskProvider")
1735 static void negMaskedInt128VectorTests(IntFunction<int[]> fa,
1736 IntFunction<boolean[]> fm) {
1737 int[] a = fa.apply(SPECIES.length());
1738 int[] r = fr.apply(SPECIES.length());
1739 boolean[] mask = fm.apply(SPECIES.length());
1740 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1741
1742 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1743 for (int i = 0; i < a.length; i += SPECIES.length()) {
1744 IntVector av = IntVector.fromArray(SPECIES, a, i);
1745 av.neg(vmask).intoArray(r, i);
1746 }
1747 }
1748
1749 assertArraysEquals(a, r, mask, Int128VectorTests::neg);
1750 }
1751
1752 static int abs(int a) {
1753 return (int)(Math.abs((int)a));
1754 }
1755
1756 @Test(dataProvider = "intUnaryOpProvider")
1757 static void absInt128VectorTests(IntFunction<int[]> fa) {
1758 int[] a = fa.apply(SPECIES.length());
1759 int[] r = fr.apply(SPECIES.length());
1760
1761 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1762 for (int i = 0; i < a.length; i += SPECIES.length()) {
1763 IntVector av = IntVector.fromArray(SPECIES, a, i);
1764 av.abs().intoArray(r, i);
1765 }
1766 }
1767
1768 assertArraysEquals(a, r, Int128VectorTests::abs);
1769 }
1770
1771 @Test(dataProvider = "intUnaryOpMaskProvider")
1772 static void absMaskedInt128VectorTests(IntFunction<int[]> fa,
1773 IntFunction<boolean[]> fm) {
1774 int[] a = fa.apply(SPECIES.length());
1775 int[] r = fr.apply(SPECIES.length());
1776 boolean[] mask = fm.apply(SPECIES.length());
1777 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1778
1779 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1780 for (int i = 0; i < a.length; i += SPECIES.length()) {
1781 IntVector av = IntVector.fromArray(SPECIES, a, i);
1782 av.abs(vmask).intoArray(r, i);
1783 }
1784 }
1785
1786 assertArraysEquals(a, r, mask, Int128VectorTests::abs);
1787 }
1788
1789
1790 static int not(int a) {
1791 return (int)(~((int)a));
1792 }
1793
1794
1795
1796 @Test(dataProvider = "intUnaryOpProvider")
1797 static void notInt128VectorTests(IntFunction<int[]> fa) {
1798 int[] a = fa.apply(SPECIES.length());
1799 int[] r = fr.apply(SPECIES.length());
1800
1801 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1802 for (int i = 0; i < a.length; i += SPECIES.length()) {
1803 IntVector av = IntVector.fromArray(SPECIES, a, i);
1804 av.not().intoArray(r, i);
1805 }
1806 }
1807
1808 assertArraysEquals(a, r, Int128VectorTests::not);
1809 }
1810
1811
1812
1813 @Test(dataProvider = "intUnaryOpMaskProvider")
1814 static void notMaskedInt128VectorTests(IntFunction<int[]> fa,
1815 IntFunction<boolean[]> fm) {
1816 int[] a = fa.apply(SPECIES.length());
1817 int[] r = fr.apply(SPECIES.length());
1818 boolean[] mask = fm.apply(SPECIES.length());
1819 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1820
1821 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1822 for (int i = 0; i < a.length; i += SPECIES.length()) {
1823 IntVector av = IntVector.fromArray(SPECIES, a, i);
1824 av.not(vmask).intoArray(r, i);
1825 }
1826 }
1827
1828 assertArraysEquals(a, r, mask, Int128VectorTests::not);
1829 }
1830
1831
1832
1833
1834
1835 static int[] gather(int a[], int ix, int[] b, int iy) {
1836 int[] res = new int[SPECIES.length()];
1837 for (int i = 0; i < SPECIES.length(); i++) {
1838 int bi = iy + i;
1839 res[i] = a[b[bi] + ix];
1840 }
1841 return res;
1842 }
1843
1844 @Test(dataProvider = "intUnaryOpIndexProvider")
1845 static void gatherInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1846 int[] a = fa.apply(SPECIES.length());
1847 int[] b = fs.apply(a.length, SPECIES.length());
1848 int[] r = new int[a.length];
1849
1850 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1851 for (int i = 0; i < a.length; i += SPECIES.length()) {
1852 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i);
1853 av.intoArray(r, i);
1854 }
1855 }
1856
1857 assertArraysEquals(a, b, r, Int128VectorTests::gather);
1858 }
1859
1860
1861 static int[] scatter(int a[], int ix, int[] b, int iy) {
1862 int[] res = new int[SPECIES.length()];
1863 for (int i = 0; i < SPECIES.length(); i++) {
1864 int bi = iy + i;
1865 res[b[bi]] = a[i + ix];
1866 }
1867 return res;
1868 }
1869
1870 @Test(dataProvider = "intUnaryOpIndexProvider")
1871 static void scatterInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1872 int[] a = fa.apply(SPECIES.length());
1873 int[] b = fs.apply(a.length, SPECIES.length());
1874 int[] r = new int[a.length];
1875
1876 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1877 for (int i = 0; i < a.length; i += SPECIES.length()) {
1878 IntVector av = IntVector.fromArray(SPECIES, a, i);
1879 av.intoArray(r, i, b, i);
1880 }
1881 }
1882
1883 assertArraysEquals(a, b, r, Int128VectorTests::scatter);
1884 }
1885
1886 }
1887