1 /* 2 * Copyright (c) 2018, 2022, 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 -XX:-TieredCompilation 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.Objects; 51 import java.util.stream.Collectors; 52 import java.util.stream.Stream; 53 54 @Test 55 public class Int128VectorTests extends AbstractVectorTest { 56 57 static final VectorSpecies<Integer> SPECIES = 58 IntVector.SPECIES_128; 59 60 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); 61 62 63 private static final int CONST_SHIFT = Integer.SIZE / 2; 64 65 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); 66 67 interface FUnOp { 68 int apply(int a); 69 } 70 71 static void assertArraysEquals(int[] r, int[] a, FUnOp f) { 72 int i = 0; 73 try { 74 for (; i < a.length; i++) { 75 Assert.assertEquals(r[i], f.apply(a[i])); 76 } 77 } catch (AssertionError e) { 78 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]); 79 } 80 } 81 82 interface FUnArrayOp { 83 int[] apply(int a); 84 } 85 86 static void assertArraysEquals(int[] r, int[] a, FUnArrayOp f) { 87 int i = 0; 88 try { 89 for (; i < a.length; i += SPECIES.length()) { 90 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 91 f.apply(a[i])); 92 } 93 } catch (AssertionError e) { 94 int[] ref = f.apply(a[i]); 95 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 96 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref) 97 + ", res: " + Arrays.toString(res) 98 + "), at index #" + i); 99 } 100 } 101 102 static void assertArraysEquals(int[] r, int[] a, boolean[] mask, FUnOp f) { 103 int i = 0; 104 try { 105 for (; i < a.length; i++) { 106 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]); 107 } 108 } catch (AssertionError e) { 109 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()]); 110 } 111 } 112 113 interface FReductionOp { 114 int apply(int[] a, int idx); 115 } 116 117 interface FReductionAllOp { 118 int apply(int[] a); 119 } 120 121 static void assertReductionArraysEquals(int[] r, int rc, int[] a, 122 FReductionOp f, FReductionAllOp fa) { 123 int i = 0; 124 try { 125 Assert.assertEquals(rc, fa.apply(a)); 126 for (; i < a.length; i += SPECIES.length()) { 127 Assert.assertEquals(r[i], f.apply(a, i)); 128 } 129 } catch (AssertionError e) { 130 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!"); 131 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i); 132 } 133 } 134 135 interface FReductionMaskedOp { 136 int apply(int[] a, int idx, boolean[] mask); 137 } 138 139 interface FReductionAllMaskedOp { 140 int apply(int[] a, boolean[] mask); 141 } 142 143 static void assertReductionArraysEqualsMasked(int[] r, int rc, int[] a, boolean[] mask, 144 FReductionMaskedOp f, FReductionAllMaskedOp fa) { 145 int i = 0; 146 try { 147 Assert.assertEquals(rc, fa.apply(a, mask)); 148 for (; i < a.length; i += SPECIES.length()) { 149 Assert.assertEquals(r[i], f.apply(a, i, mask)); 150 } 151 } catch (AssertionError e) { 152 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!"); 153 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i); 154 } 155 } 156 157 interface FReductionOpLong { 158 long apply(int[] a, int idx); 159 } 160 161 interface FReductionAllOpLong { 162 long apply(int[] a); 163 } 164 165 static void assertReductionLongArraysEquals(long[] r, long rc, int[] a, 166 FReductionOpLong f, FReductionAllOpLong fa) { 167 int i = 0; 168 try { 169 Assert.assertEquals(rc, fa.apply(a)); 170 for (; i < a.length; i += SPECIES.length()) { 171 Assert.assertEquals(r[i], f.apply(a, i)); 172 } 173 } catch (AssertionError e) { 174 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!"); 175 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i); 176 } 177 } 178 179 interface FReductionMaskedOpLong { 180 long apply(int[] a, int idx, boolean[] mask); 181 } 182 183 interface FReductionAllMaskedOpLong { 184 long apply(int[] a, boolean[] mask); 185 } 186 187 static void assertReductionLongArraysEqualsMasked(long[] r, long rc, int[] a, boolean[] mask, 188 FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) { 189 int i = 0; 190 try { 191 Assert.assertEquals(rc, fa.apply(a, mask)); 192 for (; i < a.length; i += SPECIES.length()) { 193 Assert.assertEquals(r[i], f.apply(a, i, mask)); 194 } 195 } catch (AssertionError e) { 196 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!"); 197 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i); 198 } 199 } 200 201 interface FBoolReductionOp { 202 boolean apply(boolean[] a, int idx); 203 } 204 205 static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) { 206 int i = 0; 207 try { 208 for (; i < a.length; i += SPECIES.length()) { 209 Assert.assertEquals(r[i], f.apply(a, i)); 210 } 211 } catch (AssertionError e) { 212 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i); 213 } 214 } 215 216 interface FMaskReductionOp { 217 int apply(boolean[] a, int idx); 218 } 219 220 static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) { 221 int i = 0; 222 try { 223 for (; i < a.length; i += SPECIES.length()) { 224 Assert.assertEquals(r[i], f.apply(a, i)); 225 } 226 } catch (AssertionError e) { 227 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i); 228 } 229 } 230 231 static void assertInsertArraysEquals(int[] r, int[] a, int element, int index, int start, int end) { 232 int i = start; 233 try { 234 for (; i < end; i += 1) { 235 if(i%SPECIES.length() == index) { 236 Assert.assertEquals(r[i], element); 237 } else { 238 Assert.assertEquals(r[i], a[i]); 239 } 240 } 241 } catch (AssertionError e) { 242 if (i%SPECIES.length() == index) { 243 Assert.assertEquals(r[i], element, "at index #" + i); 244 } else { 245 Assert.assertEquals(r[i], a[i], "at index #" + i); 246 } 247 } 248 } 249 250 static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, int vector_len) { 251 int i = 0, j = 0; 252 try { 253 for (; i < a.length; i += vector_len) { 254 for (j = 0; j < vector_len; j++) { 255 Assert.assertEquals(r[i+j], a[i+order[i+j]]); 256 } 257 } 258 } catch (AssertionError e) { 259 int idx = i + j; 260 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]); 261 } 262 } 263 264 static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, int vector_len) { 265 int i = 0, j = 0; 266 try { 267 for (; i < a.length; i += vector_len) { 268 for (j = 0; j < vector_len; j++) { 269 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]); 270 } 271 } 272 } catch (AssertionError e) { 273 int idx = i + j; 274 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]); 275 } 276 } 277 278 static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) { 279 int i = 0, j = 0; 280 try { 281 for (; i < a.length; i += vector_len) { 282 for (j = 0; j < vector_len; j++) { 283 if (mask[j % SPECIES.length()]) 284 Assert.assertEquals(r[i+j], a[i+order[i+j]]); 285 else 286 Assert.assertEquals(r[i+j], (int)0); 287 } 288 } 289 } catch (AssertionError e) { 290 int idx = i + j; 291 if (mask[j % SPECIES.length()]) 292 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]); 293 else 294 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]); 295 } 296 } 297 298 static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) { 299 int i = 0, j = 0; 300 try { 301 for (; i < a.length; i += vector_len) { 302 for (j = 0; j < vector_len; j++) { 303 if (mask[j % SPECIES.length()]) 304 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]); 305 else 306 Assert.assertEquals(r[i+j], (int)0); 307 } 308 } 309 } catch (AssertionError e) { 310 int idx = i + j; 311 if (mask[j % SPECIES.length()]) 312 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]); 313 else 314 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]); 315 } 316 } 317 318 static void assertBroadcastArraysEquals(int[] r, int[] a) { 319 int i = 0; 320 for (; i < a.length; i += SPECIES.length()) { 321 int idx = i; 322 for (int j = idx; j < (idx + SPECIES.length()); j++) 323 a[j]=a[idx]; 324 } 325 326 try { 327 for (i = 0; i < a.length; i++) { 328 Assert.assertEquals(r[i], a[i]); 329 } 330 } catch (AssertionError e) { 331 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]); 332 } 333 } 334 335 interface FBinOp { 336 int apply(int a, int b); 337 } 338 339 interface FBinMaskOp { 340 int apply(int a, int b, boolean m); 341 342 static FBinMaskOp lift(FBinOp f) { 343 return (a, b, m) -> m ? f.apply(a, b) : a; 344 } 345 } 346 347 static void assertArraysEquals(int[] r, int[] a, int[] b, FBinOp f) { 348 int i = 0; 349 try { 350 for (; i < a.length; i++) { 351 Assert.assertEquals(r[i], f.apply(a[i], b[i])); 352 } 353 } catch (AssertionError e) { 354 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i); 355 } 356 } 357 358 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, FBinOp f) { 359 int i = 0; 360 try { 361 for (; i < a.length; i++) { 362 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])); 363 } 364 } catch (AssertionError e) { 365 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]), 366 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i); 367 } 368 } 369 370 static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, FBinOp f) { 371 int i = 0; 372 try { 373 for (; i < a.length; i++) { 374 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]))); 375 } 376 } catch (AssertionError e) { 377 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])), 378 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i); 379 } 380 } 381 382 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) { 383 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f)); 384 } 385 386 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) { 387 int i = 0; 388 try { 389 for (; i < a.length; i++) { 390 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()])); 391 } 392 } catch (AssertionError err) { 393 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()]); 394 } 395 } 396 397 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) { 398 assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f)); 399 } 400 401 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) { 402 int i = 0; 403 try { 404 for (; i < a.length; i++) { 405 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()])); 406 } 407 } catch (AssertionError err) { 408 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], 409 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + 410 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + 411 mask[i % SPECIES.length()]); 412 } 413 } 414 415 static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) { 416 assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f)); 417 } 418 419 static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) { 420 int i = 0; 421 try { 422 for (; i < a.length; i++) { 423 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()])); 424 } 425 } catch (AssertionError err) { 426 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), 427 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + 428 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + 429 mask[i % SPECIES.length()]); 430 } 431 } 432 433 static void assertShiftArraysEquals(int[] r, int[] a, int[] b, FBinOp f) { 434 int i = 0; 435 int j = 0; 436 try { 437 for (; j < a.length; j += SPECIES.length()) { 438 for (i = 0; i < SPECIES.length(); i++) { 439 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j])); 440 } 441 } 442 } catch (AssertionError e) { 443 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j); 444 } 445 } 446 447 static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) { 448 assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f)); 449 } 450 451 static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) { 452 int i = 0; 453 int j = 0; 454 try { 455 for (; j < a.length; j += SPECIES.length()) { 456 for (i = 0; i < SPECIES.length(); i++) { 457 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i])); 458 } 459 } 460 } catch (AssertionError err) { 461 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]); 462 } 463 } 464 465 interface FBinConstOp { 466 int apply(int a); 467 } 468 469 interface FBinConstMaskOp { 470 int apply(int a, boolean m); 471 472 static FBinConstMaskOp lift(FBinConstOp f) { 473 return (a, m) -> m ? f.apply(a) : a; 474 } 475 } 476 477 static void assertShiftConstEquals(int[] r, int[] a, FBinConstOp f) { 478 int i = 0; 479 int j = 0; 480 try { 481 for (; j < a.length; j += SPECIES.length()) { 482 for (i = 0; i < SPECIES.length(); i++) { 483 Assert.assertEquals(r[i+j], f.apply(a[i+j])); 484 } 485 } 486 } catch (AssertionError e) { 487 Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j); 488 } 489 } 490 491 static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstOp f) { 492 assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f)); 493 } 494 495 static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstMaskOp f) { 496 int i = 0; 497 int j = 0; 498 try { 499 for (; j < a.length; j += SPECIES.length()) { 500 for (i = 0; i < SPECIES.length(); i++) { 501 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i])); 502 } 503 } 504 } catch (AssertionError err) { 505 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]); 506 } 507 } 508 509 interface FTernOp { 510 int apply(int a, int b, int c); 511 } 512 513 interface FTernMaskOp { 514 int apply(int a, int b, int c, boolean m); 515 516 static FTernMaskOp lift(FTernOp f) { 517 return (a, b, c, m) -> m ? f.apply(a, b, c) : a; 518 } 519 } 520 521 static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) { 522 int i = 0; 523 try { 524 for (; i < a.length; i++) { 525 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i])); 526 } 527 } catch (AssertionError e) { 528 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]); 529 } 530 } 531 532 static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernOp f) { 533 assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f)); 534 } 535 536 static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernMaskOp f) { 537 int i = 0; 538 try { 539 for (; i < a.length; i++) { 540 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()])); 541 } 542 } catch (AssertionError err) { 543 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " 544 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]); 545 } 546 } 547 548 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) { 549 int i = 0; 550 try { 551 for (; i < a.length; i++) { 552 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()])); 553 } 554 } catch (AssertionError e) { 555 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + 556 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + 557 c[(i / SPECIES.length()) * SPECIES.length()]); 558 } 559 } 560 561 static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) { 562 int i = 0; 563 try { 564 for (; i < a.length; i++) { 565 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i])); 566 } 567 } catch (AssertionError e) { 568 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" + 569 i + ", input1 = " + a[i] + ", input2 = " + 570 b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]); 571 } 572 } 573 574 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, 575 FTernOp f) { 576 assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f)); 577 } 578 579 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, 580 FTernMaskOp f) { 581 int i = 0; 582 try { 583 for (; i < a.length; i++) { 584 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()], 585 mask[i % SPECIES.length()])); 586 } 587 } catch (AssertionError err) { 588 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()], 589 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + 590 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + 591 mask[i % SPECIES.length()]); 592 } 593 } 594 595 static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, 596 FTernOp f) { 597 assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f)); 598 } 599 600 static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, 601 FTernMaskOp f) { 602 int i = 0; 603 try { 604 for (; i < a.length; i++) { 605 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i], 606 mask[i % SPECIES.length()])); 607 } 608 } catch (AssertionError err) { 609 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i], 610 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + 611 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + 612 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]); 613 } 614 } 615 616 static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) { 617 int i = 0; 618 try { 619 for (; i < a.length; i++) { 620 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], 621 c[(i / SPECIES.length()) * SPECIES.length()])); 622 } 623 } catch (AssertionError e) { 624 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], 625 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] 626 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + 627 c[(i / SPECIES.length()) * SPECIES.length()]); 628 } 629 } 630 631 static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, 632 FTernOp f) { 633 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f)); 634 } 635 636 static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, 637 FTernMaskOp f) { 638 int i = 0; 639 try { 640 for (; i < a.length; i++) { 641 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], 642 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()])); 643 } 644 } catch (AssertionError err) { 645 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], 646 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #" 647 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + 648 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + 649 mask[i % SPECIES.length()]); 650 } 651 } 652 653 654 655 interface FBinArrayOp { 656 int apply(int[] a, int b); 657 } 658 659 static void assertArraysEquals(int[] r, int[] a, FBinArrayOp f) { 660 int i = 0; 661 try { 662 for (; i < a.length; i++) { 663 Assert.assertEquals(r[i], f.apply(a, i)); 664 } 665 } catch (AssertionError e) { 666 Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i); 667 } 668 } 669 670 interface FGatherScatterOp { 671 int[] apply(int[] a, int ix, int[] b, int iy); 672 } 673 674 static void assertArraysEquals(int[] r, int[] a, int[] b, FGatherScatterOp f) { 675 int i = 0; 676 try { 677 for (; i < a.length; i += SPECIES.length()) { 678 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 679 f.apply(a, i, b, i)); 680 } 681 } catch (AssertionError e) { 682 int[] ref = f.apply(a, i, b, i); 683 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 684 Assert.assertEquals(res, ref, 685 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: " 686 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length())) 687 + ", b: " 688 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length())) 689 + " at index #" + i); 690 } 691 } 692 693 interface FGatherMaskedOp { 694 int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy); 695 } 696 697 interface FScatterMaskedOp { 698 int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy); 699 } 700 701 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FGatherMaskedOp f) { 702 int i = 0; 703 try { 704 for (; i < a.length; i += SPECIES.length()) { 705 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 706 f.apply(a, i, mask, b, i)); 707 } 708 } catch (AssertionError e) { 709 int[] ref = f.apply(a, i, mask, b, i); 710 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 711 Assert.assertEquals(res, ref, 712 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: " 713 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length())) 714 + ", b: " 715 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length())) 716 + ", mask: " 717 + Arrays.toString(mask) 718 + " at index #" + i); 719 } 720 } 721 722 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FScatterMaskedOp f) { 723 int i = 0; 724 try { 725 for (; i < a.length; i += SPECIES.length()) { 726 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 727 f.apply(r, a, i, mask, b, i)); 728 } 729 } catch (AssertionError e) { 730 int[] ref = f.apply(r, a, i, mask, b, i); 731 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 732 Assert.assertEquals(res, ref, 733 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: " 734 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length())) 735 + ", b: " 736 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length())) 737 + ", r: " 738 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length())) 739 + ", mask: " 740 + Arrays.toString(mask) 741 + " at index #" + i); 742 } 743 } 744 745 interface FLaneOp { 746 int[] apply(int[] a, int origin, int idx); 747 } 748 749 static void assertArraysEquals(int[] r, int[] a, int origin, FLaneOp f) { 750 int i = 0; 751 try { 752 for (; i < a.length; i += SPECIES.length()) { 753 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 754 f.apply(a, origin, i)); 755 } 756 } catch (AssertionError e) { 757 int[] ref = f.apply(a, origin, i); 758 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 759 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref) 760 + ", res: " + Arrays.toString(res) 761 + "), at index #" + i); 762 } 763 } 764 765 interface FLaneBop { 766 int[] apply(int[] a, int[] b, int origin, int idx); 767 } 768 769 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, FLaneBop f) { 770 int i = 0; 771 try { 772 for (; i < a.length; i += SPECIES.length()) { 773 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 774 f.apply(a, b, origin, i)); 775 } 776 } catch (AssertionError e) { 777 int[] ref = f.apply(a, b, origin, i); 778 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 779 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref) 780 + ", res: " + Arrays.toString(res) 781 + "), at index #" + i 782 + ", at origin #" + origin); 783 } 784 } 785 786 interface FLaneMaskedBop { 787 int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx); 788 } 789 790 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, boolean[] mask, FLaneMaskedBop f) { 791 int i = 0; 792 try { 793 for (; i < a.length; i += SPECIES.length()) { 794 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 795 f.apply(a, b, origin, mask, i)); 796 } 797 } catch (AssertionError e) { 798 int[] ref = f.apply(a, b, origin, mask, i); 799 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 800 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref) 801 + ", res: " + Arrays.toString(res) 802 + "), at index #" + i 803 + ", at origin #" + origin); 804 } 805 } 806 807 interface FLanePartBop { 808 int[] apply(int[] a, int[] b, int origin, int part, int idx); 809 } 810 811 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, FLanePartBop f) { 812 int i = 0; 813 try { 814 for (; i < a.length; i += SPECIES.length()) { 815 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 816 f.apply(a, b, origin, part, i)); 817 } 818 } catch (AssertionError e) { 819 int[] ref = f.apply(a, b, origin, part, i); 820 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 821 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref) 822 + ", res: " + Arrays.toString(res) 823 + "), at index #" + i 824 + ", at origin #" + origin 825 + ", with part #" + part); 826 } 827 } 828 829 interface FLanePartMaskedBop { 830 int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx); 831 } 832 833 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) { 834 int i = 0; 835 try { 836 for (; i < a.length; i += SPECIES.length()) { 837 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 838 f.apply(a, b, origin, part, mask, i)); 839 } 840 } catch (AssertionError e) { 841 int[] ref = f.apply(a, b, origin, part, mask, i); 842 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 843 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref) 844 + ", res: " + Arrays.toString(res) 845 + "), at index #" + i 846 + ", at origin #" + origin 847 + ", with part #" + part); 848 } 849 } 850 851 852 static void assertArraysEquals(int[] r, int[] a, int offs) { 853 int i = 0; 854 try { 855 for (; i < r.length; i++) { 856 Assert.assertEquals(r[i], (int)(a[i+offs])); 857 } 858 } catch (AssertionError e) { 859 Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]); 860 } 861 } 862 863 864 865 static void assertArraysEquals(long[] r, int[] a, int offs) { 866 int i = 0; 867 try { 868 for (; i < r.length; i++) { 869 Assert.assertEquals(r[i], (long)(a[i+offs])); 870 } 871 } catch (AssertionError e) { 872 Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]); 873 } 874 } 875 876 static void assertArraysEquals(double[] r, int[] a, int offs) { 877 int i = 0; 878 try { 879 for (; i < r.length; i++) { 880 Assert.assertEquals(r[i], (double)(a[i+offs])); 881 } 882 } catch (AssertionError e) { 883 Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]); 884 } 885 } 886 887 888 static int bits(int e) { 889 return e; 890 } 891 892 static final List<IntFunction<int[]>> INT_GENERATORS = List.of( 893 withToString("int[-i * 5]", (int s) -> { 894 return fill(s * BUFFER_REPS, 895 i -> (int)(-i * 5)); 896 }), 897 withToString("int[i * 5]", (int s) -> { 898 return fill(s * BUFFER_REPS, 899 i -> (int)(i * 5)); 900 }), 901 withToString("int[i + 1]", (int s) -> { 902 return fill(s * BUFFER_REPS, 903 i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1))); 904 }), 905 withToString("int[cornerCaseValue(i)]", (int s) -> { 906 return fill(s * BUFFER_REPS, 907 i -> cornerCaseValue(i)); 908 }) 909 ); 910 911 // Create combinations of pairs 912 // @@@ Might be sensitive to order e.g. div by 0 913 static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS = 914 Stream.of(INT_GENERATORS.get(0)). 915 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))). 916 collect(Collectors.toList()); 917 918 @DataProvider 919 public Object[][] boolUnaryOpProvider() { 920 return BOOL_ARRAY_GENERATORS.stream(). 921 map(f -> new Object[]{f}). 922 toArray(Object[][]::new); 923 } 924 925 static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES = 926 INT_GENERATOR_PAIRS.stream(). 927 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))). 928 collect(Collectors.toList()); 929 930 @DataProvider 931 public Object[][] intBinaryOpProvider() { 932 return INT_GENERATOR_PAIRS.stream().map(List::toArray). 933 toArray(Object[][]::new); 934 } 935 936 @DataProvider 937 public Object[][] intIndexedOpProvider() { 938 return INT_GENERATOR_PAIRS.stream().map(List::toArray). 939 toArray(Object[][]::new); 940 } 941 942 @DataProvider 943 public Object[][] intBinaryOpMaskProvider() { 944 return BOOLEAN_MASK_GENERATORS.stream(). 945 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> { 946 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray(); 947 })). 948 toArray(Object[][]::new); 949 } 950 951 @DataProvider 952 public Object[][] intTernaryOpProvider() { 953 return INT_GENERATOR_TRIPLES.stream().map(List::toArray). 954 toArray(Object[][]::new); 955 } 956 957 @DataProvider 958 public Object[][] intTernaryOpMaskProvider() { 959 return BOOLEAN_MASK_GENERATORS.stream(). 960 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> { 961 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray(); 962 })). 963 toArray(Object[][]::new); 964 } 965 966 @DataProvider 967 public Object[][] intUnaryOpProvider() { 968 return INT_GENERATORS.stream(). 969 map(f -> new Object[]{f}). 970 toArray(Object[][]::new); 971 } 972 973 @DataProvider 974 public Object[][] intUnaryOpMaskProvider() { 975 return BOOLEAN_MASK_GENERATORS.stream(). 976 flatMap(fm -> INT_GENERATORS.stream().map(fa -> { 977 return new Object[] {fa, fm}; 978 })). 979 toArray(Object[][]::new); 980 } 981 982 983 984 @DataProvider 985 public Object[][] maskProvider() { 986 return BOOLEAN_MASK_GENERATORS.stream(). 987 map(f -> new Object[]{f}). 988 toArray(Object[][]::new); 989 } 990 991 @DataProvider 992 public Object[][] maskCompareOpProvider() { 993 return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray). 994 toArray(Object[][]::new); 995 } 996 997 @DataProvider 998 public Object[][] shuffleProvider() { 999 return INT_SHUFFLE_GENERATORS.stream(). 1000 map(f -> new Object[]{f}). 1001 toArray(Object[][]::new); 1002 } 1003 1004 @DataProvider 1005 public Object[][] shuffleCompareOpProvider() { 1006 return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray). 1007 toArray(Object[][]::new); 1008 } 1009 1010 @DataProvider 1011 public Object[][] intUnaryOpShuffleProvider() { 1012 return INT_SHUFFLE_GENERATORS.stream(). 1013 flatMap(fs -> INT_GENERATORS.stream().map(fa -> { 1014 return new Object[] {fa, fs}; 1015 })). 1016 toArray(Object[][]::new); 1017 } 1018 1019 @DataProvider 1020 public Object[][] intUnaryOpShuffleMaskProvider() { 1021 return BOOLEAN_MASK_GENERATORS.stream(). 1022 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream(). 1023 flatMap(fs -> INT_GENERATORS.stream().map(fa -> { 1024 return new Object[] {fa, fs, fm}; 1025 }))). 1026 toArray(Object[][]::new); 1027 } 1028 1029 1030 static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of( 1031 withToString("int[i]", (int s) -> { 1032 return fill(s * BUFFER_REPS, 1033 i -> (int)i); 1034 }), 1035 withToString("int[i - length / 2]", (int s) -> { 1036 return fill(s * BUFFER_REPS, 1037 i -> (int)(i - (s * BUFFER_REPS / 2))); 1038 }), 1039 withToString("int[i + 1]", (int s) -> { 1040 return fill(s * BUFFER_REPS, 1041 i -> (int)(i + 1)); 1042 }), 1043 withToString("int[i - 2]", (int s) -> { 1044 return fill(s * BUFFER_REPS, 1045 i -> (int)(i - 2)); 1046 }), 1047 withToString("int[zigZag(i)]", (int s) -> { 1048 return fill(s * BUFFER_REPS, 1049 i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2))); 1050 }), 1051 withToString("int[cornerCaseValue(i)]", (int s) -> { 1052 return fill(s * BUFFER_REPS, 1053 i -> cornerCaseValue(i)); 1054 }) 1055 ); 1056 1057 static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS = 1058 INT_COMPARE_GENERATORS.stream(). 1059 map(fa -> List.of(fa)). 1060 collect(Collectors.toList()); 1061 1062 @DataProvider 1063 public Object[][] intTestOpProvider() { 1064 return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray). 1065 toArray(Object[][]::new); 1066 } 1067 1068 @DataProvider 1069 public Object[][] intTestOpMaskProvider() { 1070 return BOOLEAN_MASK_GENERATORS.stream(). 1071 flatMap(fm -> INT_TEST_GENERATOR_ARGS.stream().map(lfa -> { 1072 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray(); 1073 })). 1074 toArray(Object[][]::new); 1075 } 1076 1077 static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS = 1078 INT_COMPARE_GENERATORS.stream(). 1079 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))). 1080 collect(Collectors.toList()); 1081 1082 @DataProvider 1083 public Object[][] intCompareOpProvider() { 1084 return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray). 1085 toArray(Object[][]::new); 1086 } 1087 1088 @DataProvider 1089 public Object[][] intCompareOpMaskProvider() { 1090 return BOOLEAN_MASK_GENERATORS.stream(). 1091 flatMap(fm -> INT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> { 1092 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray(); 1093 })). 1094 toArray(Object[][]::new); 1095 } 1096 1097 interface ToIntF { 1098 int apply(int i); 1099 } 1100 1101 static int[] fill(int s , ToIntF f) { 1102 return fill(new int[s], f); 1103 } 1104 1105 static int[] fill(int[] a, ToIntF f) { 1106 for (int i = 0; i < a.length; i++) { 1107 a[i] = f.apply(i); 1108 } 1109 return a; 1110 } 1111 1112 static int cornerCaseValue(int i) { 1113 switch(i % 5) { 1114 case 0: 1115 return Integer.MAX_VALUE; 1116 case 1: 1117 return Integer.MIN_VALUE; 1118 case 2: 1119 return Integer.MIN_VALUE; 1120 case 3: 1121 return Integer.MAX_VALUE; 1122 default: 1123 return (int)0; 1124 } 1125 } 1126 1127 static int get(int[] a, int i) { 1128 return (int) a[i]; 1129 } 1130 1131 static final IntFunction<int[]> fr = (vl) -> { 1132 int length = BUFFER_REPS * vl; 1133 return new int[length]; 1134 }; 1135 1136 static final IntFunction<boolean[]> fmr = (vl) -> { 1137 int length = BUFFER_REPS * vl; 1138 return new boolean[length]; 1139 }; 1140 1141 static final IntFunction<long[]> lfr = (vl) -> { 1142 int length = BUFFER_REPS * vl; 1143 return new long[length]; 1144 }; 1145 1146 static void replaceZero(int[] a, int v) { 1147 for (int i = 0; i < a.length; i++) { 1148 if (a[i] == 0) { 1149 a[i] = v; 1150 } 1151 } 1152 } 1153 1154 static void replaceZero(int[] a, boolean[] mask, int v) { 1155 for (int i = 0; i < a.length; i++) { 1156 if (mask[i % mask.length] && a[i] == 0) { 1157 a[i] = v; 1158 } 1159 } 1160 } 1161 1162 static int ROL_scalar(int a, int b) { 1163 return Integer.rotateLeft(a, ((int)b)); 1164 } 1165 1166 static int ROR_scalar(int a, int b) { 1167 return Integer.rotateRight(a, ((int)b)); 1168 } 1169 1170 static boolean eq(int a, int b) { 1171 return a == b; 1172 } 1173 1174 static boolean neq(int a, int b) { 1175 return a != b; 1176 } 1177 1178 static boolean lt(int a, int b) { 1179 return a < b; 1180 } 1181 1182 static boolean le(int a, int b) { 1183 return a <= b; 1184 } 1185 1186 static boolean gt(int a, int b) { 1187 return a > b; 1188 } 1189 1190 static boolean ge(int a, int b) { 1191 return a >= b; 1192 } 1193 1194 static boolean ult(int a, int b) { 1195 return Integer.compareUnsigned(a, b) < 0; 1196 } 1197 1198 static boolean ule(int a, int b) { 1199 return Integer.compareUnsigned(a, b) <= 0; 1200 } 1201 1202 static boolean ugt(int a, int b) { 1203 return Integer.compareUnsigned(a, b) > 0; 1204 } 1205 1206 static boolean uge(int a, int b) { 1207 return Integer.compareUnsigned(a, b) >= 0; 1208 } 1209 1210 static int firstNonZero(int a, int b) { 1211 return Integer.compare(a, (int) 0) != 0 ? a : b; 1212 } 1213 1214 @Test 1215 static void smokeTest1() { 1216 IntVector three = IntVector.broadcast(SPECIES, (byte)-3); 1217 IntVector three2 = (IntVector) SPECIES.broadcast(-3); 1218 assert(three.eq(three2).allTrue()); 1219 IntVector three3 = three2.broadcast(1).broadcast(-3); 1220 assert(three.eq(three3).allTrue()); 1221 int scale = 2; 1222 Class<?> ETYPE = int.class; 1223 if (ETYPE == double.class || ETYPE == long.class) 1224 scale = 1000000; 1225 else if (ETYPE == byte.class && SPECIES.length() >= 64) 1226 scale = 1; 1227 IntVector higher = three.addIndex(scale); 1228 VectorMask<Integer> m = three.compare(VectorOperators.LE, higher); 1229 assert(m.allTrue()); 1230 m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE); 1231 assert(m.allTrue()); 1232 int max = higher.reduceLanes(VectorOperators.MAX); 1233 assert(max == -3 + scale * (SPECIES.length()-1)); 1234 } 1235 1236 private static int[] 1237 bothToArray(IntVector a, IntVector b) { 1238 int[] r = new int[a.length() + b.length()]; 1239 a.intoArray(r, 0); 1240 b.intoArray(r, a.length()); 1241 return r; 1242 } 1243 1244 @Test 1245 static void smokeTest2() { 1246 // Do some zipping and shuffling. 1247 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1); 1248 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector(); 1249 Assert.assertEquals(io, io2); 1250 IntVector a = io.add((int)1); //[1,2] 1251 IntVector b = a.neg(); //[-1,-2] 1252 int[] abValues = bothToArray(a,b); //[1,2,-1,-2] 1253 VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0); 1254 VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1); 1255 IntVector zab0 = a.rearrange(zip0,b); //[1,-1] 1256 IntVector zab1 = a.rearrange(zip1,b); //[2,-2] 1257 int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2] 1258 // manually zip 1259 int[] manual = new int[zabValues.length]; 1260 for (int i = 0; i < manual.length; i += 2) { 1261 manual[i+0] = abValues[i/2]; 1262 manual[i+1] = abValues[a.length() + i/2]; 1263 } 1264 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual)); 1265 VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0); 1266 VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1); 1267 IntVector uab0 = zab0.rearrange(unz0,zab1); 1268 IntVector uab1 = zab0.rearrange(unz1,zab1); 1269 int[] abValues1 = bothToArray(uab0, uab1); 1270 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1)); 1271 } 1272 1273 static void iotaShuffle() { 1274 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1); 1275 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector(); 1276 Assert.assertEquals(io, io2); 1277 } 1278 1279 @Test 1280 // Test all shuffle related operations. 1281 static void shuffleTest() { 1282 // To test backend instructions, make sure that C2 is used. 1283 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) { 1284 iotaShuffle(); 1285 } 1286 } 1287 1288 @Test 1289 void viewAsIntegeralLanesTest() { 1290 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes(); 1291 Assert.assertEquals(asIntegral.species(), SPECIES); 1292 } 1293 1294 @Test 1295 void viewAsFloatingLanesTest() { 1296 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes(); 1297 VectorSpecies<?> asFloatingSpecies = asFloating.species(); 1298 Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType()); 1299 Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape()); 1300 Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length()); 1301 Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES); 1302 } 1303 1304 @Test 1305 // Test div by 0. 1306 static void bitwiseDivByZeroSmokeTest() { 1307 try { 1308 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1); 1309 IntVector b = (IntVector) SPECIES.broadcast(0); 1310 a.div(b); 1311 Assert.fail(); 1312 } catch (ArithmeticException e) { 1313 } 1314 1315 try { 1316 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1); 1317 IntVector b = (IntVector) SPECIES.broadcast(0); 1318 VectorMask<Integer> m = a.lt((int) 1); 1319 a.div(b, m); 1320 Assert.fail(); 1321 } catch (ArithmeticException e) { 1322 } 1323 } 1324 static int ADD(int a, int b) { 1325 return (int)(a + b); 1326 } 1327 1328 @Test(dataProvider = "intBinaryOpProvider") 1329 static void ADDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1330 int[] a = fa.apply(SPECIES.length()); 1331 int[] b = fb.apply(SPECIES.length()); 1332 int[] r = fr.apply(SPECIES.length()); 1333 1334 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1335 for (int i = 0; i < a.length; i += SPECIES.length()) { 1336 IntVector av = IntVector.fromArray(SPECIES, a, i); 1337 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1338 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i); 1339 } 1340 } 1341 1342 assertArraysEquals(r, a, b, Int128VectorTests::ADD); 1343 } 1344 static int add(int a, int b) { 1345 return (int)(a + b); 1346 } 1347 1348 @Test(dataProvider = "intBinaryOpProvider") 1349 static void addInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1350 int[] a = fa.apply(SPECIES.length()); 1351 int[] b = fb.apply(SPECIES.length()); 1352 int[] r = fr.apply(SPECIES.length()); 1353 1354 for (int i = 0; i < a.length; i += SPECIES.length()) { 1355 IntVector av = IntVector.fromArray(SPECIES, a, i); 1356 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1357 av.add(bv).intoArray(r, i); 1358 } 1359 1360 assertArraysEquals(r, a, b, Int128VectorTests::add); 1361 } 1362 1363 @Test(dataProvider = "intBinaryOpMaskProvider") 1364 static void ADDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1365 IntFunction<boolean[]> fm) { 1366 int[] a = fa.apply(SPECIES.length()); 1367 int[] b = fb.apply(SPECIES.length()); 1368 int[] r = fr.apply(SPECIES.length()); 1369 boolean[] mask = fm.apply(SPECIES.length()); 1370 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1371 1372 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1373 for (int i = 0; i < a.length; i += SPECIES.length()) { 1374 IntVector av = IntVector.fromArray(SPECIES, a, i); 1375 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1376 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i); 1377 } 1378 } 1379 1380 assertArraysEquals(r, a, b, mask, Int128VectorTests::ADD); 1381 } 1382 1383 @Test(dataProvider = "intBinaryOpMaskProvider") 1384 static void addInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1385 IntFunction<boolean[]> fm) { 1386 int[] a = fa.apply(SPECIES.length()); 1387 int[] b = fb.apply(SPECIES.length()); 1388 int[] r = fr.apply(SPECIES.length()); 1389 boolean[] mask = fm.apply(SPECIES.length()); 1390 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1391 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 av.add(bv, vmask).intoArray(r, i); 1396 } 1397 1398 assertArraysEquals(r, a, b, mask, Int128VectorTests::add); 1399 } 1400 static int SUB(int a, int b) { 1401 return (int)(a - b); 1402 } 1403 1404 @Test(dataProvider = "intBinaryOpProvider") 1405 static void SUBInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1406 int[] a = fa.apply(SPECIES.length()); 1407 int[] b = fb.apply(SPECIES.length()); 1408 int[] r = fr.apply(SPECIES.length()); 1409 1410 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1411 for (int i = 0; i < a.length; i += SPECIES.length()) { 1412 IntVector av = IntVector.fromArray(SPECIES, a, i); 1413 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1414 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i); 1415 } 1416 } 1417 1418 assertArraysEquals(r, a, b, Int128VectorTests::SUB); 1419 } 1420 static int sub(int a, int b) { 1421 return (int)(a - b); 1422 } 1423 1424 @Test(dataProvider = "intBinaryOpProvider") 1425 static void subInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1426 int[] a = fa.apply(SPECIES.length()); 1427 int[] b = fb.apply(SPECIES.length()); 1428 int[] r = fr.apply(SPECIES.length()); 1429 1430 for (int i = 0; i < a.length; i += SPECIES.length()) { 1431 IntVector av = IntVector.fromArray(SPECIES, a, i); 1432 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1433 av.sub(bv).intoArray(r, i); 1434 } 1435 1436 assertArraysEquals(r, a, b, Int128VectorTests::sub); 1437 } 1438 1439 @Test(dataProvider = "intBinaryOpMaskProvider") 1440 static void SUBInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1441 IntFunction<boolean[]> fm) { 1442 int[] a = fa.apply(SPECIES.length()); 1443 int[] b = fb.apply(SPECIES.length()); 1444 int[] r = fr.apply(SPECIES.length()); 1445 boolean[] mask = fm.apply(SPECIES.length()); 1446 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1447 1448 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1449 for (int i = 0; i < a.length; i += SPECIES.length()) { 1450 IntVector av = IntVector.fromArray(SPECIES, a, i); 1451 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1452 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i); 1453 } 1454 } 1455 1456 assertArraysEquals(r, a, b, mask, Int128VectorTests::SUB); 1457 } 1458 1459 @Test(dataProvider = "intBinaryOpMaskProvider") 1460 static void subInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1461 IntFunction<boolean[]> fm) { 1462 int[] a = fa.apply(SPECIES.length()); 1463 int[] b = fb.apply(SPECIES.length()); 1464 int[] r = fr.apply(SPECIES.length()); 1465 boolean[] mask = fm.apply(SPECIES.length()); 1466 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1467 1468 for (int i = 0; i < a.length; i += SPECIES.length()) { 1469 IntVector av = IntVector.fromArray(SPECIES, a, i); 1470 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1471 av.sub(bv, vmask).intoArray(r, i); 1472 } 1473 1474 assertArraysEquals(r, a, b, mask, Int128VectorTests::sub); 1475 } 1476 static int MUL(int a, int b) { 1477 return (int)(a * b); 1478 } 1479 1480 @Test(dataProvider = "intBinaryOpProvider") 1481 static void MULInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1482 int[] a = fa.apply(SPECIES.length()); 1483 int[] b = fb.apply(SPECIES.length()); 1484 int[] r = fr.apply(SPECIES.length()); 1485 1486 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1487 for (int i = 0; i < a.length; i += SPECIES.length()) { 1488 IntVector av = IntVector.fromArray(SPECIES, a, i); 1489 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1490 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i); 1491 } 1492 } 1493 1494 assertArraysEquals(r, a, b, Int128VectorTests::MUL); 1495 } 1496 static int mul(int a, int b) { 1497 return (int)(a * b); 1498 } 1499 1500 @Test(dataProvider = "intBinaryOpProvider") 1501 static void mulInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1502 int[] a = fa.apply(SPECIES.length()); 1503 int[] b = fb.apply(SPECIES.length()); 1504 int[] r = fr.apply(SPECIES.length()); 1505 1506 for (int i = 0; i < a.length; i += SPECIES.length()) { 1507 IntVector av = IntVector.fromArray(SPECIES, a, i); 1508 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1509 av.mul(bv).intoArray(r, i); 1510 } 1511 1512 assertArraysEquals(r, a, b, Int128VectorTests::mul); 1513 } 1514 1515 @Test(dataProvider = "intBinaryOpMaskProvider") 1516 static void MULInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1517 IntFunction<boolean[]> fm) { 1518 int[] a = fa.apply(SPECIES.length()); 1519 int[] b = fb.apply(SPECIES.length()); 1520 int[] r = fr.apply(SPECIES.length()); 1521 boolean[] mask = fm.apply(SPECIES.length()); 1522 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1523 1524 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1525 for (int i = 0; i < a.length; i += SPECIES.length()) { 1526 IntVector av = IntVector.fromArray(SPECIES, a, i); 1527 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1528 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i); 1529 } 1530 } 1531 1532 assertArraysEquals(r, a, b, mask, Int128VectorTests::MUL); 1533 } 1534 1535 @Test(dataProvider = "intBinaryOpMaskProvider") 1536 static void mulInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1537 IntFunction<boolean[]> fm) { 1538 int[] a = fa.apply(SPECIES.length()); 1539 int[] b = fb.apply(SPECIES.length()); 1540 int[] r = fr.apply(SPECIES.length()); 1541 boolean[] mask = fm.apply(SPECIES.length()); 1542 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1543 1544 for (int i = 0; i < a.length; i += SPECIES.length()) { 1545 IntVector av = IntVector.fromArray(SPECIES, a, i); 1546 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1547 av.mul(bv, vmask).intoArray(r, i); 1548 } 1549 1550 assertArraysEquals(r, a, b, mask, Int128VectorTests::mul); 1551 } 1552 1553 1554 1555 static int DIV(int a, int b) { 1556 return (int)(a / b); 1557 } 1558 1559 @Test(dataProvider = "intBinaryOpProvider") 1560 static void DIVInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1561 int[] a = fa.apply(SPECIES.length()); 1562 int[] b = fb.apply(SPECIES.length()); 1563 int[] r = fr.apply(SPECIES.length()); 1564 1565 replaceZero(b, (int) 1); 1566 1567 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1568 for (int i = 0; i < a.length; i += SPECIES.length()) { 1569 IntVector av = IntVector.fromArray(SPECIES, a, i); 1570 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1571 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i); 1572 } 1573 } 1574 1575 assertArraysEquals(r, a, b, Int128VectorTests::DIV); 1576 } 1577 static int div(int a, int b) { 1578 return (int)(a / b); 1579 } 1580 1581 @Test(dataProvider = "intBinaryOpProvider") 1582 static void divInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1583 int[] a = fa.apply(SPECIES.length()); 1584 int[] b = fb.apply(SPECIES.length()); 1585 int[] r = fr.apply(SPECIES.length()); 1586 1587 replaceZero(b, (int) 1); 1588 1589 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1590 for (int i = 0; i < a.length; i += SPECIES.length()) { 1591 IntVector av = IntVector.fromArray(SPECIES, a, i); 1592 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1593 av.div(bv).intoArray(r, i); 1594 } 1595 } 1596 1597 assertArraysEquals(r, a, b, Int128VectorTests::div); 1598 } 1599 1600 1601 1602 @Test(dataProvider = "intBinaryOpMaskProvider") 1603 static void DIVInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1604 IntFunction<boolean[]> fm) { 1605 int[] a = fa.apply(SPECIES.length()); 1606 int[] b = fb.apply(SPECIES.length()); 1607 int[] r = fr.apply(SPECIES.length()); 1608 boolean[] mask = fm.apply(SPECIES.length()); 1609 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1610 1611 replaceZero(b, mask, (int) 1); 1612 1613 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1614 for (int i = 0; i < a.length; i += SPECIES.length()) { 1615 IntVector av = IntVector.fromArray(SPECIES, a, i); 1616 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1617 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i); 1618 } 1619 } 1620 1621 assertArraysEquals(r, a, b, mask, Int128VectorTests::DIV); 1622 } 1623 1624 @Test(dataProvider = "intBinaryOpMaskProvider") 1625 static void divInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1626 IntFunction<boolean[]> fm) { 1627 int[] a = fa.apply(SPECIES.length()); 1628 int[] b = fb.apply(SPECIES.length()); 1629 int[] r = fr.apply(SPECIES.length()); 1630 boolean[] mask = fm.apply(SPECIES.length()); 1631 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1632 1633 replaceZero(b, mask, (int) 1); 1634 1635 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1636 for (int i = 0; i < a.length; i += SPECIES.length()) { 1637 IntVector av = IntVector.fromArray(SPECIES, a, i); 1638 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1639 av.div(bv, vmask).intoArray(r, i); 1640 } 1641 } 1642 1643 assertArraysEquals(r, a, b, mask, Int128VectorTests::div); 1644 } 1645 1646 static int FIRST_NONZERO(int a, int b) { 1647 return (int)((a)!=0?a:b); 1648 } 1649 1650 @Test(dataProvider = "intBinaryOpProvider") 1651 static void FIRST_NONZEROInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1652 int[] a = fa.apply(SPECIES.length()); 1653 int[] b = fb.apply(SPECIES.length()); 1654 int[] r = fr.apply(SPECIES.length()); 1655 1656 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1657 for (int i = 0; i < a.length; i += SPECIES.length()) { 1658 IntVector av = IntVector.fromArray(SPECIES, a, i); 1659 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1660 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i); 1661 } 1662 } 1663 1664 assertArraysEquals(r, a, b, Int128VectorTests::FIRST_NONZERO); 1665 } 1666 1667 @Test(dataProvider = "intBinaryOpMaskProvider") 1668 static void FIRST_NONZEROInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1669 IntFunction<boolean[]> fm) { 1670 int[] a = fa.apply(SPECIES.length()); 1671 int[] b = fb.apply(SPECIES.length()); 1672 int[] r = fr.apply(SPECIES.length()); 1673 boolean[] mask = fm.apply(SPECIES.length()); 1674 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1675 1676 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1677 for (int i = 0; i < a.length; i += SPECIES.length()) { 1678 IntVector av = IntVector.fromArray(SPECIES, a, i); 1679 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1680 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i); 1681 } 1682 } 1683 1684 assertArraysEquals(r, a, b, mask, Int128VectorTests::FIRST_NONZERO); 1685 } 1686 1687 static int AND(int a, int b) { 1688 return (int)(a & b); 1689 } 1690 1691 @Test(dataProvider = "intBinaryOpProvider") 1692 static void ANDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1693 int[] a = fa.apply(SPECIES.length()); 1694 int[] b = fb.apply(SPECIES.length()); 1695 int[] r = fr.apply(SPECIES.length()); 1696 1697 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1698 for (int i = 0; i < a.length; i += SPECIES.length()) { 1699 IntVector av = IntVector.fromArray(SPECIES, a, i); 1700 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1701 av.lanewise(VectorOperators.AND, bv).intoArray(r, i); 1702 } 1703 } 1704 1705 assertArraysEquals(r, a, b, Int128VectorTests::AND); 1706 } 1707 static int and(int a, int b) { 1708 return (int)(a & b); 1709 } 1710 1711 @Test(dataProvider = "intBinaryOpProvider") 1712 static void andInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1713 int[] a = fa.apply(SPECIES.length()); 1714 int[] b = fb.apply(SPECIES.length()); 1715 int[] r = fr.apply(SPECIES.length()); 1716 1717 for (int i = 0; i < a.length; i += SPECIES.length()) { 1718 IntVector av = IntVector.fromArray(SPECIES, a, i); 1719 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1720 av.and(bv).intoArray(r, i); 1721 } 1722 1723 assertArraysEquals(r, a, b, Int128VectorTests::and); 1724 } 1725 1726 1727 1728 @Test(dataProvider = "intBinaryOpMaskProvider") 1729 static void ANDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1730 IntFunction<boolean[]> fm) { 1731 int[] a = fa.apply(SPECIES.length()); 1732 int[] b = fb.apply(SPECIES.length()); 1733 int[] r = fr.apply(SPECIES.length()); 1734 boolean[] mask = fm.apply(SPECIES.length()); 1735 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1736 1737 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1738 for (int i = 0; i < a.length; i += SPECIES.length()) { 1739 IntVector av = IntVector.fromArray(SPECIES, a, i); 1740 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1741 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i); 1742 } 1743 } 1744 1745 assertArraysEquals(r, a, b, mask, Int128VectorTests::AND); 1746 } 1747 1748 1749 static int AND_NOT(int a, int b) { 1750 return (int)(a & ~b); 1751 } 1752 1753 @Test(dataProvider = "intBinaryOpProvider") 1754 static void AND_NOTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1755 int[] a = fa.apply(SPECIES.length()); 1756 int[] b = fb.apply(SPECIES.length()); 1757 int[] r = fr.apply(SPECIES.length()); 1758 1759 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1760 for (int i = 0; i < a.length; i += SPECIES.length()) { 1761 IntVector av = IntVector.fromArray(SPECIES, a, i); 1762 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1763 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i); 1764 } 1765 } 1766 1767 assertArraysEquals(r, a, b, Int128VectorTests::AND_NOT); 1768 } 1769 1770 1771 1772 @Test(dataProvider = "intBinaryOpMaskProvider") 1773 static void AND_NOTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1774 IntFunction<boolean[]> fm) { 1775 int[] a = fa.apply(SPECIES.length()); 1776 int[] b = fb.apply(SPECIES.length()); 1777 int[] r = fr.apply(SPECIES.length()); 1778 boolean[] mask = fm.apply(SPECIES.length()); 1779 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1780 1781 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1782 for (int i = 0; i < a.length; i += SPECIES.length()) { 1783 IntVector av = IntVector.fromArray(SPECIES, a, i); 1784 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1785 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i); 1786 } 1787 } 1788 1789 assertArraysEquals(r, a, b, mask, Int128VectorTests::AND_NOT); 1790 } 1791 1792 1793 static int OR(int a, int b) { 1794 return (int)(a | b); 1795 } 1796 1797 @Test(dataProvider = "intBinaryOpProvider") 1798 static void ORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1799 int[] a = fa.apply(SPECIES.length()); 1800 int[] b = fb.apply(SPECIES.length()); 1801 int[] r = fr.apply(SPECIES.length()); 1802 1803 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1804 for (int i = 0; i < a.length; i += SPECIES.length()) { 1805 IntVector av = IntVector.fromArray(SPECIES, a, i); 1806 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1807 av.lanewise(VectorOperators.OR, bv).intoArray(r, i); 1808 } 1809 } 1810 1811 assertArraysEquals(r, a, b, Int128VectorTests::OR); 1812 } 1813 static int or(int a, int b) { 1814 return (int)(a | b); 1815 } 1816 1817 @Test(dataProvider = "intBinaryOpProvider") 1818 static void orInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1819 int[] a = fa.apply(SPECIES.length()); 1820 int[] b = fb.apply(SPECIES.length()); 1821 int[] r = fr.apply(SPECIES.length()); 1822 1823 for (int i = 0; i < a.length; i += SPECIES.length()) { 1824 IntVector av = IntVector.fromArray(SPECIES, a, i); 1825 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1826 av.or(bv).intoArray(r, i); 1827 } 1828 1829 assertArraysEquals(r, a, b, Int128VectorTests::or); 1830 } 1831 1832 1833 1834 @Test(dataProvider = "intBinaryOpMaskProvider") 1835 static void ORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1836 IntFunction<boolean[]> fm) { 1837 int[] a = fa.apply(SPECIES.length()); 1838 int[] b = fb.apply(SPECIES.length()); 1839 int[] r = fr.apply(SPECIES.length()); 1840 boolean[] mask = fm.apply(SPECIES.length()); 1841 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1842 1843 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1844 for (int i = 0; i < a.length; i += SPECIES.length()) { 1845 IntVector av = IntVector.fromArray(SPECIES, a, i); 1846 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1847 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i); 1848 } 1849 } 1850 1851 assertArraysEquals(r, a, b, mask, Int128VectorTests::OR); 1852 } 1853 1854 1855 static int XOR(int a, int b) { 1856 return (int)(a ^ b); 1857 } 1858 1859 @Test(dataProvider = "intBinaryOpProvider") 1860 static void XORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1861 int[] a = fa.apply(SPECIES.length()); 1862 int[] b = fb.apply(SPECIES.length()); 1863 int[] r = fr.apply(SPECIES.length()); 1864 1865 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1866 for (int i = 0; i < a.length; i += SPECIES.length()) { 1867 IntVector av = IntVector.fromArray(SPECIES, a, i); 1868 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1869 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i); 1870 } 1871 } 1872 1873 assertArraysEquals(r, a, b, Int128VectorTests::XOR); 1874 } 1875 1876 1877 1878 @Test(dataProvider = "intBinaryOpMaskProvider") 1879 static void XORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 1880 IntFunction<boolean[]> fm) { 1881 int[] a = fa.apply(SPECIES.length()); 1882 int[] b = fb.apply(SPECIES.length()); 1883 int[] r = fr.apply(SPECIES.length()); 1884 boolean[] mask = fm.apply(SPECIES.length()); 1885 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1886 1887 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1888 for (int i = 0; i < a.length; i += SPECIES.length()) { 1889 IntVector av = IntVector.fromArray(SPECIES, a, i); 1890 IntVector bv = IntVector.fromArray(SPECIES, b, i); 1891 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i); 1892 } 1893 } 1894 1895 assertArraysEquals(r, a, b, mask, Int128VectorTests::XOR); 1896 } 1897 1898 1899 @Test(dataProvider = "intBinaryOpProvider") 1900 static void addInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1901 int[] a = fa.apply(SPECIES.length()); 1902 int[] b = fb.apply(SPECIES.length()); 1903 int[] r = fr.apply(SPECIES.length()); 1904 1905 for (int i = 0; i < a.length; i += SPECIES.length()) { 1906 IntVector av = IntVector.fromArray(SPECIES, a, i); 1907 av.add(b[i]).intoArray(r, i); 1908 } 1909 1910 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::add); 1911 } 1912 1913 @Test(dataProvider = "intBinaryOpMaskProvider") 1914 static void addInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 1915 IntFunction<boolean[]> fm) { 1916 int[] a = fa.apply(SPECIES.length()); 1917 int[] b = fb.apply(SPECIES.length()); 1918 int[] r = fr.apply(SPECIES.length()); 1919 boolean[] mask = fm.apply(SPECIES.length()); 1920 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1921 1922 for (int i = 0; i < a.length; i += SPECIES.length()) { 1923 IntVector av = IntVector.fromArray(SPECIES, a, i); 1924 av.add(b[i], vmask).intoArray(r, i); 1925 } 1926 1927 assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::add); 1928 } 1929 1930 @Test(dataProvider = "intBinaryOpProvider") 1931 static void subInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1932 int[] a = fa.apply(SPECIES.length()); 1933 int[] b = fb.apply(SPECIES.length()); 1934 int[] r = fr.apply(SPECIES.length()); 1935 1936 for (int i = 0; i < a.length; i += SPECIES.length()) { 1937 IntVector av = IntVector.fromArray(SPECIES, a, i); 1938 av.sub(b[i]).intoArray(r, i); 1939 } 1940 1941 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::sub); 1942 } 1943 1944 @Test(dataProvider = "intBinaryOpMaskProvider") 1945 static void subInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 1946 IntFunction<boolean[]> fm) { 1947 int[] a = fa.apply(SPECIES.length()); 1948 int[] b = fb.apply(SPECIES.length()); 1949 int[] r = fr.apply(SPECIES.length()); 1950 boolean[] mask = fm.apply(SPECIES.length()); 1951 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1952 1953 for (int i = 0; i < a.length; i += SPECIES.length()) { 1954 IntVector av = IntVector.fromArray(SPECIES, a, i); 1955 av.sub(b[i], vmask).intoArray(r, i); 1956 } 1957 1958 assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::sub); 1959 } 1960 1961 @Test(dataProvider = "intBinaryOpProvider") 1962 static void mulInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1963 int[] a = fa.apply(SPECIES.length()); 1964 int[] b = fb.apply(SPECIES.length()); 1965 int[] r = fr.apply(SPECIES.length()); 1966 1967 for (int i = 0; i < a.length; i += SPECIES.length()) { 1968 IntVector av = IntVector.fromArray(SPECIES, a, i); 1969 av.mul(b[i]).intoArray(r, i); 1970 } 1971 1972 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::mul); 1973 } 1974 1975 @Test(dataProvider = "intBinaryOpMaskProvider") 1976 static void mulInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 1977 IntFunction<boolean[]> fm) { 1978 int[] a = fa.apply(SPECIES.length()); 1979 int[] b = fb.apply(SPECIES.length()); 1980 int[] r = fr.apply(SPECIES.length()); 1981 boolean[] mask = fm.apply(SPECIES.length()); 1982 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1983 1984 for (int i = 0; i < a.length; i += SPECIES.length()) { 1985 IntVector av = IntVector.fromArray(SPECIES, a, i); 1986 av.mul(b[i], vmask).intoArray(r, i); 1987 } 1988 1989 assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::mul); 1990 } 1991 1992 1993 1994 1995 @Test(dataProvider = "intBinaryOpProvider") 1996 static void divInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 1997 int[] a = fa.apply(SPECIES.length()); 1998 int[] b = fb.apply(SPECIES.length()); 1999 int[] r = fr.apply(SPECIES.length()); 2000 2001 replaceZero(b, (int) 1); 2002 2003 for (int i = 0; i < a.length; i += SPECIES.length()) { 2004 IntVector av = IntVector.fromArray(SPECIES, a, i); 2005 av.div(b[i]).intoArray(r, i); 2006 } 2007 2008 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::div); 2009 } 2010 2011 2012 2013 @Test(dataProvider = "intBinaryOpMaskProvider") 2014 static void divInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 2015 IntFunction<boolean[]> fm) { 2016 int[] a = fa.apply(SPECIES.length()); 2017 int[] b = fb.apply(SPECIES.length()); 2018 int[] r = fr.apply(SPECIES.length()); 2019 boolean[] mask = fm.apply(SPECIES.length()); 2020 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2021 2022 replaceZero(b, (int) 1); 2023 2024 for (int i = 0; i < a.length; i += SPECIES.length()) { 2025 IntVector av = IntVector.fromArray(SPECIES, a, i); 2026 av.div(b[i], vmask).intoArray(r, i); 2027 } 2028 2029 assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::div); 2030 } 2031 2032 2033 2034 @Test(dataProvider = "intBinaryOpProvider") 2035 static void ORInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2036 int[] a = fa.apply(SPECIES.length()); 2037 int[] b = fb.apply(SPECIES.length()); 2038 int[] r = fr.apply(SPECIES.length()); 2039 2040 for (int i = 0; i < a.length; i += SPECIES.length()) { 2041 IntVector av = IntVector.fromArray(SPECIES, a, i); 2042 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); 2043 } 2044 2045 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::OR); 2046 } 2047 2048 @Test(dataProvider = "intBinaryOpProvider") 2049 static void orInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2050 int[] a = fa.apply(SPECIES.length()); 2051 int[] b = fb.apply(SPECIES.length()); 2052 int[] r = fr.apply(SPECIES.length()); 2053 2054 for (int i = 0; i < a.length; i += SPECIES.length()) { 2055 IntVector av = IntVector.fromArray(SPECIES, a, i); 2056 av.or(b[i]).intoArray(r, i); 2057 } 2058 2059 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::or); 2060 } 2061 2062 2063 2064 @Test(dataProvider = "intBinaryOpMaskProvider") 2065 static void ORInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 2066 IntFunction<boolean[]> fm) { 2067 int[] a = fa.apply(SPECIES.length()); 2068 int[] b = fb.apply(SPECIES.length()); 2069 int[] r = fr.apply(SPECIES.length()); 2070 boolean[] mask = fm.apply(SPECIES.length()); 2071 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2072 2073 for (int i = 0; i < a.length; i += SPECIES.length()) { 2074 IntVector av = IntVector.fromArray(SPECIES, a, i); 2075 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); 2076 } 2077 2078 assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::OR); 2079 } 2080 2081 2082 2083 @Test(dataProvider = "intBinaryOpProvider") 2084 static void ANDInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2085 int[] a = fa.apply(SPECIES.length()); 2086 int[] b = fb.apply(SPECIES.length()); 2087 int[] r = fr.apply(SPECIES.length()); 2088 2089 for (int i = 0; i < a.length; i += SPECIES.length()) { 2090 IntVector av = IntVector.fromArray(SPECIES, a, i); 2091 av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); 2092 } 2093 2094 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::AND); 2095 } 2096 2097 @Test(dataProvider = "intBinaryOpProvider") 2098 static void andInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2099 int[] a = fa.apply(SPECIES.length()); 2100 int[] b = fb.apply(SPECIES.length()); 2101 int[] r = fr.apply(SPECIES.length()); 2102 2103 for (int i = 0; i < a.length; i += SPECIES.length()) { 2104 IntVector av = IntVector.fromArray(SPECIES, a, i); 2105 av.and(b[i]).intoArray(r, i); 2106 } 2107 2108 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::and); 2109 } 2110 2111 2112 2113 @Test(dataProvider = "intBinaryOpMaskProvider") 2114 static void ANDInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 2115 IntFunction<boolean[]> fm) { 2116 int[] a = fa.apply(SPECIES.length()); 2117 int[] b = fb.apply(SPECIES.length()); 2118 int[] r = fr.apply(SPECIES.length()); 2119 boolean[] mask = fm.apply(SPECIES.length()); 2120 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2121 2122 for (int i = 0; i < a.length; i += SPECIES.length()) { 2123 IntVector av = IntVector.fromArray(SPECIES, a, i); 2124 av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); 2125 } 2126 2127 assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::AND); 2128 } 2129 2130 2131 2132 @Test(dataProvider = "intBinaryOpProvider") 2133 static void ORInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2134 int[] a = fa.apply(SPECIES.length()); 2135 int[] b = fb.apply(SPECIES.length()); 2136 int[] r = fr.apply(SPECIES.length()); 2137 2138 for (int i = 0; i < a.length; i += SPECIES.length()) { 2139 IntVector av = IntVector.fromArray(SPECIES, a, i); 2140 av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); 2141 } 2142 2143 assertBroadcastLongArraysEquals(r, a, b, Int128VectorTests::OR); 2144 } 2145 2146 2147 2148 @Test(dataProvider = "intBinaryOpMaskProvider") 2149 static void ORInt128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 2150 IntFunction<boolean[]> fm) { 2151 int[] a = fa.apply(SPECIES.length()); 2152 int[] b = fb.apply(SPECIES.length()); 2153 int[] r = fr.apply(SPECIES.length()); 2154 boolean[] mask = fm.apply(SPECIES.length()); 2155 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2156 2157 for (int i = 0; i < a.length; i += SPECIES.length()) { 2158 IntVector av = IntVector.fromArray(SPECIES, a, i); 2159 av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); 2160 } 2161 2162 assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::OR); 2163 } 2164 2165 2166 @Test(dataProvider = "intBinaryOpProvider") 2167 static void ADDInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2168 int[] a = fa.apply(SPECIES.length()); 2169 int[] b = fb.apply(SPECIES.length()); 2170 int[] r = fr.apply(SPECIES.length()); 2171 2172 for (int i = 0; i < a.length; i += SPECIES.length()) { 2173 IntVector av = IntVector.fromArray(SPECIES, a, i); 2174 av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); 2175 } 2176 2177 assertBroadcastLongArraysEquals(r, a, b, Int128VectorTests::ADD); 2178 } 2179 2180 @Test(dataProvider = "intBinaryOpMaskProvider") 2181 static void ADDInt128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 2182 IntFunction<boolean[]> fm) { 2183 int[] a = fa.apply(SPECIES.length()); 2184 int[] b = fb.apply(SPECIES.length()); 2185 int[] r = fr.apply(SPECIES.length()); 2186 boolean[] mask = fm.apply(SPECIES.length()); 2187 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2188 2189 for (int i = 0; i < a.length; i += SPECIES.length()) { 2190 IntVector av = IntVector.fromArray(SPECIES, a, i); 2191 av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); 2192 } 2193 2194 assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::ADD); 2195 } 2196 2197 static int LSHL(int a, int b) { 2198 return (int)((a << b)); 2199 } 2200 2201 @Test(dataProvider = "intBinaryOpProvider") 2202 static void LSHLInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2203 int[] a = fa.apply(SPECIES.length()); 2204 int[] b = fb.apply(SPECIES.length()); 2205 int[] r = fr.apply(SPECIES.length()); 2206 2207 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2208 for (int i = 0; i < a.length; i += SPECIES.length()) { 2209 IntVector av = IntVector.fromArray(SPECIES, a, i); 2210 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2211 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i); 2212 } 2213 } 2214 2215 assertArraysEquals(r, a, b, Int128VectorTests::LSHL); 2216 } 2217 2218 2219 2220 @Test(dataProvider = "intBinaryOpMaskProvider") 2221 static void LSHLInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2222 IntFunction<boolean[]> fm) { 2223 int[] a = fa.apply(SPECIES.length()); 2224 int[] b = fb.apply(SPECIES.length()); 2225 int[] r = fr.apply(SPECIES.length()); 2226 boolean[] mask = fm.apply(SPECIES.length()); 2227 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2228 2229 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2230 for (int i = 0; i < a.length; i += SPECIES.length()) { 2231 IntVector av = IntVector.fromArray(SPECIES, a, i); 2232 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2233 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i); 2234 } 2235 } 2236 2237 assertArraysEquals(r, a, b, mask, Int128VectorTests::LSHL); 2238 } 2239 2240 2241 2242 2243 2244 2245 static int ASHR(int a, int b) { 2246 return (int)((a >> b)); 2247 } 2248 2249 @Test(dataProvider = "intBinaryOpProvider") 2250 static void ASHRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2251 int[] a = fa.apply(SPECIES.length()); 2252 int[] b = fb.apply(SPECIES.length()); 2253 int[] r = fr.apply(SPECIES.length()); 2254 2255 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2256 for (int i = 0; i < a.length; i += SPECIES.length()) { 2257 IntVector av = IntVector.fromArray(SPECIES, a, i); 2258 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2259 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i); 2260 } 2261 } 2262 2263 assertArraysEquals(r, a, b, Int128VectorTests::ASHR); 2264 } 2265 2266 2267 2268 @Test(dataProvider = "intBinaryOpMaskProvider") 2269 static void ASHRInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2270 IntFunction<boolean[]> fm) { 2271 int[] a = fa.apply(SPECIES.length()); 2272 int[] b = fb.apply(SPECIES.length()); 2273 int[] r = fr.apply(SPECIES.length()); 2274 boolean[] mask = fm.apply(SPECIES.length()); 2275 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2276 2277 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2278 for (int i = 0; i < a.length; i += SPECIES.length()) { 2279 IntVector av = IntVector.fromArray(SPECIES, a, i); 2280 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2281 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i); 2282 } 2283 } 2284 2285 assertArraysEquals(r, a, b, mask, Int128VectorTests::ASHR); 2286 } 2287 2288 2289 2290 2291 2292 2293 static int LSHR(int a, int b) { 2294 return (int)((a >>> b)); 2295 } 2296 2297 @Test(dataProvider = "intBinaryOpProvider") 2298 static void LSHRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2299 int[] a = fa.apply(SPECIES.length()); 2300 int[] b = fb.apply(SPECIES.length()); 2301 int[] r = fr.apply(SPECIES.length()); 2302 2303 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2304 for (int i = 0; i < a.length; i += SPECIES.length()) { 2305 IntVector av = IntVector.fromArray(SPECIES, a, i); 2306 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2307 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i); 2308 } 2309 } 2310 2311 assertArraysEquals(r, a, b, Int128VectorTests::LSHR); 2312 } 2313 2314 2315 2316 @Test(dataProvider = "intBinaryOpMaskProvider") 2317 static void LSHRInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2318 IntFunction<boolean[]> fm) { 2319 int[] a = fa.apply(SPECIES.length()); 2320 int[] b = fb.apply(SPECIES.length()); 2321 int[] r = fr.apply(SPECIES.length()); 2322 boolean[] mask = fm.apply(SPECIES.length()); 2323 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2324 2325 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2326 for (int i = 0; i < a.length; i += SPECIES.length()) { 2327 IntVector av = IntVector.fromArray(SPECIES, a, i); 2328 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2329 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i); 2330 } 2331 } 2332 2333 assertArraysEquals(r, a, b, mask, Int128VectorTests::LSHR); 2334 } 2335 2336 2337 2338 2339 2340 2341 static int LSHL_unary(int a, int b) { 2342 return (int)((a << b)); 2343 } 2344 2345 @Test(dataProvider = "intBinaryOpProvider") 2346 static void LSHLInt128VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2347 int[] a = fa.apply(SPECIES.length()); 2348 int[] b = fb.apply(SPECIES.length()); 2349 int[] r = fr.apply(SPECIES.length()); 2350 2351 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2352 for (int i = 0; i < a.length; i += SPECIES.length()) { 2353 IntVector av = IntVector.fromArray(SPECIES, a, i); 2354 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i); 2355 } 2356 } 2357 2358 assertShiftArraysEquals(r, a, b, Int128VectorTests::LSHL_unary); 2359 } 2360 2361 2362 2363 @Test(dataProvider = "intBinaryOpMaskProvider") 2364 static void LSHLInt128VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2365 IntFunction<boolean[]> fm) { 2366 int[] a = fa.apply(SPECIES.length()); 2367 int[] b = fb.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 2372 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2373 for (int i = 0; i < a.length; i += SPECIES.length()) { 2374 IntVector av = IntVector.fromArray(SPECIES, a, i); 2375 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i); 2376 } 2377 } 2378 2379 assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::LSHL_unary); 2380 } 2381 2382 2383 2384 2385 2386 2387 static int LSHR_unary(int a, int b) { 2388 return (int)((a >>> b)); 2389 } 2390 2391 @Test(dataProvider = "intBinaryOpProvider") 2392 static void LSHRInt128VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2393 int[] a = fa.apply(SPECIES.length()); 2394 int[] b = fb.apply(SPECIES.length()); 2395 int[] r = fr.apply(SPECIES.length()); 2396 2397 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2398 for (int i = 0; i < a.length; i += SPECIES.length()) { 2399 IntVector av = IntVector.fromArray(SPECIES, a, i); 2400 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i); 2401 } 2402 } 2403 2404 assertShiftArraysEquals(r, a, b, Int128VectorTests::LSHR_unary); 2405 } 2406 2407 2408 2409 @Test(dataProvider = "intBinaryOpMaskProvider") 2410 static void LSHRInt128VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2411 IntFunction<boolean[]> fm) { 2412 int[] a = fa.apply(SPECIES.length()); 2413 int[] b = fb.apply(SPECIES.length()); 2414 int[] r = fr.apply(SPECIES.length()); 2415 boolean[] mask = fm.apply(SPECIES.length()); 2416 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 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 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i); 2422 } 2423 } 2424 2425 assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::LSHR_unary); 2426 } 2427 2428 2429 2430 2431 2432 2433 static int ASHR_unary(int a, int b) { 2434 return (int)((a >> b)); 2435 } 2436 2437 @Test(dataProvider = "intBinaryOpProvider") 2438 static void ASHRInt128VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2439 int[] a = fa.apply(SPECIES.length()); 2440 int[] b = fb.apply(SPECIES.length()); 2441 int[] r = fr.apply(SPECIES.length()); 2442 2443 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2444 for (int i = 0; i < a.length; i += SPECIES.length()) { 2445 IntVector av = IntVector.fromArray(SPECIES, a, i); 2446 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i); 2447 } 2448 } 2449 2450 assertShiftArraysEquals(r, a, b, Int128VectorTests::ASHR_unary); 2451 } 2452 2453 2454 2455 @Test(dataProvider = "intBinaryOpMaskProvider") 2456 static void ASHRInt128VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2457 IntFunction<boolean[]> fm) { 2458 int[] a = fa.apply(SPECIES.length()); 2459 int[] b = fb.apply(SPECIES.length()); 2460 int[] r = fr.apply(SPECIES.length()); 2461 boolean[] mask = fm.apply(SPECIES.length()); 2462 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2463 2464 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2465 for (int i = 0; i < a.length; i += SPECIES.length()) { 2466 IntVector av = IntVector.fromArray(SPECIES, a, i); 2467 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i); 2468 } 2469 } 2470 2471 assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ASHR_unary); 2472 } 2473 2474 2475 2476 2477 2478 2479 static int ROR(int a, int b) { 2480 return (int)(ROR_scalar(a,b)); 2481 } 2482 2483 @Test(dataProvider = "intBinaryOpProvider") 2484 static void RORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2485 int[] a = fa.apply(SPECIES.length()); 2486 int[] b = fb.apply(SPECIES.length()); 2487 int[] r = fr.apply(SPECIES.length()); 2488 2489 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2490 for (int i = 0; i < a.length; i += SPECIES.length()) { 2491 IntVector av = IntVector.fromArray(SPECIES, a, i); 2492 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2493 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i); 2494 } 2495 } 2496 2497 assertArraysEquals(r, a, b, Int128VectorTests::ROR); 2498 } 2499 2500 2501 2502 @Test(dataProvider = "intBinaryOpMaskProvider") 2503 static void RORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2504 IntFunction<boolean[]> fm) { 2505 int[] a = fa.apply(SPECIES.length()); 2506 int[] b = fb.apply(SPECIES.length()); 2507 int[] r = fr.apply(SPECIES.length()); 2508 boolean[] mask = fm.apply(SPECIES.length()); 2509 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2510 2511 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2512 for (int i = 0; i < a.length; i += SPECIES.length()) { 2513 IntVector av = IntVector.fromArray(SPECIES, a, i); 2514 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2515 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i); 2516 } 2517 } 2518 2519 assertArraysEquals(r, a, b, mask, Int128VectorTests::ROR); 2520 } 2521 2522 2523 static int ROL(int a, int b) { 2524 return (int)(ROL_scalar(a,b)); 2525 } 2526 2527 @Test(dataProvider = "intBinaryOpProvider") 2528 static void ROLInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2529 int[] a = fa.apply(SPECIES.length()); 2530 int[] b = fb.apply(SPECIES.length()); 2531 int[] r = fr.apply(SPECIES.length()); 2532 2533 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2534 for (int i = 0; i < a.length; i += SPECIES.length()) { 2535 IntVector av = IntVector.fromArray(SPECIES, a, i); 2536 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2537 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i); 2538 } 2539 } 2540 2541 assertArraysEquals(r, a, b, Int128VectorTests::ROL); 2542 } 2543 2544 2545 2546 @Test(dataProvider = "intBinaryOpMaskProvider") 2547 static void ROLInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2548 IntFunction<boolean[]> fm) { 2549 int[] a = fa.apply(SPECIES.length()); 2550 int[] b = fb.apply(SPECIES.length()); 2551 int[] r = fr.apply(SPECIES.length()); 2552 boolean[] mask = fm.apply(SPECIES.length()); 2553 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2554 2555 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2556 for (int i = 0; i < a.length; i += SPECIES.length()) { 2557 IntVector av = IntVector.fromArray(SPECIES, a, i); 2558 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2559 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i); 2560 } 2561 } 2562 2563 assertArraysEquals(r, a, b, mask, Int128VectorTests::ROL); 2564 } 2565 2566 2567 static int ROR_unary(int a, int b) { 2568 return (int)(ROR_scalar(a, b)); 2569 } 2570 2571 @Test(dataProvider = "intBinaryOpProvider") 2572 static void RORInt128VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2573 int[] a = fa.apply(SPECIES.length()); 2574 int[] b = fb.apply(SPECIES.length()); 2575 int[] r = fr.apply(SPECIES.length()); 2576 2577 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2578 for (int i = 0; i < a.length; i += SPECIES.length()) { 2579 IntVector av = IntVector.fromArray(SPECIES, a, i); 2580 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i); 2581 } 2582 } 2583 2584 assertShiftArraysEquals(r, a, b, Int128VectorTests::ROR_unary); 2585 } 2586 2587 2588 2589 @Test(dataProvider = "intBinaryOpMaskProvider") 2590 static void RORInt128VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2591 IntFunction<boolean[]> fm) { 2592 int[] a = fa.apply(SPECIES.length()); 2593 int[] b = fb.apply(SPECIES.length()); 2594 int[] r = fr.apply(SPECIES.length()); 2595 boolean[] mask = fm.apply(SPECIES.length()); 2596 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 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 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i); 2602 } 2603 } 2604 2605 assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ROR_unary); 2606 } 2607 2608 2609 static int ROL_unary(int a, int b) { 2610 return (int)(ROL_scalar(a, b)); 2611 } 2612 2613 @Test(dataProvider = "intBinaryOpProvider") 2614 static void ROLInt128VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2615 int[] a = fa.apply(SPECIES.length()); 2616 int[] b = fb.apply(SPECIES.length()); 2617 int[] r = fr.apply(SPECIES.length()); 2618 2619 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2620 for (int i = 0; i < a.length; i += SPECIES.length()) { 2621 IntVector av = IntVector.fromArray(SPECIES, a, i); 2622 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i); 2623 } 2624 } 2625 2626 assertShiftArraysEquals(r, a, b, Int128VectorTests::ROL_unary); 2627 } 2628 2629 2630 2631 @Test(dataProvider = "intBinaryOpMaskProvider") 2632 static void ROLInt128VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 2633 IntFunction<boolean[]> fm) { 2634 int[] a = fa.apply(SPECIES.length()); 2635 int[] b = fb.apply(SPECIES.length()); 2636 int[] r = fr.apply(SPECIES.length()); 2637 boolean[] mask = fm.apply(SPECIES.length()); 2638 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2639 2640 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2641 for (int i = 0; i < a.length; i += SPECIES.length()) { 2642 IntVector av = IntVector.fromArray(SPECIES, a, i); 2643 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i); 2644 } 2645 } 2646 2647 assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ROL_unary); 2648 } 2649 2650 2651 static int LSHR_binary_const(int a) { 2652 return (int)((a >>> CONST_SHIFT)); 2653 } 2654 2655 @Test(dataProvider = "intUnaryOpProvider") 2656 static void LSHRInt128VectorTestsScalarShiftConst(IntFunction<int[]> fa) { 2657 int[] a = fa.apply(SPECIES.length()); 2658 int[] r = fr.apply(SPECIES.length()); 2659 2660 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2661 for (int i = 0; i < a.length; i += SPECIES.length()) { 2662 IntVector av = IntVector.fromArray(SPECIES, a, i); 2663 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i); 2664 } 2665 } 2666 2667 assertShiftConstEquals(r, a, Int128VectorTests::LSHR_binary_const); 2668 } 2669 2670 2671 2672 @Test(dataProvider = "intUnaryOpMaskProvider") 2673 static void LSHRInt128VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa, 2674 IntFunction<boolean[]> fm) { 2675 int[] a = fa.apply(SPECIES.length()); 2676 int[] r = fr.apply(SPECIES.length()); 2677 boolean[] mask = fm.apply(SPECIES.length()); 2678 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2679 2680 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2681 for (int i = 0; i < a.length; i += SPECIES.length()) { 2682 IntVector av = IntVector.fromArray(SPECIES, a, i); 2683 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i); 2684 } 2685 } 2686 2687 assertShiftConstEquals(r, a, mask, Int128VectorTests::LSHR_binary_const); 2688 } 2689 2690 2691 2692 2693 2694 2695 2696 static int LSHL_binary_const(int a) { 2697 return (int)((a << CONST_SHIFT)); 2698 } 2699 2700 @Test(dataProvider = "intUnaryOpProvider") 2701 static void LSHLInt128VectorTestsScalarShiftConst(IntFunction<int[]> fa) { 2702 int[] a = fa.apply(SPECIES.length()); 2703 int[] r = fr.apply(SPECIES.length()); 2704 2705 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2706 for (int i = 0; i < a.length; i += SPECIES.length()) { 2707 IntVector av = IntVector.fromArray(SPECIES, a, i); 2708 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i); 2709 } 2710 } 2711 2712 assertShiftConstEquals(r, a, Int128VectorTests::LSHL_binary_const); 2713 } 2714 2715 2716 2717 @Test(dataProvider = "intUnaryOpMaskProvider") 2718 static void LSHLInt128VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa, 2719 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 2725 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2726 for (int i = 0; i < a.length; i += SPECIES.length()) { 2727 IntVector av = IntVector.fromArray(SPECIES, a, i); 2728 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i); 2729 } 2730 } 2731 2732 assertShiftConstEquals(r, a, mask, Int128VectorTests::LSHL_binary_const); 2733 } 2734 2735 2736 2737 static int ASHR_binary_const(int a) { 2738 return (int)((a >> CONST_SHIFT)); 2739 } 2740 2741 @Test(dataProvider = "intUnaryOpProvider") 2742 static void ASHRInt128VectorTestsScalarShiftConst(IntFunction<int[]> fa) { 2743 int[] a = fa.apply(SPECIES.length()); 2744 int[] r = fr.apply(SPECIES.length()); 2745 2746 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2747 for (int i = 0; i < a.length; i += SPECIES.length()) { 2748 IntVector av = IntVector.fromArray(SPECIES, a, i); 2749 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i); 2750 } 2751 } 2752 2753 assertShiftConstEquals(r, a, Int128VectorTests::ASHR_binary_const); 2754 } 2755 2756 2757 2758 @Test(dataProvider = "intUnaryOpMaskProvider") 2759 static void ASHRInt128VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa, 2760 IntFunction<boolean[]> fm) { 2761 int[] a = fa.apply(SPECIES.length()); 2762 int[] r = fr.apply(SPECIES.length()); 2763 boolean[] mask = fm.apply(SPECIES.length()); 2764 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2765 2766 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2767 for (int i = 0; i < a.length; i += SPECIES.length()) { 2768 IntVector av = IntVector.fromArray(SPECIES, a, i); 2769 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i); 2770 } 2771 } 2772 2773 assertShiftConstEquals(r, a, mask, Int128VectorTests::ASHR_binary_const); 2774 } 2775 2776 2777 2778 static int ROR_binary_const(int a) { 2779 return (int)(ROR_scalar(a, CONST_SHIFT)); 2780 } 2781 2782 @Test(dataProvider = "intUnaryOpProvider") 2783 static void RORInt128VectorTestsScalarShiftConst(IntFunction<int[]> fa) { 2784 int[] a = fa.apply(SPECIES.length()); 2785 int[] r = fr.apply(SPECIES.length()); 2786 2787 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2788 for (int i = 0; i < a.length; i += SPECIES.length()) { 2789 IntVector av = IntVector.fromArray(SPECIES, a, i); 2790 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i); 2791 } 2792 } 2793 2794 assertShiftConstEquals(r, a, Int128VectorTests::ROR_binary_const); 2795 } 2796 2797 2798 2799 @Test(dataProvider = "intUnaryOpMaskProvider") 2800 static void RORInt128VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa, 2801 IntFunction<boolean[]> fm) { 2802 int[] a = fa.apply(SPECIES.length()); 2803 int[] r = fr.apply(SPECIES.length()); 2804 boolean[] mask = fm.apply(SPECIES.length()); 2805 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2806 2807 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2808 for (int i = 0; i < a.length; i += SPECIES.length()) { 2809 IntVector av = IntVector.fromArray(SPECIES, a, i); 2810 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i); 2811 } 2812 } 2813 2814 assertShiftConstEquals(r, a, mask, Int128VectorTests::ROR_binary_const); 2815 } 2816 2817 2818 2819 static int ROL_binary_const(int a) { 2820 return (int)(ROL_scalar(a, CONST_SHIFT)); 2821 } 2822 2823 @Test(dataProvider = "intUnaryOpProvider") 2824 static void ROLInt128VectorTestsScalarShiftConst(IntFunction<int[]> fa) { 2825 int[] a = fa.apply(SPECIES.length()); 2826 int[] r = fr.apply(SPECIES.length()); 2827 2828 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2829 for (int i = 0; i < a.length; i += SPECIES.length()) { 2830 IntVector av = IntVector.fromArray(SPECIES, a, i); 2831 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i); 2832 } 2833 } 2834 2835 assertShiftConstEquals(r, a, Int128VectorTests::ROL_binary_const); 2836 } 2837 2838 2839 2840 @Test(dataProvider = "intUnaryOpMaskProvider") 2841 static void ROLInt128VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa, 2842 IntFunction<boolean[]> fm) { 2843 int[] a = fa.apply(SPECIES.length()); 2844 int[] r = fr.apply(SPECIES.length()); 2845 boolean[] mask = fm.apply(SPECIES.length()); 2846 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 2847 2848 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2849 for (int i = 0; i < a.length; i += SPECIES.length()) { 2850 IntVector av = IntVector.fromArray(SPECIES, a, i); 2851 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i); 2852 } 2853 } 2854 2855 assertShiftConstEquals(r, a, mask, Int128VectorTests::ROL_binary_const); 2856 } 2857 2858 2859 static int MIN(int a, int b) { 2860 return (int)(Math.min(a, b)); 2861 } 2862 2863 @Test(dataProvider = "intBinaryOpProvider") 2864 static void MINInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2865 int[] a = fa.apply(SPECIES.length()); 2866 int[] b = fb.apply(SPECIES.length()); 2867 int[] r = fr.apply(SPECIES.length()); 2868 2869 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2870 for (int i = 0; i < a.length; i += SPECIES.length()) { 2871 IntVector av = IntVector.fromArray(SPECIES, a, i); 2872 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2873 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i); 2874 } 2875 } 2876 2877 assertArraysEquals(r, a, b, Int128VectorTests::MIN); 2878 } 2879 static int min(int a, int b) { 2880 return (int)(Math.min(a, b)); 2881 } 2882 2883 @Test(dataProvider = "intBinaryOpProvider") 2884 static void minInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2885 int[] a = fa.apply(SPECIES.length()); 2886 int[] b = fb.apply(SPECIES.length()); 2887 int[] r = fr.apply(SPECIES.length()); 2888 2889 for (int i = 0; i < a.length; i += SPECIES.length()) { 2890 IntVector av = IntVector.fromArray(SPECIES, a, i); 2891 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2892 av.min(bv).intoArray(r, i); 2893 } 2894 2895 assertArraysEquals(r, a, b, Int128VectorTests::min); 2896 } 2897 static int MAX(int a, int b) { 2898 return (int)(Math.max(a, b)); 2899 } 2900 2901 @Test(dataProvider = "intBinaryOpProvider") 2902 static void MAXInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2903 int[] a = fa.apply(SPECIES.length()); 2904 int[] b = fb.apply(SPECIES.length()); 2905 int[] r = fr.apply(SPECIES.length()); 2906 2907 for (int ic = 0; ic < INVOC_COUNT; ic++) { 2908 for (int i = 0; i < a.length; i += SPECIES.length()) { 2909 IntVector av = IntVector.fromArray(SPECIES, a, i); 2910 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2911 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i); 2912 } 2913 } 2914 2915 assertArraysEquals(r, a, b, Int128VectorTests::MAX); 2916 } 2917 static int max(int a, int b) { 2918 return (int)(Math.max(a, b)); 2919 } 2920 2921 @Test(dataProvider = "intBinaryOpProvider") 2922 static void maxInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2923 int[] a = fa.apply(SPECIES.length()); 2924 int[] b = fb.apply(SPECIES.length()); 2925 int[] r = fr.apply(SPECIES.length()); 2926 2927 for (int i = 0; i < a.length; i += SPECIES.length()) { 2928 IntVector av = IntVector.fromArray(SPECIES, a, i); 2929 IntVector bv = IntVector.fromArray(SPECIES, b, i); 2930 av.max(bv).intoArray(r, i); 2931 } 2932 2933 assertArraysEquals(r, a, b, Int128VectorTests::max); 2934 } 2935 2936 @Test(dataProvider = "intBinaryOpProvider") 2937 static void MINInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2938 int[] a = fa.apply(SPECIES.length()); 2939 int[] b = fb.apply(SPECIES.length()); 2940 int[] r = fr.apply(SPECIES.length()); 2941 2942 for (int i = 0; i < a.length; i += SPECIES.length()) { 2943 IntVector av = IntVector.fromArray(SPECIES, a, i); 2944 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); 2945 } 2946 2947 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::MIN); 2948 } 2949 2950 @Test(dataProvider = "intBinaryOpProvider") 2951 static void minInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2952 int[] a = fa.apply(SPECIES.length()); 2953 int[] b = fb.apply(SPECIES.length()); 2954 int[] r = fr.apply(SPECIES.length()); 2955 2956 for (int i = 0; i < a.length; i += SPECIES.length()) { 2957 IntVector av = IntVector.fromArray(SPECIES, a, i); 2958 av.min(b[i]).intoArray(r, i); 2959 } 2960 2961 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::min); 2962 } 2963 2964 @Test(dataProvider = "intBinaryOpProvider") 2965 static void MAXInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2966 int[] a = fa.apply(SPECIES.length()); 2967 int[] b = fb.apply(SPECIES.length()); 2968 int[] r = fr.apply(SPECIES.length()); 2969 2970 for (int i = 0; i < a.length; i += SPECIES.length()) { 2971 IntVector av = IntVector.fromArray(SPECIES, a, i); 2972 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); 2973 } 2974 2975 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::MAX); 2976 } 2977 2978 @Test(dataProvider = "intBinaryOpProvider") 2979 static void maxInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 2980 int[] a = fa.apply(SPECIES.length()); 2981 int[] b = fb.apply(SPECIES.length()); 2982 int[] r = fr.apply(SPECIES.length()); 2983 2984 for (int i = 0; i < a.length; i += SPECIES.length()) { 2985 IntVector av = IntVector.fromArray(SPECIES, a, i); 2986 av.max(b[i]).intoArray(r, i); 2987 } 2988 2989 assertBroadcastArraysEquals(r, a, b, Int128VectorTests::max); 2990 } 2991 2992 static int ANDReduce(int[] a, int idx) { 2993 int res = -1; 2994 for (int i = idx; i < (idx + SPECIES.length()); i++) { 2995 res &= a[i]; 2996 } 2997 2998 return res; 2999 } 3000 3001 static int ANDReduceAll(int[] a) { 3002 int res = -1; 3003 for (int i = 0; i < a.length; i += SPECIES.length()) { 3004 res &= ANDReduce(a, i); 3005 } 3006 3007 return res; 3008 } 3009 3010 3011 @Test(dataProvider = "intUnaryOpProvider") 3012 static void ANDReduceInt128VectorTests(IntFunction<int[]> fa) { 3013 int[] a = fa.apply(SPECIES.length()); 3014 int[] r = fr.apply(SPECIES.length()); 3015 int ra = -1; 3016 3017 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3018 for (int i = 0; i < a.length; i += SPECIES.length()) { 3019 IntVector av = IntVector.fromArray(SPECIES, a, i); 3020 r[i] = av.reduceLanes(VectorOperators.AND); 3021 } 3022 } 3023 3024 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3025 ra = -1; 3026 for (int i = 0; i < a.length; i += SPECIES.length()) { 3027 IntVector av = IntVector.fromArray(SPECIES, a, i); 3028 ra &= av.reduceLanes(VectorOperators.AND); 3029 } 3030 } 3031 3032 assertReductionArraysEquals(r, ra, a, 3033 Int128VectorTests::ANDReduce, Int128VectorTests::ANDReduceAll); 3034 } 3035 3036 3037 static int ANDReduceMasked(int[] a, int idx, boolean[] mask) { 3038 int res = -1; 3039 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3040 if (mask[i % SPECIES.length()]) 3041 res &= a[i]; 3042 } 3043 3044 return res; 3045 } 3046 3047 static int ANDReduceAllMasked(int[] a, boolean[] mask) { 3048 int res = -1; 3049 for (int i = 0; i < a.length; i += SPECIES.length()) { 3050 res &= ANDReduceMasked(a, i, mask); 3051 } 3052 3053 return res; 3054 } 3055 3056 3057 @Test(dataProvider = "intUnaryOpMaskProvider") 3058 static void ANDReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3059 int[] a = fa.apply(SPECIES.length()); 3060 int[] r = fr.apply(SPECIES.length()); 3061 boolean[] mask = fm.apply(SPECIES.length()); 3062 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3063 int ra = -1; 3064 3065 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3066 for (int i = 0; i < a.length; i += SPECIES.length()) { 3067 IntVector av = IntVector.fromArray(SPECIES, a, i); 3068 r[i] = av.reduceLanes(VectorOperators.AND, vmask); 3069 } 3070 } 3071 3072 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3073 ra = -1; 3074 for (int i = 0; i < a.length; i += SPECIES.length()) { 3075 IntVector av = IntVector.fromArray(SPECIES, a, i); 3076 ra &= av.reduceLanes(VectorOperators.AND, vmask); 3077 } 3078 } 3079 3080 assertReductionArraysEqualsMasked(r, ra, a, mask, 3081 Int128VectorTests::ANDReduceMasked, Int128VectorTests::ANDReduceAllMasked); 3082 } 3083 3084 3085 static int ORReduce(int[] a, int idx) { 3086 int res = 0; 3087 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3088 res |= a[i]; 3089 } 3090 3091 return res; 3092 } 3093 3094 static int ORReduceAll(int[] a) { 3095 int res = 0; 3096 for (int i = 0; i < a.length; i += SPECIES.length()) { 3097 res |= ORReduce(a, i); 3098 } 3099 3100 return res; 3101 } 3102 3103 3104 @Test(dataProvider = "intUnaryOpProvider") 3105 static void ORReduceInt128VectorTests(IntFunction<int[]> fa) { 3106 int[] a = fa.apply(SPECIES.length()); 3107 int[] r = fr.apply(SPECIES.length()); 3108 int ra = 0; 3109 3110 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3111 for (int i = 0; i < a.length; i += SPECIES.length()) { 3112 IntVector av = IntVector.fromArray(SPECIES, a, i); 3113 r[i] = av.reduceLanes(VectorOperators.OR); 3114 } 3115 } 3116 3117 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3118 ra = 0; 3119 for (int i = 0; i < a.length; i += SPECIES.length()) { 3120 IntVector av = IntVector.fromArray(SPECIES, a, i); 3121 ra |= av.reduceLanes(VectorOperators.OR); 3122 } 3123 } 3124 3125 assertReductionArraysEquals(r, ra, a, 3126 Int128VectorTests::ORReduce, Int128VectorTests::ORReduceAll); 3127 } 3128 3129 3130 static int ORReduceMasked(int[] a, int idx, boolean[] mask) { 3131 int res = 0; 3132 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3133 if (mask[i % SPECIES.length()]) 3134 res |= a[i]; 3135 } 3136 3137 return res; 3138 } 3139 3140 static int ORReduceAllMasked(int[] a, boolean[] mask) { 3141 int res = 0; 3142 for (int i = 0; i < a.length; i += SPECIES.length()) { 3143 res |= ORReduceMasked(a, i, mask); 3144 } 3145 3146 return res; 3147 } 3148 3149 3150 @Test(dataProvider = "intUnaryOpMaskProvider") 3151 static void ORReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3152 int[] a = fa.apply(SPECIES.length()); 3153 int[] r = fr.apply(SPECIES.length()); 3154 boolean[] mask = fm.apply(SPECIES.length()); 3155 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3156 int ra = 0; 3157 3158 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3159 for (int i = 0; i < a.length; i += SPECIES.length()) { 3160 IntVector av = IntVector.fromArray(SPECIES, a, i); 3161 r[i] = av.reduceLanes(VectorOperators.OR, vmask); 3162 } 3163 } 3164 3165 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3166 ra = 0; 3167 for (int i = 0; i < a.length; i += SPECIES.length()) { 3168 IntVector av = IntVector.fromArray(SPECIES, a, i); 3169 ra |= av.reduceLanes(VectorOperators.OR, vmask); 3170 } 3171 } 3172 3173 assertReductionArraysEqualsMasked(r, ra, a, mask, 3174 Int128VectorTests::ORReduceMasked, Int128VectorTests::ORReduceAllMasked); 3175 } 3176 3177 3178 static int XORReduce(int[] a, int idx) { 3179 int res = 0; 3180 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3181 res ^= a[i]; 3182 } 3183 3184 return res; 3185 } 3186 3187 static int XORReduceAll(int[] a) { 3188 int res = 0; 3189 for (int i = 0; i < a.length; i += SPECIES.length()) { 3190 res ^= XORReduce(a, i); 3191 } 3192 3193 return res; 3194 } 3195 3196 3197 @Test(dataProvider = "intUnaryOpProvider") 3198 static void XORReduceInt128VectorTests(IntFunction<int[]> fa) { 3199 int[] a = fa.apply(SPECIES.length()); 3200 int[] r = fr.apply(SPECIES.length()); 3201 int ra = 0; 3202 3203 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3204 for (int i = 0; i < a.length; i += SPECIES.length()) { 3205 IntVector av = IntVector.fromArray(SPECIES, a, i); 3206 r[i] = av.reduceLanes(VectorOperators.XOR); 3207 } 3208 } 3209 3210 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3211 ra = 0; 3212 for (int i = 0; i < a.length; i += SPECIES.length()) { 3213 IntVector av = IntVector.fromArray(SPECIES, a, i); 3214 ra ^= av.reduceLanes(VectorOperators.XOR); 3215 } 3216 } 3217 3218 assertReductionArraysEquals(r, ra, a, 3219 Int128VectorTests::XORReduce, Int128VectorTests::XORReduceAll); 3220 } 3221 3222 3223 static int XORReduceMasked(int[] a, int idx, boolean[] mask) { 3224 int res = 0; 3225 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3226 if (mask[i % SPECIES.length()]) 3227 res ^= a[i]; 3228 } 3229 3230 return res; 3231 } 3232 3233 static int XORReduceAllMasked(int[] a, boolean[] mask) { 3234 int res = 0; 3235 for (int i = 0; i < a.length; i += SPECIES.length()) { 3236 res ^= XORReduceMasked(a, i, mask); 3237 } 3238 3239 return res; 3240 } 3241 3242 3243 @Test(dataProvider = "intUnaryOpMaskProvider") 3244 static void XORReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3245 int[] a = fa.apply(SPECIES.length()); 3246 int[] r = fr.apply(SPECIES.length()); 3247 boolean[] mask = fm.apply(SPECIES.length()); 3248 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3249 int ra = 0; 3250 3251 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3252 for (int i = 0; i < a.length; i += SPECIES.length()) { 3253 IntVector av = IntVector.fromArray(SPECIES, a, i); 3254 r[i] = av.reduceLanes(VectorOperators.XOR, vmask); 3255 } 3256 } 3257 3258 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3259 ra = 0; 3260 for (int i = 0; i < a.length; i += SPECIES.length()) { 3261 IntVector av = IntVector.fromArray(SPECIES, a, i); 3262 ra ^= av.reduceLanes(VectorOperators.XOR, vmask); 3263 } 3264 } 3265 3266 assertReductionArraysEqualsMasked(r, ra, a, mask, 3267 Int128VectorTests::XORReduceMasked, Int128VectorTests::XORReduceAllMasked); 3268 } 3269 3270 static int ADDReduce(int[] a, int idx) { 3271 int res = 0; 3272 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3273 res += a[i]; 3274 } 3275 3276 return res; 3277 } 3278 3279 static int ADDReduceAll(int[] a) { 3280 int res = 0; 3281 for (int i = 0; i < a.length; i += SPECIES.length()) { 3282 res += ADDReduce(a, i); 3283 } 3284 3285 return res; 3286 } 3287 @Test(dataProvider = "intUnaryOpProvider") 3288 static void ADDReduceInt128VectorTests(IntFunction<int[]> fa) { 3289 int[] a = fa.apply(SPECIES.length()); 3290 int[] r = fr.apply(SPECIES.length()); 3291 int ra = 0; 3292 3293 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3294 for (int i = 0; i < a.length; i += SPECIES.length()) { 3295 IntVector av = IntVector.fromArray(SPECIES, a, i); 3296 r[i] = av.reduceLanes(VectorOperators.ADD); 3297 } 3298 } 3299 3300 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3301 ra = 0; 3302 for (int i = 0; i < a.length; i += SPECIES.length()) { 3303 IntVector av = IntVector.fromArray(SPECIES, a, i); 3304 ra += av.reduceLanes(VectorOperators.ADD); 3305 } 3306 } 3307 3308 assertReductionArraysEquals(r, ra, a, 3309 Int128VectorTests::ADDReduce, Int128VectorTests::ADDReduceAll); 3310 } 3311 static int ADDReduceMasked(int[] a, int idx, boolean[] mask) { 3312 int res = 0; 3313 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3314 if (mask[i % SPECIES.length()]) 3315 res += a[i]; 3316 } 3317 3318 return res; 3319 } 3320 3321 static int ADDReduceAllMasked(int[] a, boolean[] mask) { 3322 int res = 0; 3323 for (int i = 0; i < a.length; i += SPECIES.length()) { 3324 res += ADDReduceMasked(a, i, mask); 3325 } 3326 3327 return res; 3328 } 3329 @Test(dataProvider = "intUnaryOpMaskProvider") 3330 static void ADDReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3331 int[] a = fa.apply(SPECIES.length()); 3332 int[] r = fr.apply(SPECIES.length()); 3333 boolean[] mask = fm.apply(SPECIES.length()); 3334 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3335 int ra = 0; 3336 3337 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3338 for (int i = 0; i < a.length; i += SPECIES.length()) { 3339 IntVector av = IntVector.fromArray(SPECIES, a, i); 3340 r[i] = av.reduceLanes(VectorOperators.ADD, vmask); 3341 } 3342 } 3343 3344 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3345 ra = 0; 3346 for (int i = 0; i < a.length; i += SPECIES.length()) { 3347 IntVector av = IntVector.fromArray(SPECIES, a, i); 3348 ra += av.reduceLanes(VectorOperators.ADD, vmask); 3349 } 3350 } 3351 3352 assertReductionArraysEqualsMasked(r, ra, a, mask, 3353 Int128VectorTests::ADDReduceMasked, Int128VectorTests::ADDReduceAllMasked); 3354 } 3355 static int MULReduce(int[] a, int idx) { 3356 int res = 1; 3357 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3358 res *= a[i]; 3359 } 3360 3361 return res; 3362 } 3363 3364 static int MULReduceAll(int[] a) { 3365 int res = 1; 3366 for (int i = 0; i < a.length; i += SPECIES.length()) { 3367 res *= MULReduce(a, i); 3368 } 3369 3370 return res; 3371 } 3372 @Test(dataProvider = "intUnaryOpProvider") 3373 static void MULReduceInt128VectorTests(IntFunction<int[]> fa) { 3374 int[] a = fa.apply(SPECIES.length()); 3375 int[] r = fr.apply(SPECIES.length()); 3376 int ra = 1; 3377 3378 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3379 for (int i = 0; i < a.length; i += SPECIES.length()) { 3380 IntVector av = IntVector.fromArray(SPECIES, a, i); 3381 r[i] = av.reduceLanes(VectorOperators.MUL); 3382 } 3383 } 3384 3385 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3386 ra = 1; 3387 for (int i = 0; i < a.length; i += SPECIES.length()) { 3388 IntVector av = IntVector.fromArray(SPECIES, a, i); 3389 ra *= av.reduceLanes(VectorOperators.MUL); 3390 } 3391 } 3392 3393 assertReductionArraysEquals(r, ra, a, 3394 Int128VectorTests::MULReduce, Int128VectorTests::MULReduceAll); 3395 } 3396 static int MULReduceMasked(int[] a, int idx, boolean[] mask) { 3397 int res = 1; 3398 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3399 if (mask[i % SPECIES.length()]) 3400 res *= a[i]; 3401 } 3402 3403 return res; 3404 } 3405 3406 static int MULReduceAllMasked(int[] a, boolean[] mask) { 3407 int res = 1; 3408 for (int i = 0; i < a.length; i += SPECIES.length()) { 3409 res *= MULReduceMasked(a, i, mask); 3410 } 3411 3412 return res; 3413 } 3414 @Test(dataProvider = "intUnaryOpMaskProvider") 3415 static void MULReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3416 int[] a = fa.apply(SPECIES.length()); 3417 int[] r = fr.apply(SPECIES.length()); 3418 boolean[] mask = fm.apply(SPECIES.length()); 3419 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3420 int ra = 1; 3421 3422 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3423 for (int i = 0; i < a.length; i += SPECIES.length()) { 3424 IntVector av = IntVector.fromArray(SPECIES, a, i); 3425 r[i] = av.reduceLanes(VectorOperators.MUL, vmask); 3426 } 3427 } 3428 3429 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3430 ra = 1; 3431 for (int i = 0; i < a.length; i += SPECIES.length()) { 3432 IntVector av = IntVector.fromArray(SPECIES, a, i); 3433 ra *= av.reduceLanes(VectorOperators.MUL, vmask); 3434 } 3435 } 3436 3437 assertReductionArraysEqualsMasked(r, ra, a, mask, 3438 Int128VectorTests::MULReduceMasked, Int128VectorTests::MULReduceAllMasked); 3439 } 3440 static int MINReduce(int[] a, int idx) { 3441 int res = Integer.MAX_VALUE; 3442 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3443 res = (int) Math.min(res, a[i]); 3444 } 3445 3446 return res; 3447 } 3448 3449 static int MINReduceAll(int[] a) { 3450 int res = Integer.MAX_VALUE; 3451 for (int i = 0; i < a.length; i += SPECIES.length()) { 3452 res = (int) Math.min(res, MINReduce(a, i)); 3453 } 3454 3455 return res; 3456 } 3457 @Test(dataProvider = "intUnaryOpProvider") 3458 static void MINReduceInt128VectorTests(IntFunction<int[]> fa) { 3459 int[] a = fa.apply(SPECIES.length()); 3460 int[] r = fr.apply(SPECIES.length()); 3461 int ra = Integer.MAX_VALUE; 3462 3463 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3464 for (int i = 0; i < a.length; i += SPECIES.length()) { 3465 IntVector av = IntVector.fromArray(SPECIES, a, i); 3466 r[i] = av.reduceLanes(VectorOperators.MIN); 3467 } 3468 } 3469 3470 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3471 ra = Integer.MAX_VALUE; 3472 for (int i = 0; i < a.length; i += SPECIES.length()) { 3473 IntVector av = IntVector.fromArray(SPECIES, a, i); 3474 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN)); 3475 } 3476 } 3477 3478 assertReductionArraysEquals(r, ra, a, 3479 Int128VectorTests::MINReduce, Int128VectorTests::MINReduceAll); 3480 } 3481 static int MINReduceMasked(int[] a, int idx, boolean[] mask) { 3482 int res = Integer.MAX_VALUE; 3483 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3484 if (mask[i % SPECIES.length()]) 3485 res = (int) Math.min(res, a[i]); 3486 } 3487 3488 return res; 3489 } 3490 3491 static int MINReduceAllMasked(int[] a, boolean[] mask) { 3492 int res = Integer.MAX_VALUE; 3493 for (int i = 0; i < a.length; i += SPECIES.length()) { 3494 res = (int) Math.min(res, MINReduceMasked(a, i, mask)); 3495 } 3496 3497 return res; 3498 } 3499 @Test(dataProvider = "intUnaryOpMaskProvider") 3500 static void MINReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3501 int[] a = fa.apply(SPECIES.length()); 3502 int[] r = fr.apply(SPECIES.length()); 3503 boolean[] mask = fm.apply(SPECIES.length()); 3504 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3505 int ra = Integer.MAX_VALUE; 3506 3507 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3508 for (int i = 0; i < a.length; i += SPECIES.length()) { 3509 IntVector av = IntVector.fromArray(SPECIES, a, i); 3510 r[i] = av.reduceLanes(VectorOperators.MIN, vmask); 3511 } 3512 } 3513 3514 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3515 ra = Integer.MAX_VALUE; 3516 for (int i = 0; i < a.length; i += SPECIES.length()) { 3517 IntVector av = IntVector.fromArray(SPECIES, a, i); 3518 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask)); 3519 } 3520 } 3521 3522 assertReductionArraysEqualsMasked(r, ra, a, mask, 3523 Int128VectorTests::MINReduceMasked, Int128VectorTests::MINReduceAllMasked); 3524 } 3525 static int MAXReduce(int[] a, int idx) { 3526 int res = Integer.MIN_VALUE; 3527 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3528 res = (int) Math.max(res, a[i]); 3529 } 3530 3531 return res; 3532 } 3533 3534 static int MAXReduceAll(int[] a) { 3535 int res = Integer.MIN_VALUE; 3536 for (int i = 0; i < a.length; i += SPECIES.length()) { 3537 res = (int) Math.max(res, MAXReduce(a, i)); 3538 } 3539 3540 return res; 3541 } 3542 @Test(dataProvider = "intUnaryOpProvider") 3543 static void MAXReduceInt128VectorTests(IntFunction<int[]> fa) { 3544 int[] a = fa.apply(SPECIES.length()); 3545 int[] r = fr.apply(SPECIES.length()); 3546 int ra = Integer.MIN_VALUE; 3547 3548 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3549 for (int i = 0; i < a.length; i += SPECIES.length()) { 3550 IntVector av = IntVector.fromArray(SPECIES, a, i); 3551 r[i] = av.reduceLanes(VectorOperators.MAX); 3552 } 3553 } 3554 3555 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3556 ra = Integer.MIN_VALUE; 3557 for (int i = 0; i < a.length; i += SPECIES.length()) { 3558 IntVector av = IntVector.fromArray(SPECIES, a, i); 3559 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX)); 3560 } 3561 } 3562 3563 assertReductionArraysEquals(r, ra, a, 3564 Int128VectorTests::MAXReduce, Int128VectorTests::MAXReduceAll); 3565 } 3566 static int MAXReduceMasked(int[] a, int idx, boolean[] mask) { 3567 int res = Integer.MIN_VALUE; 3568 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3569 if (mask[i % SPECIES.length()]) 3570 res = (int) Math.max(res, a[i]); 3571 } 3572 3573 return res; 3574 } 3575 3576 static int MAXReduceAllMasked(int[] a, boolean[] mask) { 3577 int res = Integer.MIN_VALUE; 3578 for (int i = 0; i < a.length; i += SPECIES.length()) { 3579 res = (int) Math.max(res, MAXReduceMasked(a, i, mask)); 3580 } 3581 3582 return res; 3583 } 3584 @Test(dataProvider = "intUnaryOpMaskProvider") 3585 static void MAXReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3586 int[] a = fa.apply(SPECIES.length()); 3587 int[] r = fr.apply(SPECIES.length()); 3588 boolean[] mask = fm.apply(SPECIES.length()); 3589 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3590 int ra = Integer.MIN_VALUE; 3591 3592 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3593 for (int i = 0; i < a.length; i += SPECIES.length()) { 3594 IntVector av = IntVector.fromArray(SPECIES, a, i); 3595 r[i] = av.reduceLanes(VectorOperators.MAX, vmask); 3596 } 3597 } 3598 3599 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3600 ra = Integer.MIN_VALUE; 3601 for (int i = 0; i < a.length; i += SPECIES.length()) { 3602 IntVector av = IntVector.fromArray(SPECIES, a, i); 3603 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask)); 3604 } 3605 } 3606 3607 assertReductionArraysEqualsMasked(r, ra, a, mask, 3608 Int128VectorTests::MAXReduceMasked, Int128VectorTests::MAXReduceAllMasked); 3609 } 3610 static int FIRST_NONZEROReduce(int[] a, int idx) { 3611 int res = (int) 0; 3612 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3613 res = firstNonZero(res, a[i]); 3614 } 3615 3616 return res; 3617 } 3618 3619 static int FIRST_NONZEROReduceAll(int[] a) { 3620 int res = (int) 0; 3621 for (int i = 0; i < a.length; i += SPECIES.length()) { 3622 res = firstNonZero(res, FIRST_NONZEROReduce(a, i)); 3623 } 3624 3625 return res; 3626 } 3627 @Test(dataProvider = "intUnaryOpProvider") 3628 static void FIRST_NONZEROReduceInt128VectorTests(IntFunction<int[]> fa) { 3629 int[] a = fa.apply(SPECIES.length()); 3630 int[] r = fr.apply(SPECIES.length()); 3631 int ra = (int) 0; 3632 3633 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3634 for (int i = 0; i < a.length; i += SPECIES.length()) { 3635 IntVector av = IntVector.fromArray(SPECIES, a, i); 3636 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO); 3637 } 3638 } 3639 3640 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3641 ra = (int) 0; 3642 for (int i = 0; i < a.length; i += SPECIES.length()) { 3643 IntVector av = IntVector.fromArray(SPECIES, a, i); 3644 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO)); 3645 } 3646 } 3647 3648 assertReductionArraysEquals(r, ra, a, 3649 Int128VectorTests::FIRST_NONZEROReduce, Int128VectorTests::FIRST_NONZEROReduceAll); 3650 } 3651 static int FIRST_NONZEROReduceMasked(int[] a, int idx, boolean[] mask) { 3652 int res = (int) 0; 3653 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3654 if (mask[i % SPECIES.length()]) 3655 res = firstNonZero(res, a[i]); 3656 } 3657 3658 return res; 3659 } 3660 3661 static int FIRST_NONZEROReduceAllMasked(int[] a, boolean[] mask) { 3662 int res = (int) 0; 3663 for (int i = 0; i < a.length; i += SPECIES.length()) { 3664 res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask)); 3665 } 3666 3667 return res; 3668 } 3669 @Test(dataProvider = "intUnaryOpMaskProvider") 3670 static void FIRST_NONZEROReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 3671 int[] a = fa.apply(SPECIES.length()); 3672 int[] r = fr.apply(SPECIES.length()); 3673 boolean[] mask = fm.apply(SPECIES.length()); 3674 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3675 int ra = (int) 0; 3676 3677 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3678 for (int i = 0; i < a.length; i += SPECIES.length()) { 3679 IntVector av = IntVector.fromArray(SPECIES, a, i); 3680 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask); 3681 } 3682 } 3683 3684 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3685 ra = (int) 0; 3686 for (int i = 0; i < a.length; i += SPECIES.length()) { 3687 IntVector av = IntVector.fromArray(SPECIES, a, i); 3688 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask)); 3689 } 3690 } 3691 3692 assertReductionArraysEqualsMasked(r, ra, a, mask, 3693 Int128VectorTests::FIRST_NONZEROReduceMasked, Int128VectorTests::FIRST_NONZEROReduceAllMasked); 3694 } 3695 3696 static boolean anyTrue(boolean[] a, int idx) { 3697 boolean res = false; 3698 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3699 res |= a[i]; 3700 } 3701 3702 return res; 3703 } 3704 3705 3706 @Test(dataProvider = "boolUnaryOpProvider") 3707 static void anyTrueInt128VectorTests(IntFunction<boolean[]> fm) { 3708 boolean[] mask = fm.apply(SPECIES.length()); 3709 boolean[] r = fmr.apply(SPECIES.length()); 3710 3711 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3712 for (int i = 0; i < mask.length; i += SPECIES.length()) { 3713 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i); 3714 r[i] = vmask.anyTrue(); 3715 } 3716 } 3717 3718 assertReductionBoolArraysEquals(r, mask, Int128VectorTests::anyTrue); 3719 } 3720 3721 3722 static boolean allTrue(boolean[] a, int idx) { 3723 boolean res = true; 3724 for (int i = idx; i < (idx + SPECIES.length()); i++) { 3725 res &= a[i]; 3726 } 3727 3728 return res; 3729 } 3730 3731 3732 @Test(dataProvider = "boolUnaryOpProvider") 3733 static void allTrueInt128VectorTests(IntFunction<boolean[]> fm) { 3734 boolean[] mask = fm.apply(SPECIES.length()); 3735 boolean[] r = fmr.apply(SPECIES.length()); 3736 3737 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3738 for (int i = 0; i < mask.length; i += SPECIES.length()) { 3739 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i); 3740 r[i] = vmask.allTrue(); 3741 } 3742 } 3743 3744 assertReductionBoolArraysEquals(r, mask, Int128VectorTests::allTrue); 3745 } 3746 3747 3748 @Test(dataProvider = "intUnaryOpProvider") 3749 static void withInt128VectorTests(IntFunction<int []> fa) { 3750 int[] a = fa.apply(SPECIES.length()); 3751 int[] r = fr.apply(SPECIES.length()); 3752 3753 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3754 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) { 3755 IntVector av = IntVector.fromArray(SPECIES, a, i); 3756 av.withLane((j++ & (SPECIES.length()-1)), (int)(65535+i)).intoArray(r, i); 3757 } 3758 } 3759 3760 3761 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) { 3762 assertInsertArraysEquals(r, a, (int)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length()); 3763 } 3764 } 3765 static boolean testIS_DEFAULT(int a) { 3766 return bits(a)==0; 3767 } 3768 3769 @Test(dataProvider = "intTestOpProvider") 3770 static void IS_DEFAULTInt128VectorTests(IntFunction<int[]> fa) { 3771 int[] a = fa.apply(SPECIES.length()); 3772 3773 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3774 for (int i = 0; i < a.length; i += SPECIES.length()) { 3775 IntVector av = IntVector.fromArray(SPECIES, a, i); 3776 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT); 3777 3778 // Check results as part of computation. 3779 for (int j = 0; j < SPECIES.length(); j++) { 3780 Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j])); 3781 } 3782 } 3783 } 3784 } 3785 3786 @Test(dataProvider = "intTestOpMaskProvider") 3787 static void IS_DEFAULTMaskedInt128VectorTests(IntFunction<int[]> fa, 3788 IntFunction<boolean[]> fm) { 3789 int[] a = fa.apply(SPECIES.length()); 3790 boolean[] mask = fm.apply(SPECIES.length()); 3791 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3792 3793 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3794 for (int i = 0; i < a.length; i += SPECIES.length()) { 3795 IntVector av = IntVector.fromArray(SPECIES, a, i); 3796 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT, vmask); 3797 3798 // Check results as part of computation. 3799 for (int j = 0; j < SPECIES.length(); j++) { 3800 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j])); 3801 } 3802 } 3803 } 3804 } 3805 static boolean testIS_NEGATIVE(int a) { 3806 return bits(a)<0; 3807 } 3808 3809 @Test(dataProvider = "intTestOpProvider") 3810 static void IS_NEGATIVEInt128VectorTests(IntFunction<int[]> fa) { 3811 int[] a = fa.apply(SPECIES.length()); 3812 3813 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3814 for (int i = 0; i < a.length; i += SPECIES.length()) { 3815 IntVector av = IntVector.fromArray(SPECIES, a, i); 3816 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE); 3817 3818 // Check results as part of computation. 3819 for (int j = 0; j < SPECIES.length(); j++) { 3820 Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j])); 3821 } 3822 } 3823 } 3824 } 3825 3826 @Test(dataProvider = "intTestOpMaskProvider") 3827 static void IS_NEGATIVEMaskedInt128VectorTests(IntFunction<int[]> fa, 3828 IntFunction<boolean[]> fm) { 3829 int[] a = fa.apply(SPECIES.length()); 3830 boolean[] mask = fm.apply(SPECIES.length()); 3831 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3832 3833 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3834 for (int i = 0; i < a.length; i += SPECIES.length()) { 3835 IntVector av = IntVector.fromArray(SPECIES, a, i); 3836 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE, vmask); 3837 3838 // Check results as part of computation. 3839 for (int j = 0; j < SPECIES.length(); j++) { 3840 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j])); 3841 } 3842 } 3843 } 3844 } 3845 3846 3847 3848 3849 @Test(dataProvider = "intCompareOpProvider") 3850 static void LTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 3851 int[] a = fa.apply(SPECIES.length()); 3852 int[] b = fb.apply(SPECIES.length()); 3853 3854 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3855 for (int i = 0; i < a.length; i += SPECIES.length()) { 3856 IntVector av = IntVector.fromArray(SPECIES, a, i); 3857 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3858 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv); 3859 3860 // Check results as part of computation. 3861 for (int j = 0; j < SPECIES.length(); j++) { 3862 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j])); 3863 } 3864 } 3865 } 3866 } 3867 3868 3869 @Test(dataProvider = "intCompareOpProvider") 3870 static void ltInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 3871 int[] a = fa.apply(SPECIES.length()); 3872 int[] b = fb.apply(SPECIES.length()); 3873 3874 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3875 for (int i = 0; i < a.length; i += SPECIES.length()) { 3876 IntVector av = IntVector.fromArray(SPECIES, a, i); 3877 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3878 VectorMask<Integer> mv = av.lt(bv); 3879 3880 // Check results as part of computation. 3881 for (int j = 0; j < SPECIES.length(); j++) { 3882 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j])); 3883 } 3884 } 3885 } 3886 } 3887 3888 @Test(dataProvider = "intCompareOpMaskProvider") 3889 static void LTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 3890 IntFunction<boolean[]> fm) { 3891 int[] a = fa.apply(SPECIES.length()); 3892 int[] b = fb.apply(SPECIES.length()); 3893 boolean[] mask = fm.apply(SPECIES.length()); 3894 3895 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3896 3897 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3898 for (int i = 0; i < a.length; i += SPECIES.length()) { 3899 IntVector av = IntVector.fromArray(SPECIES, a, i); 3900 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3901 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv, vmask); 3902 3903 // Check results as part of computation. 3904 for (int j = 0; j < SPECIES.length(); j++) { 3905 Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j])); 3906 } 3907 } 3908 } 3909 } 3910 3911 3912 @Test(dataProvider = "intCompareOpProvider") 3913 static void GTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 3914 int[] a = fa.apply(SPECIES.length()); 3915 int[] b = fb.apply(SPECIES.length()); 3916 3917 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3918 for (int i = 0; i < a.length; i += SPECIES.length()) { 3919 IntVector av = IntVector.fromArray(SPECIES, a, i); 3920 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3921 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv); 3922 3923 // Check results as part of computation. 3924 for (int j = 0; j < SPECIES.length(); j++) { 3925 Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j])); 3926 } 3927 } 3928 } 3929 } 3930 3931 @Test(dataProvider = "intCompareOpMaskProvider") 3932 static void GTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 3933 IntFunction<boolean[]> fm) { 3934 int[] a = fa.apply(SPECIES.length()); 3935 int[] b = fb.apply(SPECIES.length()); 3936 boolean[] mask = fm.apply(SPECIES.length()); 3937 3938 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 3939 3940 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3941 for (int i = 0; i < a.length; i += SPECIES.length()) { 3942 IntVector av = IntVector.fromArray(SPECIES, a, i); 3943 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3944 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv, vmask); 3945 3946 // Check results as part of computation. 3947 for (int j = 0; j < SPECIES.length(); j++) { 3948 Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j])); 3949 } 3950 } 3951 } 3952 } 3953 3954 3955 @Test(dataProvider = "intCompareOpProvider") 3956 static void EQInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 3957 int[] a = fa.apply(SPECIES.length()); 3958 int[] b = fb.apply(SPECIES.length()); 3959 3960 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3961 for (int i = 0; i < a.length; i += SPECIES.length()) { 3962 IntVector av = IntVector.fromArray(SPECIES, a, i); 3963 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3964 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv); 3965 3966 // Check results as part of computation. 3967 for (int j = 0; j < SPECIES.length(); j++) { 3968 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j])); 3969 } 3970 } 3971 } 3972 } 3973 3974 3975 @Test(dataProvider = "intCompareOpProvider") 3976 static void eqInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 3977 int[] a = fa.apply(SPECIES.length()); 3978 int[] b = fb.apply(SPECIES.length()); 3979 3980 for (int ic = 0; ic < INVOC_COUNT; ic++) { 3981 for (int i = 0; i < a.length; i += SPECIES.length()) { 3982 IntVector av = IntVector.fromArray(SPECIES, a, i); 3983 IntVector bv = IntVector.fromArray(SPECIES, b, i); 3984 VectorMask<Integer> mv = av.eq(bv); 3985 3986 // Check results as part of computation. 3987 for (int j = 0; j < SPECIES.length(); j++) { 3988 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j])); 3989 } 3990 } 3991 } 3992 } 3993 3994 @Test(dataProvider = "intCompareOpMaskProvider") 3995 static void EQInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 3996 IntFunction<boolean[]> fm) { 3997 int[] a = fa.apply(SPECIES.length()); 3998 int[] b = fb.apply(SPECIES.length()); 3999 boolean[] mask = fm.apply(SPECIES.length()); 4000 4001 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4002 4003 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4004 for (int i = 0; i < a.length; i += SPECIES.length()) { 4005 IntVector av = IntVector.fromArray(SPECIES, a, i); 4006 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4007 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv, vmask); 4008 4009 // Check results as part of computation. 4010 for (int j = 0; j < SPECIES.length(); j++) { 4011 Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j])); 4012 } 4013 } 4014 } 4015 } 4016 4017 4018 @Test(dataProvider = "intCompareOpProvider") 4019 static void NEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4020 int[] a = fa.apply(SPECIES.length()); 4021 int[] b = fb.apply(SPECIES.length()); 4022 4023 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4024 for (int i = 0; i < a.length; i += SPECIES.length()) { 4025 IntVector av = IntVector.fromArray(SPECIES, a, i); 4026 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4027 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv); 4028 4029 // Check results as part of computation. 4030 for (int j = 0; j < SPECIES.length(); j++) { 4031 Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j])); 4032 } 4033 } 4034 } 4035 } 4036 4037 @Test(dataProvider = "intCompareOpMaskProvider") 4038 static void NEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4039 IntFunction<boolean[]> fm) { 4040 int[] a = fa.apply(SPECIES.length()); 4041 int[] b = fb.apply(SPECIES.length()); 4042 boolean[] mask = fm.apply(SPECIES.length()); 4043 4044 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4045 4046 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4047 for (int i = 0; i < a.length; i += SPECIES.length()) { 4048 IntVector av = IntVector.fromArray(SPECIES, a, i); 4049 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4050 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv, vmask); 4051 4052 // Check results as part of computation. 4053 for (int j = 0; j < SPECIES.length(); j++) { 4054 Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j])); 4055 } 4056 } 4057 } 4058 } 4059 4060 4061 @Test(dataProvider = "intCompareOpProvider") 4062 static void LEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4063 int[] a = fa.apply(SPECIES.length()); 4064 int[] b = fb.apply(SPECIES.length()); 4065 4066 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4067 for (int i = 0; i < a.length; i += SPECIES.length()) { 4068 IntVector av = IntVector.fromArray(SPECIES, a, i); 4069 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4070 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv); 4071 4072 // Check results as part of computation. 4073 for (int j = 0; j < SPECIES.length(); j++) { 4074 Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j])); 4075 } 4076 } 4077 } 4078 } 4079 4080 @Test(dataProvider = "intCompareOpMaskProvider") 4081 static void LEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4082 IntFunction<boolean[]> fm) { 4083 int[] a = fa.apply(SPECIES.length()); 4084 int[] b = fb.apply(SPECIES.length()); 4085 boolean[] mask = fm.apply(SPECIES.length()); 4086 4087 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4088 4089 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4090 for (int i = 0; i < a.length; i += SPECIES.length()) { 4091 IntVector av = IntVector.fromArray(SPECIES, a, i); 4092 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4093 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv, vmask); 4094 4095 // Check results as part of computation. 4096 for (int j = 0; j < SPECIES.length(); j++) { 4097 Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j])); 4098 } 4099 } 4100 } 4101 } 4102 4103 4104 @Test(dataProvider = "intCompareOpProvider") 4105 static void GEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4106 int[] a = fa.apply(SPECIES.length()); 4107 int[] b = fb.apply(SPECIES.length()); 4108 4109 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4110 for (int i = 0; i < a.length; i += SPECIES.length()) { 4111 IntVector av = IntVector.fromArray(SPECIES, a, i); 4112 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4113 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv); 4114 4115 // Check results as part of computation. 4116 for (int j = 0; j < SPECIES.length(); j++) { 4117 Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j])); 4118 } 4119 } 4120 } 4121 } 4122 4123 @Test(dataProvider = "intCompareOpMaskProvider") 4124 static void GEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4125 IntFunction<boolean[]> fm) { 4126 int[] a = fa.apply(SPECIES.length()); 4127 int[] b = fb.apply(SPECIES.length()); 4128 boolean[] mask = fm.apply(SPECIES.length()); 4129 4130 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4131 4132 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4133 for (int i = 0; i < a.length; i += SPECIES.length()) { 4134 IntVector av = IntVector.fromArray(SPECIES, a, i); 4135 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4136 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv, vmask); 4137 4138 // Check results as part of computation. 4139 for (int j = 0; j < SPECIES.length(); j++) { 4140 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j])); 4141 } 4142 } 4143 } 4144 } 4145 4146 4147 4148 @Test(dataProvider = "intCompareOpProvider") 4149 static void UNSIGNED_LTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4150 int[] a = fa.apply(SPECIES.length()); 4151 int[] b = fb.apply(SPECIES.length()); 4152 4153 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4154 for (int i = 0; i < a.length; i += SPECIES.length()) { 4155 IntVector av = IntVector.fromArray(SPECIES, a, i); 4156 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4157 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LT, bv); 4158 4159 // Check results as part of computation. 4160 for (int j = 0; j < SPECIES.length(); j++) { 4161 Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j])); 4162 } 4163 } 4164 } 4165 } 4166 4167 4168 4169 @Test(dataProvider = "intCompareOpMaskProvider") 4170 static void UNSIGNED_LTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4171 IntFunction<boolean[]> fm) { 4172 int[] a = fa.apply(SPECIES.length()); 4173 int[] b = fb.apply(SPECIES.length()); 4174 boolean[] mask = fm.apply(SPECIES.length()); 4175 4176 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4177 4178 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4179 for (int i = 0; i < a.length; i += SPECIES.length()) { 4180 IntVector av = IntVector.fromArray(SPECIES, a, i); 4181 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4182 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask); 4183 4184 // Check results as part of computation. 4185 for (int j = 0; j < SPECIES.length(); j++) { 4186 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j])); 4187 } 4188 } 4189 } 4190 } 4191 4192 4193 4194 4195 @Test(dataProvider = "intCompareOpProvider") 4196 static void UNSIGNED_GTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4197 int[] a = fa.apply(SPECIES.length()); 4198 int[] b = fb.apply(SPECIES.length()); 4199 4200 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4201 for (int i = 0; i < a.length; i += SPECIES.length()) { 4202 IntVector av = IntVector.fromArray(SPECIES, a, i); 4203 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4204 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GT, bv); 4205 4206 // Check results as part of computation. 4207 for (int j = 0; j < SPECIES.length(); j++) { 4208 Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j])); 4209 } 4210 } 4211 } 4212 } 4213 4214 4215 4216 @Test(dataProvider = "intCompareOpMaskProvider") 4217 static void UNSIGNED_GTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4218 IntFunction<boolean[]> fm) { 4219 int[] a = fa.apply(SPECIES.length()); 4220 int[] b = fb.apply(SPECIES.length()); 4221 boolean[] mask = fm.apply(SPECIES.length()); 4222 4223 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4224 4225 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4226 for (int i = 0; i < a.length; i += SPECIES.length()) { 4227 IntVector av = IntVector.fromArray(SPECIES, a, i); 4228 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4229 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask); 4230 4231 // Check results as part of computation. 4232 for (int j = 0; j < SPECIES.length(); j++) { 4233 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j])); 4234 } 4235 } 4236 } 4237 } 4238 4239 4240 4241 4242 @Test(dataProvider = "intCompareOpProvider") 4243 static void UNSIGNED_LEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4244 int[] a = fa.apply(SPECIES.length()); 4245 int[] b = fb.apply(SPECIES.length()); 4246 4247 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4248 for (int i = 0; i < a.length; i += SPECIES.length()) { 4249 IntVector av = IntVector.fromArray(SPECIES, a, i); 4250 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4251 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LE, bv); 4252 4253 // Check results as part of computation. 4254 for (int j = 0; j < SPECIES.length(); j++) { 4255 Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j])); 4256 } 4257 } 4258 } 4259 } 4260 4261 4262 4263 @Test(dataProvider = "intCompareOpMaskProvider") 4264 static void UNSIGNED_LEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4265 IntFunction<boolean[]> fm) { 4266 int[] a = fa.apply(SPECIES.length()); 4267 int[] b = fb.apply(SPECIES.length()); 4268 boolean[] mask = fm.apply(SPECIES.length()); 4269 4270 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4271 4272 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4273 for (int i = 0; i < a.length; i += SPECIES.length()) { 4274 IntVector av = IntVector.fromArray(SPECIES, a, i); 4275 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4276 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask); 4277 4278 // Check results as part of computation. 4279 for (int j = 0; j < SPECIES.length(); j++) { 4280 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j])); 4281 } 4282 } 4283 } 4284 } 4285 4286 4287 4288 4289 @Test(dataProvider = "intCompareOpProvider") 4290 static void UNSIGNED_GEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4291 int[] a = fa.apply(SPECIES.length()); 4292 int[] b = fb.apply(SPECIES.length()); 4293 4294 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4295 for (int i = 0; i < a.length; i += SPECIES.length()) { 4296 IntVector av = IntVector.fromArray(SPECIES, a, i); 4297 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4298 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GE, bv); 4299 4300 // Check results as part of computation. 4301 for (int j = 0; j < SPECIES.length(); j++) { 4302 Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j])); 4303 } 4304 } 4305 } 4306 } 4307 4308 4309 4310 @Test(dataProvider = "intCompareOpMaskProvider") 4311 static void UNSIGNED_GEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4312 IntFunction<boolean[]> fm) { 4313 int[] a = fa.apply(SPECIES.length()); 4314 int[] b = fb.apply(SPECIES.length()); 4315 boolean[] mask = fm.apply(SPECIES.length()); 4316 4317 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4318 4319 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4320 for (int i = 0; i < a.length; i += SPECIES.length()) { 4321 IntVector av = IntVector.fromArray(SPECIES, a, i); 4322 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4323 VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask); 4324 4325 // Check results as part of computation. 4326 for (int j = 0; j < SPECIES.length(); j++) { 4327 Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j])); 4328 } 4329 } 4330 } 4331 } 4332 4333 4334 4335 @Test(dataProvider = "intCompareOpProvider") 4336 static void LTInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4337 int[] a = fa.apply(SPECIES.length()); 4338 int[] b = fb.apply(SPECIES.length()); 4339 4340 for (int i = 0; i < a.length; i += SPECIES.length()) { 4341 IntVector av = IntVector.fromArray(SPECIES, a, i); 4342 VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i]); 4343 4344 // Check results as part of computation. 4345 for (int j = 0; j < SPECIES.length(); j++) { 4346 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]); 4347 } 4348 } 4349 } 4350 4351 4352 @Test(dataProvider = "intCompareOpMaskProvider") 4353 static void LTInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, 4354 IntFunction<int[]> fb, IntFunction<boolean[]> fm) { 4355 int[] a = fa.apply(SPECIES.length()); 4356 int[] b = fb.apply(SPECIES.length()); 4357 boolean[] mask = fm.apply(SPECIES.length()); 4358 4359 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4360 4361 for (int i = 0; i < a.length; i += SPECIES.length()) { 4362 IntVector av = IntVector.fromArray(SPECIES, a, i); 4363 VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i], vmask); 4364 4365 // Check results as part of computation. 4366 for (int j = 0; j < SPECIES.length(); j++) { 4367 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i])); 4368 } 4369 } 4370 } 4371 4372 @Test(dataProvider = "intCompareOpProvider") 4373 static void LTInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4374 int[] a = fa.apply(SPECIES.length()); 4375 int[] b = fb.apply(SPECIES.length()); 4376 4377 for (int i = 0; i < a.length; i += SPECIES.length()) { 4378 IntVector av = IntVector.fromArray(SPECIES, a, i); 4379 VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i]); 4380 4381 // Check results as part of computation. 4382 for (int j = 0; j < SPECIES.length(); j++) { 4383 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (int)((long)b[i])); 4384 } 4385 } 4386 } 4387 4388 4389 @Test(dataProvider = "intCompareOpMaskProvider") 4390 static void LTInt128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa, 4391 IntFunction<int[]> fb, IntFunction<boolean[]> fm) { 4392 int[] a = fa.apply(SPECIES.length()); 4393 int[] b = fb.apply(SPECIES.length()); 4394 boolean[] mask = fm.apply(SPECIES.length()); 4395 4396 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4397 4398 for (int i = 0; i < a.length; i += SPECIES.length()) { 4399 IntVector av = IntVector.fromArray(SPECIES, a, i); 4400 VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i], vmask); 4401 4402 // Check results as part of computation. 4403 for (int j = 0; j < SPECIES.length(); j++) { 4404 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (int)((long)b[i]))); 4405 } 4406 } 4407 } 4408 4409 @Test(dataProvider = "intCompareOpProvider") 4410 static void EQInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4411 int[] a = fa.apply(SPECIES.length()); 4412 int[] b = fb.apply(SPECIES.length()); 4413 4414 for (int i = 0; i < a.length; i += SPECIES.length()) { 4415 IntVector av = IntVector.fromArray(SPECIES, a, i); 4416 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i]); 4417 4418 // Check results as part of computation. 4419 for (int j = 0; j < SPECIES.length(); j++) { 4420 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]); 4421 } 4422 } 4423 } 4424 4425 4426 @Test(dataProvider = "intCompareOpMaskProvider") 4427 static void EQInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, 4428 IntFunction<int[]> fb, IntFunction<boolean[]> fm) { 4429 int[] a = fa.apply(SPECIES.length()); 4430 int[] b = fb.apply(SPECIES.length()); 4431 boolean[] mask = fm.apply(SPECIES.length()); 4432 4433 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4434 4435 for (int i = 0; i < a.length; i += SPECIES.length()) { 4436 IntVector av = IntVector.fromArray(SPECIES, a, i); 4437 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i], vmask); 4438 4439 // Check results as part of computation. 4440 for (int j = 0; j < SPECIES.length(); j++) { 4441 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i])); 4442 } 4443 } 4444 } 4445 4446 @Test(dataProvider = "intCompareOpProvider") 4447 static void EQInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4448 int[] a = fa.apply(SPECIES.length()); 4449 int[] b = fb.apply(SPECIES.length()); 4450 4451 for (int i = 0; i < a.length; i += SPECIES.length()) { 4452 IntVector av = IntVector.fromArray(SPECIES, a, i); 4453 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i]); 4454 4455 // Check results as part of computation. 4456 for (int j = 0; j < SPECIES.length(); j++) { 4457 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (int)((long)b[i])); 4458 } 4459 } 4460 } 4461 4462 4463 @Test(dataProvider = "intCompareOpMaskProvider") 4464 static void EQInt128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa, 4465 IntFunction<int[]> fb, IntFunction<boolean[]> fm) { 4466 int[] a = fa.apply(SPECIES.length()); 4467 int[] b = fb.apply(SPECIES.length()); 4468 boolean[] mask = fm.apply(SPECIES.length()); 4469 4470 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4471 4472 for (int i = 0; i < a.length; i += SPECIES.length()) { 4473 IntVector av = IntVector.fromArray(SPECIES, a, i); 4474 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask); 4475 4476 // Check results as part of computation. 4477 for (int j = 0; j < SPECIES.length(); j++) { 4478 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (int)((long)b[i]))); 4479 } 4480 } 4481 } 4482 4483 static int blend(int a, int b, boolean mask) { 4484 return mask ? b : a; 4485 } 4486 4487 @Test(dataProvider = "intBinaryOpMaskProvider") 4488 static void blendInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, 4489 IntFunction<boolean[]> fm) { 4490 int[] a = fa.apply(SPECIES.length()); 4491 int[] b = fb.apply(SPECIES.length()); 4492 int[] r = fr.apply(SPECIES.length()); 4493 boolean[] mask = fm.apply(SPECIES.length()); 4494 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4495 4496 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4497 for (int i = 0; i < a.length; i += SPECIES.length()) { 4498 IntVector av = IntVector.fromArray(SPECIES, a, i); 4499 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4500 av.blend(bv, vmask).intoArray(r, i); 4501 } 4502 } 4503 4504 assertArraysEquals(r, a, b, mask, Int128VectorTests::blend); 4505 } 4506 4507 @Test(dataProvider = "intUnaryOpShuffleProvider") 4508 static void RearrangeInt128VectorTests(IntFunction<int[]> fa, 4509 BiFunction<Integer,Integer,int[]> fs) { 4510 int[] a = fa.apply(SPECIES.length()); 4511 int[] order = fs.apply(a.length, SPECIES.length()); 4512 int[] r = fr.apply(SPECIES.length()); 4513 4514 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4515 for (int i = 0; i < a.length; i += SPECIES.length()) { 4516 IntVector av = IntVector.fromArray(SPECIES, a, i); 4517 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i); 4518 } 4519 } 4520 4521 assertRearrangeArraysEquals(r, a, order, SPECIES.length()); 4522 } 4523 4524 @Test(dataProvider = "intUnaryOpShuffleMaskProvider") 4525 static void RearrangeInt128VectorTestsMaskedSmokeTest(IntFunction<int[]> fa, 4526 BiFunction<Integer,Integer,int[]> fs, 4527 IntFunction<boolean[]> fm) { 4528 int[] a = fa.apply(SPECIES.length()); 4529 int[] order = fs.apply(a.length, SPECIES.length()); 4530 int[] r = fr.apply(SPECIES.length()); 4531 boolean[] mask = fm.apply(SPECIES.length()); 4532 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4533 4534 for (int i = 0; i < a.length; i += SPECIES.length()) { 4535 IntVector av = IntVector.fromArray(SPECIES, a, i); 4536 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i); 4537 } 4538 4539 assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length()); 4540 } 4541 @Test(dataProvider = "intUnaryOpProvider") 4542 static void getInt128VectorTests(IntFunction<int[]> fa) { 4543 int[] a = fa.apply(SPECIES.length()); 4544 int[] r = fr.apply(SPECIES.length()); 4545 4546 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4547 for (int i = 0; i < a.length; i += SPECIES.length()) { 4548 IntVector av = IntVector.fromArray(SPECIES, a, i); 4549 int num_lanes = SPECIES.length(); 4550 // Manually unroll because full unroll happens after intrinsification. 4551 // Unroll is needed because get intrinsic requires for index to be a known constant. 4552 if (num_lanes == 1) { 4553 r[i]=av.lane(0); 4554 } else if (num_lanes == 2) { 4555 r[i]=av.lane(0); 4556 r[i+1]=av.lane(1); 4557 } else if (num_lanes == 4) { 4558 r[i]=av.lane(0); 4559 r[i+1]=av.lane(1); 4560 r[i+2]=av.lane(2); 4561 r[i+3]=av.lane(3); 4562 } else if (num_lanes == 8) { 4563 r[i]=av.lane(0); 4564 r[i+1]=av.lane(1); 4565 r[i+2]=av.lane(2); 4566 r[i+3]=av.lane(3); 4567 r[i+4]=av.lane(4); 4568 r[i+5]=av.lane(5); 4569 r[i+6]=av.lane(6); 4570 r[i+7]=av.lane(7); 4571 } else if (num_lanes == 16) { 4572 r[i]=av.lane(0); 4573 r[i+1]=av.lane(1); 4574 r[i+2]=av.lane(2); 4575 r[i+3]=av.lane(3); 4576 r[i+4]=av.lane(4); 4577 r[i+5]=av.lane(5); 4578 r[i+6]=av.lane(6); 4579 r[i+7]=av.lane(7); 4580 r[i+8]=av.lane(8); 4581 r[i+9]=av.lane(9); 4582 r[i+10]=av.lane(10); 4583 r[i+11]=av.lane(11); 4584 r[i+12]=av.lane(12); 4585 r[i+13]=av.lane(13); 4586 r[i+14]=av.lane(14); 4587 r[i+15]=av.lane(15); 4588 } else if (num_lanes == 32) { 4589 r[i]=av.lane(0); 4590 r[i+1]=av.lane(1); 4591 r[i+2]=av.lane(2); 4592 r[i+3]=av.lane(3); 4593 r[i+4]=av.lane(4); 4594 r[i+5]=av.lane(5); 4595 r[i+6]=av.lane(6); 4596 r[i+7]=av.lane(7); 4597 r[i+8]=av.lane(8); 4598 r[i+9]=av.lane(9); 4599 r[i+10]=av.lane(10); 4600 r[i+11]=av.lane(11); 4601 r[i+12]=av.lane(12); 4602 r[i+13]=av.lane(13); 4603 r[i+14]=av.lane(14); 4604 r[i+15]=av.lane(15); 4605 r[i+16]=av.lane(16); 4606 r[i+17]=av.lane(17); 4607 r[i+18]=av.lane(18); 4608 r[i+19]=av.lane(19); 4609 r[i+20]=av.lane(20); 4610 r[i+21]=av.lane(21); 4611 r[i+22]=av.lane(22); 4612 r[i+23]=av.lane(23); 4613 r[i+24]=av.lane(24); 4614 r[i+25]=av.lane(25); 4615 r[i+26]=av.lane(26); 4616 r[i+27]=av.lane(27); 4617 r[i+28]=av.lane(28); 4618 r[i+29]=av.lane(29); 4619 r[i+30]=av.lane(30); 4620 r[i+31]=av.lane(31); 4621 } else if (num_lanes == 64) { 4622 r[i]=av.lane(0); 4623 r[i+1]=av.lane(1); 4624 r[i+2]=av.lane(2); 4625 r[i+3]=av.lane(3); 4626 r[i+4]=av.lane(4); 4627 r[i+5]=av.lane(5); 4628 r[i+6]=av.lane(6); 4629 r[i+7]=av.lane(7); 4630 r[i+8]=av.lane(8); 4631 r[i+9]=av.lane(9); 4632 r[i+10]=av.lane(10); 4633 r[i+11]=av.lane(11); 4634 r[i+12]=av.lane(12); 4635 r[i+13]=av.lane(13); 4636 r[i+14]=av.lane(14); 4637 r[i+15]=av.lane(15); 4638 r[i+16]=av.lane(16); 4639 r[i+17]=av.lane(17); 4640 r[i+18]=av.lane(18); 4641 r[i+19]=av.lane(19); 4642 r[i+20]=av.lane(20); 4643 r[i+21]=av.lane(21); 4644 r[i+22]=av.lane(22); 4645 r[i+23]=av.lane(23); 4646 r[i+24]=av.lane(24); 4647 r[i+25]=av.lane(25); 4648 r[i+26]=av.lane(26); 4649 r[i+27]=av.lane(27); 4650 r[i+28]=av.lane(28); 4651 r[i+29]=av.lane(29); 4652 r[i+30]=av.lane(30); 4653 r[i+31]=av.lane(31); 4654 r[i+32]=av.lane(32); 4655 r[i+33]=av.lane(33); 4656 r[i+34]=av.lane(34); 4657 r[i+35]=av.lane(35); 4658 r[i+36]=av.lane(36); 4659 r[i+37]=av.lane(37); 4660 r[i+38]=av.lane(38); 4661 r[i+39]=av.lane(39); 4662 r[i+40]=av.lane(40); 4663 r[i+41]=av.lane(41); 4664 r[i+42]=av.lane(42); 4665 r[i+43]=av.lane(43); 4666 r[i+44]=av.lane(44); 4667 r[i+45]=av.lane(45); 4668 r[i+46]=av.lane(46); 4669 r[i+47]=av.lane(47); 4670 r[i+48]=av.lane(48); 4671 r[i+49]=av.lane(49); 4672 r[i+50]=av.lane(50); 4673 r[i+51]=av.lane(51); 4674 r[i+52]=av.lane(52); 4675 r[i+53]=av.lane(53); 4676 r[i+54]=av.lane(54); 4677 r[i+55]=av.lane(55); 4678 r[i+56]=av.lane(56); 4679 r[i+57]=av.lane(57); 4680 r[i+58]=av.lane(58); 4681 r[i+59]=av.lane(59); 4682 r[i+60]=av.lane(60); 4683 r[i+61]=av.lane(61); 4684 r[i+62]=av.lane(62); 4685 r[i+63]=av.lane(63); 4686 } else { 4687 for (int j = 0; j < SPECIES.length(); j++) { 4688 r[i+j]=av.lane(j); 4689 } 4690 } 4691 } 4692 } 4693 4694 assertArraysEquals(r, a, Int128VectorTests::get); 4695 } 4696 4697 @Test(dataProvider = "intUnaryOpProvider") 4698 static void BroadcastInt128VectorTests(IntFunction<int[]> fa) { 4699 int[] a = fa.apply(SPECIES.length()); 4700 int[] r = new int[a.length]; 4701 4702 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4703 for (int i = 0; i < a.length; i += SPECIES.length()) { 4704 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i); 4705 } 4706 } 4707 4708 assertBroadcastArraysEquals(r, a); 4709 } 4710 4711 4712 4713 4714 4715 @Test(dataProvider = "intUnaryOpProvider") 4716 static void ZeroInt128VectorTests(IntFunction<int[]> fa) { 4717 int[] a = fa.apply(SPECIES.length()); 4718 int[] r = new int[a.length]; 4719 4720 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4721 for (int i = 0; i < a.length; i += SPECIES.length()) { 4722 IntVector.zero(SPECIES).intoArray(a, i); 4723 } 4724 } 4725 4726 Assert.assertEquals(a, r); 4727 } 4728 4729 4730 4731 4732 static int[] sliceUnary(int[] a, int origin, int idx) { 4733 int[] res = new int[SPECIES.length()]; 4734 for (int i = 0; i < SPECIES.length(); i++){ 4735 if(i+origin < SPECIES.length()) 4736 res[i] = a[idx+i+origin]; 4737 else 4738 res[i] = (int)0; 4739 } 4740 return res; 4741 } 4742 4743 @Test(dataProvider = "intUnaryOpProvider") 4744 static void sliceUnaryInt128VectorTests(IntFunction<int[]> fa) { 4745 int[] a = fa.apply(SPECIES.length()); 4746 int[] r = new int[a.length]; 4747 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 4748 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4749 for (int i = 0; i < a.length; i += SPECIES.length()) { 4750 IntVector av = IntVector.fromArray(SPECIES, a, i); 4751 av.slice(origin).intoArray(r, i); 4752 } 4753 } 4754 4755 assertArraysEquals(r, a, origin, Int128VectorTests::sliceUnary); 4756 } 4757 static int[] sliceBinary(int[] a, int[] b, int origin, int idx) { 4758 int[] res = new int[SPECIES.length()]; 4759 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4760 if(i+origin < SPECIES.length()) 4761 res[i] = a[idx+i+origin]; 4762 else { 4763 res[i] = b[idx+j]; 4764 j++; 4765 } 4766 } 4767 return res; 4768 } 4769 4770 @Test(dataProvider = "intBinaryOpProvider") 4771 static void sliceBinaryInt128VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4772 int[] a = fa.apply(SPECIES.length()); 4773 int[] b = fb.apply(SPECIES.length()); 4774 int[] r = new int[a.length]; 4775 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 4776 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4777 for (int i = 0; i < a.length; i += SPECIES.length()) { 4778 IntVector av = IntVector.fromArray(SPECIES, a, i); 4779 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4780 av.slice(origin, bv).intoArray(r, i); 4781 } 4782 } 4783 4784 assertArraysEquals(r, a, b, origin, Int128VectorTests::sliceBinary); 4785 } 4786 static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) { 4787 int[] res = new int[SPECIES.length()]; 4788 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4789 if(i+origin < SPECIES.length()) 4790 res[i] = mask[i] ? a[idx+i+origin] : (int)0; 4791 else { 4792 res[i] = mask[i] ? b[idx+j] : (int)0; 4793 j++; 4794 } 4795 } 4796 return res; 4797 } 4798 4799 @Test(dataProvider = "intBinaryOpMaskProvider") 4800 static void sliceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4801 IntFunction<boolean[]> fm) { 4802 int[] a = fa.apply(SPECIES.length()); 4803 int[] b = fb.apply(SPECIES.length()); 4804 boolean[] mask = fm.apply(SPECIES.length()); 4805 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4806 4807 int[] r = new int[a.length]; 4808 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 4809 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4810 for (int i = 0; i < a.length; i += SPECIES.length()) { 4811 IntVector av = IntVector.fromArray(SPECIES, a, i); 4812 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4813 av.slice(origin, bv, vmask).intoArray(r, i); 4814 } 4815 } 4816 4817 assertArraysEquals(r, a, b, origin, mask, Int128VectorTests::slice); 4818 } 4819 static int[] unsliceUnary(int[] a, int origin, int idx) { 4820 int[] res = new int[SPECIES.length()]; 4821 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4822 if(i < origin) 4823 res[i] = (int)0; 4824 else { 4825 res[i] = a[idx+j]; 4826 j++; 4827 } 4828 } 4829 return res; 4830 } 4831 4832 @Test(dataProvider = "intUnaryOpProvider") 4833 static void unsliceUnaryInt128VectorTests(IntFunction<int[]> fa) { 4834 int[] a = fa.apply(SPECIES.length()); 4835 int[] r = new int[a.length]; 4836 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 4837 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4838 for (int i = 0; i < a.length; i += SPECIES.length()) { 4839 IntVector av = IntVector.fromArray(SPECIES, a, i); 4840 av.unslice(origin).intoArray(r, i); 4841 } 4842 } 4843 4844 assertArraysEquals(r, a, origin, Int128VectorTests::unsliceUnary); 4845 } 4846 static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) { 4847 int[] res = new int[SPECIES.length()]; 4848 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4849 if (part == 0) { 4850 if (i < origin) 4851 res[i] = b[idx+i]; 4852 else { 4853 res[i] = a[idx+j]; 4854 j++; 4855 } 4856 } else if (part == 1) { 4857 if (i < origin) 4858 res[i] = a[idx+SPECIES.length()-origin+i]; 4859 else { 4860 res[i] = b[idx+origin+j]; 4861 j++; 4862 } 4863 } 4864 } 4865 return res; 4866 } 4867 4868 @Test(dataProvider = "intBinaryOpProvider") 4869 static void unsliceBinaryInt128VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) { 4870 int[] a = fa.apply(SPECIES.length()); 4871 int[] b = fb.apply(SPECIES.length()); 4872 int[] r = new int[a.length]; 4873 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 4874 int part = (new java.util.Random()).nextInt(2); 4875 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4876 for (int i = 0; i < a.length; i += SPECIES.length()) { 4877 IntVector av = IntVector.fromArray(SPECIES, a, i); 4878 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4879 av.unslice(origin, bv, part).intoArray(r, i); 4880 } 4881 } 4882 4883 assertArraysEquals(r, a, b, origin, part, Int128VectorTests::unsliceBinary); 4884 } 4885 static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) { 4886 int[] res = new int[SPECIES.length()]; 4887 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4888 if(i+origin < SPECIES.length()) 4889 res[i] = b[idx+i+origin]; 4890 else { 4891 res[i] = b[idx+j]; 4892 j++; 4893 } 4894 } 4895 for (int i = 0; i < SPECIES.length(); i++){ 4896 res[i] = mask[i] ? a[idx+i] : res[i]; 4897 } 4898 int[] res1 = new int[SPECIES.length()]; 4899 if (part == 0) { 4900 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4901 if (i < origin) 4902 res1[i] = b[idx+i]; 4903 else { 4904 res1[i] = res[j]; 4905 j++; 4906 } 4907 } 4908 } else if (part == 1) { 4909 for (int i = 0, j = 0; i < SPECIES.length(); i++){ 4910 if (i < origin) 4911 res1[i] = res[SPECIES.length()-origin+i]; 4912 else { 4913 res1[i] = b[idx+origin+j]; 4914 j++; 4915 } 4916 } 4917 } 4918 return res1; 4919 } 4920 4921 @Test(dataProvider = "intBinaryOpMaskProvider") 4922 static void unsliceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 4923 IntFunction<boolean[]> fm) { 4924 int[] a = fa.apply(SPECIES.length()); 4925 int[] b = fb.apply(SPECIES.length()); 4926 boolean[] mask = fm.apply(SPECIES.length()); 4927 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 4928 int[] r = new int[a.length]; 4929 int origin = (new java.util.Random()).nextInt(SPECIES.length()); 4930 int part = (new java.util.Random()).nextInt(2); 4931 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4932 for (int i = 0; i < a.length; i += SPECIES.length()) { 4933 IntVector av = IntVector.fromArray(SPECIES, a, i); 4934 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4935 av.unslice(origin, bv, part, vmask).intoArray(r, i); 4936 } 4937 } 4938 4939 assertArraysEquals(r, a, b, origin, part, mask, Int128VectorTests::unslice); 4940 } 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 static int BITWISE_BLEND(int a, int b, int c) { 4965 return (int)((a&~(c))|(b&c)); 4966 } 4967 static int bitwiseBlend(int a, int b, int c) { 4968 return (int)((a&~(c))|(b&c)); 4969 } 4970 4971 4972 @Test(dataProvider = "intTernaryOpProvider") 4973 static void BITWISE_BLENDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 4974 int[] a = fa.apply(SPECIES.length()); 4975 int[] b = fb.apply(SPECIES.length()); 4976 int[] c = fc.apply(SPECIES.length()); 4977 int[] r = fr.apply(SPECIES.length()); 4978 4979 for (int ic = 0; ic < INVOC_COUNT; ic++) { 4980 for (int i = 0; i < a.length; i += SPECIES.length()) { 4981 IntVector av = IntVector.fromArray(SPECIES, a, i); 4982 IntVector bv = IntVector.fromArray(SPECIES, b, i); 4983 IntVector cv = IntVector.fromArray(SPECIES, c, i); 4984 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i); 4985 } 4986 } 4987 4988 assertArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); 4989 } 4990 @Test(dataProvider = "intTernaryOpProvider") 4991 static void bitwiseBlendInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 4992 int[] a = fa.apply(SPECIES.length()); 4993 int[] b = fb.apply(SPECIES.length()); 4994 int[] c = fc.apply(SPECIES.length()); 4995 int[] r = fr.apply(SPECIES.length()); 4996 4997 for (int i = 0; i < a.length; i += SPECIES.length()) { 4998 IntVector av = IntVector.fromArray(SPECIES, a, i); 4999 IntVector bv = IntVector.fromArray(SPECIES, b, i); 5000 IntVector cv = IntVector.fromArray(SPECIES, c, i); 5001 av.bitwiseBlend(bv, cv).intoArray(r, i); 5002 } 5003 5004 assertArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); 5005 } 5006 5007 5008 @Test(dataProvider = "intTernaryOpMaskProvider") 5009 static void BITWISE_BLENDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb, 5010 IntFunction<int[]> fc, IntFunction<boolean[]> fm) { 5011 int[] a = fa.apply(SPECIES.length()); 5012 int[] b = fb.apply(SPECIES.length()); 5013 int[] c = fc.apply(SPECIES.length()); 5014 int[] r = fr.apply(SPECIES.length()); 5015 boolean[] mask = fm.apply(SPECIES.length()); 5016 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5017 5018 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5019 for (int i = 0; i < a.length; i += SPECIES.length()) { 5020 IntVector av = IntVector.fromArray(SPECIES, a, i); 5021 IntVector bv = IntVector.fromArray(SPECIES, b, i); 5022 IntVector cv = IntVector.fromArray(SPECIES, c, i); 5023 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i); 5024 } 5025 } 5026 5027 assertArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); 5028 } 5029 5030 5031 5032 5033 @Test(dataProvider = "intTernaryOpProvider") 5034 static void BITWISE_BLENDInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 5035 int[] a = fa.apply(SPECIES.length()); 5036 int[] b = fb.apply(SPECIES.length()); 5037 int[] c = fc.apply(SPECIES.length()); 5038 int[] r = fr.apply(SPECIES.length()); 5039 5040 for (int i = 0; i < a.length; i += SPECIES.length()) { 5041 IntVector av = IntVector.fromArray(SPECIES, a, i); 5042 IntVector bv = IntVector.fromArray(SPECIES, b, i); 5043 av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); 5044 } 5045 assertBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); 5046 } 5047 5048 @Test(dataProvider = "intTernaryOpProvider") 5049 static void BITWISE_BLENDInt128VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 5050 int[] a = fa.apply(SPECIES.length()); 5051 int[] b = fb.apply(SPECIES.length()); 5052 int[] c = fc.apply(SPECIES.length()); 5053 int[] r = fr.apply(SPECIES.length()); 5054 5055 for (int i = 0; i < a.length; i += SPECIES.length()) { 5056 IntVector av = IntVector.fromArray(SPECIES, a, i); 5057 IntVector cv = IntVector.fromArray(SPECIES, c, i); 5058 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); 5059 } 5060 assertAltBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); 5061 } 5062 @Test(dataProvider = "intTernaryOpProvider") 5063 static void bitwiseBlendInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 5064 int[] a = fa.apply(SPECIES.length()); 5065 int[] b = fb.apply(SPECIES.length()); 5066 int[] c = fc.apply(SPECIES.length()); 5067 int[] r = fr.apply(SPECIES.length()); 5068 5069 for (int i = 0; i < a.length; i += SPECIES.length()) { 5070 IntVector av = IntVector.fromArray(SPECIES, a, i); 5071 IntVector bv = IntVector.fromArray(SPECIES, b, i); 5072 av.bitwiseBlend(bv, c[i]).intoArray(r, i); 5073 } 5074 assertBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); 5075 } 5076 5077 @Test(dataProvider = "intTernaryOpProvider") 5078 static void bitwiseBlendInt128VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 5079 int[] a = fa.apply(SPECIES.length()); 5080 int[] b = fb.apply(SPECIES.length()); 5081 int[] c = fc.apply(SPECIES.length()); 5082 int[] r = fr.apply(SPECIES.length()); 5083 5084 for (int i = 0; i < a.length; i += SPECIES.length()) { 5085 IntVector av = IntVector.fromArray(SPECIES, a, i); 5086 IntVector cv = IntVector.fromArray(SPECIES, c, i); 5087 av.bitwiseBlend(b[i], cv).intoArray(r, i); 5088 } 5089 assertAltBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); 5090 } 5091 5092 5093 @Test(dataProvider = "intTernaryOpMaskProvider") 5094 static void BITWISE_BLENDInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 5095 IntFunction<int[]> fc, IntFunction<boolean[]> fm) { 5096 int[] a = fa.apply(SPECIES.length()); 5097 int[] b = fb.apply(SPECIES.length()); 5098 int[] c = fc.apply(SPECIES.length()); 5099 int[] r = fr.apply(SPECIES.length()); 5100 boolean[] mask = fm.apply(SPECIES.length()); 5101 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5102 5103 for (int i = 0; i < a.length; i += SPECIES.length()) { 5104 IntVector av = IntVector.fromArray(SPECIES, a, i); 5105 IntVector bv = IntVector.fromArray(SPECIES, b, i); 5106 av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); 5107 } 5108 5109 assertBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); 5110 } 5111 5112 @Test(dataProvider = "intTernaryOpMaskProvider") 5113 static void BITWISE_BLENDInt128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 5114 IntFunction<int[]> fc, IntFunction<boolean[]> fm) { 5115 int[] a = fa.apply(SPECIES.length()); 5116 int[] b = fb.apply(SPECIES.length()); 5117 int[] c = fc.apply(SPECIES.length()); 5118 int[] r = fr.apply(SPECIES.length()); 5119 boolean[] mask = fm.apply(SPECIES.length()); 5120 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5121 5122 for (int i = 0; i < a.length; i += SPECIES.length()) { 5123 IntVector av = IntVector.fromArray(SPECIES, a, i); 5124 IntVector cv = IntVector.fromArray(SPECIES, c, i); 5125 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); 5126 } 5127 5128 assertAltBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); 5129 } 5130 5131 5132 5133 5134 @Test(dataProvider = "intTernaryOpProvider") 5135 static void BITWISE_BLENDInt128VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 5136 int[] a = fa.apply(SPECIES.length()); 5137 int[] b = fb.apply(SPECIES.length()); 5138 int[] c = fc.apply(SPECIES.length()); 5139 int[] r = fr.apply(SPECIES.length()); 5140 5141 for (int i = 0; i < a.length; i += SPECIES.length()) { 5142 IntVector av = IntVector.fromArray(SPECIES, a, i); 5143 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); 5144 } 5145 5146 assertDoubleBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); 5147 } 5148 @Test(dataProvider = "intTernaryOpProvider") 5149 static void bitwiseBlendInt128VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) { 5150 int[] a = fa.apply(SPECIES.length()); 5151 int[] b = fb.apply(SPECIES.length()); 5152 int[] c = fc.apply(SPECIES.length()); 5153 int[] r = fr.apply(SPECIES.length()); 5154 5155 for (int i = 0; i < a.length; i += SPECIES.length()) { 5156 IntVector av = IntVector.fromArray(SPECIES, a, i); 5157 av.bitwiseBlend(b[i], c[i]).intoArray(r, i); 5158 } 5159 5160 assertDoubleBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); 5161 } 5162 5163 5164 @Test(dataProvider = "intTernaryOpMaskProvider") 5165 static void BITWISE_BLENDInt128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 5166 IntFunction<int[]> fc, IntFunction<boolean[]> fm) { 5167 int[] a = fa.apply(SPECIES.length()); 5168 int[] b = fb.apply(SPECIES.length()); 5169 int[] c = fc.apply(SPECIES.length()); 5170 int[] r = fr.apply(SPECIES.length()); 5171 boolean[] mask = fm.apply(SPECIES.length()); 5172 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5173 5174 for (int i = 0; i < a.length; i += SPECIES.length()) { 5175 IntVector av = IntVector.fromArray(SPECIES, a, i); 5176 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); 5177 } 5178 5179 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); 5180 } 5181 5182 5183 static int NEG(int a) { 5184 return (int)(-((int)a)); 5185 } 5186 5187 static int neg(int a) { 5188 return (int)(-((int)a)); 5189 } 5190 5191 @Test(dataProvider = "intUnaryOpProvider") 5192 static void NEGInt128VectorTests(IntFunction<int[]> fa) { 5193 int[] a = fa.apply(SPECIES.length()); 5194 int[] r = fr.apply(SPECIES.length()); 5195 5196 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5197 for (int i = 0; i < a.length; i += SPECIES.length()) { 5198 IntVector av = IntVector.fromArray(SPECIES, a, i); 5199 av.lanewise(VectorOperators.NEG).intoArray(r, i); 5200 } 5201 } 5202 5203 assertArraysEquals(r, a, Int128VectorTests::NEG); 5204 } 5205 5206 @Test(dataProvider = "intUnaryOpProvider") 5207 static void negInt128VectorTests(IntFunction<int[]> fa) { 5208 int[] a = fa.apply(SPECIES.length()); 5209 int[] r = fr.apply(SPECIES.length()); 5210 5211 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5212 for (int i = 0; i < a.length; i += SPECIES.length()) { 5213 IntVector av = IntVector.fromArray(SPECIES, a, i); 5214 av.neg().intoArray(r, i); 5215 } 5216 } 5217 5218 assertArraysEquals(r, a, Int128VectorTests::neg); 5219 } 5220 5221 @Test(dataProvider = "intUnaryOpMaskProvider") 5222 static void NEGMaskedInt128VectorTests(IntFunction<int[]> fa, 5223 IntFunction<boolean[]> fm) { 5224 int[] a = fa.apply(SPECIES.length()); 5225 int[] r = fr.apply(SPECIES.length()); 5226 boolean[] mask = fm.apply(SPECIES.length()); 5227 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5228 5229 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5230 for (int i = 0; i < a.length; i += SPECIES.length()) { 5231 IntVector av = IntVector.fromArray(SPECIES, a, i); 5232 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i); 5233 } 5234 } 5235 5236 assertArraysEquals(r, a, mask, Int128VectorTests::NEG); 5237 } 5238 5239 static int ABS(int a) { 5240 return (int)(Math.abs((int)a)); 5241 } 5242 5243 static int abs(int a) { 5244 return (int)(Math.abs((int)a)); 5245 } 5246 5247 @Test(dataProvider = "intUnaryOpProvider") 5248 static void ABSInt128VectorTests(IntFunction<int[]> fa) { 5249 int[] a = fa.apply(SPECIES.length()); 5250 int[] r = fr.apply(SPECIES.length()); 5251 5252 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5253 for (int i = 0; i < a.length; i += SPECIES.length()) { 5254 IntVector av = IntVector.fromArray(SPECIES, a, i); 5255 av.lanewise(VectorOperators.ABS).intoArray(r, i); 5256 } 5257 } 5258 5259 assertArraysEquals(r, a, Int128VectorTests::ABS); 5260 } 5261 5262 @Test(dataProvider = "intUnaryOpProvider") 5263 static void absInt128VectorTests(IntFunction<int[]> fa) { 5264 int[] a = fa.apply(SPECIES.length()); 5265 int[] r = fr.apply(SPECIES.length()); 5266 5267 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5268 for (int i = 0; i < a.length; i += SPECIES.length()) { 5269 IntVector av = IntVector.fromArray(SPECIES, a, i); 5270 av.abs().intoArray(r, i); 5271 } 5272 } 5273 5274 assertArraysEquals(r, a, Int128VectorTests::abs); 5275 } 5276 5277 @Test(dataProvider = "intUnaryOpMaskProvider") 5278 static void ABSMaskedInt128VectorTests(IntFunction<int[]> fa, 5279 IntFunction<boolean[]> fm) { 5280 int[] a = fa.apply(SPECIES.length()); 5281 int[] r = fr.apply(SPECIES.length()); 5282 boolean[] mask = fm.apply(SPECIES.length()); 5283 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5284 5285 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5286 for (int i = 0; i < a.length; i += SPECIES.length()) { 5287 IntVector av = IntVector.fromArray(SPECIES, a, i); 5288 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i); 5289 } 5290 } 5291 5292 assertArraysEquals(r, a, mask, Int128VectorTests::ABS); 5293 } 5294 5295 5296 static int NOT(int a) { 5297 return (int)(~((int)a)); 5298 } 5299 5300 static int not(int a) { 5301 return (int)(~((int)a)); 5302 } 5303 5304 5305 5306 @Test(dataProvider = "intUnaryOpProvider") 5307 static void NOTInt128VectorTests(IntFunction<int[]> fa) { 5308 int[] a = fa.apply(SPECIES.length()); 5309 int[] r = fr.apply(SPECIES.length()); 5310 5311 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5312 for (int i = 0; i < a.length; i += SPECIES.length()) { 5313 IntVector av = IntVector.fromArray(SPECIES, a, i); 5314 av.lanewise(VectorOperators.NOT).intoArray(r, i); 5315 } 5316 } 5317 5318 assertArraysEquals(r, a, Int128VectorTests::NOT); 5319 } 5320 5321 @Test(dataProvider = "intUnaryOpProvider") 5322 static void notInt128VectorTests(IntFunction<int[]> fa) { 5323 int[] a = fa.apply(SPECIES.length()); 5324 int[] r = fr.apply(SPECIES.length()); 5325 5326 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5327 for (int i = 0; i < a.length; i += SPECIES.length()) { 5328 IntVector av = IntVector.fromArray(SPECIES, a, i); 5329 av.not().intoArray(r, i); 5330 } 5331 } 5332 5333 assertArraysEquals(r, a, Int128VectorTests::not); 5334 } 5335 5336 5337 5338 @Test(dataProvider = "intUnaryOpMaskProvider") 5339 static void NOTMaskedInt128VectorTests(IntFunction<int[]> fa, 5340 IntFunction<boolean[]> fm) { 5341 int[] a = fa.apply(SPECIES.length()); 5342 int[] r = fr.apply(SPECIES.length()); 5343 boolean[] mask = fm.apply(SPECIES.length()); 5344 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5345 5346 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5347 for (int i = 0; i < a.length; i += SPECIES.length()) { 5348 IntVector av = IntVector.fromArray(SPECIES, a, i); 5349 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i); 5350 } 5351 } 5352 5353 assertArraysEquals(r, a, mask, Int128VectorTests::NOT); 5354 } 5355 5356 5357 5358 static int ZOMO(int a) { 5359 return (int)((a==0?0:-1)); 5360 } 5361 5362 5363 5364 @Test(dataProvider = "intUnaryOpProvider") 5365 static void ZOMOInt128VectorTests(IntFunction<int[]> fa) { 5366 int[] a = fa.apply(SPECIES.length()); 5367 int[] r = fr.apply(SPECIES.length()); 5368 5369 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5370 for (int i = 0; i < a.length; i += SPECIES.length()) { 5371 IntVector av = IntVector.fromArray(SPECIES, a, i); 5372 av.lanewise(VectorOperators.ZOMO).intoArray(r, i); 5373 } 5374 } 5375 5376 assertArraysEquals(r, a, Int128VectorTests::ZOMO); 5377 } 5378 5379 5380 5381 @Test(dataProvider = "intUnaryOpMaskProvider") 5382 static void ZOMOMaskedInt128VectorTests(IntFunction<int[]> fa, 5383 IntFunction<boolean[]> fm) { 5384 int[] a = fa.apply(SPECIES.length()); 5385 int[] r = fr.apply(SPECIES.length()); 5386 boolean[] mask = fm.apply(SPECIES.length()); 5387 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5388 5389 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5390 for (int i = 0; i < a.length; i += SPECIES.length()) { 5391 IntVector av = IntVector.fromArray(SPECIES, a, i); 5392 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i); 5393 } 5394 } 5395 5396 assertArraysEquals(r, a, mask, Int128VectorTests::ZOMO); 5397 } 5398 5399 5400 5401 5402 5403 @Test(dataProvider = "intCompareOpProvider") 5404 static void ltInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 5405 int[] a = fa.apply(SPECIES.length()); 5406 int[] b = fb.apply(SPECIES.length()); 5407 5408 for (int i = 0; i < a.length; i += SPECIES.length()) { 5409 IntVector av = IntVector.fromArray(SPECIES, a, i); 5410 VectorMask<Integer> mv = av.lt(b[i]); 5411 5412 // Check results as part of computation. 5413 for (int j = 0; j < SPECIES.length(); j++) { 5414 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]); 5415 } 5416 } 5417 } 5418 5419 @Test(dataProvider = "intCompareOpProvider") 5420 static void eqInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) { 5421 int[] a = fa.apply(SPECIES.length()); 5422 int[] b = fb.apply(SPECIES.length()); 5423 5424 for (int i = 0; i < a.length; i += SPECIES.length()) { 5425 IntVector av = IntVector.fromArray(SPECIES, a, i); 5426 VectorMask<Integer> mv = av.eq(b[i]); 5427 5428 // Check results as part of computation. 5429 for (int j = 0; j < SPECIES.length(); j++) { 5430 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]); 5431 } 5432 } 5433 } 5434 5435 @Test(dataProvider = "intUnaryOpProvider") 5436 static void toIntArrayInt128VectorTestsSmokeTest(IntFunction<int[]> fa) { 5437 int[] a = fa.apply(SPECIES.length()); 5438 5439 for (int i = 0; i < a.length; i += SPECIES.length()) { 5440 IntVector av = IntVector.fromArray(SPECIES, a, i); 5441 int[] r = av.toIntArray(); 5442 assertArraysEquals(r, a, i); 5443 } 5444 } 5445 5446 @Test(dataProvider = "intUnaryOpProvider") 5447 static void toLongArrayInt128VectorTestsSmokeTest(IntFunction<int[]> fa) { 5448 int[] a = fa.apply(SPECIES.length()); 5449 5450 for (int i = 0; i < a.length; i += SPECIES.length()) { 5451 IntVector av = IntVector.fromArray(SPECIES, a, i); 5452 long[] r = av.toLongArray(); 5453 assertArraysEquals(r, a, i); 5454 } 5455 } 5456 5457 @Test(dataProvider = "intUnaryOpProvider") 5458 static void toDoubleArrayInt128VectorTestsSmokeTest(IntFunction<int[]> fa) { 5459 int[] a = fa.apply(SPECIES.length()); 5460 5461 for (int i = 0; i < a.length; i += SPECIES.length()) { 5462 IntVector av = IntVector.fromArray(SPECIES, a, i); 5463 double[] r = av.toDoubleArray(); 5464 assertArraysEquals(r, a, i); 5465 } 5466 } 5467 5468 @Test(dataProvider = "intUnaryOpProvider") 5469 static void toStringInt128VectorTestsSmokeTest(IntFunction<int[]> fa) { 5470 int[] a = fa.apply(SPECIES.length()); 5471 5472 for (int i = 0; i < a.length; i += SPECIES.length()) { 5473 IntVector av = IntVector.fromArray(SPECIES, a, i); 5474 String str = av.toString(); 5475 5476 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length()); 5477 Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str); 5478 } 5479 } 5480 5481 @Test(dataProvider = "intUnaryOpProvider") 5482 static void hashCodeInt128VectorTestsSmokeTest(IntFunction<int[]> fa) { 5483 int[] a = fa.apply(SPECIES.length()); 5484 5485 for (int i = 0; i < a.length; i += SPECIES.length()) { 5486 IntVector av = IntVector.fromArray(SPECIES, a, i); 5487 int hash = av.hashCode(); 5488 5489 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length()); 5490 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr)); 5491 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash); 5492 } 5493 } 5494 5495 5496 static long ADDReduceLong(int[] a, int idx) { 5497 int res = 0; 5498 for (int i = idx; i < (idx + SPECIES.length()); i++) { 5499 res += a[i]; 5500 } 5501 5502 return (long)res; 5503 } 5504 5505 static long ADDReduceAllLong(int[] a) { 5506 long res = 0; 5507 for (int i = 0; i < a.length; i += SPECIES.length()) { 5508 res += ADDReduceLong(a, i); 5509 } 5510 5511 return res; 5512 } 5513 5514 @Test(dataProvider = "intUnaryOpProvider") 5515 static void ADDReduceLongInt128VectorTests(IntFunction<int[]> fa) { 5516 int[] a = fa.apply(SPECIES.length()); 5517 long[] r = lfr.apply(SPECIES.length()); 5518 long ra = 0; 5519 5520 for (int i = 0; i < a.length; i += SPECIES.length()) { 5521 IntVector av = IntVector.fromArray(SPECIES, a, i); 5522 r[i] = av.reduceLanesToLong(VectorOperators.ADD); 5523 } 5524 5525 ra = 0; 5526 for (int i = 0; i < a.length; i ++) { 5527 ra += r[i]; 5528 } 5529 5530 assertReductionLongArraysEquals(r, ra, a, 5531 Int128VectorTests::ADDReduceLong, Int128VectorTests::ADDReduceAllLong); 5532 } 5533 5534 static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) { 5535 int res = 0; 5536 for (int i = idx; i < (idx + SPECIES.length()); i++) { 5537 if(mask[i % SPECIES.length()]) 5538 res += a[i]; 5539 } 5540 5541 return (long)res; 5542 } 5543 5544 static long ADDReduceAllLongMasked(int[] a, boolean[] mask) { 5545 long res = 0; 5546 for (int i = 0; i < a.length; i += SPECIES.length()) { 5547 res += ADDReduceLongMasked(a, i, mask); 5548 } 5549 5550 return res; 5551 } 5552 5553 @Test(dataProvider = "intUnaryOpMaskProvider") 5554 static void ADDReduceLongInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) { 5555 int[] a = fa.apply(SPECIES.length()); 5556 long[] r = lfr.apply(SPECIES.length()); 5557 boolean[] mask = fm.apply(SPECIES.length()); 5558 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5559 long ra = 0; 5560 5561 for (int i = 0; i < a.length; i += SPECIES.length()) { 5562 IntVector av = IntVector.fromArray(SPECIES, a, i); 5563 r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask); 5564 } 5565 5566 ra = 0; 5567 for (int i = 0; i < a.length; i ++) { 5568 ra += r[i]; 5569 } 5570 5571 assertReductionLongArraysEqualsMasked(r, ra, a, mask, 5572 Int128VectorTests::ADDReduceLongMasked, Int128VectorTests::ADDReduceAllLongMasked); 5573 } 5574 5575 @Test(dataProvider = "intUnaryOpProvider") 5576 static void BroadcastLongInt128VectorTestsSmokeTest(IntFunction<int[]> fa) { 5577 int[] a = fa.apply(SPECIES.length()); 5578 int[] r = new int[a.length]; 5579 5580 for (int i = 0; i < a.length; i += SPECIES.length()) { 5581 IntVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i); 5582 } 5583 assertBroadcastArraysEquals(r, a); 5584 } 5585 5586 @Test(dataProvider = "intBinaryOpMaskProvider") 5587 static void blendInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, 5588 IntFunction<boolean[]> fm) { 5589 int[] a = fa.apply(SPECIES.length()); 5590 int[] b = fb.apply(SPECIES.length()); 5591 int[] r = fr.apply(SPECIES.length()); 5592 boolean[] mask = fm.apply(SPECIES.length()); 5593 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5594 5595 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5596 for (int i = 0; i < a.length; i += SPECIES.length()) { 5597 IntVector av = IntVector.fromArray(SPECIES, a, i); 5598 av.blend((long)b[i], vmask).intoArray(r, i); 5599 } 5600 } 5601 assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::blend); 5602 } 5603 5604 5605 @Test(dataProvider = "intUnaryOpShuffleProvider") 5606 static void SelectFromInt128VectorTests(IntFunction<int[]> fa, 5607 BiFunction<Integer,Integer,int[]> fs) { 5608 int[] a = fa.apply(SPECIES.length()); 5609 int[] order = fs.apply(a.length, SPECIES.length()); 5610 int[] r = fr.apply(SPECIES.length()); 5611 5612 for (int i = 0; i < a.length; i += SPECIES.length()) { 5613 IntVector av = IntVector.fromArray(SPECIES, a, i); 5614 IntVector bv = IntVector.fromArray(SPECIES, order, i); 5615 bv.selectFrom(av).intoArray(r, i); 5616 } 5617 5618 assertSelectFromArraysEquals(r, a, order, SPECIES.length()); 5619 } 5620 5621 @Test(dataProvider = "intUnaryOpShuffleMaskProvider") 5622 static void SelectFromInt128VectorTestsMaskedSmokeTest(IntFunction<int[]> fa, 5623 BiFunction<Integer,Integer,int[]> fs, 5624 IntFunction<boolean[]> fm) { 5625 int[] a = fa.apply(SPECIES.length()); 5626 int[] order = fs.apply(a.length, SPECIES.length()); 5627 int[] r = fr.apply(SPECIES.length()); 5628 boolean[] mask = fm.apply(SPECIES.length()); 5629 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0); 5630 5631 for (int i = 0; i < a.length; i += SPECIES.length()) { 5632 IntVector av = IntVector.fromArray(SPECIES, a, i); 5633 IntVector bv = IntVector.fromArray(SPECIES, order, i); 5634 bv.selectFrom(av, vmask).intoArray(r, i); 5635 } 5636 5637 assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length()); 5638 } 5639 5640 @Test(dataProvider = "shuffleProvider") 5641 static void shuffleMiscellaneousInt128VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) { 5642 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); 5643 5644 for (int i = 0; i < a.length; i += SPECIES.length()) { 5645 var shuffle = VectorShuffle.fromArray(SPECIES, a, i); 5646 int hash = shuffle.hashCode(); 5647 int length = shuffle.length(); 5648 5649 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length()); 5650 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr)); 5651 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash); 5652 Assert.assertEquals(length, SPECIES.length()); 5653 } 5654 } 5655 5656 @Test(dataProvider = "shuffleProvider") 5657 static void shuffleToStringInt128VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) { 5658 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); 5659 5660 for (int i = 0; i < a.length; i += SPECIES.length()) { 5661 var shuffle = VectorShuffle.fromArray(SPECIES, a, i); 5662 String str = shuffle.toString(); 5663 5664 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length()); 5665 Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " + 5666 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str); 5667 } 5668 } 5669 5670 @Test(dataProvider = "shuffleCompareOpProvider") 5671 static void shuffleEqualsInt128VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) { 5672 int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); 5673 int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); 5674 5675 for (int i = 0; i < a.length; i += SPECIES.length()) { 5676 var av = VectorShuffle.fromArray(SPECIES, a, i); 5677 var bv = VectorShuffle.fromArray(SPECIES, b, i); 5678 boolean eq = av.equals(bv); 5679 int to = i + SPECIES.length(); 5680 Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to)); 5681 } 5682 } 5683 5684 @Test(dataProvider = "maskCompareOpProvider") 5685 static void maskEqualsInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) { 5686 boolean[] a = fa.apply(SPECIES.length()); 5687 boolean[] b = fb.apply(SPECIES.length()); 5688 5689 for (int i = 0; i < a.length; i += SPECIES.length()) { 5690 var av = SPECIES.loadMask(a, i); 5691 var bv = SPECIES.loadMask(b, i); 5692 boolean equals = av.equals(bv); 5693 int to = i + SPECIES.length(); 5694 Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to)); 5695 } 5696 } 5697 5698 static boolean beq(boolean a, boolean b) { 5699 return (a == b); 5700 } 5701 5702 @Test(dataProvider = "maskCompareOpProvider") 5703 static void maskEqInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) { 5704 boolean[] a = fa.apply(SPECIES.length()); 5705 boolean[] b = fb.apply(SPECIES.length()); 5706 boolean[] r = new boolean[a.length]; 5707 5708 for (int i = 0; i < a.length; i += SPECIES.length()) { 5709 var av = SPECIES.loadMask(a, i); 5710 var bv = SPECIES.loadMask(b, i); 5711 var cv = av.eq(bv); 5712 cv.intoArray(r, i); 5713 } 5714 assertArraysEquals(r, a, b, Int128VectorTests::beq); 5715 } 5716 5717 @Test(dataProvider = "maskProvider") 5718 static void maskHashCodeInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) { 5719 boolean[] a = fa.apply(SPECIES.length()); 5720 5721 for (int i = 0; i < a.length; i += SPECIES.length()) { 5722 var vmask = SPECIES.loadMask(a, i); 5723 int hash = vmask.hashCode(); 5724 5725 boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length()); 5726 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr)); 5727 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash); 5728 } 5729 } 5730 5731 static int maskTrueCount(boolean[] a, int idx) { 5732 int trueCount = 0; 5733 for (int i = idx; i < idx + SPECIES.length(); i++) { 5734 trueCount += a[i] ? 1 : 0; 5735 } 5736 return trueCount; 5737 } 5738 5739 @Test(dataProvider = "maskProvider") 5740 static void maskTrueCountInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) { 5741 boolean[] a = fa.apply(SPECIES.length()); 5742 int[] r = new int[a.length]; 5743 5744 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) { 5745 for (int i = 0; i < a.length; i += SPECIES.length()) { 5746 var vmask = SPECIES.loadMask(a, i); 5747 r[i] = vmask.trueCount(); 5748 } 5749 } 5750 5751 assertMaskReductionArraysEquals(r, a, Int128VectorTests::maskTrueCount); 5752 } 5753 5754 static int maskLastTrue(boolean[] a, int idx) { 5755 int i = idx + SPECIES.length() - 1; 5756 for (; i >= idx; i--) { 5757 if (a[i]) { 5758 break; 5759 } 5760 } 5761 return i - idx; 5762 } 5763 5764 @Test(dataProvider = "maskProvider") 5765 static void maskLastTrueInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) { 5766 boolean[] a = fa.apply(SPECIES.length()); 5767 int[] r = new int[a.length]; 5768 5769 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) { 5770 for (int i = 0; i < a.length; i += SPECIES.length()) { 5771 var vmask = SPECIES.loadMask(a, i); 5772 r[i] = vmask.lastTrue(); 5773 } 5774 } 5775 5776 assertMaskReductionArraysEquals(r, a, Int128VectorTests::maskLastTrue); 5777 } 5778 5779 static int maskFirstTrue(boolean[] a, int idx) { 5780 int i = idx; 5781 for (; i < idx + SPECIES.length(); i++) { 5782 if (a[i]) { 5783 break; 5784 } 5785 } 5786 return i - idx; 5787 } 5788 5789 @Test(dataProvider = "maskProvider") 5790 static void maskFirstTrueInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) { 5791 boolean[] a = fa.apply(SPECIES.length()); 5792 int[] r = new int[a.length]; 5793 5794 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) { 5795 for (int i = 0; i < a.length; i += SPECIES.length()) { 5796 var vmask = SPECIES.loadMask(a, i); 5797 r[i] = vmask.firstTrue(); 5798 } 5799 } 5800 5801 assertMaskReductionArraysEquals(r, a, Int128VectorTests::maskFirstTrue); 5802 } 5803 5804 @DataProvider 5805 public static Object[][] longMaskProvider() { 5806 return new Object[][]{ 5807 {0xFFFFFFFFFFFFFFFFL}, 5808 {0x0000000000000000L}, 5809 {0x5555555555555555L}, 5810 {0x0123456789abcdefL}, 5811 }; 5812 } 5813 5814 @Test(dataProvider = "longMaskProvider") 5815 static void maskFromToLongInt128VectorTestsSmokeTest(long inputLong) { 5816 var vmask = VectorMask.fromLong(SPECIES, inputLong); 5817 long outputLong = vmask.toLong(); 5818 Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length())))))); 5819 } 5820 5821 @DataProvider 5822 public static Object[][] offsetProvider() { 5823 return new Object[][]{ 5824 {0}, 5825 {-1}, 5826 {+1}, 5827 {+2}, 5828 {-2}, 5829 }; 5830 } 5831 5832 @Test(dataProvider = "offsetProvider") 5833 static void indexInRangeInt128VectorTestsSmokeTest(int offset) { 5834 int limit = SPECIES.length() * BUFFER_REPS; 5835 for (int i = 0; i < limit; i += SPECIES.length()) { 5836 var actualMask = SPECIES.indexInRange(i + offset, limit); 5837 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit); 5838 assert(actualMask.equals(expectedMask)); 5839 for (int j = 0; j < SPECIES.length(); j++) { 5840 int index = i + j + offset; 5841 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit); 5842 } 5843 } 5844 } 5845 5846 @DataProvider 5847 public static Object[][] lengthProvider() { 5848 return new Object[][]{ 5849 {0}, 5850 {1}, 5851 {32}, 5852 {37}, 5853 {1024}, 5854 {1024+1}, 5855 {1024+5}, 5856 }; 5857 } 5858 5859 @Test(dataProvider = "lengthProvider") 5860 static void loopBoundInt128VectorTestsSmokeTest(int length) { 5861 int actualLoopBound = SPECIES.loopBound(length); 5862 int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); 5863 Assert.assertEquals(actualLoopBound, expectedLoopBound); 5864 } 5865 5866 @Test 5867 static void ElementSizeInt128VectorTestsSmokeTest() { 5868 IntVector av = IntVector.zero(SPECIES); 5869 int elsize = av.elementSize(); 5870 Assert.assertEquals(elsize, Integer.SIZE); 5871 } 5872 5873 @Test 5874 static void VectorShapeInt128VectorTestsSmokeTest() { 5875 IntVector av = IntVector.zero(SPECIES); 5876 VectorShape vsh = av.shape(); 5877 assert(vsh.equals(VectorShape.S_128_BIT)); 5878 } 5879 5880 @Test 5881 static void ShapeWithLanesInt128VectorTestsSmokeTest() { 5882 IntVector av = IntVector.zero(SPECIES); 5883 VectorShape vsh = av.shape(); 5884 VectorSpecies species = vsh.withLanes(int.class); 5885 assert(species.equals(SPECIES)); 5886 } 5887 5888 @Test 5889 static void ElementTypeInt128VectorTestsSmokeTest() { 5890 IntVector av = IntVector.zero(SPECIES); 5891 assert(av.species().elementType() == int.class); 5892 } 5893 5894 @Test 5895 static void SpeciesElementSizeInt128VectorTestsSmokeTest() { 5896 IntVector av = IntVector.zero(SPECIES); 5897 assert(av.species().elementSize() == Integer.SIZE); 5898 } 5899 5900 @Test 5901 static void VectorTypeInt128VectorTestsSmokeTest() { 5902 IntVector av = IntVector.zero(SPECIES); 5903 assert(av.species().vectorType() == av.getClass()); 5904 } 5905 5906 @Test 5907 static void WithLanesInt128VectorTestsSmokeTest() { 5908 IntVector av = IntVector.zero(SPECIES); 5909 VectorSpecies species = av.species().withLanes(int.class); 5910 assert(species.equals(SPECIES)); 5911 } 5912 5913 @Test 5914 static void WithShapeInt128VectorTestsSmokeTest() { 5915 IntVector av = IntVector.zero(SPECIES); 5916 VectorShape vsh = av.shape(); 5917 VectorSpecies species = av.species().withShape(vsh); 5918 assert(species.equals(SPECIES)); 5919 } 5920 5921 @Test 5922 static void MaskAllTrueInt128VectorTestsSmokeTest() { 5923 for (int ic = 0; ic < INVOC_COUNT; ic++) { 5924 Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); 5925 } 5926 } 5927 } 5928