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