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