1 /*
2 * Copyright (c) 2018, 2020, 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 any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @modules jdk.incubator.vector
27 * @run testng/othervm -ea -esa -Xbatch Int128VectorTests
28 */
29
30 // -- This file was mechanically generated: Do not edit! -- //
31
32 import jdk.incubator.vector.VectorShape;
33 import jdk.incubator.vector.VectorSpecies;
34 import jdk.incubator.vector.VectorShuffle;
35 import jdk.incubator.vector.VectorMask;
36 import jdk.incubator.vector.VectorOperators;
37 import jdk.incubator.vector.Vector;
38
39 import jdk.incubator.vector.IntVector;
40
41 import org.testng.Assert;
42 import org.testng.annotations.DataProvider;
43 import org.testng.annotations.Test;
44
45 import java.lang.Integer;
46 import java.util.List;
47 import java.util.Arrays;
48 import java.util.function.BiFunction;
49 import java.util.function.IntFunction;
50 import java.util.stream.Collectors;
51 import java.util.stream.Stream;
52
53 @Test
54 public class Int128VectorTests extends AbstractVectorTest {
55
56 static final VectorSpecies<Integer> SPECIES =
57 IntVector.SPECIES_128;
58
59 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
60
61
62 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128);
63
64 static final int BUFFER_SIZE = Integer.getInteger("jdk.incubator.vector.test.buffer-size", BUFFER_REPS * (128 / 8));
65
66 interface FUnOp {
67 int apply(int a);
68 }
69
70 static void assertArraysEquals(int[] a, int[] r, FUnOp f) {
71 int i = 0;
72 try {
73 for (; i < a.length; i++) {
74 Assert.assertEquals(r[i], f.apply(a[i]));
75 }
76 } catch (AssertionError e) {
77 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
78 }
79 }
80
81 interface FUnArrayOp {
82 int[] apply(int a);
83 }
84
85 static void assertArraysEquals(int[] a, int[] r, FUnArrayOp f) {
86 int i = 0;
87 try {
88 for (; i < a.length; i += SPECIES.length()) {
89 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
90 f.apply(a[i]));
91 }
92 } catch (AssertionError e) {
93 int[] ref = f.apply(a[i]);
94 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
95 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
96 + ", res: " + Arrays.toString(res)
97 + "), at index #" + i);
98 }
99 }
100
101 static void assertArraysEquals(int[] a, int[] r, boolean[] mask, FUnOp f) {
102 int i = 0;
103 try {
104 for (; i < a.length; i++) {
105 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
106 }
107 } catch (AssertionError e) {
108 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()]);
109 }
110 }
111
112 interface FReductionOp {
113 int apply(int[] a, int idx);
114 }
115
116 interface FReductionAllOp {
117 int apply(int[] a);
118 }
119
120 static void assertReductionArraysEquals(int[] a, int[] b, int c,
121 FReductionOp f, FReductionAllOp fa) {
122 int i = 0;
123 try {
124 Assert.assertEquals(c, fa.apply(a));
125 for (; i < a.length; i += SPECIES.length()) {
126 Assert.assertEquals(b[i], f.apply(a, i));
127 }
128 } catch (AssertionError e) {
129 Assert.assertEquals(c, fa.apply(a), "Final result is incorrect!");
130 Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
131 }
132 }
133
134 interface FReductionMaskedOp {
135 int apply(int[] a, int idx, boolean[] mask);
136 }
137
138 interface FReductionAllMaskedOp {
139 int apply(int[] a, boolean[] mask);
140 }
141
142 static void assertReductionArraysEqualsMasked(int[] a, int[] b, int c, boolean[] mask,
143 FReductionMaskedOp f, FReductionAllMaskedOp fa) {
144 int i = 0;
145 try {
146 Assert.assertEquals(c, fa.apply(a, mask));
147 for (; i < a.length; i += SPECIES.length()) {
148 Assert.assertEquals(b[i], f.apply(a, i, mask));
149 }
150 } catch (AssertionError e) {
151 Assert.assertEquals(c, fa.apply(a, mask), "Final result is incorrect!");
152 Assert.assertEquals(b[i], f.apply(a, i, mask), "at index #" + i);
153 }
154 }
155
156 interface FBoolReductionOp {
157 boolean apply(boolean[] a, int idx);
158 }
159
160 static void assertReductionBoolArraysEquals(boolean[] a, boolean[] b, FBoolReductionOp f) {
161 int i = 0;
162 try {
163 for (; i < a.length; i += SPECIES.length()) {
164 Assert.assertEquals(b[i], f.apply(a, i));
165 }
166 } catch (AssertionError e) {
167 Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
168 }
169 }
170
171 static void assertInsertArraysEquals(int[] a, int[] b, int element, int index) {
172 int i = 0;
173 try {
174 for (; i < a.length; i += 1) {
175 if(i%SPECIES.length() == index) {
176 Assert.assertEquals(b[i], element);
177 } else {
178 Assert.assertEquals(b[i], a[i]);
179 }
180 }
181 } catch (AssertionError e) {
182 if (i%SPECIES.length() == index) {
183 Assert.assertEquals(b[i], element, "at index #" + i);
184 } else {
185 Assert.assertEquals(b[i], a[i], "at index #" + i);
186 }
187 }
188 }
189
190 static void assertRearrangeArraysEquals(int[] a, int[] r, int[] order, int vector_len) {
191 int i = 0, j = 0;
192 try {
193 for (; i < a.length; i += vector_len) {
194 for (j = 0; j < vector_len; j++) {
195 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
196 }
197 }
198 } catch (AssertionError e) {
199 int idx = i + j;
200 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
201 }
202 }
203
204 static void assertBroadcastArraysEquals(int[]a, int[]r) {
205 int i = 0;
206 for (; i < a.length; i += SPECIES.length()) {
207 int idx = i;
208 for (int j = idx; j < (idx + SPECIES.length()); j++)
209 a[j]=a[idx];
210 }
211
212 try {
213 for (i = 0; i < a.length; i++) {
214 Assert.assertEquals(r[i], a[i]);
215 }
216 } catch (AssertionError e) {
217 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
218 }
219 }
220
221 interface FBinOp {
222 int apply(int a, int b);
223 }
224
225 interface FBinMaskOp {
226 int apply(int a, int b, boolean m);
227
228 static FBinMaskOp lift(FBinOp f) {
229 return (a, b, m) -> m ? f.apply(a, b) : a;
230 }
231 }
232
233 static void assertArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
234 int i = 0;
235 try {
236 for (; i < a.length; i++) {
237 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
238 }
239 } catch (AssertionError e) {
240 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
241 }
242 }
243
244 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
245 int i = 0;
246 try {
247 for (; i < a.length; i++) {
248 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
249 }
250 } catch (AssertionError e) {
251 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]), "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
252 }
253 }
254
255 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
256 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
257 }
258
259 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
260 int i = 0;
261 try {
262 for (; i < a.length; i++) {
263 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
264 }
265 } catch (AssertionError err) {
266 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()]);
267 }
268 }
269
270 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
271 assertBroadcastArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
272 }
273
274 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
275 int i = 0;
276 try {
277 for (; i < a.length; i++) {
278 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
279 }
280 } catch (AssertionError err) {
281 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + mask[i % SPECIES.length()]);
282 }
283 }
284
285 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
286 int i = 0;
287 int j = 0;
288 try {
289 for (; j < a.length; j += SPECIES.length()) {
290 for (i = 0; i < SPECIES.length(); i++) {
291 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
292 }
293 }
294 } catch (AssertionError e) {
295 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
296 }
297 }
298
299 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
300 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
301 }
302
303 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
304 int i = 0;
305 int j = 0;
306 try {
307 for (; j < a.length; j += SPECIES.length()) {
308 for (i = 0; i < SPECIES.length(); i++) {
309 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
310 }
311 }
312 } catch (AssertionError err) {
313 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]);
314 }
315 }
316
317 interface FTernOp {
318 int apply(int a, int b, int c);
319 }
320
321 interface FTernMaskOp {
322 int apply(int a, int b, int c, boolean m);
323
324 static FTernMaskOp lift(FTernOp f) {
325 return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
326 }
327 }
328
329 static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, FTernOp f) {
330 int i = 0;
331 try {
332 for (; i < a.length; i++) {
333 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
334 }
335 } catch (AssertionError e) {
336 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
337 }
338 }
339
340 static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, boolean[] mask, FTernOp f) {
341 assertArraysEquals(a, b, c, r, mask, FTernMaskOp.lift(f));
342 }
343
344 static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, boolean[] mask, FTernMaskOp f) {
345 int i = 0;
346 try {
347 for (; i < a.length; i++) {
348 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
349 }
350 } catch (AssertionError err) {
351 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
352 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
353 }
354 }
355
356
357 interface FBinArrayOp {
358 int apply(int[] a, int b);
359 }
360
361 static void assertArraysEquals(int[] a, int[] r, FBinArrayOp f) {
362 int i = 0;
363 try {
364 for (; i < a.length; i++) {
365 Assert.assertEquals(r[i], f.apply(a, i));
366 }
367 } catch (AssertionError e) {
368 Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
369 }
370 }
371
372 interface FGatherScatterOp {
373 int[] apply(int[] a, int ix, int[] b, int iy);
374 }
375
376 static void assertArraysEquals(int[] a, int[] b, int[] r, FGatherScatterOp f) {
377 int i = 0;
378 try {
379 for (; i < a.length; i += SPECIES.length()) {
380 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
381 f.apply(a, i, b, i));
382 }
383 } catch (AssertionError e) {
384 int[] ref = f.apply(a, i, b, i);
385 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
386 Assert.assertEquals(res, ref,
387 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
388 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
389 + ", b: "
390 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
391 + " at index #" + i);
392 }
393 }
394
395 interface FGatherMaskedOp {
396 int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
397 }
398
399 interface FScatterMaskedOp {
400 int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
401 }
402
403 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FGatherMaskedOp f) {
404 int i = 0;
405 try {
406 for (; i < a.length; i += SPECIES.length()) {
407 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
408 f.apply(a, i, mask, b, i));
409 }
410 } catch (AssertionError e) {
411 int[] ref = f.apply(a, i, mask, b, i);
412 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
413 Assert.assertEquals(ref, res,
414 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
415 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
416 + ", b: "
417 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
418 + ", mask: "
419 + Arrays.toString(mask)
420 + " at index #" + i);
421 }
422 }
423
424 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FScatterMaskedOp f) {
425 int i = 0;
426 try {
427 for (; i < a.length; i += SPECIES.length()) {
428 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
429 f.apply(r, a, i, mask, b, i));
430 }
431 } catch (AssertionError e) {
432 int[] ref = f.apply(r, a, i, mask, b, i);
433 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
434 Assert.assertEquals(ref, res,
435 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
436 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
437 + ", b: "
438 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
439 + ", r: "
440 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
441 + ", mask: "
442 + Arrays.toString(mask)
443 + " at index #" + i);
444 }
445 }
446
447 interface FLaneOp {
448 int[] apply(int[] a, int origin, int idx);
449 }
450
451 static void assertArraysEquals(int[] a, int[] r, int origin, FLaneOp f) {
452 int i = 0;
453 try {
454 for (; i < a.length; i += SPECIES.length()) {
455 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
456 f.apply(a, origin, i));
457 }
458 } catch (AssertionError e) {
459 int[] ref = f.apply(a, origin, i);
460 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
461 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
462 + ", res: " + Arrays.toString(res)
463 + "), at index #" + i);
464 }
465 }
466
467 interface FLaneBop {
468 int[] apply(int[] a, int[] b, int origin, int idx);
469 }
470
471 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, FLaneBop f) {
472 int i = 0;
473 try {
474 for (; i < a.length; i += SPECIES.length()) {
475 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
476 f.apply(a, b, origin, i));
477 }
478 } catch (AssertionError e) {
479 int[] ref = f.apply(a, b, origin, i);
480 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
481 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
482 + ", res: " + Arrays.toString(res)
483 + "), at index #" + i
484 + ", at origin #" + origin);
485 }
486 }
487
488 interface FLaneMaskedBop {
489 int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
490 }
491
492 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, boolean[] mask, FLaneMaskedBop f) {
493 int i = 0;
494 try {
495 for (; i < a.length; i += SPECIES.length()) {
496 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
497 f.apply(a, b, origin, mask, i));
498 }
499 } catch (AssertionError e) {
500 int[] ref = f.apply(a, b, origin, mask, i);
501 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
502 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
503 + ", res: " + Arrays.toString(res)
504 + "), at index #" + i
505 + ", at origin #" + origin);
506 }
507 }
508
509 interface FLanePartBop {
510 int[] apply(int[] a, int[] b, int origin, int part, int idx);
511 }
512
513 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, int part, FLanePartBop f) {
514 int i = 0;
515 try {
516 for (; i < a.length; i += SPECIES.length()) {
517 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
518 f.apply(a, b, origin, part, i));
519 }
520 } catch (AssertionError e) {
521 int[] ref = f.apply(a, b, origin, part, i);
522 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
523 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
524 + ", res: " + Arrays.toString(res)
525 + "), at index #" + i
526 + ", at origin #" + origin
527 + ", with part #" + part);
528 }
529 }
530
531 interface FLanePartMaskedBop {
532 int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
533 }
534
535 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
536 int i = 0;
537 try {
538 for (; i < a.length; i += SPECIES.length()) {
539 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
540 f.apply(a, b, origin, part, mask, i));
541 }
542 } catch (AssertionError e) {
543 int[] ref = f.apply(a, b, origin, part, mask, i);
544 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
545 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
546 + ", res: " + Arrays.toString(res)
547 + "), at index #" + i
548 + ", at origin #" + origin
549 + ", with part #" + part);
550 }
551 }
552
553 static int bits(int e) {
554 return e;
555 }
556
557 static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
558 withToString("int[-i * 5]", (int s) -> {
559 return fill(s * BUFFER_REPS,
560 i -> (int)(-i * 5));
561 }),
562 withToString("int[i * 5]", (int s) -> {
563 return fill(s * BUFFER_REPS,
564 i -> (int)(i * 5));
565 }),
566 withToString("int[i + 1]", (int s) -> {
567 return fill(s * BUFFER_REPS,
568 i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
569 }),
570 withToString("int[cornerCaseValue(i)]", (int s) -> {
571 return fill(s * BUFFER_REPS,
572 i -> cornerCaseValue(i));
573 })
574 );
575
576 // Create combinations of pairs
577 // @@@ Might be sensitive to order e.g. div by 0
578 static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
579 Stream.of(INT_GENERATORS.get(0)).
580 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
581 collect(Collectors.toList());
582
583 @DataProvider
584 public Object[][] boolUnaryOpProvider() {
585 return BOOL_ARRAY_GENERATORS.stream().
586 map(f -> new Object[]{f}).
587 toArray(Object[][]::new);
588 }
589
590 static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
591 INT_GENERATOR_PAIRS.stream().
592 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
593 collect(Collectors.toList());
594
595 @DataProvider
596 public Object[][] intBinaryOpProvider() {
597 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
598 toArray(Object[][]::new);
599 }
600
601 @DataProvider
602 public Object[][] intIndexedOpProvider() {
603 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
604 toArray(Object[][]::new);
605 }
606
607 @DataProvider
608 public Object[][] intBinaryOpMaskProvider() {
609 return BOOLEAN_MASK_GENERATORS.stream().
610 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
611 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
612 })).
613 toArray(Object[][]::new);
614 }
615
616 @DataProvider
617 public Object[][] intTernaryOpProvider() {
618 return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
619 toArray(Object[][]::new);
620 }
621
622 @DataProvider
623 public Object[][] intTernaryOpMaskProvider() {
624 return BOOLEAN_MASK_GENERATORS.stream().
625 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
626 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
627 })).
628 toArray(Object[][]::new);
629 }
630
631 @DataProvider
632 public Object[][] intUnaryOpProvider() {
633 return INT_GENERATORS.stream().
634 map(f -> new Object[]{f}).
635 toArray(Object[][]::new);
636 }
637
638 @DataProvider
639 public Object[][] intUnaryOpMaskProvider() {
640 return BOOLEAN_MASK_GENERATORS.stream().
641 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
642 return new Object[] {fa, fm};
643 })).
644 toArray(Object[][]::new);
645 }
646
647 @DataProvider
648 public Object[][] intUnaryOpShuffleProvider() {
649 return INT_SHUFFLE_GENERATORS.stream().
650 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
651 return new Object[] {fa, fs};
652 })).
653 toArray(Object[][]::new);
654 }
655
656 @DataProvider
657 public Object[][] intUnaryOpIndexProvider() {
658 return INT_INDEX_GENERATORS.stream().
659 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
660 return new Object[] {fa, fs};
661 })).
662 toArray(Object[][]::new);
663 }
664
665 @DataProvider
666 public Object[][] intUnaryMaskedOpIndexProvider() {
667 return BOOLEAN_MASK_GENERATORS.stream().
668 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
669 INT_GENERATORS.stream().map(fa -> {
670 return new Object[] {fa, fm, fs};
671 }))).
672 toArray(Object[][]::new);
673 }
674
675 @DataProvider
676 public Object[][] scatterMaskedOpIndexProvider() {
677 return BOOLEAN_MASK_GENERATORS.stream().
678 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
679 INT_GENERATORS.stream().flatMap(fn ->
680 INT_GENERATORS.stream().map(fa -> {
681 return new Object[] {fa, fn, fm, fs};
682 })))).
683 toArray(Object[][]::new);
684 }
685
686 static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
687 withToString("int[i]", (int s) -> {
688 return fill(s * BUFFER_REPS,
689 i -> (int)i);
690 }),
691 withToString("int[i + 1]", (int s) -> {
692 return fill(s * BUFFER_REPS,
693 i -> (int)(i + 1));
694 }),
695 withToString("int[i - 2]", (int s) -> {
696 return fill(s * BUFFER_REPS,
697 i -> (int)(i - 2));
698 }),
699 withToString("int[zigZag(i)]", (int s) -> {
700 return fill(s * BUFFER_REPS,
701 i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
702 }),
703 withToString("int[cornerCaseValue(i)]", (int s) -> {
704 return fill(s * BUFFER_REPS,
705 i -> cornerCaseValue(i));
706 })
707 );
708
709 static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
710 INT_COMPARE_GENERATORS.stream().
711 map(fa -> List.of(fa)).
712 collect(Collectors.toList());
713
714 @DataProvider
715 public Object[][] intTestOpProvider() {
716 return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
717 toArray(Object[][]::new);
718 }
719
720 static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
721 INT_COMPARE_GENERATORS.stream().
722 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
723 collect(Collectors.toList());
724
725 @DataProvider
726 public Object[][] intCompareOpProvider() {
727 return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
728 toArray(Object[][]::new);
729 }
730
731 interface ToIntF {
732 int apply(int i);
733 }
734
735 static int[] fill(int s , ToIntF f) {
736 return fill(new int[s], f);
737 }
738
739 static int[] fill(int[] a, ToIntF f) {
740 for (int i = 0; i < a.length; i++) {
741 a[i] = f.apply(i);
742 }
743 return a;
744 }
745
746 static int cornerCaseValue(int i) {
747 switch(i % 5) {
748 case 0:
749 return Integer.MAX_VALUE;
750 case 1:
751 return Integer.MIN_VALUE;
752 case 2:
753 return Integer.MIN_VALUE;
754 case 3:
755 return Integer.MAX_VALUE;
756 default:
757 return (int)0;
758 }
759 }
760 static int get(int[] a, int i) {
761 return (int) a[i];
762 }
763
764 static final IntFunction<int[]> fr = (vl) -> {
765 int length = BUFFER_REPS * vl;
766 return new int[length];
767 };
768
769 static final IntFunction<boolean[]> fmr = (vl) -> {
770 int length = BUFFER_REPS * vl;
771 return new boolean[length];
772 };
773
774 static void replaceZero(int[] a, int v) {
775 for (int i = 0; i < a.length; i++) {
776 if (a[i] == 0) {
777 a[i] = v;
778 }
779 }
780 }
781
782 static void replaceZero(int[] a, boolean[] mask, int v) {
783 for (int i = 0; i < a.length; i++) {
784 if (mask[i % mask.length] && a[i] == 0) {
785 a[i] = v;
786 }
787 }
788 }
789
790 @Test
791 static void smokeTest1() {
792 IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
793 IntVector three2 = (IntVector) SPECIES.broadcast(-3);
794 assert(three.eq(three2).allTrue());
795 IntVector three3 = three2.broadcast(1).broadcast(-3);
796 assert(three.eq(three3).allTrue());
797 int scale = 2;
798 Class<?> ETYPE = int.class;
799 if (ETYPE == double.class || ETYPE == long.class)
800 scale = 1000000;
801 else if (ETYPE == byte.class && SPECIES.length() >= 64)
802 scale = 1;
803 IntVector higher = three.addIndex(scale);
804 VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
805 assert(m.allTrue());
806 m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
807 assert(m.allTrue());
808 int max = higher.reduceLanes(VectorOperators.MAX);
809 assert(max == -3 + scale * (SPECIES.length()-1));
810 }
811
812 private static int[]
813 bothToArray(IntVector a, IntVector b) {
814 int[] r = new int[a.length() + b.length()];
815 a.intoArray(r, 0);
816 b.intoArray(r, a.length());
817 return r;
818 }
819
820 @Test
821 static void smokeTest2() {
822 // Do some zipping and shuffling.
823 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
824 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
825 Assert.assertEquals(io, io2);
826 IntVector a = io.add((int)1); //[1,2]
827 IntVector b = a.neg(); //[-1,-2]
828 int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
829 VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
830 VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
831 IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
832 IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
833 int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
834 // manually zip
835 int[] manual = new int[zabValues.length];
836 for (int i = 0; i < manual.length; i += 2) {
837 manual[i+0] = abValues[i/2];
838 manual[i+1] = abValues[a.length() + i/2];
839 }
840 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
841 VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
842 VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
843 IntVector uab0 = zab0.rearrange(unz0,zab1);
844 IntVector uab1 = zab0.rearrange(unz1,zab1);
845 int[] abValues1 = bothToArray(uab0, uab1);
846 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
847 }
848
849 static void iotaShuffle() {
850 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
851 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
852 Assert.assertEquals(io, io2);
853 }
854
855 @Test
856 // Test all shuffle related operations.
857 static void shuffleTest() {
858 // To test backend instructions, make sure that C2 is used.
859 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
860 iotaShuffle();
861 }
862 }
863
864 @Test
865 void viewAsIntegeralLanesTest() {
866 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
867 Assert.assertEquals(asIntegral.species(), SPECIES);
868 }
869
870 @Test
871 void viewAsFloatingLanesTest() {
872 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
873 VectorSpecies<?> asFloatingSpecies = asFloating.species();
874 Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
875 Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
876 Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
877 Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
878 }
879
880 @Test
881 // Test div by 0.
882 static void bitwiseDivByZeroSmokeTest() {
883 try {
884 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
885 IntVector b = (IntVector) SPECIES.broadcast(0);
886 a.div(b);
887 Assert.fail();
888 } catch (ArithmeticException e) {
889 }
890
891 try {
892 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
893 IntVector b = (IntVector) SPECIES.broadcast(0);
894 VectorMask<Integer> m = a.lt((int) 1);
895 a.div(b, m);
896 Assert.fail();
897 } catch (ArithmeticException e) {
898 }
899 }
900 static int ADD(int a, int b) {
901 return (int)(a + b);
902 }
903
904 @Test(dataProvider = "intBinaryOpProvider")
905 static void ADDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
906 int[] a = fa.apply(SPECIES.length());
907 int[] b = fb.apply(SPECIES.length());
908 int[] r = fr.apply(SPECIES.length());
909
910 for (int ic = 0; ic < INVOC_COUNT; ic++) {
911 for (int i = 0; i < a.length; i += SPECIES.length()) {
912 IntVector av = IntVector.fromArray(SPECIES, a, i);
913 IntVector bv = IntVector.fromArray(SPECIES, b, i);
914 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
915 }
916 }
917
918 assertArraysEquals(a, b, r, Int128VectorTests::ADD);
919 }
920 static int add(int a, int b) {
921 return (int)(a + b);
922 }
923
924 @Test(dataProvider = "intBinaryOpProvider")
925 static void addInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
926 int[] a = fa.apply(SPECIES.length());
927 int[] b = fb.apply(SPECIES.length());
928 int[] r = fr.apply(SPECIES.length());
929
930 for (int ic = 0; ic < INVOC_COUNT; ic++) {
931 for (int i = 0; i < a.length; i += SPECIES.length()) {
932 IntVector av = IntVector.fromArray(SPECIES, a, i);
933 IntVector bv = IntVector.fromArray(SPECIES, b, i);
934 av.add(bv).intoArray(r, i);
935 }
936 }
937
938 assertArraysEquals(a, b, r, Int128VectorTests::add);
939 }
940
941 @Test(dataProvider = "intBinaryOpMaskProvider")
942 static void ADDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
943 IntFunction<boolean[]> fm) {
944 int[] a = fa.apply(SPECIES.length());
945 int[] b = fb.apply(SPECIES.length());
946 int[] r = fr.apply(SPECIES.length());
947 boolean[] mask = fm.apply(SPECIES.length());
948 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
949
950 for (int ic = 0; ic < INVOC_COUNT; ic++) {
951 for (int i = 0; i < a.length; i += SPECIES.length()) {
952 IntVector av = IntVector.fromArray(SPECIES, a, i);
953 IntVector bv = IntVector.fromArray(SPECIES, b, i);
954 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
955 }
956 }
957
958 assertArraysEquals(a, b, r, mask, Int128VectorTests::ADD);
959 }
960
961 @Test(dataProvider = "intBinaryOpMaskProvider")
962 static void addInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
963 IntFunction<boolean[]> fm) {
964 int[] a = fa.apply(SPECIES.length());
965 int[] b = fb.apply(SPECIES.length());
966 int[] r = fr.apply(SPECIES.length());
967 boolean[] mask = fm.apply(SPECIES.length());
968 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
969
970 for (int ic = 0; ic < INVOC_COUNT; ic++) {
971 for (int i = 0; i < a.length; i += SPECIES.length()) {
972 IntVector av = IntVector.fromArray(SPECIES, a, i);
973 IntVector bv = IntVector.fromArray(SPECIES, b, i);
974 av.add(bv, vmask).intoArray(r, i);
975 }
976 }
977
978 assertArraysEquals(a, b, r, mask, Int128VectorTests::add);
979 }
980 static int SUB(int a, int b) {
981 return (int)(a - b);
982 }
983
984 @Test(dataProvider = "intBinaryOpProvider")
985 static void SUBInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
986 int[] a = fa.apply(SPECIES.length());
987 int[] b = fb.apply(SPECIES.length());
988 int[] r = fr.apply(SPECIES.length());
989
990 for (int ic = 0; ic < INVOC_COUNT; ic++) {
991 for (int i = 0; i < a.length; i += SPECIES.length()) {
992 IntVector av = IntVector.fromArray(SPECIES, a, i);
993 IntVector bv = IntVector.fromArray(SPECIES, b, i);
994 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
995 }
996 }
997
998 assertArraysEquals(a, b, r, Int128VectorTests::SUB);
999 }
1000 static int sub(int a, int b) {
1001 return (int)(a - b);
1002 }
1003
1004 @Test(dataProvider = "intBinaryOpProvider")
1005 static void subInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1006 int[] a = fa.apply(SPECIES.length());
1007 int[] b = fb.apply(SPECIES.length());
1008 int[] r = fr.apply(SPECIES.length());
1009
1010 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1011 for (int i = 0; i < a.length; i += SPECIES.length()) {
1012 IntVector av = IntVector.fromArray(SPECIES, a, i);
1013 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1014 av.sub(bv).intoArray(r, i);
1015 }
1016 }
1017
1018 assertArraysEquals(a, b, r, Int128VectorTests::sub);
1019 }
1020
1021 @Test(dataProvider = "intBinaryOpMaskProvider")
1022 static void SUBInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1023 IntFunction<boolean[]> fm) {
1024 int[] a = fa.apply(SPECIES.length());
1025 int[] b = fb.apply(SPECIES.length());
1026 int[] r = fr.apply(SPECIES.length());
1027 boolean[] mask = fm.apply(SPECIES.length());
1028 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1029
1030 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1031 for (int i = 0; i < a.length; i += SPECIES.length()) {
1032 IntVector av = IntVector.fromArray(SPECIES, a, i);
1033 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1034 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1035 }
1036 }
1037
1038 assertArraysEquals(a, b, r, mask, Int128VectorTests::SUB);
1039 }
1040
1041 @Test(dataProvider = "intBinaryOpMaskProvider")
1042 static void subInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1043 IntFunction<boolean[]> fm) {
1044 int[] a = fa.apply(SPECIES.length());
1045 int[] b = fb.apply(SPECIES.length());
1046 int[] r = fr.apply(SPECIES.length());
1047 boolean[] mask = fm.apply(SPECIES.length());
1048 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1049
1050 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1051 for (int i = 0; i < a.length; i += SPECIES.length()) {
1052 IntVector av = IntVector.fromArray(SPECIES, a, i);
1053 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1054 av.sub(bv, vmask).intoArray(r, i);
1055 }
1056 }
1057
1058 assertArraysEquals(a, b, r, mask, Int128VectorTests::sub);
1059 }
1060 static int MUL(int a, int b) {
1061 return (int)(a * b);
1062 }
1063
1064 @Test(dataProvider = "intBinaryOpProvider")
1065 static void MULInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1066 int[] a = fa.apply(SPECIES.length());
1067 int[] b = fb.apply(SPECIES.length());
1068 int[] r = fr.apply(SPECIES.length());
1069
1070 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1071 for (int i = 0; i < a.length; i += SPECIES.length()) {
1072 IntVector av = IntVector.fromArray(SPECIES, a, i);
1073 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1074 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1075 }
1076 }
1077
1078 assertArraysEquals(a, b, r, Int128VectorTests::MUL);
1079 }
1080 static int mul(int a, int b) {
1081 return (int)(a * b);
1082 }
1083
1084 @Test(dataProvider = "intBinaryOpProvider")
1085 static void mulInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1086 int[] a = fa.apply(SPECIES.length());
1087 int[] b = fb.apply(SPECIES.length());
1088 int[] r = fr.apply(SPECIES.length());
1089
1090 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1091 for (int i = 0; i < a.length; i += SPECIES.length()) {
1092 IntVector av = IntVector.fromArray(SPECIES, a, i);
1093 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1094 av.mul(bv).intoArray(r, i);
1095 }
1096 }
1097
1098 assertArraysEquals(a, b, r, Int128VectorTests::mul);
1099 }
1100
1101 @Test(dataProvider = "intBinaryOpMaskProvider")
1102 static void MULInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1103 IntFunction<boolean[]> fm) {
1104 int[] a = fa.apply(SPECIES.length());
1105 int[] b = fb.apply(SPECIES.length());
1106 int[] r = fr.apply(SPECIES.length());
1107 boolean[] mask = fm.apply(SPECIES.length());
1108 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1109
1110 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1111 for (int i = 0; i < a.length; i += SPECIES.length()) {
1112 IntVector av = IntVector.fromArray(SPECIES, a, i);
1113 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1114 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1115 }
1116 }
1117
1118 assertArraysEquals(a, b, r, mask, Int128VectorTests::MUL);
1119 }
1120
1121 @Test(dataProvider = "intBinaryOpMaskProvider")
1122 static void mulInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1123 IntFunction<boolean[]> fm) {
1124 int[] a = fa.apply(SPECIES.length());
1125 int[] b = fb.apply(SPECIES.length());
1126 int[] r = fr.apply(SPECIES.length());
1127 boolean[] mask = fm.apply(SPECIES.length());
1128 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1129
1130 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1131 for (int i = 0; i < a.length; i += SPECIES.length()) {
1132 IntVector av = IntVector.fromArray(SPECIES, a, i);
1133 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1134 av.mul(bv, vmask).intoArray(r, i);
1135 }
1136 }
1137
1138 assertArraysEquals(a, b, r, mask, Int128VectorTests::mul);
1139 }
1140
1141
1142
1143 static int DIV(int a, int b) {
1144 return (int)(a / b);
1145 }
1146
1147 @Test(dataProvider = "intBinaryOpProvider")
1148 static void DIVInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1149 int[] a = fa.apply(SPECIES.length());
1150 int[] b = fb.apply(SPECIES.length());
1151 int[] r = fr.apply(SPECIES.length());
1152
1153 replaceZero(b, (int) 1);
1154
1155 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1156 for (int i = 0; i < a.length; i += SPECIES.length()) {
1157 IntVector av = IntVector.fromArray(SPECIES, a, i);
1158 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1159 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1160 }
1161 }
1162
1163 assertArraysEquals(a, b, r, Int128VectorTests::DIV);
1164 }
1165 static int div(int a, int b) {
1166 return (int)(a / b);
1167 }
1168
1169 @Test(dataProvider = "intBinaryOpProvider")
1170 static void divInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1171 int[] a = fa.apply(SPECIES.length());
1172 int[] b = fb.apply(SPECIES.length());
1173 int[] r = fr.apply(SPECIES.length());
1174
1175 replaceZero(b, (int) 1);
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 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1181 av.div(bv).intoArray(r, i);
1182 }
1183 }
1184
1185 assertArraysEquals(a, b, r, Int128VectorTests::div);
1186 }
1187
1188
1189
1190 @Test(dataProvider = "intBinaryOpMaskProvider")
1191 static void DIVInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1192 IntFunction<boolean[]> fm) {
1193 int[] a = fa.apply(SPECIES.length());
1194 int[] b = fb.apply(SPECIES.length());
1195 int[] r = fr.apply(SPECIES.length());
1196 boolean[] mask = fm.apply(SPECIES.length());
1197 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1198
1199 replaceZero(b, mask, (int) 1);
1200
1201 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1202 for (int i = 0; i < a.length; i += SPECIES.length()) {
1203 IntVector av = IntVector.fromArray(SPECIES, a, i);
1204 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1205 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1206 }
1207 }
1208
1209 assertArraysEquals(a, b, r, mask, Int128VectorTests::DIV);
1210 }
1211
1212 @Test(dataProvider = "intBinaryOpMaskProvider")
1213 static void divInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1214 IntFunction<boolean[]> fm) {
1215 int[] a = fa.apply(SPECIES.length());
1216 int[] b = fb.apply(SPECIES.length());
1217 int[] r = fr.apply(SPECIES.length());
1218 boolean[] mask = fm.apply(SPECIES.length());
1219 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1220
1221 replaceZero(b, mask, (int) 1);
1222
1223 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1224 for (int i = 0; i < a.length; i += SPECIES.length()) {
1225 IntVector av = IntVector.fromArray(SPECIES, a, i);
1226 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1227 av.div(bv, vmask).intoArray(r, i);
1228 }
1229 }
1230
1231 assertArraysEquals(a, b, r, mask, Int128VectorTests::div);
1232 }
1233
1234 static int FIRST_NONZERO(int a, int b) {
1235 return (int)((a)!=0?a:b);
1236 }
1237
1238 @Test(dataProvider = "intBinaryOpProvider")
1239 static void FIRST_NONZEROInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1240 int[] a = fa.apply(SPECIES.length());
1241 int[] b = fb.apply(SPECIES.length());
1242 int[] r = fr.apply(SPECIES.length());
1243
1244 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1245 for (int i = 0; i < a.length; i += SPECIES.length()) {
1246 IntVector av = IntVector.fromArray(SPECIES, a, i);
1247 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1248 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1249 }
1250 }
1251
1252 assertArraysEquals(a, b, r, Int128VectorTests::FIRST_NONZERO);
1253 }
1254
1255 @Test(dataProvider = "intBinaryOpMaskProvider")
1256 static void FIRST_NONZEROInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1257 IntFunction<boolean[]> fm) {
1258 int[] a = fa.apply(SPECIES.length());
1259 int[] b = fb.apply(SPECIES.length());
1260 int[] r = fr.apply(SPECIES.length());
1261 boolean[] mask = fm.apply(SPECIES.length());
1262 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1263
1264 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1265 for (int i = 0; i < a.length; i += SPECIES.length()) {
1266 IntVector av = IntVector.fromArray(SPECIES, a, i);
1267 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1268 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1269 }
1270 }
1271
1272 assertArraysEquals(a, b, r, mask, Int128VectorTests::FIRST_NONZERO);
1273 }
1274
1275 static int AND(int a, int b) {
1276 return (int)(a & b);
1277 }
1278
1279 @Test(dataProvider = "intBinaryOpProvider")
1280 static void ANDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1281 int[] a = fa.apply(SPECIES.length());
1282 int[] b = fb.apply(SPECIES.length());
1283 int[] r = fr.apply(SPECIES.length());
1284
1285 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1286 for (int i = 0; i < a.length; i += SPECIES.length()) {
1287 IntVector av = IntVector.fromArray(SPECIES, a, i);
1288 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1289 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1290 }
1291 }
1292
1293 assertArraysEquals(a, b, r, Int128VectorTests::AND);
1294 }
1295 static int and(int a, int b) {
1296 return (int)(a & b);
1297 }
1298
1299 @Test(dataProvider = "intBinaryOpProvider")
1300 static void andInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1301 int[] a = fa.apply(SPECIES.length());
1302 int[] b = fb.apply(SPECIES.length());
1303 int[] r = fr.apply(SPECIES.length());
1304
1305 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1306 for (int i = 0; i < a.length; i += SPECIES.length()) {
1307 IntVector av = IntVector.fromArray(SPECIES, a, i);
1308 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1309 av.and(bv).intoArray(r, i);
1310 }
1311 }
1312
1313 assertArraysEquals(a, b, r, Int128VectorTests::and);
1314 }
1315
1316
1317
1318 @Test(dataProvider = "intBinaryOpMaskProvider")
1319 static void ANDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1320 IntFunction<boolean[]> fm) {
1321 int[] a = fa.apply(SPECIES.length());
1322 int[] b = fb.apply(SPECIES.length());
1323 int[] r = fr.apply(SPECIES.length());
1324 boolean[] mask = fm.apply(SPECIES.length());
1325 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1326
1327 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1328 for (int i = 0; i < a.length; i += SPECIES.length()) {
1329 IntVector av = IntVector.fromArray(SPECIES, a, i);
1330 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1331 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1332 }
1333 }
1334
1335 assertArraysEquals(a, b, r, mask, Int128VectorTests::AND);
1336 }
1337
1338
1339 static int AND_NOT(int a, int b) {
1340 return (int)(a & ~b);
1341 }
1342
1343 @Test(dataProvider = "intBinaryOpProvider")
1344 static void AND_NOTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1345 int[] a = fa.apply(SPECIES.length());
1346 int[] b = fb.apply(SPECIES.length());
1347 int[] r = fr.apply(SPECIES.length());
1348
1349 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1350 for (int i = 0; i < a.length; i += SPECIES.length()) {
1351 IntVector av = IntVector.fromArray(SPECIES, a, i);
1352 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1353 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1354 }
1355 }
1356
1357 assertArraysEquals(a, b, r, Int128VectorTests::AND_NOT);
1358 }
1359
1360
1361
1362 @Test(dataProvider = "intBinaryOpMaskProvider")
1363 static void AND_NOTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1364 IntFunction<boolean[]> fm) {
1365 int[] a = fa.apply(SPECIES.length());
1366 int[] b = fb.apply(SPECIES.length());
1367 int[] r = fr.apply(SPECIES.length());
1368 boolean[] mask = fm.apply(SPECIES.length());
1369 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1370
1371 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1372 for (int i = 0; i < a.length; i += SPECIES.length()) {
1373 IntVector av = IntVector.fromArray(SPECIES, a, i);
1374 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1375 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1376 }
1377 }
1378
1379 assertArraysEquals(a, b, r, mask, Int128VectorTests::AND_NOT);
1380 }
1381
1382
1383 static int OR(int a, int b) {
1384 return (int)(a | b);
1385 }
1386
1387 @Test(dataProvider = "intBinaryOpProvider")
1388 static void ORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1389 int[] a = fa.apply(SPECIES.length());
1390 int[] b = fb.apply(SPECIES.length());
1391 int[] r = fr.apply(SPECIES.length());
1392
1393 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1394 for (int i = 0; i < a.length; i += SPECIES.length()) {
1395 IntVector av = IntVector.fromArray(SPECIES, a, i);
1396 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1397 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1398 }
1399 }
1400
1401 assertArraysEquals(a, b, r, Int128VectorTests::OR);
1402 }
1403 static int or(int a, int b) {
1404 return (int)(a | b);
1405 }
1406
1407 @Test(dataProvider = "intBinaryOpProvider")
1408 static void orInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1409 int[] a = fa.apply(SPECIES.length());
1410 int[] b = fb.apply(SPECIES.length());
1411 int[] r = fr.apply(SPECIES.length());
1412
1413 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1414 for (int i = 0; i < a.length; i += SPECIES.length()) {
1415 IntVector av = IntVector.fromArray(SPECIES, a, i);
1416 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1417 av.or(bv).intoArray(r, i);
1418 }
1419 }
1420
1421 assertArraysEquals(a, b, r, Int128VectorTests::or);
1422 }
1423
1424
1425
1426 @Test(dataProvider = "intBinaryOpMaskProvider")
1427 static void ORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1428 IntFunction<boolean[]> fm) {
1429 int[] a = fa.apply(SPECIES.length());
1430 int[] b = fb.apply(SPECIES.length());
1431 int[] r = fr.apply(SPECIES.length());
1432 boolean[] mask = fm.apply(SPECIES.length());
1433 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1434
1435 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1436 for (int i = 0; i < a.length; i += SPECIES.length()) {
1437 IntVector av = IntVector.fromArray(SPECIES, a, i);
1438 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1439 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1440 }
1441 }
1442
1443 assertArraysEquals(a, b, r, mask, Int128VectorTests::OR);
1444 }
1445
1446
1447 static int XOR(int a, int b) {
1448 return (int)(a ^ b);
1449 }
1450
1451 @Test(dataProvider = "intBinaryOpProvider")
1452 static void XORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1453 int[] a = fa.apply(SPECIES.length());
1454 int[] b = fb.apply(SPECIES.length());
1455 int[] r = fr.apply(SPECIES.length());
1456
1457 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1458 for (int i = 0; i < a.length; i += SPECIES.length()) {
1459 IntVector av = IntVector.fromArray(SPECIES, a, i);
1460 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1461 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1462 }
1463 }
1464
1465 assertArraysEquals(a, b, r, Int128VectorTests::XOR);
1466 }
1467
1468
1469
1470 @Test(dataProvider = "intBinaryOpMaskProvider")
1471 static void XORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1472 IntFunction<boolean[]> fm) {
1473 int[] a = fa.apply(SPECIES.length());
1474 int[] b = fb.apply(SPECIES.length());
1475 int[] r = fr.apply(SPECIES.length());
1476 boolean[] mask = fm.apply(SPECIES.length());
1477 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
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 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1484 }
1485 }
1486
1487 assertArraysEquals(a, b, r, mask, Int128VectorTests::XOR);
1488 }
1489
1490
1491 @Test(dataProvider = "intBinaryOpProvider")
1492 static void addInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1493 int[] a = fa.apply(SPECIES.length());
1494 int[] b = fb.apply(SPECIES.length());
1495 int[] r = fr.apply(SPECIES.length());
1496
1497 for (int i = 0; i < a.length; i += SPECIES.length()) {
1498 IntVector av = IntVector.fromArray(SPECIES, a, i);
1499 av.add(b[i]).intoArray(r, i);
1500 }
1501
1502 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::add);
1503 }
1504
1505 @Test(dataProvider = "intBinaryOpMaskProvider")
1506 static void addInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1507 IntFunction<boolean[]> fm) {
1508 int[] a = fa.apply(SPECIES.length());
1509 int[] b = fb.apply(SPECIES.length());
1510 int[] r = fr.apply(SPECIES.length());
1511 boolean[] mask = fm.apply(SPECIES.length());
1512 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1513
1514 for (int i = 0; i < a.length; i += SPECIES.length()) {
1515 IntVector av = IntVector.fromArray(SPECIES, a, i);
1516 av.add(b[i], vmask).intoArray(r, i);
1517 }
1518
1519 assertBroadcastArraysEquals(a, b, r, mask, Int128VectorTests::add);
1520 }
1521
1522 @Test(dataProvider = "intBinaryOpProvider")
1523 static void subInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1524 int[] a = fa.apply(SPECIES.length());
1525 int[] b = fb.apply(SPECIES.length());
1526 int[] r = fr.apply(SPECIES.length());
1527
1528 for (int i = 0; i < a.length; i += SPECIES.length()) {
1529 IntVector av = IntVector.fromArray(SPECIES, a, i);
1530 av.sub(b[i]).intoArray(r, i);
1531 }
1532
1533 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::sub);
1534 }
1535
1536 @Test(dataProvider = "intBinaryOpMaskProvider")
1537 static void subInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1538 IntFunction<boolean[]> fm) {
1539 int[] a = fa.apply(SPECIES.length());
1540 int[] b = fb.apply(SPECIES.length());
1541 int[] r = fr.apply(SPECIES.length());
1542 boolean[] mask = fm.apply(SPECIES.length());
1543 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1544
1545 for (int i = 0; i < a.length; i += SPECIES.length()) {
1546 IntVector av = IntVector.fromArray(SPECIES, a, i);
1547 av.sub(b[i], vmask).intoArray(r, i);
1548 }
1549
1550 assertBroadcastArraysEquals(a, b, r, mask, Int128VectorTests::sub);
1551 }
1552
1553 @Test(dataProvider = "intBinaryOpProvider")
1554 static void mulInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1555 int[] a = fa.apply(SPECIES.length());
1556 int[] b = fb.apply(SPECIES.length());
1557 int[] r = fr.apply(SPECIES.length());
1558
1559 for (int i = 0; i < a.length; i += SPECIES.length()) {
1560 IntVector av = IntVector.fromArray(SPECIES, a, i);
1561 av.mul(b[i]).intoArray(r, i);
1562 }
1563
1564 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::mul);
1565 }
1566
1567 @Test(dataProvider = "intBinaryOpMaskProvider")
1568 static void mulInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1569 IntFunction<boolean[]> fm) {
1570 int[] a = fa.apply(SPECIES.length());
1571 int[] b = fb.apply(SPECIES.length());
1572 int[] r = fr.apply(SPECIES.length());
1573 boolean[] mask = fm.apply(SPECIES.length());
1574 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1575
1576 for (int i = 0; i < a.length; i += SPECIES.length()) {
1577 IntVector av = IntVector.fromArray(SPECIES, a, i);
1578 av.mul(b[i], vmask).intoArray(r, i);
1579 }
1580
1581 assertBroadcastArraysEquals(a, b, r, mask, Int128VectorTests::mul);
1582 }
1583
1584
1585
1586
1587 @Test(dataProvider = "intBinaryOpProvider")
1588 static void divInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1589 int[] a = fa.apply(SPECIES.length());
1590 int[] b = fb.apply(SPECIES.length());
1591 int[] r = fr.apply(SPECIES.length());
1592
1593 replaceZero(b, (int) 1);
1594
1595 for (int i = 0; i < a.length; i += SPECIES.length()) {
1596 IntVector av = IntVector.fromArray(SPECIES, a, i);
1597 av.div(b[i]).intoArray(r, i);
1598 }
1599
1600 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::div);
1601 }
1602
1603
1604
1605 @Test(dataProvider = "intBinaryOpMaskProvider")
1606 static void divInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1607 IntFunction<boolean[]> fm) {
1608 int[] a = fa.apply(SPECIES.length());
1609 int[] b = fb.apply(SPECIES.length());
1610 int[] r = fr.apply(SPECIES.length());
1611 boolean[] mask = fm.apply(SPECIES.length());
1612 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1613
1614 replaceZero(b, (int) 1);
1615
1616 for (int i = 0; i < a.length; i += SPECIES.length()) {
1617 IntVector av = IntVector.fromArray(SPECIES, a, i);
1618 av.div(b[i], vmask).intoArray(r, i);
1619 }
1620
1621 assertBroadcastArraysEquals(a, b, r, mask, Int128VectorTests::div);
1622 }
1623
1624
1625
1626 @Test(dataProvider = "intBinaryOpProvider")
1627 static void ORInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1628 int[] a = fa.apply(SPECIES.length());
1629 int[] b = fb.apply(SPECIES.length());
1630 int[] r = fr.apply(SPECIES.length());
1631
1632 for (int i = 0; i < a.length; i += SPECIES.length()) {
1633 IntVector av = IntVector.fromArray(SPECIES, a, i);
1634 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
1635 }
1636
1637 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::OR);
1638 }
1639
1640 @Test(dataProvider = "intBinaryOpProvider")
1641 static void orInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1642 int[] a = fa.apply(SPECIES.length());
1643 int[] b = fb.apply(SPECIES.length());
1644 int[] r = fr.apply(SPECIES.length());
1645
1646 for (int i = 0; i < a.length; i += SPECIES.length()) {
1647 IntVector av = IntVector.fromArray(SPECIES, a, i);
1648 av.or(b[i]).intoArray(r, i);
1649 }
1650
1651 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::or);
1652 }
1653
1654
1655
1656 @Test(dataProvider = "intBinaryOpMaskProvider")
1657 static void ORInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1658 IntFunction<boolean[]> fm) {
1659 int[] a = fa.apply(SPECIES.length());
1660 int[] b = fb.apply(SPECIES.length());
1661 int[] r = fr.apply(SPECIES.length());
1662 boolean[] mask = fm.apply(SPECIES.length());
1663 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1664
1665 for (int i = 0; i < a.length; i += SPECIES.length()) {
1666 IntVector av = IntVector.fromArray(SPECIES, a, i);
1667 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
1668 }
1669
1670 assertBroadcastArraysEquals(a, b, r, mask, Int128VectorTests::OR);
1671 }
1672
1673
1674 static int LSHL(int a, int b) {
1675 return (int)((a << b));
1676 }
1677
1678 @Test(dataProvider = "intBinaryOpProvider")
1679 static void LSHLInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1680 int[] a = fa.apply(SPECIES.length());
1681 int[] b = fb.apply(SPECIES.length());
1682 int[] r = fr.apply(SPECIES.length());
1683
1684 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1685 for (int i = 0; i < a.length; i += SPECIES.length()) {
1686 IntVector av = IntVector.fromArray(SPECIES, a, i);
1687 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1688 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
1689 }
1690 }
1691
1692 assertArraysEquals(a, b, r, Int128VectorTests::LSHL);
1693 }
1694
1695
1696
1697 @Test(dataProvider = "intBinaryOpMaskProvider")
1698 static void LSHLInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1699 IntFunction<boolean[]> fm) {
1700 int[] a = fa.apply(SPECIES.length());
1701 int[] b = fb.apply(SPECIES.length());
1702 int[] r = fr.apply(SPECIES.length());
1703 boolean[] mask = fm.apply(SPECIES.length());
1704 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1705
1706 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1707 for (int i = 0; i < a.length; i += SPECIES.length()) {
1708 IntVector av = IntVector.fromArray(SPECIES, a, i);
1709 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1710 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
1711 }
1712 }
1713
1714 assertArraysEquals(a, b, r, mask, Int128VectorTests::LSHL);
1715 }
1716
1717
1718
1719
1720
1721
1722 static int ASHR(int a, int b) {
1723 return (int)((a >> b));
1724 }
1725
1726 @Test(dataProvider = "intBinaryOpProvider")
1727 static void ASHRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1728 int[] a = fa.apply(SPECIES.length());
1729 int[] b = fb.apply(SPECIES.length());
1730 int[] r = fr.apply(SPECIES.length());
1731
1732 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1733 for (int i = 0; i < a.length; i += SPECIES.length()) {
1734 IntVector av = IntVector.fromArray(SPECIES, a, i);
1735 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1736 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
1737 }
1738 }
1739
1740 assertArraysEquals(a, b, r, Int128VectorTests::ASHR);
1741 }
1742
1743
1744
1745 @Test(dataProvider = "intBinaryOpMaskProvider")
1746 static void ASHRInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1747 IntFunction<boolean[]> fm) {
1748 int[] a = fa.apply(SPECIES.length());
1749 int[] b = fb.apply(SPECIES.length());
1750 int[] r = fr.apply(SPECIES.length());
1751 boolean[] mask = fm.apply(SPECIES.length());
1752 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
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 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1758 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
1759 }
1760 }
1761
1762 assertArraysEquals(a, b, r, mask, Int128VectorTests::ASHR);
1763 }
1764
1765
1766
1767
1768
1769
1770 static int LSHR(int a, int b) {
1771 return (int)((a >>> b));
1772 }
1773
1774 @Test(dataProvider = "intBinaryOpProvider")
1775 static void LSHRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1776 int[] a = fa.apply(SPECIES.length());
1777 int[] b = fb.apply(SPECIES.length());
1778 int[] r = fr.apply(SPECIES.length());
1779
1780 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1781 for (int i = 0; i < a.length; i += SPECIES.length()) {
1782 IntVector av = IntVector.fromArray(SPECIES, a, i);
1783 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1784 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
1785 }
1786 }
1787
1788 assertArraysEquals(a, b, r, Int128VectorTests::LSHR);
1789 }
1790
1791
1792
1793 @Test(dataProvider = "intBinaryOpMaskProvider")
1794 static void LSHRInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1795 IntFunction<boolean[]> fm) {
1796 int[] a = fa.apply(SPECIES.length());
1797 int[] b = fb.apply(SPECIES.length());
1798 int[] r = fr.apply(SPECIES.length());
1799 boolean[] mask = fm.apply(SPECIES.length());
1800 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1801
1802 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1803 for (int i = 0; i < a.length; i += SPECIES.length()) {
1804 IntVector av = IntVector.fromArray(SPECIES, a, i);
1805 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1806 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
1807 }
1808 }
1809
1810 assertArraysEquals(a, b, r, mask, Int128VectorTests::LSHR);
1811 }
1812
1813
1814
1815
1816
1817
1818 static int LSHL_unary(int a, int b) {
1819 return (int)((a << b));
1820 }
1821
1822 @Test(dataProvider = "intBinaryOpProvider")
1823 static void LSHLInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1824 int[] a = fa.apply(SPECIES.length());
1825 int[] b = fb.apply(SPECIES.length());
1826 int[] r = fr.apply(SPECIES.length());
1827
1828 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1829 for (int i = 0; i < a.length; i += SPECIES.length()) {
1830 IntVector av = IntVector.fromArray(SPECIES, a, i);
1831 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
1832 }
1833 }
1834
1835 assertShiftArraysEquals(a, b, r, Int128VectorTests::LSHL_unary);
1836 }
1837
1838
1839
1840 @Test(dataProvider = "intBinaryOpMaskProvider")
1841 static void LSHLInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1842 IntFunction<boolean[]> fm) {
1843 int[] a = fa.apply(SPECIES.length());
1844 int[] b = fb.apply(SPECIES.length());
1845 int[] r = fr.apply(SPECIES.length());
1846 boolean[] mask = fm.apply(SPECIES.length());
1847 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1848
1849 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1850 for (int i = 0; i < a.length; i += SPECIES.length()) {
1851 IntVector av = IntVector.fromArray(SPECIES, a, i);
1852 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
1853 }
1854 }
1855
1856 assertShiftArraysEquals(a, b, r, mask, Int128VectorTests::LSHL_unary);
1857 }
1858
1859
1860
1861
1862
1863
1864 static int LSHR_unary(int a, int b) {
1865 return (int)((a >>> b));
1866 }
1867
1868 @Test(dataProvider = "intBinaryOpProvider")
1869 static void LSHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1870 int[] a = fa.apply(SPECIES.length());
1871 int[] b = fb.apply(SPECIES.length());
1872 int[] r = fr.apply(SPECIES.length());
1873
1874 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1875 for (int i = 0; i < a.length; i += SPECIES.length()) {
1876 IntVector av = IntVector.fromArray(SPECIES, a, i);
1877 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
1878 }
1879 }
1880
1881 assertShiftArraysEquals(a, b, r, Int128VectorTests::LSHR_unary);
1882 }
1883
1884
1885
1886 @Test(dataProvider = "intBinaryOpMaskProvider")
1887 static void LSHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1888 IntFunction<boolean[]> fm) {
1889 int[] a = fa.apply(SPECIES.length());
1890 int[] b = fb.apply(SPECIES.length());
1891 int[] r = fr.apply(SPECIES.length());
1892 boolean[] mask = fm.apply(SPECIES.length());
1893 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1894
1895 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1896 for (int i = 0; i < a.length; i += SPECIES.length()) {
1897 IntVector av = IntVector.fromArray(SPECIES, a, i);
1898 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
1899 }
1900 }
1901
1902 assertShiftArraysEquals(a, b, r, mask, Int128VectorTests::LSHR_unary);
1903 }
1904
1905
1906
1907
1908
1909
1910 static int ASHR_unary(int a, int b) {
1911 return (int)((a >> b));
1912 }
1913
1914 @Test(dataProvider = "intBinaryOpProvider")
1915 static void ASHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1916 int[] a = fa.apply(SPECIES.length());
1917 int[] b = fb.apply(SPECIES.length());
1918 int[] r = fr.apply(SPECIES.length());
1919
1920 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1921 for (int i = 0; i < a.length; i += SPECIES.length()) {
1922 IntVector av = IntVector.fromArray(SPECIES, a, i);
1923 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
1924 }
1925 }
1926
1927 assertShiftArraysEquals(a, b, r, Int128VectorTests::ASHR_unary);
1928 }
1929
1930
1931
1932 @Test(dataProvider = "intBinaryOpMaskProvider")
1933 static void ASHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1934 IntFunction<boolean[]> fm) {
1935 int[] a = fa.apply(SPECIES.length());
1936 int[] b = fb.apply(SPECIES.length());
1937 int[] r = fr.apply(SPECIES.length());
1938 boolean[] mask = fm.apply(SPECIES.length());
1939 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1940
1941 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1942 for (int i = 0; i < a.length; i += SPECIES.length()) {
1943 IntVector av = IntVector.fromArray(SPECIES, a, i);
1944 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
1945 }
1946 }
1947
1948 assertShiftArraysEquals(a, b, r, mask, Int128VectorTests::ASHR_unary);
1949 }
1950
1951
1952
1953
1954
1955 static int MIN(int a, int b) {
1956 return (int)(Math.min(a, b));
1957 }
1958
1959 @Test(dataProvider = "intBinaryOpProvider")
1960 static void MINInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1961 int[] a = fa.apply(SPECIES.length());
1962 int[] b = fb.apply(SPECIES.length());
1963 int[] r = fr.apply(SPECIES.length());
1964
1965 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1966 for (int i = 0; i < a.length; i += SPECIES.length()) {
1967 IntVector av = IntVector.fromArray(SPECIES, a, i);
1968 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1969 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
1970 }
1971 }
1972
1973 assertArraysEquals(a, b, r, Int128VectorTests::MIN);
1974 }
1975 static int min(int a, int b) {
1976 return (int)(Math.min(a, b));
1977 }
1978
1979 @Test(dataProvider = "intBinaryOpProvider")
1980 static void minInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1981 int[] a = fa.apply(SPECIES.length());
1982 int[] b = fb.apply(SPECIES.length());
1983 int[] r = fr.apply(SPECIES.length());
1984
1985 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1986 for (int i = 0; i < a.length; i += SPECIES.length()) {
1987 IntVector av = IntVector.fromArray(SPECIES, a, i);
1988 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1989 av.min(bv).intoArray(r, i);
1990 }
1991 }
1992
1993 assertArraysEquals(a, b, r, Int128VectorTests::min);
1994 }
1995 static int MAX(int a, int b) {
1996 return (int)(Math.max(a, b));
1997 }
1998
1999 @Test(dataProvider = "intBinaryOpProvider")
2000 static void MAXInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2001 int[] a = fa.apply(SPECIES.length());
2002 int[] b = fb.apply(SPECIES.length());
2003 int[] r = fr.apply(SPECIES.length());
2004
2005 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2006 for (int i = 0; i < a.length; i += SPECIES.length()) {
2007 IntVector av = IntVector.fromArray(SPECIES, a, i);
2008 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2009 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2010 }
2011 }
2012
2013 assertArraysEquals(a, b, r, Int128VectorTests::MAX);
2014 }
2015 static int max(int a, int b) {
2016 return (int)(Math.max(a, b));
2017 }
2018
2019 @Test(dataProvider = "intBinaryOpProvider")
2020 static void maxInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2021 int[] a = fa.apply(SPECIES.length());
2022 int[] b = fb.apply(SPECIES.length());
2023 int[] r = fr.apply(SPECIES.length());
2024
2025 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2026 for (int i = 0; i < a.length; i += SPECIES.length()) {
2027 IntVector av = IntVector.fromArray(SPECIES, a, i);
2028 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2029 av.max(bv).intoArray(r, i);
2030 }
2031 }
2032
2033 assertArraysEquals(a, b, r, Int128VectorTests::max);
2034 }
2035
2036 @Test(dataProvider = "intBinaryOpProvider")
2037 static void MINInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2038 int[] a = fa.apply(SPECIES.length());
2039 int[] b = fb.apply(SPECIES.length());
2040 int[] r = fr.apply(SPECIES.length());
2041
2042 for (int i = 0; i < a.length; i += SPECIES.length()) {
2043 IntVector av = IntVector.fromArray(SPECIES, a, i);
2044 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2045 }
2046
2047 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::MIN);
2048 }
2049
2050 @Test(dataProvider = "intBinaryOpProvider")
2051 static void minInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2052 int[] a = fa.apply(SPECIES.length());
2053 int[] b = fb.apply(SPECIES.length());
2054 int[] r = fr.apply(SPECIES.length());
2055
2056 for (int i = 0; i < a.length; i += SPECIES.length()) {
2057 IntVector av = IntVector.fromArray(SPECIES, a, i);
2058 av.min(b[i]).intoArray(r, i);
2059 }
2060
2061 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::min);
2062 }
2063
2064 @Test(dataProvider = "intBinaryOpProvider")
2065 static void MAXInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2066 int[] a = fa.apply(SPECIES.length());
2067 int[] b = fb.apply(SPECIES.length());
2068 int[] r = fr.apply(SPECIES.length());
2069
2070 for (int i = 0; i < a.length; i += SPECIES.length()) {
2071 IntVector av = IntVector.fromArray(SPECIES, a, i);
2072 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2073 }
2074
2075 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::MAX);
2076 }
2077
2078 @Test(dataProvider = "intBinaryOpProvider")
2079 static void maxInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2080 int[] a = fa.apply(SPECIES.length());
2081 int[] b = fb.apply(SPECIES.length());
2082 int[] r = fr.apply(SPECIES.length());
2083
2084 for (int i = 0; i < a.length; i += SPECIES.length()) {
2085 IntVector av = IntVector.fromArray(SPECIES, a, i);
2086 av.max(b[i]).intoArray(r, i);
2087 }
2088
2089 assertBroadcastArraysEquals(a, b, r, Int128VectorTests::max);
2090 }
2091
2092 static int AND(int[] a, int idx) {
2093 int res = -1;
2094 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2095 res &= a[i];
2096 }
2097
2098 return res;
2099 }
2100
2101 static int AND(int[] a) {
2102 int res = -1;
2103 for (int i = 0; i < a.length; i += SPECIES.length()) {
2104 int tmp = -1;
2105 for (int j = 0; j < SPECIES.length(); j++) {
2106 tmp &= a[i + j];
2107 }
2108 res &= tmp;
2109 }
2110
2111 return res;
2112 }
2113
2114
2115 @Test(dataProvider = "intUnaryOpProvider")
2116 static void ANDInt128VectorTests(IntFunction<int[]> fa) {
2117 int[] a = fa.apply(SPECIES.length());
2118 int[] r = fr.apply(SPECIES.length());
2119 int ra = -1;
2120
2121 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2122 for (int i = 0; i < a.length; i += SPECIES.length()) {
2123 IntVector av = IntVector.fromArray(SPECIES, a, i);
2124 r[i] = av.reduceLanes(VectorOperators.AND);
2125 }
2126 }
2127
2128 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2129 ra = -1;
2130 for (int i = 0; i < a.length; i += SPECIES.length()) {
2131 IntVector av = IntVector.fromArray(SPECIES, a, i);
2132 ra &= av.reduceLanes(VectorOperators.AND);
2133 }
2134 }
2135
2136 assertReductionArraysEquals(a, r, ra, Int128VectorTests::AND, Int128VectorTests::AND);
2137 }
2138
2139
2140 static int ANDMasked(int[] a, int idx, boolean[] mask) {
2141 int res = -1;
2142 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2143 if(mask[i % SPECIES.length()])
2144 res &= a[i];
2145 }
2146
2147 return res;
2148 }
2149
2150 static int ANDMasked(int[] a, boolean[] mask) {
2151 int res = -1;
2152 for (int i = 0; i < a.length; i += SPECIES.length()) {
2153 int tmp = -1;
2154 for (int j = 0; j < SPECIES.length(); j++) {
2155 if(mask[(i + j) % SPECIES.length()])
2156 tmp &= a[i + j];
2157 }
2158 res &= tmp;
2159 }
2160
2161 return res;
2162 }
2163
2164
2165 @Test(dataProvider = "intUnaryOpMaskProvider")
2166 static void ANDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2167 int[] a = fa.apply(SPECIES.length());
2168 int[] r = fr.apply(SPECIES.length());
2169 boolean[] mask = fm.apply(SPECIES.length());
2170 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2171 int ra = -1;
2172
2173 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2174 for (int i = 0; i < a.length; i += SPECIES.length()) {
2175 IntVector av = IntVector.fromArray(SPECIES, a, i);
2176 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
2177 }
2178 }
2179
2180 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2181 ra = -1;
2182 for (int i = 0; i < a.length; i += SPECIES.length()) {
2183 IntVector av = IntVector.fromArray(SPECIES, a, i);
2184 ra &= av.reduceLanes(VectorOperators.AND, vmask);
2185 }
2186 }
2187
2188 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::ANDMasked, Int128VectorTests::ANDMasked);
2189 }
2190
2191
2192 static int OR(int[] a, int idx) {
2193 int res = 0;
2194 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2195 res |= a[i];
2196 }
2197
2198 return res;
2199 }
2200
2201 static int OR(int[] a) {
2202 int res = 0;
2203 for (int i = 0; i < a.length; i += SPECIES.length()) {
2204 int tmp = 0;
2205 for (int j = 0; j < SPECIES.length(); j++) {
2206 tmp |= a[i + j];
2207 }
2208 res |= tmp;
2209 }
2210
2211 return res;
2212 }
2213
2214
2215 @Test(dataProvider = "intUnaryOpProvider")
2216 static void ORInt128VectorTests(IntFunction<int[]> fa) {
2217 int[] a = fa.apply(SPECIES.length());
2218 int[] r = fr.apply(SPECIES.length());
2219 int ra = 0;
2220
2221 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2222 for (int i = 0; i < a.length; i += SPECIES.length()) {
2223 IntVector av = IntVector.fromArray(SPECIES, a, i);
2224 r[i] = av.reduceLanes(VectorOperators.OR);
2225 }
2226 }
2227
2228 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2229 ra = 0;
2230 for (int i = 0; i < a.length; i += SPECIES.length()) {
2231 IntVector av = IntVector.fromArray(SPECIES, a, i);
2232 ra |= av.reduceLanes(VectorOperators.OR);
2233 }
2234 }
2235
2236 assertReductionArraysEquals(a, r, ra, Int128VectorTests::OR, Int128VectorTests::OR);
2237 }
2238
2239
2240 static int ORMasked(int[] a, int idx, boolean[] mask) {
2241 int res = 0;
2242 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2243 if(mask[i % SPECIES.length()])
2244 res |= a[i];
2245 }
2246
2247 return res;
2248 }
2249
2250 static int ORMasked(int[] a, boolean[] mask) {
2251 int res = 0;
2252 for (int i = 0; i < a.length; i += SPECIES.length()) {
2253 int tmp = 0;
2254 for (int j = 0; j < SPECIES.length(); j++) {
2255 if(mask[(i + j) % SPECIES.length()])
2256 tmp |= a[i + j];
2257 }
2258 res |= tmp;
2259 }
2260
2261 return res;
2262 }
2263
2264
2265 @Test(dataProvider = "intUnaryOpMaskProvider")
2266 static void ORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2267 int[] a = fa.apply(SPECIES.length());
2268 int[] r = fr.apply(SPECIES.length());
2269 boolean[] mask = fm.apply(SPECIES.length());
2270 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2271 int ra = 0;
2272
2273 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2274 for (int i = 0; i < a.length; i += SPECIES.length()) {
2275 IntVector av = IntVector.fromArray(SPECIES, a, i);
2276 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
2277 }
2278 }
2279
2280 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2281 ra = 0;
2282 for (int i = 0; i < a.length; i += SPECIES.length()) {
2283 IntVector av = IntVector.fromArray(SPECIES, a, i);
2284 ra |= av.reduceLanes(VectorOperators.OR, vmask);
2285 }
2286 }
2287
2288 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::ORMasked, Int128VectorTests::ORMasked);
2289 }
2290
2291
2292 static int XOR(int[] a, int idx) {
2293 int res = 0;
2294 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2295 res ^= a[i];
2296 }
2297
2298 return res;
2299 }
2300
2301 static int XOR(int[] a) {
2302 int res = 0;
2303 for (int i = 0; i < a.length; i += SPECIES.length()) {
2304 int tmp = 0;
2305 for (int j = 0; j < SPECIES.length(); j++) {
2306 tmp ^= a[i + j];
2307 }
2308 res ^= tmp;
2309 }
2310
2311 return res;
2312 }
2313
2314
2315 @Test(dataProvider = "intUnaryOpProvider")
2316 static void XORInt128VectorTests(IntFunction<int[]> fa) {
2317 int[] a = fa.apply(SPECIES.length());
2318 int[] r = fr.apply(SPECIES.length());
2319 int ra = 0;
2320
2321 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2322 for (int i = 0; i < a.length; i += SPECIES.length()) {
2323 IntVector av = IntVector.fromArray(SPECIES, a, i);
2324 r[i] = av.reduceLanes(VectorOperators.XOR);
2325 }
2326 }
2327
2328 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2329 ra = 0;
2330 for (int i = 0; i < a.length; i += SPECIES.length()) {
2331 IntVector av = IntVector.fromArray(SPECIES, a, i);
2332 ra ^= av.reduceLanes(VectorOperators.XOR);
2333 }
2334 }
2335
2336 assertReductionArraysEquals(a, r, ra, Int128VectorTests::XOR, Int128VectorTests::XOR);
2337 }
2338
2339
2340 static int XORMasked(int[] a, int idx, boolean[] mask) {
2341 int res = 0;
2342 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2343 if(mask[i % SPECIES.length()])
2344 res ^= a[i];
2345 }
2346
2347 return res;
2348 }
2349
2350 static int XORMasked(int[] a, boolean[] mask) {
2351 int res = 0;
2352 for (int i = 0; i < a.length; i += SPECIES.length()) {
2353 int tmp = 0;
2354 for (int j = 0; j < SPECIES.length(); j++) {
2355 if(mask[(i + j) % SPECIES.length()])
2356 tmp ^= a[i + j];
2357 }
2358 res ^= tmp;
2359 }
2360
2361 return res;
2362 }
2363
2364
2365 @Test(dataProvider = "intUnaryOpMaskProvider")
2366 static void XORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2367 int[] a = fa.apply(SPECIES.length());
2368 int[] r = fr.apply(SPECIES.length());
2369 boolean[] mask = fm.apply(SPECIES.length());
2370 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2371 int ra = 0;
2372
2373 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2374 for (int i = 0; i < a.length; i += SPECIES.length()) {
2375 IntVector av = IntVector.fromArray(SPECIES, a, i);
2376 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
2377 }
2378 }
2379
2380 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2381 ra = 0;
2382 for (int i = 0; i < a.length; i += SPECIES.length()) {
2383 IntVector av = IntVector.fromArray(SPECIES, a, i);
2384 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
2385 }
2386 }
2387
2388 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::XORMasked, Int128VectorTests::XORMasked);
2389 }
2390
2391 static int ADD(int[] a, int idx) {
2392 int res = 0;
2393 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2394 res += a[i];
2395 }
2396
2397 return res;
2398 }
2399
2400 static int ADD(int[] a) {
2401 int res = 0;
2402 for (int i = 0; i < a.length; i += SPECIES.length()) {
2403 int tmp = 0;
2404 for (int j = 0; j < SPECIES.length(); j++) {
2405 tmp += a[i + j];
2406 }
2407 res += tmp;
2408 }
2409
2410 return res;
2411 }
2412 @Test(dataProvider = "intUnaryOpProvider")
2413 static void ADDInt128VectorTests(IntFunction<int[]> fa) {
2414 int[] a = fa.apply(SPECIES.length());
2415 int[] r = fr.apply(SPECIES.length());
2416 int ra = 0;
2417
2418 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2419 for (int i = 0; i < a.length; i += SPECIES.length()) {
2420 IntVector av = IntVector.fromArray(SPECIES, a, i);
2421 r[i] = av.reduceLanes(VectorOperators.ADD);
2422 }
2423 }
2424
2425 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2426 ra = 0;
2427 for (int i = 0; i < a.length; i += SPECIES.length()) {
2428 IntVector av = IntVector.fromArray(SPECIES, a, i);
2429 ra += av.reduceLanes(VectorOperators.ADD);
2430 }
2431 }
2432
2433 assertReductionArraysEquals(a, r, ra, Int128VectorTests::ADD, Int128VectorTests::ADD);
2434 }
2435 static int ADDMasked(int[] a, int idx, boolean[] mask) {
2436 int res = 0;
2437 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2438 if(mask[i % SPECIES.length()])
2439 res += a[i];
2440 }
2441
2442 return res;
2443 }
2444
2445 static int ADDMasked(int[] a, boolean[] mask) {
2446 int res = 0;
2447 for (int i = 0; i < a.length; i += SPECIES.length()) {
2448 int tmp = 0;
2449 for (int j = 0; j < SPECIES.length(); j++) {
2450 if(mask[(i + j) % SPECIES.length()])
2451 tmp += a[i + j];
2452 }
2453 res += tmp;
2454 }
2455
2456 return res;
2457 }
2458 @Test(dataProvider = "intUnaryOpMaskProvider")
2459 static void ADDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2460 int[] a = fa.apply(SPECIES.length());
2461 int[] r = fr.apply(SPECIES.length());
2462 boolean[] mask = fm.apply(SPECIES.length());
2463 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2464 int ra = 0;
2465
2466 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2467 for (int i = 0; i < a.length; i += SPECIES.length()) {
2468 IntVector av = IntVector.fromArray(SPECIES, a, i);
2469 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
2470 }
2471 }
2472
2473 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2474 ra = 0;
2475 for (int i = 0; i < a.length; i += SPECIES.length()) {
2476 IntVector av = IntVector.fromArray(SPECIES, a, i);
2477 ra += av.reduceLanes(VectorOperators.ADD, vmask);
2478 }
2479 }
2480
2481 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::ADDMasked, Int128VectorTests::ADDMasked);
2482 }
2483 static int MUL(int[] a, int idx) {
2484 int res = 1;
2485 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2486 res *= a[i];
2487 }
2488
2489 return res;
2490 }
2491
2492 static int MUL(int[] a) {
2493 int res = 1;
2494 for (int i = 0; i < a.length; i += SPECIES.length()) {
2495 int tmp = 1;
2496 for (int j = 0; j < SPECIES.length(); j++) {
2497 tmp *= a[i + j];
2498 }
2499 res *= tmp;
2500 }
2501
2502 return res;
2503 }
2504 @Test(dataProvider = "intUnaryOpProvider")
2505 static void MULInt128VectorTests(IntFunction<int[]> fa) {
2506 int[] a = fa.apply(SPECIES.length());
2507 int[] r = fr.apply(SPECIES.length());
2508 int ra = 1;
2509
2510 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2511 for (int i = 0; i < a.length; i += SPECIES.length()) {
2512 IntVector av = IntVector.fromArray(SPECIES, a, i);
2513 r[i] = av.reduceLanes(VectorOperators.MUL);
2514 }
2515 }
2516
2517 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2518 ra = 1;
2519 for (int i = 0; i < a.length; i += SPECIES.length()) {
2520 IntVector av = IntVector.fromArray(SPECIES, a, i);
2521 ra *= av.reduceLanes(VectorOperators.MUL);
2522 }
2523 }
2524
2525 assertReductionArraysEquals(a, r, ra, Int128VectorTests::MUL, Int128VectorTests::MUL);
2526 }
2527 static int MULMasked(int[] a, int idx, boolean[] mask) {
2528 int res = 1;
2529 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2530 if(mask[i % SPECIES.length()])
2531 res *= a[i];
2532 }
2533
2534 return res;
2535 }
2536
2537 static int MULMasked(int[] a, boolean[] mask) {
2538 int res = 1;
2539 for (int i = 0; i < a.length; i += SPECIES.length()) {
2540 int tmp = 1;
2541 for (int j = 0; j < SPECIES.length(); j++) {
2542 if(mask[(i + j) % SPECIES.length()])
2543 tmp *= a[i + j];
2544 }
2545 res *= tmp;
2546 }
2547
2548 return res;
2549 }
2550 @Test(dataProvider = "intUnaryOpMaskProvider")
2551 static void MULInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2552 int[] a = fa.apply(SPECIES.length());
2553 int[] r = fr.apply(SPECIES.length());
2554 boolean[] mask = fm.apply(SPECIES.length());
2555 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2556 int ra = 1;
2557
2558 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2559 for (int i = 0; i < a.length; i += SPECIES.length()) {
2560 IntVector av = IntVector.fromArray(SPECIES, a, i);
2561 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
2562 }
2563 }
2564
2565 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2566 ra = 1;
2567 for (int i = 0; i < a.length; i += SPECIES.length()) {
2568 IntVector av = IntVector.fromArray(SPECIES, a, i);
2569 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
2570 }
2571 }
2572
2573 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::MULMasked, Int128VectorTests::MULMasked);
2574 }
2575 static int MIN(int[] a, int idx) {
2576 int res = Integer.MAX_VALUE;
2577 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2578 res = (int)Math.min(res, a[i]);
2579 }
2580
2581 return res;
2582 }
2583
2584 static int MIN(int[] a) {
2585 int res = Integer.MAX_VALUE;
2586 for (int i = 0; i < a.length; i++) {
2587 res = (int)Math.min(res, a[i]);
2588 }
2589
2590 return res;
2591 }
2592 @Test(dataProvider = "intUnaryOpProvider")
2593 static void MINInt128VectorTests(IntFunction<int[]> fa) {
2594 int[] a = fa.apply(SPECIES.length());
2595 int[] r = fr.apply(SPECIES.length());
2596 int ra = Integer.MAX_VALUE;
2597
2598 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2599 for (int i = 0; i < a.length; i += SPECIES.length()) {
2600 IntVector av = IntVector.fromArray(SPECIES, a, i);
2601 r[i] = av.reduceLanes(VectorOperators.MIN);
2602 }
2603 }
2604
2605 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2606 ra = Integer.MAX_VALUE;
2607 for (int i = 0; i < a.length; i += SPECIES.length()) {
2608 IntVector av = IntVector.fromArray(SPECIES, a, i);
2609 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN));
2610 }
2611 }
2612
2613 assertReductionArraysEquals(a, r, ra, Int128VectorTests::MIN, Int128VectorTests::MIN);
2614 }
2615 static int MINMasked(int[] a, int idx, boolean[] mask) {
2616 int res = Integer.MAX_VALUE;
2617 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2618 if(mask[i % SPECIES.length()])
2619 res = (int)Math.min(res, a[i]);
2620 }
2621
2622 return res;
2623 }
2624
2625 static int MINMasked(int[] a, boolean[] mask) {
2626 int res = Integer.MAX_VALUE;
2627 for (int i = 0; i < a.length; i++) {
2628 if(mask[i % SPECIES.length()])
2629 res = (int)Math.min(res, a[i]);
2630 }
2631
2632 return res;
2633 }
2634 @Test(dataProvider = "intUnaryOpMaskProvider")
2635 static void MINInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2636 int[] a = fa.apply(SPECIES.length());
2637 int[] r = fr.apply(SPECIES.length());
2638 boolean[] mask = fm.apply(SPECIES.length());
2639 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2640 int ra = Integer.MAX_VALUE;
2641
2642 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2643 for (int i = 0; i < a.length; i += SPECIES.length()) {
2644 IntVector av = IntVector.fromArray(SPECIES, a, i);
2645 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
2646 }
2647 }
2648
2649 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2650 ra = Integer.MAX_VALUE;
2651 for (int i = 0; i < a.length; i += SPECIES.length()) {
2652 IntVector av = IntVector.fromArray(SPECIES, a, i);
2653 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
2654 }
2655 }
2656
2657 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::MINMasked, Int128VectorTests::MINMasked);
2658 }
2659 static int MAX(int[] a, int idx) {
2660 int res = Integer.MIN_VALUE;
2661 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2662 res = (int)Math.max(res, a[i]);
2663 }
2664
2665 return res;
2666 }
2667
2668 static int MAX(int[] a) {
2669 int res = Integer.MIN_VALUE;
2670 for (int i = 0; i < a.length; i++) {
2671 res = (int)Math.max(res, a[i]);
2672 }
2673
2674 return res;
2675 }
2676 @Test(dataProvider = "intUnaryOpProvider")
2677 static void MAXInt128VectorTests(IntFunction<int[]> fa) {
2678 int[] a = fa.apply(SPECIES.length());
2679 int[] r = fr.apply(SPECIES.length());
2680 int ra = Integer.MIN_VALUE;
2681
2682 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2683 for (int i = 0; i < a.length; i += SPECIES.length()) {
2684 IntVector av = IntVector.fromArray(SPECIES, a, i);
2685 r[i] = av.reduceLanes(VectorOperators.MAX);
2686 }
2687 }
2688
2689 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2690 ra = Integer.MIN_VALUE;
2691 for (int i = 0; i < a.length; i += SPECIES.length()) {
2692 IntVector av = IntVector.fromArray(SPECIES, a, i);
2693 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX));
2694 }
2695 }
2696
2697 assertReductionArraysEquals(a, r, ra, Int128VectorTests::MAX, Int128VectorTests::MAX);
2698 }
2699 static int MAXMasked(int[] a, int idx, boolean[] mask) {
2700 int res = Integer.MIN_VALUE;
2701 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2702 if(mask[i % SPECIES.length()])
2703 res = (int)Math.max(res, a[i]);
2704 }
2705
2706 return res;
2707 }
2708
2709 static int MAXMasked(int[] a, boolean[] mask) {
2710 int res = Integer.MIN_VALUE;
2711 for (int i = 0; i < a.length; i++) {
2712 if(mask[i % SPECIES.length()])
2713 res = (int)Math.max(res, a[i]);
2714 }
2715
2716 return res;
2717 }
2718 @Test(dataProvider = "intUnaryOpMaskProvider")
2719 static void MAXInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2720 int[] a = fa.apply(SPECIES.length());
2721 int[] r = fr.apply(SPECIES.length());
2722 boolean[] mask = fm.apply(SPECIES.length());
2723 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2724 int ra = Integer.MIN_VALUE;
2725
2726 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2727 for (int i = 0; i < a.length; i += SPECIES.length()) {
2728 IntVector av = IntVector.fromArray(SPECIES, a, i);
2729 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
2730 }
2731 }
2732
2733 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2734 ra = Integer.MIN_VALUE;
2735 for (int i = 0; i < a.length; i += SPECIES.length()) {
2736 IntVector av = IntVector.fromArray(SPECIES, a, i);
2737 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
2738 }
2739 }
2740
2741 assertReductionArraysEqualsMasked(a, r, ra, mask, Int128VectorTests::MAXMasked, Int128VectorTests::MAXMasked);
2742 }
2743
2744 static boolean anyTrue(boolean[] a, int idx) {
2745 boolean res = false;
2746 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2747 res |= a[i];
2748 }
2749
2750 return res;
2751 }
2752
2753
2754 @Test(dataProvider = "boolUnaryOpProvider")
2755 static void anyTrueInt128VectorTests(IntFunction<boolean[]> fm) {
2756 boolean[] mask = fm.apply(SPECIES.length());
2757 boolean[] r = fmr.apply(SPECIES.length());
2758
2759 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2760 for (int i = 0; i < mask.length; i += SPECIES.length()) {
2761 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
2762 r[i] = vmask.anyTrue();
2763 }
2764 }
2765
2766 assertReductionBoolArraysEquals(mask, r, Int128VectorTests::anyTrue);
2767 }
2768
2769
2770 static boolean allTrue(boolean[] a, int idx) {
2771 boolean res = true;
2772 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2773 res &= a[i];
2774 }
2775
2776 return res;
2777 }
2778
2779
2780 @Test(dataProvider = "boolUnaryOpProvider")
2781 static void allTrueInt128VectorTests(IntFunction<boolean[]> fm) {
2782 boolean[] mask = fm.apply(SPECIES.length());
2783 boolean[] r = fmr.apply(SPECIES.length());
2784
2785 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2786 for (int i = 0; i < mask.length; i += SPECIES.length()) {
2787 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
2788 r[i] = vmask.allTrue();
2789 }
2790 }
2791
2792 assertReductionBoolArraysEquals(mask, r, Int128VectorTests::allTrue);
2793 }
2794
2795
2796 @Test(dataProvider = "intUnaryOpProvider")
2797 static void withInt128VectorTests(IntFunction<int []> fa) {
2798 int[] a = fa.apply(SPECIES.length());
2799 int[] r = fr.apply(SPECIES.length());
2800
2801 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2802 for (int i = 0; i < a.length; i += SPECIES.length()) {
2803 IntVector av = IntVector.fromArray(SPECIES, a, i);
2804 av.withLane(0, (int)4).intoArray(r, i);
2805 }
2806 }
2807
2808 assertInsertArraysEquals(a, r, (int)4, 0);
2809 }
2810 static boolean testIS_DEFAULT(int a) {
2811 return bits(a)==0;
2812 }
2813
2814 @Test(dataProvider = "intTestOpProvider")
2815 static void IS_DEFAULTInt128VectorTests(IntFunction<int[]> fa) {
2816 int[] a = fa.apply(SPECIES.length());
2817
2818 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2819 for (int i = 0; i < a.length; i += SPECIES.length()) {
2820 IntVector av = IntVector.fromArray(SPECIES, a, i);
2821 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
2822
2823 // Check results as part of computation.
2824 for (int j = 0; j < SPECIES.length(); j++) {
2825
2826 Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
2827 }
2828 }
2829 }
2830 }
2831
2832 static boolean testIS_NEGATIVE(int a) {
2833 return bits(a)<0;
2834 }
2835
2836 @Test(dataProvider = "intTestOpProvider")
2837 static void IS_NEGATIVEInt128VectorTests(IntFunction<int[]> fa) {
2838 int[] a = fa.apply(SPECIES.length());
2839
2840 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2841 for (int i = 0; i < a.length; i += SPECIES.length()) {
2842 IntVector av = IntVector.fromArray(SPECIES, a, i);
2843 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
2844
2845 // Check results as part of computation.
2846 for (int j = 0; j < SPECIES.length(); j++) {
2847
2848 Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
2849 }
2850 }
2851 }
2852 }
2853
2854
2855
2856
2857
2858 @Test(dataProvider = "intCompareOpProvider")
2859 static void LTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2860 int[] a = fa.apply(SPECIES.length());
2861 int[] b = fb.apply(SPECIES.length());
2862
2863 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2864 for (int i = 0; i < a.length; i += SPECIES.length()) {
2865 IntVector av = IntVector.fromArray(SPECIES, a, i);
2866 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2867 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
2868
2869 // Check results as part of computation.
2870 for (int j = 0; j < SPECIES.length(); j++) {
2871 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
2872 }
2873 }
2874 }
2875 }
2876
2877
2878 @Test(dataProvider = "intCompareOpProvider")
2879 static void ltInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2880 int[] a = fa.apply(SPECIES.length());
2881 int[] b = fb.apply(SPECIES.length());
2882
2883 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2884 for (int i = 0; i < a.length; i += SPECIES.length()) {
2885 IntVector av = IntVector.fromArray(SPECIES, a, i);
2886 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2887 VectorMask<Integer> mv = av.lt(bv);
2888
2889 // Check results as part of computation.
2890 for (int j = 0; j < SPECIES.length(); j++) {
2891 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
2892 }
2893 }
2894 }
2895 }
2896
2897
2898 @Test(dataProvider = "intCompareOpProvider")
2899 static void GTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2900 int[] a = fa.apply(SPECIES.length());
2901 int[] b = fb.apply(SPECIES.length());
2902
2903 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2904 for (int i = 0; i < a.length; i += SPECIES.length()) {
2905 IntVector av = IntVector.fromArray(SPECIES, a, i);
2906 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2907 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
2908
2909 // Check results as part of computation.
2910 for (int j = 0; j < SPECIES.length(); j++) {
2911 Assert.assertEquals(mv.laneIsSet(j), a[i + j] > b[i + j]);
2912 }
2913 }
2914 }
2915 }
2916
2917
2918 @Test(dataProvider = "intCompareOpProvider")
2919 static void EQInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2920 int[] a = fa.apply(SPECIES.length());
2921 int[] b = fb.apply(SPECIES.length());
2922
2923 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2924 for (int i = 0; i < a.length; i += SPECIES.length()) {
2925 IntVector av = IntVector.fromArray(SPECIES, a, i);
2926 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2927 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
2928
2929 // Check results as part of computation.
2930 for (int j = 0; j < SPECIES.length(); j++) {
2931 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
2932 }
2933 }
2934 }
2935 }
2936
2937
2938 @Test(dataProvider = "intCompareOpProvider")
2939 static void eqInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2940 int[] a = fa.apply(SPECIES.length());
2941 int[] b = fb.apply(SPECIES.length());
2942
2943 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2944 for (int i = 0; i < a.length; i += SPECIES.length()) {
2945 IntVector av = IntVector.fromArray(SPECIES, a, i);
2946 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2947 VectorMask<Integer> mv = av.eq(bv);
2948
2949 // Check results as part of computation.
2950 for (int j = 0; j < SPECIES.length(); j++) {
2951 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
2952 }
2953 }
2954 }
2955 }
2956
2957
2958 @Test(dataProvider = "intCompareOpProvider")
2959 static void NEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2960 int[] a = fa.apply(SPECIES.length());
2961 int[] b = fb.apply(SPECIES.length());
2962
2963 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2964 for (int i = 0; i < a.length; i += SPECIES.length()) {
2965 IntVector av = IntVector.fromArray(SPECIES, a, i);
2966 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2967 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
2968
2969 // Check results as part of computation.
2970 for (int j = 0; j < SPECIES.length(); j++) {
2971 Assert.assertEquals(mv.laneIsSet(j), a[i + j] != b[i + j]);
2972 }
2973 }
2974 }
2975 }
2976
2977
2978 @Test(dataProvider = "intCompareOpProvider")
2979 static void LEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2980 int[] a = fa.apply(SPECIES.length());
2981 int[] b = fb.apply(SPECIES.length());
2982
2983 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2984 for (int i = 0; i < a.length; i += SPECIES.length()) {
2985 IntVector av = IntVector.fromArray(SPECIES, a, i);
2986 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2987 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
2988
2989 // Check results as part of computation.
2990 for (int j = 0; j < SPECIES.length(); j++) {
2991 Assert.assertEquals(mv.laneIsSet(j), a[i + j] <= b[i + j]);
2992 }
2993 }
2994 }
2995 }
2996
2997
2998 @Test(dataProvider = "intCompareOpProvider")
2999 static void GEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3000 int[] a = fa.apply(SPECIES.length());
3001 int[] b = fb.apply(SPECIES.length());
3002
3003 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3004 for (int i = 0; i < a.length; i += SPECIES.length()) {
3005 IntVector av = IntVector.fromArray(SPECIES, a, i);
3006 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3007 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
3008
3009 // Check results as part of computation.
3010 for (int j = 0; j < SPECIES.length(); j++) {
3011 Assert.assertEquals(mv.laneIsSet(j), a[i + j] >= b[i + j]);
3012 }
3013 }
3014 }
3015 }
3016
3017
3018 static int blend(int a, int b, boolean mask) {
3019 return mask ? b : a;
3020 }
3021
3022 @Test(dataProvider = "intBinaryOpMaskProvider")
3023 static void blendInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
3024 IntFunction<boolean[]> fm) {
3025 int[] a = fa.apply(SPECIES.length());
3026 int[] b = fb.apply(SPECIES.length());
3027 int[] r = fr.apply(SPECIES.length());
3028 boolean[] mask = fm.apply(SPECIES.length());
3029 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3030
3031 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3032 for (int i = 0; i < a.length; i += SPECIES.length()) {
3033 IntVector av = IntVector.fromArray(SPECIES, a, i);
3034 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3035 av.blend(bv, vmask).intoArray(r, i);
3036 }
3037 }
3038
3039 assertArraysEquals(a, b, r, mask, Int128VectorTests::blend);
3040 }
3041
3042 @Test(dataProvider = "intUnaryOpShuffleProvider")
3043 static void RearrangeInt128VectorTests(IntFunction<int[]> fa,
3044 BiFunction<Integer,Integer,int[]> fs) {
3045 int[] a = fa.apply(SPECIES.length());
3046 int[] order = fs.apply(a.length, SPECIES.length());
3047 int[] r = fr.apply(SPECIES.length());
3048
3049 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3050 for (int i = 0; i < a.length; i += SPECIES.length()) {
3051 IntVector av = IntVector.fromArray(SPECIES, a, i);
3052 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
3053 }
3054 }
3055
3056 assertRearrangeArraysEquals(a, r, order, SPECIES.length());
3057 }
3058
3059
3060
3061
3062 @Test(dataProvider = "intUnaryOpProvider")
3063 static void getInt128VectorTests(IntFunction<int[]> fa) {
3064 int[] a = fa.apply(SPECIES.length());
3065 int[] r = fr.apply(SPECIES.length());
3066
3067 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3068 for (int i = 0; i < a.length; i += SPECIES.length()) {
3069 IntVector av = IntVector.fromArray(SPECIES, a, i);
3070 int num_lanes = SPECIES.length();
3071 // Manually unroll because full unroll happens after intrinsification.
3072 // Unroll is needed because get intrinsic requires for index to be a known constant.
3073 if (num_lanes == 1) {
3074 r[i]=av.lane(0);
3075 } else if (num_lanes == 2) {
3076 r[i]=av.lane(0);
3077 r[i+1]=av.lane(1);
3078 } else if (num_lanes == 4) {
3079 r[i]=av.lane(0);
3080 r[i+1]=av.lane(1);
3081 r[i+2]=av.lane(2);
3082 r[i+3]=av.lane(3);
3083 } else if (num_lanes == 8) {
3084 r[i]=av.lane(0);
3085 r[i+1]=av.lane(1);
3086 r[i+2]=av.lane(2);
3087 r[i+3]=av.lane(3);
3088 r[i+4]=av.lane(4);
3089 r[i+5]=av.lane(5);
3090 r[i+6]=av.lane(6);
3091 r[i+7]=av.lane(7);
3092 } else if (num_lanes == 16) {
3093 r[i]=av.lane(0);
3094 r[i+1]=av.lane(1);
3095 r[i+2]=av.lane(2);
3096 r[i+3]=av.lane(3);
3097 r[i+4]=av.lane(4);
3098 r[i+5]=av.lane(5);
3099 r[i+6]=av.lane(6);
3100 r[i+7]=av.lane(7);
3101 r[i+8]=av.lane(8);
3102 r[i+9]=av.lane(9);
3103 r[i+10]=av.lane(10);
3104 r[i+11]=av.lane(11);
3105 r[i+12]=av.lane(12);
3106 r[i+13]=av.lane(13);
3107 r[i+14]=av.lane(14);
3108 r[i+15]=av.lane(15);
3109 } else if (num_lanes == 32) {
3110 r[i]=av.lane(0);
3111 r[i+1]=av.lane(1);
3112 r[i+2]=av.lane(2);
3113 r[i+3]=av.lane(3);
3114 r[i+4]=av.lane(4);
3115 r[i+5]=av.lane(5);
3116 r[i+6]=av.lane(6);
3117 r[i+7]=av.lane(7);
3118 r[i+8]=av.lane(8);
3119 r[i+9]=av.lane(9);
3120 r[i+10]=av.lane(10);
3121 r[i+11]=av.lane(11);
3122 r[i+12]=av.lane(12);
3123 r[i+13]=av.lane(13);
3124 r[i+14]=av.lane(14);
3125 r[i+15]=av.lane(15);
3126 r[i+16]=av.lane(16);
3127 r[i+17]=av.lane(17);
3128 r[i+18]=av.lane(18);
3129 r[i+19]=av.lane(19);
3130 r[i+20]=av.lane(20);
3131 r[i+21]=av.lane(21);
3132 r[i+22]=av.lane(22);
3133 r[i+23]=av.lane(23);
3134 r[i+24]=av.lane(24);
3135 r[i+25]=av.lane(25);
3136 r[i+26]=av.lane(26);
3137 r[i+27]=av.lane(27);
3138 r[i+28]=av.lane(28);
3139 r[i+29]=av.lane(29);
3140 r[i+30]=av.lane(30);
3141 r[i+31]=av.lane(31);
3142 } else if (num_lanes == 64) {
3143 r[i]=av.lane(0);
3144 r[i+1]=av.lane(1);
3145 r[i+2]=av.lane(2);
3146 r[i+3]=av.lane(3);
3147 r[i+4]=av.lane(4);
3148 r[i+5]=av.lane(5);
3149 r[i+6]=av.lane(6);
3150 r[i+7]=av.lane(7);
3151 r[i+8]=av.lane(8);
3152 r[i+9]=av.lane(9);
3153 r[i+10]=av.lane(10);
3154 r[i+11]=av.lane(11);
3155 r[i+12]=av.lane(12);
3156 r[i+13]=av.lane(13);
3157 r[i+14]=av.lane(14);
3158 r[i+15]=av.lane(15);
3159 r[i+16]=av.lane(16);
3160 r[i+17]=av.lane(17);
3161 r[i+18]=av.lane(18);
3162 r[i+19]=av.lane(19);
3163 r[i+20]=av.lane(20);
3164 r[i+21]=av.lane(21);
3165 r[i+22]=av.lane(22);
3166 r[i+23]=av.lane(23);
3167 r[i+24]=av.lane(24);
3168 r[i+25]=av.lane(25);
3169 r[i+26]=av.lane(26);
3170 r[i+27]=av.lane(27);
3171 r[i+28]=av.lane(28);
3172 r[i+29]=av.lane(29);
3173 r[i+30]=av.lane(30);
3174 r[i+31]=av.lane(31);
3175 r[i+32]=av.lane(32);
3176 r[i+33]=av.lane(33);
3177 r[i+34]=av.lane(34);
3178 r[i+35]=av.lane(35);
3179 r[i+36]=av.lane(36);
3180 r[i+37]=av.lane(37);
3181 r[i+38]=av.lane(38);
3182 r[i+39]=av.lane(39);
3183 r[i+40]=av.lane(40);
3184 r[i+41]=av.lane(41);
3185 r[i+42]=av.lane(42);
3186 r[i+43]=av.lane(43);
3187 r[i+44]=av.lane(44);
3188 r[i+45]=av.lane(45);
3189 r[i+46]=av.lane(46);
3190 r[i+47]=av.lane(47);
3191 r[i+48]=av.lane(48);
3192 r[i+49]=av.lane(49);
3193 r[i+50]=av.lane(50);
3194 r[i+51]=av.lane(51);
3195 r[i+52]=av.lane(52);
3196 r[i+53]=av.lane(53);
3197 r[i+54]=av.lane(54);
3198 r[i+55]=av.lane(55);
3199 r[i+56]=av.lane(56);
3200 r[i+57]=av.lane(57);
3201 r[i+58]=av.lane(58);
3202 r[i+59]=av.lane(59);
3203 r[i+60]=av.lane(60);
3204 r[i+61]=av.lane(61);
3205 r[i+62]=av.lane(62);
3206 r[i+63]=av.lane(63);
3207 } else {
3208 for (int j = 0; j < SPECIES.length(); j++) {
3209 r[i+j]=av.lane(j);
3210 }
3211 }
3212 }
3213 }
3214
3215 assertArraysEquals(a, r, Int128VectorTests::get);
3216 }
3217
3218 @Test(dataProvider = "intUnaryOpProvider")
3219 static void BroadcastInt128VectorTests(IntFunction<int[]> fa) {
3220 int[] a = fa.apply(SPECIES.length());
3221 int[] r = new int[a.length];
3222
3223 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3224 for (int i = 0; i < a.length; i += SPECIES.length()) {
3225 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
3226 }
3227 }
3228
3229 assertBroadcastArraysEquals(a, r);
3230 }
3231
3232
3233
3234
3235
3236 @Test(dataProvider = "intUnaryOpProvider")
3237 static void ZeroInt128VectorTests(IntFunction<int[]> fa) {
3238 int[] a = fa.apply(SPECIES.length());
3239 int[] r = new int[a.length];
3240
3241 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3242 for (int i = 0; i < a.length; i += SPECIES.length()) {
3243 IntVector.zero(SPECIES).intoArray(a, i);
3244 }
3245 }
3246
3247 Assert.assertEquals(a, r);
3248 }
3249
3250
3251
3252
3253 static int[] sliceUnary(int[] a, int origin, int idx) {
3254 int[] res = new int[SPECIES.length()];
3255 for (int i = 0; i < SPECIES.length(); i++){
3256 if(i+origin < SPECIES.length())
3257 res[i] = a[idx+i+origin];
3258 else
3259 res[i] = (int)0;
3260 }
3261 return res;
3262 }
3263
3264 @Test(dataProvider = "intUnaryOpProvider")
3265 static void sliceUnaryInt128VectorTests(IntFunction<int[]> fa) {
3266 int[] a = fa.apply(SPECIES.length());
3267 int[] r = new int[a.length];
3268 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3269 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3270 for (int i = 0; i < a.length; i += SPECIES.length()) {
3271 IntVector av = IntVector.fromArray(SPECIES, a, i);
3272 av.slice(origin).intoArray(r, i);
3273 }
3274 }
3275
3276 assertArraysEquals(a, r, origin, Int128VectorTests::sliceUnary);
3277 }
3278 static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
3279 int[] res = new int[SPECIES.length()];
3280 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3281 if(i+origin < SPECIES.length())
3282 res[i] = a[idx+i+origin];
3283 else {
3284 res[i] = b[idx+j];
3285 j++;
3286 }
3287 }
3288 return res;
3289 }
3290
3291 @Test(dataProvider = "intBinaryOpProvider")
3292 static void sliceBinaryInt128VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3293 int[] a = fa.apply(SPECIES.length());
3294 int[] b = fb.apply(SPECIES.length());
3295 int[] r = new int[a.length];
3296 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3297 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3298 for (int i = 0; i < a.length; i += SPECIES.length()) {
3299 IntVector av = IntVector.fromArray(SPECIES, a, i);
3300 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3301 av.slice(origin, bv).intoArray(r, i);
3302 }
3303 }
3304
3305 assertArraysEquals(a, b, r, origin, Int128VectorTests::sliceBinary);
3306 }
3307 static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
3308 int[] res = new int[SPECIES.length()];
3309 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3310 if(i+origin < SPECIES.length())
3311 res[i] = mask[i] ? a[idx+i+origin] : (int)0;
3312 else {
3313 res[i] = mask[i] ? b[idx+j] : (int)0;
3314 j++;
3315 }
3316 }
3317 return res;
3318 }
3319
3320 @Test(dataProvider = "intBinaryOpMaskProvider")
3321 static void sliceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3322 IntFunction<boolean[]> fm) {
3323 int[] a = fa.apply(SPECIES.length());
3324 int[] b = fb.apply(SPECIES.length());
3325 boolean[] mask = fm.apply(SPECIES.length());
3326 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3327
3328 int[] r = new int[a.length];
3329 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3330 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3331 for (int i = 0; i < a.length; i += SPECIES.length()) {
3332 IntVector av = IntVector.fromArray(SPECIES, a, i);
3333 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3334 av.slice(origin, bv, vmask).intoArray(r, i);
3335 }
3336 }
3337
3338 assertArraysEquals(a, b, r, origin, mask, Int128VectorTests::slice);
3339 }
3340 static int[] unsliceUnary(int[] a, int origin, int idx) {
3341 int[] res = new int[SPECIES.length()];
3342 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3343 if(i < origin)
3344 res[i] = (int)0;
3345 else {
3346 res[i] = a[idx+j];
3347 j++;
3348 }
3349 }
3350 return res;
3351 }
3352
3353 @Test(dataProvider = "intUnaryOpProvider")
3354 static void unsliceUnaryInt128VectorTests(IntFunction<int[]> fa) {
3355 int[] a = fa.apply(SPECIES.length());
3356 int[] r = new int[a.length];
3357 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3358 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3359 for (int i = 0; i < a.length; i += SPECIES.length()) {
3360 IntVector av = IntVector.fromArray(SPECIES, a, i);
3361 av.unslice(origin).intoArray(r, i);
3362 }
3363 }
3364
3365 assertArraysEquals(a, r, origin, Int128VectorTests::unsliceUnary);
3366 }
3367 static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
3368 int[] res = new int[SPECIES.length()];
3369 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3370 if (part == 0) {
3371 if (i < origin)
3372 res[i] = b[idx+i];
3373 else {
3374 res[i] = a[idx+j];
3375 j++;
3376 }
3377 } else if (part == 1) {
3378 if (i < origin)
3379 res[i] = a[idx+SPECIES.length()-origin+i];
3380 else {
3381 res[i] = b[idx+origin+j];
3382 j++;
3383 }
3384 }
3385 }
3386 return res;
3387 }
3388
3389 @Test(dataProvider = "intBinaryOpProvider")
3390 static void unsliceBinaryInt128VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3391 int[] a = fa.apply(SPECIES.length());
3392 int[] b = fb.apply(SPECIES.length());
3393 int[] r = new int[a.length];
3394 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3395 int part = (new java.util.Random()).nextInt(2);
3396 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3397 for (int i = 0; i < a.length; i += SPECIES.length()) {
3398 IntVector av = IntVector.fromArray(SPECIES, a, i);
3399 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3400 av.unslice(origin, bv, part).intoArray(r, i);
3401 }
3402 }
3403
3404 assertArraysEquals(a, b, r, origin, part, Int128VectorTests::unsliceBinary);
3405 }
3406 static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
3407 int[] res = new int[SPECIES.length()];
3408 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3409 if(i+origin < SPECIES.length())
3410 res[i] = b[idx+i+origin];
3411 else {
3412 res[i] = b[idx+j];
3413 j++;
3414 }
3415 }
3416 for (int i = 0; i < SPECIES.length(); i++){
3417 res[i] = mask[i] ? a[idx+i] : res[i];
3418 }
3419 int[] res1 = new int[SPECIES.length()];
3420 if (part == 0) {
3421 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3422 if (i < origin)
3423 res1[i] = b[idx+i];
3424 else {
3425 res1[i] = res[j];
3426 j++;
3427 }
3428 }
3429 } else if (part == 1) {
3430 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3431 if (i < origin)
3432 res1[i] = res[SPECIES.length()-origin+i];
3433 else {
3434 res1[i] = b[idx+origin+j];
3435 j++;
3436 }
3437 }
3438 }
3439 return res1;
3440 }
3441
3442 @Test(dataProvider = "intBinaryOpMaskProvider")
3443 static void unsliceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3444 IntFunction<boolean[]> fm) {
3445 int[] a = fa.apply(SPECIES.length());
3446 int[] b = fb.apply(SPECIES.length());
3447 boolean[] mask = fm.apply(SPECIES.length());
3448 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3449 int[] r = new int[a.length];
3450 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3451 int part = (new java.util.Random()).nextInt(2);
3452 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3453 for (int i = 0; i < a.length; i += SPECIES.length()) {
3454 IntVector av = IntVector.fromArray(SPECIES, a, i);
3455 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3456 av.unslice(origin, bv, part, vmask).intoArray(r, i);
3457 }
3458 }
3459
3460 assertArraysEquals(a, b, r, origin, part, mask, Int128VectorTests::unslice);
3461 }
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484 static int BITWISE_BLEND(int a, int b, int c) {
3485 return (int)((a&~(c))|(b&c));
3486 }
3487
3488
3489 @Test(dataProvider = "intTernaryOpProvider")
3490 static void BITWISE_BLENDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
3491 int[] a = fa.apply(SPECIES.length());
3492 int[] b = fb.apply(SPECIES.length());
3493 int[] c = fc.apply(SPECIES.length());
3494 int[] r = fr.apply(SPECIES.length());
3495
3496 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3497 for (int i = 0; i < a.length; i += SPECIES.length()) {
3498 IntVector av = IntVector.fromArray(SPECIES, a, i);
3499 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3500 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3501 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
3502 }
3503 }
3504
3505 assertArraysEquals(a, b, c, r, Int128VectorTests::BITWISE_BLEND);
3506 }
3507
3508
3509 @Test(dataProvider = "intTernaryOpMaskProvider")
3510 static void BITWISE_BLENDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
3511 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
3512 int[] a = fa.apply(SPECIES.length());
3513 int[] b = fb.apply(SPECIES.length());
3514 int[] c = fc.apply(SPECIES.length());
3515 int[] r = fr.apply(SPECIES.length());
3516 boolean[] mask = fm.apply(SPECIES.length());
3517 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3518
3519 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3520 for (int i = 0; i < a.length; i += SPECIES.length()) {
3521 IntVector av = IntVector.fromArray(SPECIES, a, i);
3522 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3523 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3524 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
3525 }
3526 }
3527
3528 assertArraysEquals(a, b, c, r, mask, Int128VectorTests::BITWISE_BLEND);
3529 }
3530
3531
3532 static int NEG(int a) {
3533 return (int)(-((int)a));
3534 }
3535
3536 static int neg(int a) {
3537 return (int)(-((int)a));
3538 }
3539
3540 @Test(dataProvider = "intUnaryOpProvider")
3541 static void NEGInt128VectorTests(IntFunction<int[]> fa) {
3542 int[] a = fa.apply(SPECIES.length());
3543 int[] r = fr.apply(SPECIES.length());
3544
3545 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3546 for (int i = 0; i < a.length; i += SPECIES.length()) {
3547 IntVector av = IntVector.fromArray(SPECIES, a, i);
3548 av.lanewise(VectorOperators.NEG).intoArray(r, i);
3549 }
3550 }
3551
3552 assertArraysEquals(a, r, Int128VectorTests::NEG);
3553 }
3554
3555 @Test(dataProvider = "intUnaryOpProvider")
3556 static void negInt128VectorTests(IntFunction<int[]> fa) {
3557 int[] a = fa.apply(SPECIES.length());
3558 int[] r = fr.apply(SPECIES.length());
3559
3560 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3561 for (int i = 0; i < a.length; i += SPECIES.length()) {
3562 IntVector av = IntVector.fromArray(SPECIES, a, i);
3563 av.neg().intoArray(r, i);
3564 }
3565 }
3566
3567 assertArraysEquals(a, r, Int128VectorTests::neg);
3568 }
3569
3570 @Test(dataProvider = "intUnaryOpMaskProvider")
3571 static void NEGMaskedInt128VectorTests(IntFunction<int[]> fa,
3572 IntFunction<boolean[]> fm) {
3573 int[] a = fa.apply(SPECIES.length());
3574 int[] r = fr.apply(SPECIES.length());
3575 boolean[] mask = fm.apply(SPECIES.length());
3576 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3577
3578 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3579 for (int i = 0; i < a.length; i += SPECIES.length()) {
3580 IntVector av = IntVector.fromArray(SPECIES, a, i);
3581 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
3582 }
3583 }
3584
3585 assertArraysEquals(a, r, mask, Int128VectorTests::NEG);
3586 }
3587
3588 static int ABS(int a) {
3589 return (int)(Math.abs((int)a));
3590 }
3591
3592 static int abs(int a) {
3593 return (int)(Math.abs((int)a));
3594 }
3595
3596 @Test(dataProvider = "intUnaryOpProvider")
3597 static void ABSInt128VectorTests(IntFunction<int[]> fa) {
3598 int[] a = fa.apply(SPECIES.length());
3599 int[] r = fr.apply(SPECIES.length());
3600
3601 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3602 for (int i = 0; i < a.length; i += SPECIES.length()) {
3603 IntVector av = IntVector.fromArray(SPECIES, a, i);
3604 av.lanewise(VectorOperators.ABS).intoArray(r, i);
3605 }
3606 }
3607
3608 assertArraysEquals(a, r, Int128VectorTests::ABS);
3609 }
3610
3611 @Test(dataProvider = "intUnaryOpProvider")
3612 static void absInt128VectorTests(IntFunction<int[]> fa) {
3613 int[] a = fa.apply(SPECIES.length());
3614 int[] r = fr.apply(SPECIES.length());
3615
3616 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3617 for (int i = 0; i < a.length; i += SPECIES.length()) {
3618 IntVector av = IntVector.fromArray(SPECIES, a, i);
3619 av.abs().intoArray(r, i);
3620 }
3621 }
3622
3623 assertArraysEquals(a, r, Int128VectorTests::abs);
3624 }
3625
3626 @Test(dataProvider = "intUnaryOpMaskProvider")
3627 static void ABSMaskedInt128VectorTests(IntFunction<int[]> fa,
3628 IntFunction<boolean[]> fm) {
3629 int[] a = fa.apply(SPECIES.length());
3630 int[] r = fr.apply(SPECIES.length());
3631 boolean[] mask = fm.apply(SPECIES.length());
3632 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3633
3634 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3635 for (int i = 0; i < a.length; i += SPECIES.length()) {
3636 IntVector av = IntVector.fromArray(SPECIES, a, i);
3637 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
3638 }
3639 }
3640
3641 assertArraysEquals(a, r, mask, Int128VectorTests::ABS);
3642 }
3643
3644
3645 static int NOT(int a) {
3646 return (int)(~((int)a));
3647 }
3648
3649 static int not(int a) {
3650 return (int)(~((int)a));
3651 }
3652
3653
3654
3655 @Test(dataProvider = "intUnaryOpProvider")
3656 static void NOTInt128VectorTests(IntFunction<int[]> fa) {
3657 int[] a = fa.apply(SPECIES.length());
3658 int[] r = fr.apply(SPECIES.length());
3659
3660 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3661 for (int i = 0; i < a.length; i += SPECIES.length()) {
3662 IntVector av = IntVector.fromArray(SPECIES, a, i);
3663 av.lanewise(VectorOperators.NOT).intoArray(r, i);
3664 }
3665 }
3666
3667 assertArraysEquals(a, r, Int128VectorTests::NOT);
3668 }
3669
3670 @Test(dataProvider = "intUnaryOpProvider")
3671 static void notInt128VectorTests(IntFunction<int[]> fa) {
3672 int[] a = fa.apply(SPECIES.length());
3673 int[] r = fr.apply(SPECIES.length());
3674
3675 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3676 for (int i = 0; i < a.length; i += SPECIES.length()) {
3677 IntVector av = IntVector.fromArray(SPECIES, a, i);
3678 av.not().intoArray(r, i);
3679 }
3680 }
3681
3682 assertArraysEquals(a, r, Int128VectorTests::not);
3683 }
3684
3685
3686
3687 @Test(dataProvider = "intUnaryOpMaskProvider")
3688 static void NOTMaskedInt128VectorTests(IntFunction<int[]> fa,
3689 IntFunction<boolean[]> fm) {
3690 int[] a = fa.apply(SPECIES.length());
3691 int[] r = fr.apply(SPECIES.length());
3692 boolean[] mask = fm.apply(SPECIES.length());
3693 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3694
3695 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3696 for (int i = 0; i < a.length; i += SPECIES.length()) {
3697 IntVector av = IntVector.fromArray(SPECIES, a, i);
3698 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
3699 }
3700 }
3701
3702 assertArraysEquals(a, r, mask, Int128VectorTests::NOT);
3703 }
3704
3705
3706
3707 static int ZOMO(int a) {
3708 return (int)((a==0?0:-1));
3709 }
3710
3711
3712
3713 @Test(dataProvider = "intUnaryOpProvider")
3714 static void ZOMOInt128VectorTests(IntFunction<int[]> fa) {
3715 int[] a = fa.apply(SPECIES.length());
3716 int[] r = fr.apply(SPECIES.length());
3717
3718 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3719 for (int i = 0; i < a.length; i += SPECIES.length()) {
3720 IntVector av = IntVector.fromArray(SPECIES, a, i);
3721 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
3722 }
3723 }
3724
3725 assertArraysEquals(a, r, Int128VectorTests::ZOMO);
3726 }
3727
3728
3729
3730 @Test(dataProvider = "intUnaryOpMaskProvider")
3731 static void ZOMOMaskedInt128VectorTests(IntFunction<int[]> fa,
3732 IntFunction<boolean[]> fm) {
3733 int[] a = fa.apply(SPECIES.length());
3734 int[] r = fr.apply(SPECIES.length());
3735 boolean[] mask = fm.apply(SPECIES.length());
3736 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3737
3738 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3739 for (int i = 0; i < a.length; i += SPECIES.length()) {
3740 IntVector av = IntVector.fromArray(SPECIES, a, i);
3741 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
3742 }
3743 }
3744
3745 assertArraysEquals(a, r, mask, Int128VectorTests::ZOMO);
3746 }
3747
3748
3749
3750
3751 static int[] gather(int a[], int ix, int[] b, int iy) {
3752 int[] res = new int[SPECIES.length()];
3753 for (int i = 0; i < SPECIES.length(); i++) {
3754 int bi = iy + i;
3755 res[i] = a[b[bi] + ix];
3756 }
3757 return res;
3758 }
3759
3760 @Test(dataProvider = "intUnaryOpIndexProvider")
3761 static void gatherInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
3762 int[] a = fa.apply(SPECIES.length());
3763 int[] b = fs.apply(a.length, SPECIES.length());
3764 int[] r = new int[a.length];
3765
3766 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3767 for (int i = 0; i < a.length; i += SPECIES.length()) {
3768 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i);
3769 av.intoArray(r, i);
3770 }
3771 }
3772
3773 assertArraysEquals(a, b, r, Int128VectorTests::gather);
3774 }
3775 static int[] gatherMasked(int a[], int ix, boolean[] mask, int[] b, int iy) {
3776 int[] res = new int[SPECIES.length()];
3777 for (int i = 0; i < SPECIES.length(); i++) {
3778 int bi = iy + i;
3779 if (mask[i]) {
3780 res[i] = a[b[bi] + ix];
3781 }
3782 }
3783 return res;
3784 }
3785
3786 @Test(dataProvider = "intUnaryMaskedOpIndexProvider")
3787 static void gatherMaskedInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
3788 int[] a = fa.apply(SPECIES.length());
3789 int[] b = fs.apply(a.length, SPECIES.length());
3790 int[] r = new int[a.length];
3791 boolean[] mask = fm.apply(SPECIES.length());
3792 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3793
3794 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3795 for (int i = 0; i < a.length; i += SPECIES.length()) {
3796 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i, vmask);
3797 av.intoArray(r, i);
3798 }
3799 }
3800
3801 assertArraysEquals(a, b, r, mask, Int128VectorTests::gatherMasked);
3802 }
3803
3804 static int[] scatter(int a[], int ix, int[] b, int iy) {
3805 int[] res = new int[SPECIES.length()];
3806 for (int i = 0; i < SPECIES.length(); i++) {
3807 int bi = iy + i;
3808 res[b[bi]] = a[i + ix];
3809 }
3810 return res;
3811 }
3812
3813 @Test(dataProvider = "intUnaryOpIndexProvider")
3814 static void scatterInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
3815 int[] a = fa.apply(SPECIES.length());
3816 int[] b = fs.apply(a.length, SPECIES.length());
3817 int[] r = new int[a.length];
3818
3819 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3820 for (int i = 0; i < a.length; i += SPECIES.length()) {
3821 IntVector av = IntVector.fromArray(SPECIES, a, i);
3822 av.intoArray(r, i, b, i);
3823 }
3824 }
3825
3826 assertArraysEquals(a, b, r, Int128VectorTests::scatter);
3827 }
3828
3829 static int[] scatterMasked(int r[], int a[], int ix, boolean[] mask, int[] b, int iy) {
3830 // First, gather r.
3831 int[] oldVal = gather(r, ix, b, iy);
3832 int[] newVal = new int[SPECIES.length()];
3833
3834 // Second, blending it with a.
3835 for (int i = 0; i < SPECIES.length(); i++) {
3836 newVal[i] = blend(oldVal[i], a[i+ix], mask[i]);
3837 }
3838
3839 // Third, scatter: copy old value of r, and scatter it manually.
3840 int[] res = Arrays.copyOfRange(r, ix, ix+SPECIES.length());
3841 for (int i = 0; i < SPECIES.length(); i++) {
3842 int bi = iy + i;
3843 res[b[bi]] = newVal[i];
3844 }
3845
3846 return res;
3847 }
3848
3849 @Test(dataProvider = "scatterMaskedOpIndexProvider")
3850 static void scatterMaskedInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
3851 int[] a = fa.apply(SPECIES.length());
3852 int[] b = fs.apply(a.length, SPECIES.length());
3853 int[] r = fb.apply(SPECIES.length());
3854 boolean[] mask = fm.apply(SPECIES.length());
3855 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3856
3857 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3858 for (int i = 0; i < a.length; i += SPECIES.length()) {
3859 IntVector av = IntVector.fromArray(SPECIES, a, i);
3860 av.intoArray(r, i, b, i, vmask);
3861 }
3862 }
3863
3864 assertArraysEquals(a, b, r, mask, Int128VectorTests::scatterMasked);
3865 }
3866
3867 }
3868