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 Int256VectorTests
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 Int256VectorTests extends AbstractVectorTest {
52
53 static final VectorSpecies<Integer> SPECIES =
54 IntVector.SPECIES_256;
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 addInt256VectorTests(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, Int256VectorTests::add);
449 }
450
451 @Test(dataProvider = "intBinaryOpMaskProvider")
452 static void addInt256VectorTests(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, Int256VectorTests::add);
469 }
470 static int sub(int a, int b) {
471 return (int)(a - b);
472 }
473
474 @Test(dataProvider = "intBinaryOpProvider")
475 static void subInt256VectorTests(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, Int256VectorTests::sub);
489 }
490
491 @Test(dataProvider = "intBinaryOpMaskProvider")
492 static void subInt256VectorTests(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, Int256VectorTests::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 mulInt256VectorTests(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, Int256VectorTests::mul);
531 }
532
533 @Test(dataProvider = "intBinaryOpMaskProvider")
534 static void mulInt256VectorTests(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, Int256VectorTests::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 andInt256VectorTests(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, Int256VectorTests::and);
572 }
573
574
575
576 @Test(dataProvider = "intBinaryOpMaskProvider")
577 static void andInt256VectorTests(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, Int256VectorTests::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 orInt256VectorTests(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, Int256VectorTests::or);
616 }
617
618
619
620 @Test(dataProvider = "intBinaryOpMaskProvider")
621 static void orInt256VectorTests(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, Int256VectorTests::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 xorInt256VectorTests(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, Int256VectorTests::xor);
660 }
661
662
663
664 @Test(dataProvider = "intBinaryOpMaskProvider")
665 static void xorInt256VectorTests(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, Int256VectorTests::xor);
682 }
683
684
685 static int shiftLeft(int a, int b) {
686 return (int)((a << b));
687 }
688
689 @Test(dataProvider = "intBinaryOpProvider")
690 static void shiftLeftInt256VectorTests(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.shiftLeft(bv).intoArray(r, i);
700 }
701 }
702
703 assertArraysEquals(a, b, r, Int256VectorTests::shiftLeft);
704 }
705
706
707
708 @Test(dataProvider = "intBinaryOpMaskProvider")
709 static void shiftLeftInt256VectorTests(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.shiftLeft(bv, vmask).intoArray(r, i);
722 }
723 }
724
725 assertArraysEquals(a, b, r, mask, Int256VectorTests::shiftLeft);
726 }
727
728
729
730
731
732
733 static int shiftRight(int a, int b) {
734 return (int)((a >>> b));
735 }
736
737 @Test(dataProvider = "intBinaryOpProvider")
738 static void shiftRightInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
739 int[] a = fa.apply(SPECIES.length());
740 int[] b = fb.apply(SPECIES.length());
741 int[] r = fr.apply(SPECIES.length());
742
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.shiftRight(bv).intoArray(r, i);
748 }
749 }
750
751 assertArraysEquals(a, b, r, Int256VectorTests::shiftRight);
752 }
753
754
755
756 @Test(dataProvider = "intBinaryOpMaskProvider")
757 static void shiftRightInt256VectorTests(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.shiftRight(bv, vmask).intoArray(r, i);
770 }
771 }
772
773 assertArraysEquals(a, b, r, mask, Int256VectorTests::shiftRight);
774 }
775
776
777
778
779
780
781 static int shiftArithmeticRight(int a, int b) {
782 return (int)((a >> b));
783 }
784
785 @Test(dataProvider = "intBinaryOpProvider")
786 static void shiftArithmeticRightInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
787 int[] a = fa.apply(SPECIES.length());
788 int[] b = fb.apply(SPECIES.length());
789 int[] r = fr.apply(SPECIES.length());
790
791 for (int ic = 0; ic < INVOC_COUNT; ic++) {
792 for (int i = 0; i < a.length; i += SPECIES.length()) {
793 IntVector av = IntVector.fromArray(SPECIES, a, i);
794 IntVector bv = IntVector.fromArray(SPECIES, b, i);
795 av.shiftArithmeticRight(bv).intoArray(r, i);
796 }
797 }
798
799 assertArraysEquals(a, b, r, Int256VectorTests::shiftArithmeticRight);
800 }
801
802
803
804 @Test(dataProvider = "intBinaryOpMaskProvider")
805 static void shiftArithmeticRightInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
806 IntFunction<boolean[]> fm) {
807 int[] a = fa.apply(SPECIES.length());
808 int[] b = fb.apply(SPECIES.length());
809 int[] r = fr.apply(SPECIES.length());
810 boolean[] mask = fm.apply(SPECIES.length());
811 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
812
813 for (int ic = 0; ic < INVOC_COUNT; ic++) {
814 for (int i = 0; i < a.length; i += SPECIES.length()) {
815 IntVector av = IntVector.fromArray(SPECIES, a, i);
816 IntVector bv = IntVector.fromArray(SPECIES, b, i);
817 av.shiftArithmeticRight(bv, vmask).intoArray(r, i);
818 }
819 }
820
821 assertArraysEquals(a, b, r, mask, Int256VectorTests::shiftArithmeticRight);
822 }
823
824
825
826
827
828
829 static int shiftLeft_unary(int a, int b) {
830 return (int)((a << b));
831 }
832
833 @Test(dataProvider = "intBinaryOpProvider")
834 static void shiftLeftInt256VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
835 int[] a = fa.apply(SPECIES.length());
836 int[] b = fb.apply(SPECIES.length());
837 int[] r = fr.apply(SPECIES.length());
838
839 for (int ic = 0; ic < INVOC_COUNT; ic++) {
840 for (int i = 0; i < a.length; i += SPECIES.length()) {
841 IntVector av = IntVector.fromArray(SPECIES, a, i);
842 av.shiftLeft((int)b[i]).intoArray(r, i);
843 }
844 }
845
846 assertShiftArraysEquals(a, b, r, Int256VectorTests::shiftLeft_unary);
847 }
848
849
850
851 @Test(dataProvider = "intBinaryOpMaskProvider")
852 static void shiftLeftInt256VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
853 IntFunction<boolean[]> fm) {
854 int[] a = fa.apply(SPECIES.length());
855 int[] b = fb.apply(SPECIES.length());
856 int[] r = fr.apply(SPECIES.length());
857 boolean[] mask = fm.apply(SPECIES.length());
858 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
859
860 for (int ic = 0; ic < INVOC_COUNT; ic++) {
861 for (int i = 0; i < a.length; i += SPECIES.length()) {
862 IntVector av = IntVector.fromArray(SPECIES, a, i);
863 av.shiftLeft((int)b[i], vmask).intoArray(r, i);
864 }
865 }
866
867 assertShiftArraysEquals(a, b, r, mask, Int256VectorTests::shiftLeft_unary);
868 }
869
870
871
872
873
874
875 static int shiftRight_unary(int a, int b) {
876 return (int)((a >>> b));
877 }
878
879 @Test(dataProvider = "intBinaryOpProvider")
880 static void shiftRightInt256VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
881 int[] a = fa.apply(SPECIES.length());
882 int[] b = fb.apply(SPECIES.length());
883 int[] r = fr.apply(SPECIES.length());
884
885 for (int ic = 0; ic < INVOC_COUNT; ic++) {
886 for (int i = 0; i < a.length; i += SPECIES.length()) {
887 IntVector av = IntVector.fromArray(SPECIES, a, i);
888 av.shiftRight((int)b[i]).intoArray(r, i);
889 }
890 }
891
892 assertShiftArraysEquals(a, b, r, Int256VectorTests::shiftRight_unary);
893 }
894
895
896
897 @Test(dataProvider = "intBinaryOpMaskProvider")
898 static void shiftRightInt256VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
899 IntFunction<boolean[]> fm) {
900 int[] a = fa.apply(SPECIES.length());
901 int[] b = fb.apply(SPECIES.length());
902 int[] r = fr.apply(SPECIES.length());
903 boolean[] mask = fm.apply(SPECIES.length());
904 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
905
906 for (int ic = 0; ic < INVOC_COUNT; ic++) {
907 for (int i = 0; i < a.length; i += SPECIES.length()) {
908 IntVector av = IntVector.fromArray(SPECIES, a, i);
909 av.shiftRight((int)b[i], vmask).intoArray(r, i);
910 }
911 }
912
913 assertShiftArraysEquals(a, b, r, mask, Int256VectorTests::shiftRight_unary);
914 }
915
916
917
918
919
920
921 static int shiftArithmeticRight_unary(int a, int b) {
922 return (int)((a >> b));
923 }
924
925 @Test(dataProvider = "intBinaryOpProvider")
926 static void shiftArithmeticRightInt256VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
927 int[] a = fa.apply(SPECIES.length());
928 int[] b = fb.apply(SPECIES.length());
929 int[] r = fr.apply(SPECIES.length());
930
931 for (int ic = 0; ic < INVOC_COUNT; ic++) {
932 for (int i = 0; i < a.length; i += SPECIES.length()) {
933 IntVector av = IntVector.fromArray(SPECIES, a, i);
934 av.shiftArithmeticRight((int)b[i]).intoArray(r, i);
935 }
936 }
937
938 assertShiftArraysEquals(a, b, r, Int256VectorTests::shiftArithmeticRight_unary);
939 }
940
941
942
943 @Test(dataProvider = "intBinaryOpMaskProvider")
944 static void shiftArithmeticRightInt256VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
945 IntFunction<boolean[]> fm) {
946 int[] a = fa.apply(SPECIES.length());
947 int[] b = fb.apply(SPECIES.length());
948 int[] r = fr.apply(SPECIES.length());
949 boolean[] mask = fm.apply(SPECIES.length());
950 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
951
952 for (int ic = 0; ic < INVOC_COUNT; ic++) {
953 for (int i = 0; i < a.length; i += SPECIES.length()) {
954 IntVector av = IntVector.fromArray(SPECIES, a, i);
955 av.shiftArithmeticRight((int)b[i], vmask).intoArray(r, i);
956 }
957 }
958
959 assertShiftArraysEquals(a, b, r, mask, Int256VectorTests::shiftArithmeticRight_unary);
960 }
961
962
963
964
965
966 static int max(int a, int b) {
967 return (int)(Math.max(a, b));
968 }
969
970 @Test(dataProvider = "intBinaryOpProvider")
971 static void maxInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
972 int[] a = fa.apply(SPECIES.length());
973 int[] b = fb.apply(SPECIES.length());
974 int[] r = fr.apply(SPECIES.length());
975
976 for (int ic = 0; ic < INVOC_COUNT; ic++) {
977 for (int i = 0; i < a.length; i += SPECIES.length()) {
978 IntVector av = IntVector.fromArray(SPECIES, a, i);
979 IntVector bv = IntVector.fromArray(SPECIES, b, i);
980 av.max(bv).intoArray(r, i);
981 }
982 }
983
984 assertArraysEquals(a, b, r, Int256VectorTests::max);
985 }
986 static int min(int a, int b) {
987 return (int)(Math.min(a, b));
988 }
989
990 @Test(dataProvider = "intBinaryOpProvider")
991 static void minInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
992 int[] a = fa.apply(SPECIES.length());
993 int[] b = fb.apply(SPECIES.length());
994 int[] r = fr.apply(SPECIES.length());
995
996 for (int ic = 0; ic < INVOC_COUNT; ic++) {
997 for (int i = 0; i < a.length; i += SPECIES.length()) {
998 IntVector av = IntVector.fromArray(SPECIES, a, i);
999 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1000 av.min(bv).intoArray(r, i);
1001 }
1002 }
1003
1004 assertArraysEquals(a, b, r, Int256VectorTests::min);
1005 }
1006
1007 static int andLanes(int[] a, int idx) {
1008 int res = -1;
1009 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1010 res &= a[i];
1011 }
1012
1013 return res;
1014 }
1015
1016 static int andLanes(int[] a) {
1017 int res = -1;
1018 for (int i = 0; i < a.length; i += SPECIES.length()) {
1019 int tmp = -1;
1020 for (int j = 0; j < SPECIES.length(); j++) {
1021 tmp &= a[i + j];
1022 }
1023 res &= tmp;
1024 }
1025
1026 return res;
1027 }
1028
1029
1030 @Test(dataProvider = "intUnaryOpProvider")
1031 static void andLanesInt256VectorTests(IntFunction<int[]> fa) {
1032 int[] a = fa.apply(SPECIES.length());
1033 int[] r = fr.apply(SPECIES.length());
1034 int ra = -1;
1035
1036 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1037 for (int i = 0; i < a.length; i += SPECIES.length()) {
1038 IntVector av = IntVector.fromArray(SPECIES, a, i);
1039 r[i] = av.andLanes();
1040 }
1041 }
1042
1043 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1044 ra = -1;
1045 for (int i = 0; i < a.length; i += SPECIES.length()) {
1046 IntVector av = IntVector.fromArray(SPECIES, a, i);
1047 ra &= av.andLanes();
1048 }
1049 }
1050
1051 assertReductionArraysEquals(a, r, ra, Int256VectorTests::andLanes, Int256VectorTests::andLanes);
1052 }
1053
1054
1055 static int orLanes(int[] a, int idx) {
1056 int res = 0;
1057 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1058 res |= a[i];
1059 }
1060
1061 return res;
1062 }
1063
1064 static int orLanes(int[] a) {
1065 int res = 0;
1066 for (int i = 0; i < a.length; i += SPECIES.length()) {
1067 int tmp = 0;
1068 for (int j = 0; j < SPECIES.length(); j++) {
1069 tmp |= a[i + j];
1070 }
1071 res |= tmp;
1072 }
1073
1074 return res;
1075 }
1076
1077
1078 @Test(dataProvider = "intUnaryOpProvider")
1079 static void orLanesInt256VectorTests(IntFunction<int[]> fa) {
1080 int[] a = fa.apply(SPECIES.length());
1081 int[] r = fr.apply(SPECIES.length());
1082 int ra = 0;
1083
1084 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1085 for (int i = 0; i < a.length; i += SPECIES.length()) {
1086 IntVector av = IntVector.fromArray(SPECIES, a, i);
1087 r[i] = av.orLanes();
1088 }
1089 }
1090
1091 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1092 ra = 0;
1093 for (int i = 0; i < a.length; i += SPECIES.length()) {
1094 IntVector av = IntVector.fromArray(SPECIES, a, i);
1095 ra |= av.orLanes();
1096 }
1097 }
1098
1099 assertReductionArraysEquals(a, r, ra, Int256VectorTests::orLanes, Int256VectorTests::orLanes);
1100 }
1101
1102
1103 static int xorLanes(int[] a, int idx) {
1104 int res = 0;
1105 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1106 res ^= a[i];
1107 }
1108
1109 return res;
1110 }
1111
1112 static int xorLanes(int[] a) {
1113 int res = 0;
1114 for (int i = 0; i < a.length; i += SPECIES.length()) {
1115 int tmp = 0;
1116 for (int j = 0; j < SPECIES.length(); j++) {
1117 tmp ^= a[i + j];
1118 }
1119 res ^= tmp;
1120 }
1121
1122 return res;
1123 }
1124
1125
1126 @Test(dataProvider = "intUnaryOpProvider")
1127 static void xorLanesInt256VectorTests(IntFunction<int[]> fa) {
1128 int[] a = fa.apply(SPECIES.length());
1129 int[] r = fr.apply(SPECIES.length());
1130 int ra = 0;
1131
1132 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1133 for (int i = 0; i < a.length; i += SPECIES.length()) {
1134 IntVector av = IntVector.fromArray(SPECIES, a, i);
1135 r[i] = av.xorLanes();
1136 }
1137 }
1138
1139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1140 ra = 0;
1141 for (int i = 0; i < a.length; i += SPECIES.length()) {
1142 IntVector av = IntVector.fromArray(SPECIES, a, i);
1143 ra ^= av.xorLanes();
1144 }
1145 }
1146
1147 assertReductionArraysEquals(a, r, ra, Int256VectorTests::xorLanes, Int256VectorTests::xorLanes);
1148 }
1149
1150 static int addLanes(int[] a, int idx) {
1151 int res = 0;
1152 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1153 res += a[i];
1154 }
1155
1156 return res;
1157 }
1158
1159 static int addLanes(int[] a) {
1160 int res = 0;
1161 for (int i = 0; i < a.length; i += SPECIES.length()) {
1162 int tmp = 0;
1163 for (int j = 0; j < SPECIES.length(); j++) {
1164 tmp += a[i + j];
1165 }
1166 res += tmp;
1167 }
1168
1169 return res;
1170 }
1171 @Test(dataProvider = "intUnaryOpProvider")
1172 static void addLanesInt256VectorTests(IntFunction<int[]> fa) {
1173 int[] a = fa.apply(SPECIES.length());
1174 int[] r = fr.apply(SPECIES.length());
1175 int ra = 0;
1176
1177 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1178 for (int i = 0; i < a.length; i += SPECIES.length()) {
1179 IntVector av = IntVector.fromArray(SPECIES, a, i);
1180 r[i] = av.addLanes();
1181 }
1182 }
1183
1184 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1185 ra = 0;
1186 for (int i = 0; i < a.length; i += SPECIES.length()) {
1187 IntVector av = IntVector.fromArray(SPECIES, a, i);
1188 ra += av.addLanes();
1189 }
1190 }
1191
1192 assertReductionArraysEquals(a, r, ra, Int256VectorTests::addLanes, Int256VectorTests::addLanes);
1193 }
1194 static int mulLanes(int[] a, int idx) {
1195 int res = 1;
1196 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1197 res *= a[i];
1198 }
1199
1200 return res;
1201 }
1202
1203 static int mulLanes(int[] a) {
1204 int res = 1;
1205 for (int i = 0; i < a.length; i += SPECIES.length()) {
1206 int tmp = 1;
1207 for (int j = 0; j < SPECIES.length(); j++) {
1208 tmp *= a[i + j];
1209 }
1210 res *= tmp;
1211 }
1212
1213 return res;
1214 }
1215 @Test(dataProvider = "intUnaryOpProvider")
1216 static void mulLanesInt256VectorTests(IntFunction<int[]> fa) {
1217 int[] a = fa.apply(SPECIES.length());
1218 int[] r = fr.apply(SPECIES.length());
1219 int ra = 1;
1220
1221 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1222 for (int i = 0; i < a.length; i += SPECIES.length()) {
1223 IntVector av = IntVector.fromArray(SPECIES, a, i);
1224 r[i] = av.mulLanes();
1225 }
1226 }
1227
1228 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1229 ra = 1;
1230 for (int i = 0; i < a.length; i += SPECIES.length()) {
1231 IntVector av = IntVector.fromArray(SPECIES, a, i);
1232 ra *= av.mulLanes();
1233 }
1234 }
1235
1236 assertReductionArraysEquals(a, r, ra, Int256VectorTests::mulLanes, Int256VectorTests::mulLanes);
1237 }
1238 static int minLanes(int[] a, int idx) {
1239 int res = Integer.MAX_VALUE;
1240 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1241 res = (int)Math.min(res, a[i]);
1242 }
1243
1244 return res;
1245 }
1246
1247 static int minLanes(int[] a) {
1248 int res = Integer.MAX_VALUE;
1249 for (int i = 0; i < a.length; i++) {
1250 res = (int)Math.min(res, a[i]);
1251 }
1252
1253 return res;
1254 }
1255 @Test(dataProvider = "intUnaryOpProvider")
1256 static void minLanesInt256VectorTests(IntFunction<int[]> fa) {
1257 int[] a = fa.apply(SPECIES.length());
1258 int[] r = fr.apply(SPECIES.length());
1259 int ra = Integer.MAX_VALUE;
1260
1261 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1262 for (int i = 0; i < a.length; i += SPECIES.length()) {
1263 IntVector av = IntVector.fromArray(SPECIES, a, i);
1264 r[i] = av.minLanes();
1265 }
1266 }
1267
1268 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1269 ra = Integer.MAX_VALUE;
1270 for (int i = 0; i < a.length; i += SPECIES.length()) {
1271 IntVector av = IntVector.fromArray(SPECIES, a, i);
1272 ra = (int)Math.min(ra, av.minLanes());
1273 }
1274 }
1275
1276 assertReductionArraysEquals(a, r, ra, Int256VectorTests::minLanes, Int256VectorTests::minLanes);
1277 }
1278 static int maxLanes(int[] a, int idx) {
1279 int res = Integer.MIN_VALUE;
1280 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1281 res = (int)Math.max(res, a[i]);
1282 }
1283
1284 return res;
1285 }
1286
1287 static int maxLanes(int[] a) {
1288 int res = Integer.MIN_VALUE;
1289 for (int i = 0; i < a.length; i++) {
1290 res = (int)Math.max(res, a[i]);
1291 }
1292
1293 return res;
1294 }
1295 @Test(dataProvider = "intUnaryOpProvider")
1296 static void maxLanesInt256VectorTests(IntFunction<int[]> fa) {
1297 int[] a = fa.apply(SPECIES.length());
1298 int[] r = fr.apply(SPECIES.length());
1299 int ra = Integer.MIN_VALUE;
1300
1301 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1302 for (int i = 0; i < a.length; i += SPECIES.length()) {
1303 IntVector av = IntVector.fromArray(SPECIES, a, i);
1304 r[i] = av.maxLanes();
1305 }
1306 }
1307
1308 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1309 ra = Integer.MIN_VALUE;
1310 for (int i = 0; i < a.length; i += SPECIES.length()) {
1311 IntVector av = IntVector.fromArray(SPECIES, a, i);
1312 ra = (int)Math.max(ra, av.maxLanes());
1313 }
1314 }
1315
1316 assertReductionArraysEquals(a, r, ra, Int256VectorTests::maxLanes, Int256VectorTests::maxLanes);
1317 }
1318
1319 static boolean anyTrue(boolean[] a, int idx) {
1320 boolean res = false;
1321 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1322 res |= a[i];
1323 }
1324
1325 return res;
1326 }
1327
1328
1329 @Test(dataProvider = "boolUnaryOpProvider")
1330 static void anyTrueInt256VectorTests(IntFunction<boolean[]> fm) {
1331 boolean[] mask = fm.apply(SPECIES.length());
1332 boolean[] r = fmr.apply(SPECIES.length());
1333
1334 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1335 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1336 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
1337 r[i] = vmask.anyTrue();
1338 }
1339 }
1340
1341 assertReductionBoolArraysEquals(mask, r, Int256VectorTests::anyTrue);
1342 }
1343
1344
1345 static boolean allTrue(boolean[] a, int idx) {
1346 boolean res = true;
1347 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1348 res &= a[i];
1349 }
1350
1351 return res;
1352 }
1353
1354
1355 @Test(dataProvider = "boolUnaryOpProvider")
1356 static void allTrueInt256VectorTests(IntFunction<boolean[]> fm) {
1357 boolean[] mask = fm.apply(SPECIES.length());
1358 boolean[] r = fmr.apply(SPECIES.length());
1359
1360 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1361 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1362 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
1363 r[i] = vmask.allTrue();
1364 }
1365 }
1366
1367 assertReductionBoolArraysEquals(mask, r, Int256VectorTests::allTrue);
1368 }
1369
1370
1371 @Test(dataProvider = "intUnaryOpProvider")
1372 static void withInt256VectorTests(IntFunction<int []> fa) {
1373 int[] a = fa.apply(SPECIES.length());
1374 int[] r = fr.apply(SPECIES.length());
1375
1376 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1377 for (int i = 0; i < a.length; i += SPECIES.length()) {
1378 IntVector av = IntVector.fromArray(SPECIES, a, i);
1379 av.with(0, (int)4).intoArray(r, i);
1380 }
1381 }
1382
1383 assertInsertArraysEquals(a, r, (int)4, 0);
1384 }
1385
1386 @Test(dataProvider = "intCompareOpProvider")
1387 static void lessThanInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1388 int[] a = fa.apply(SPECIES.length());
1389 int[] b = fb.apply(SPECIES.length());
1390
1391 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1392 for (int i = 0; i < a.length; i += SPECIES.length()) {
1393 IntVector av = IntVector.fromArray(SPECIES, a, i);
1394 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1395 VectorMask<Integer> mv = av.lessThan(bv);
1396
1397 // Check results as part of computation.
1398 for (int j = 0; j < SPECIES.length(); j++) {
1399 Assert.assertEquals(mv.lane(j), a[i + j] < b[i + j]);
1400 }
1401 }
1402 }
1403 }
1404
1405
1406 @Test(dataProvider = "intCompareOpProvider")
1407 static void greaterThanInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1408 int[] a = fa.apply(SPECIES.length());
1409 int[] b = fb.apply(SPECIES.length());
1410
1411 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1412 for (int i = 0; i < a.length; i += SPECIES.length()) {
1413 IntVector av = IntVector.fromArray(SPECIES, a, i);
1414 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1415 VectorMask<Integer> mv = av.greaterThan(bv);
1416
1417 // Check results as part of computation.
1418 for (int j = 0; j < SPECIES.length(); j++) {
1419 Assert.assertEquals(mv.lane(j), a[i + j] > b[i + j]);
1420 }
1421 }
1422 }
1423 }
1424
1425
1426 @Test(dataProvider = "intCompareOpProvider")
1427 static void equalInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1428 int[] a = fa.apply(SPECIES.length());
1429 int[] b = fb.apply(SPECIES.length());
1430
1431 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1432 for (int i = 0; i < a.length; i += SPECIES.length()) {
1433 IntVector av = IntVector.fromArray(SPECIES, a, i);
1434 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1435 VectorMask<Integer> mv = av.equal(bv);
1436
1437 // Check results as part of computation.
1438 for (int j = 0; j < SPECIES.length(); j++) {
1439 Assert.assertEquals(mv.lane(j), a[i + j] == b[i + j]);
1440 }
1441 }
1442 }
1443 }
1444
1445
1446 @Test(dataProvider = "intCompareOpProvider")
1447 static void notEqualInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1448 int[] a = fa.apply(SPECIES.length());
1449 int[] b = fb.apply(SPECIES.length());
1450
1451 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1452 for (int i = 0; i < a.length; i += SPECIES.length()) {
1453 IntVector av = IntVector.fromArray(SPECIES, a, i);
1454 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1455 VectorMask<Integer> mv = av.notEqual(bv);
1456
1457 // Check results as part of computation.
1458 for (int j = 0; j < SPECIES.length(); j++) {
1459 Assert.assertEquals(mv.lane(j), a[i + j] != b[i + j]);
1460 }
1461 }
1462 }
1463 }
1464
1465
1466 @Test(dataProvider = "intCompareOpProvider")
1467 static void lessThanEqInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1468 int[] a = fa.apply(SPECIES.length());
1469 int[] b = fb.apply(SPECIES.length());
1470
1471 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1472 for (int i = 0; i < a.length; i += SPECIES.length()) {
1473 IntVector av = IntVector.fromArray(SPECIES, a, i);
1474 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1475 VectorMask<Integer> mv = av.lessThanEq(bv);
1476
1477 // Check results as part of computation.
1478 for (int j = 0; j < SPECIES.length(); j++) {
1479 Assert.assertEquals(mv.lane(j), a[i + j] <= b[i + j]);
1480 }
1481 }
1482 }
1483 }
1484
1485
1486 @Test(dataProvider = "intCompareOpProvider")
1487 static void greaterThanEqInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1488 int[] a = fa.apply(SPECIES.length());
1489 int[] b = fb.apply(SPECIES.length());
1490
1491 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1492 for (int i = 0; i < a.length; i += SPECIES.length()) {
1493 IntVector av = IntVector.fromArray(SPECIES, a, i);
1494 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1495 VectorMask<Integer> mv = av.greaterThanEq(bv);
1496
1497 // Check results as part of computation.
1498 for (int j = 0; j < SPECIES.length(); j++) {
1499 Assert.assertEquals(mv.lane(j), a[i + j] >= b[i + j]);
1500 }
1501 }
1502 }
1503 }
1504
1505
1506 static int blend(int a, int b, boolean mask) {
1507 return mask ? b : a;
1508 }
1509
1510 @Test(dataProvider = "intBinaryOpMaskProvider")
1511 static void blendInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
1512 IntFunction<boolean[]> fm) {
1513 int[] a = fa.apply(SPECIES.length());
1514 int[] b = fb.apply(SPECIES.length());
1515 int[] r = fr.apply(SPECIES.length());
1516 boolean[] mask = fm.apply(SPECIES.length());
1517 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1518
1519 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1520 for (int i = 0; i < a.length; i += SPECIES.length()) {
1521 IntVector av = IntVector.fromArray(SPECIES, a, i);
1522 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1523 av.blend(bv, vmask).intoArray(r, i);
1524 }
1525 }
1526
1527 assertArraysEquals(a, b, r, mask, Int256VectorTests::blend);
1528 }
1529
1530 @Test(dataProvider = "intUnaryOpShuffleProvider")
1531 static void RearrangeInt256VectorTests(IntFunction<int[]> fa,
1532 BiFunction<Integer,Integer,int[]> fs) {
1533 int[] a = fa.apply(SPECIES.length());
1534 int[] order = fs.apply(a.length, SPECIES.length());
1535 int[] r = fr.apply(SPECIES.length());
1536
1537 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1538 for (int i = 0; i < a.length; i += SPECIES.length()) {
1539 IntVector av = IntVector.fromArray(SPECIES, a, i);
1540 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
1541 }
1542 }
1543
1544 assertRearrangeArraysEquals(a, r, order, SPECIES.length());
1545 }
1546
1547
1548
1549
1550 @Test(dataProvider = "intUnaryOpProvider")
1551 static void getInt256VectorTests(IntFunction<int[]> fa) {
1552 int[] a = fa.apply(SPECIES.length());
1553 int[] r = fr.apply(SPECIES.length());
1554
1555 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1556 for (int i = 0; i < a.length; i += SPECIES.length()) {
1557 IntVector av = IntVector.fromArray(SPECIES, a, i);
1558 int num_lanes = SPECIES.length();
1559 // Manually unroll because full unroll happens after intrinsification.
1560 // Unroll is needed because get intrinsic requires for index to be a known constant.
1561 if (num_lanes == 1) {
1562 r[i]=av.lane(0);
1563 } else if (num_lanes == 2) {
1564 r[i]=av.lane(0);
1565 r[i+1]=av.lane(1);
1566 } else if (num_lanes == 4) {
1567 r[i]=av.lane(0);
1568 r[i+1]=av.lane(1);
1569 r[i+2]=av.lane(2);
1570 r[i+3]=av.lane(3);
1571 } else if (num_lanes == 8) {
1572 r[i]=av.lane(0);
1573 r[i+1]=av.lane(1);
1574 r[i+2]=av.lane(2);
1575 r[i+3]=av.lane(3);
1576 r[i+4]=av.lane(4);
1577 r[i+5]=av.lane(5);
1578 r[i+6]=av.lane(6);
1579 r[i+7]=av.lane(7);
1580 } else if (num_lanes == 16) {
1581 r[i]=av.lane(0);
1582 r[i+1]=av.lane(1);
1583 r[i+2]=av.lane(2);
1584 r[i+3]=av.lane(3);
1585 r[i+4]=av.lane(4);
1586 r[i+5]=av.lane(5);
1587 r[i+6]=av.lane(6);
1588 r[i+7]=av.lane(7);
1589 r[i+8]=av.lane(8);
1590 r[i+9]=av.lane(9);
1591 r[i+10]=av.lane(10);
1592 r[i+11]=av.lane(11);
1593 r[i+12]=av.lane(12);
1594 r[i+13]=av.lane(13);
1595 r[i+14]=av.lane(14);
1596 r[i+15]=av.lane(15);
1597 } else if (num_lanes == 32) {
1598 r[i]=av.lane(0);
1599 r[i+1]=av.lane(1);
1600 r[i+2]=av.lane(2);
1601 r[i+3]=av.lane(3);
1602 r[i+4]=av.lane(4);
1603 r[i+5]=av.lane(5);
1604 r[i+6]=av.lane(6);
1605 r[i+7]=av.lane(7);
1606 r[i+8]=av.lane(8);
1607 r[i+9]=av.lane(9);
1608 r[i+10]=av.lane(10);
1609 r[i+11]=av.lane(11);
1610 r[i+12]=av.lane(12);
1611 r[i+13]=av.lane(13);
1612 r[i+14]=av.lane(14);
1613 r[i+15]=av.lane(15);
1614 r[i+16]=av.lane(16);
1615 r[i+17]=av.lane(17);
1616 r[i+18]=av.lane(18);
1617 r[i+19]=av.lane(19);
1618 r[i+20]=av.lane(20);
1619 r[i+21]=av.lane(21);
1620 r[i+22]=av.lane(22);
1621 r[i+23]=av.lane(23);
1622 r[i+24]=av.lane(24);
1623 r[i+25]=av.lane(25);
1624 r[i+26]=av.lane(26);
1625 r[i+27]=av.lane(27);
1626 r[i+28]=av.lane(28);
1627 r[i+29]=av.lane(29);
1628 r[i+30]=av.lane(30);
1629 r[i+31]=av.lane(31);
1630 } else if (num_lanes == 64) {
1631 r[i]=av.lane(0);
1632 r[i+1]=av.lane(1);
1633 r[i+2]=av.lane(2);
1634 r[i+3]=av.lane(3);
1635 r[i+4]=av.lane(4);
1636 r[i+5]=av.lane(5);
1637 r[i+6]=av.lane(6);
1638 r[i+7]=av.lane(7);
1639 r[i+8]=av.lane(8);
1640 r[i+9]=av.lane(9);
1641 r[i+10]=av.lane(10);
1642 r[i+11]=av.lane(11);
1643 r[i+12]=av.lane(12);
1644 r[i+13]=av.lane(13);
1645 r[i+14]=av.lane(14);
1646 r[i+15]=av.lane(15);
1647 r[i+16]=av.lane(16);
1648 r[i+17]=av.lane(17);
1649 r[i+18]=av.lane(18);
1650 r[i+19]=av.lane(19);
1651 r[i+20]=av.lane(20);
1652 r[i+21]=av.lane(21);
1653 r[i+22]=av.lane(22);
1654 r[i+23]=av.lane(23);
1655 r[i+24]=av.lane(24);
1656 r[i+25]=av.lane(25);
1657 r[i+26]=av.lane(26);
1658 r[i+27]=av.lane(27);
1659 r[i+28]=av.lane(28);
1660 r[i+29]=av.lane(29);
1661 r[i+30]=av.lane(30);
1662 r[i+31]=av.lane(31);
1663 r[i+32]=av.lane(32);
1664 r[i+33]=av.lane(33);
1665 r[i+34]=av.lane(34);
1666 r[i+35]=av.lane(35);
1667 r[i+36]=av.lane(36);
1668 r[i+37]=av.lane(37);
1669 r[i+38]=av.lane(38);
1670 r[i+39]=av.lane(39);
1671 r[i+40]=av.lane(40);
1672 r[i+41]=av.lane(41);
1673 r[i+42]=av.lane(42);
1674 r[i+43]=av.lane(43);
1675 r[i+44]=av.lane(44);
1676 r[i+45]=av.lane(45);
1677 r[i+46]=av.lane(46);
1678 r[i+47]=av.lane(47);
1679 r[i+48]=av.lane(48);
1680 r[i+49]=av.lane(49);
1681 r[i+50]=av.lane(50);
1682 r[i+51]=av.lane(51);
1683 r[i+52]=av.lane(52);
1684 r[i+53]=av.lane(53);
1685 r[i+54]=av.lane(54);
1686 r[i+55]=av.lane(55);
1687 r[i+56]=av.lane(56);
1688 r[i+57]=av.lane(57);
1689 r[i+58]=av.lane(58);
1690 r[i+59]=av.lane(59);
1691 r[i+60]=av.lane(60);
1692 r[i+61]=av.lane(61);
1693 r[i+62]=av.lane(62);
1694 r[i+63]=av.lane(63);
1695 } else {
1696 for (int j = 0; j < SPECIES.length(); j++) {
1697 r[i+j]=av.lane(j);
1698 }
1699 }
1700 }
1701 }
1702
1703 assertArraysEquals(a, r, Int256VectorTests::get);
1704 }
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727 static int neg(int a) {
1728 return (int)(-((int)a));
1729 }
1730
1731 @Test(dataProvider = "intUnaryOpProvider")
1732 static void negInt256VectorTests(IntFunction<int[]> fa) {
1733 int[] a = fa.apply(SPECIES.length());
1734 int[] r = fr.apply(SPECIES.length());
1735
1736 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1737 for (int i = 0; i < a.length; i += SPECIES.length()) {
1738 IntVector av = IntVector.fromArray(SPECIES, a, i);
1739 av.neg().intoArray(r, i);
1740 }
1741 }
1742
1743 assertArraysEquals(a, r, Int256VectorTests::neg);
1744 }
1745
1746 @Test(dataProvider = "intUnaryOpMaskProvider")
1747 static void negMaskedInt256VectorTests(IntFunction<int[]> fa,
1748 IntFunction<boolean[]> fm) {
1749 int[] a = fa.apply(SPECIES.length());
1750 int[] r = fr.apply(SPECIES.length());
1751 boolean[] mask = fm.apply(SPECIES.length());
1752 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1753
1754 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1755 for (int i = 0; i < a.length; i += SPECIES.length()) {
1756 IntVector av = IntVector.fromArray(SPECIES, a, i);
1757 av.neg(vmask).intoArray(r, i);
1758 }
1759 }
1760
1761 assertArraysEquals(a, r, mask, Int256VectorTests::neg);
1762 }
1763
1764 static int abs(int a) {
1765 return (int)(Math.abs((int)a));
1766 }
1767
1768 @Test(dataProvider = "intUnaryOpProvider")
1769 static void absInt256VectorTests(IntFunction<int[]> fa) {
1770 int[] a = fa.apply(SPECIES.length());
1771 int[] r = fr.apply(SPECIES.length());
1772
1773 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1774 for (int i = 0; i < a.length; i += SPECIES.length()) {
1775 IntVector av = IntVector.fromArray(SPECIES, a, i);
1776 av.abs().intoArray(r, i);
1777 }
1778 }
1779
1780 assertArraysEquals(a, r, Int256VectorTests::abs);
1781 }
1782
1783 @Test(dataProvider = "intUnaryOpMaskProvider")
1784 static void absMaskedInt256VectorTests(IntFunction<int[]> fa,
1785 IntFunction<boolean[]> fm) {
1786 int[] a = fa.apply(SPECIES.length());
1787 int[] r = fr.apply(SPECIES.length());
1788 boolean[] mask = fm.apply(SPECIES.length());
1789 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1790
1791 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1792 for (int i = 0; i < a.length; i += SPECIES.length()) {
1793 IntVector av = IntVector.fromArray(SPECIES, a, i);
1794 av.abs(vmask).intoArray(r, i);
1795 }
1796 }
1797
1798 assertArraysEquals(a, r, mask, Int256VectorTests::abs);
1799 }
1800
1801
1802 static int not(int a) {
1803 return (int)(~((int)a));
1804 }
1805
1806
1807
1808 @Test(dataProvider = "intUnaryOpProvider")
1809 static void notInt256VectorTests(IntFunction<int[]> fa) {
1810 int[] a = fa.apply(SPECIES.length());
1811 int[] r = fr.apply(SPECIES.length());
1812
1813 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1814 for (int i = 0; i < a.length; i += SPECIES.length()) {
1815 IntVector av = IntVector.fromArray(SPECIES, a, i);
1816 av.not().intoArray(r, i);
1817 }
1818 }
1819
1820 assertArraysEquals(a, r, Int256VectorTests::not);
1821 }
1822
1823
1824
1825 @Test(dataProvider = "intUnaryOpMaskProvider")
1826 static void notMaskedInt256VectorTests(IntFunction<int[]> fa,
1827 IntFunction<boolean[]> fm) {
1828 int[] a = fa.apply(SPECIES.length());
1829 int[] r = fr.apply(SPECIES.length());
1830 boolean[] mask = fm.apply(SPECIES.length());
1831 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
1832
1833 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1834 for (int i = 0; i < a.length; i += SPECIES.length()) {
1835 IntVector av = IntVector.fromArray(SPECIES, a, i);
1836 av.not(vmask).intoArray(r, i);
1837 }
1838 }
1839
1840 assertArraysEquals(a, r, mask, Int256VectorTests::not);
1841 }
1842
1843
1844
1845
1846
1847 static int[] gather(int a[], int ix, int[] b, int iy) {
1848 int[] res = new int[SPECIES.length()];
1849 for (int i = 0; i < SPECIES.length(); i++) {
1850 int bi = iy + i;
1851 res[i] = a[b[bi] + ix];
1852 }
1853 return res;
1854 }
1855
1856 @Test(dataProvider = "intUnaryOpIndexProvider")
1857 static void gatherInt256VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1858 int[] a = fa.apply(SPECIES.length());
1859 int[] b = fs.apply(a.length, SPECIES.length());
1860 int[] r = new int[a.length];
1861
1862 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1863 for (int i = 0; i < a.length; i += SPECIES.length()) {
1864 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i);
1865 av.intoArray(r, i);
1866 }
1867 }
1868
1869 assertArraysEquals(a, b, r, Int256VectorTests::gather);
1870 }
1871
1872
1873 static int[] scatter(int a[], int ix, int[] b, int iy) {
1874 int[] res = new int[SPECIES.length()];
1875 for (int i = 0; i < SPECIES.length(); i++) {
1876 int bi = iy + i;
1877 res[b[bi]] = a[i + ix];
1878 }
1879 return res;
1880 }
1881
1882 @Test(dataProvider = "intUnaryOpIndexProvider")
1883 static void scatterInt256VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1884 int[] a = fa.apply(SPECIES.length());
1885 int[] b = fs.apply(a.length, SPECIES.length());
1886 int[] r = new int[a.length];
1887
1888 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1889 for (int i = 0; i < a.length; i += SPECIES.length()) {
1890 IntVector av = IntVector.fromArray(SPECIES, a, i);
1891 av.intoArray(r, i, b, i);
1892 }
1893 }
1894
1895 assertArraysEquals(a, b, r, Int256VectorTests::scatter);
1896 }
1897
1898 }
1899