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