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.foreign jdk.incubator.vector java.base/jdk.internal.vm.annotation 27 * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED 28 * -XX:-TieredCompilation ByteMaxVectorLoadStoreTests 29 * 30 */ 31 32 // -- This file was mechanically generated: Do not edit! -- // 33 34 import jdk.incubator.foreign.MemorySegment; 35 import jdk.incubator.foreign.ResourceScope; 36 import jdk.incubator.foreign.ValueLayout; 37 import jdk.incubator.vector.ByteVector; 38 import jdk.incubator.vector.VectorMask; 39 import jdk.incubator.vector.VectorShape; 40 import jdk.incubator.vector.VectorSpecies; 41 import jdk.incubator.vector.VectorShuffle; 42 import jdk.internal.vm.annotation.DontInline; 43 import org.testng.Assert; 44 import org.testng.annotations.DataProvider; 45 import org.testng.annotations.Test; 46 47 import java.nio.ByteOrder; 48 import java.util.List; 49 import java.util.function.*; 50 51 @Test 52 public class ByteMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { 53 static final VectorSpecies<Byte> SPECIES = 54 ByteVector.SPECIES_MAX; 55 56 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); 57 58 static VectorShape getMaxBit() { 59 return VectorShape.S_Max_BIT; 60 } 61 62 private static final int Max = 256; // juts so we can do N/Max 63 64 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max); 65 66 static void assertArraysEquals(byte[] r, byte[] a, boolean[] mask) { 67 int i = 0; 68 try { 69 for (; i < a.length; i++) { 70 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? a[i] : (byte) 0); 71 } 72 } catch (AssertionError e) { 73 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? a[i] : (byte) 0, "at index #" + i); 74 } 75 } 76 77 static final List<IntFunction<byte[]>> BYTE_GENERATORS = List.of( 78 withToString("byte[i * 5]", (int s) -> { 79 return fill(s * BUFFER_REPS, 80 i -> (byte)(i * 5)); 81 }), 82 withToString("byte[i + 1]", (int s) -> { 83 return fill(s * BUFFER_REPS, 84 i -> (((byte)(i + 1) == 0) ? 1 : (byte)(i + 1))); 85 }) 86 ); 87 88 // Relative to array.length 89 static final List<IntFunction<Integer>> INDEX_GENERATORS = List.of( 90 withToString("-1", (int l) -> { 91 return -1; 92 }), 93 withToString("l", (int l) -> { 94 return l; 95 }), 96 withToString("l - 1", (int l) -> { 97 return l - 1; 98 }), 99 withToString("l + 1", (int l) -> { 100 return l + 1; 101 }), 102 withToString("l - speciesl + 1", (int l) -> { 103 return l - SPECIES.length() + 1; 104 }), 105 withToString("l + speciesl - 1", (int l) -> { 106 return l + SPECIES.length() - 1; 107 }), 108 withToString("l + speciesl", (int l) -> { 109 return l + SPECIES.length(); 110 }), 111 withToString("l + speciesl + 1", (int l) -> { 112 return l + SPECIES.length() + 1; 113 }) 114 ); 115 116 // Relative to byte[] array.length or MemorySegment.byteSize() 117 static final List<IntFunction<Integer>> BYTE_INDEX_GENERATORS = List.of( 118 withToString("-1", (int l) -> { 119 return -1; 120 }), 121 withToString("l", (int l) -> { 122 return l; 123 }), 124 withToString("l - 1", (int l) -> { 125 return l - 1; 126 }), 127 withToString("l + 1", (int l) -> { 128 return l + 1; 129 }), 130 withToString("l - speciesl*ebsize + 1", (int l) -> { 131 return l - SPECIES.vectorByteSize() + 1; 132 }), 133 withToString("l + speciesl*ebsize - 1", (int l) -> { 134 return l + SPECIES.vectorByteSize() - 1; 135 }), 136 withToString("l + speciesl*ebsize", (int l) -> { 137 return l + SPECIES.vectorByteSize(); 138 }), 139 withToString("l + speciesl*ebsize + 1", (int l) -> { 140 return l + SPECIES.vectorByteSize() + 1; 141 }) 142 ); 143 144 @DataProvider 145 public Object[][] byteProvider() { 146 return BYTE_GENERATORS.stream(). 147 map(f -> new Object[]{f}). 148 toArray(Object[][]::new); 149 } 150 151 @DataProvider 152 public Object[][] maskProvider() { 153 return BOOLEAN_MASK_GENERATORS.stream(). 154 map(f -> new Object[]{f}). 155 toArray(Object[][]::new); 156 } 157 158 @DataProvider 159 public Object[][] byteProviderForIOOBE() { 160 var f = BYTE_GENERATORS.get(0); 161 return INDEX_GENERATORS.stream().map(fi -> { 162 return new Object[] {f, fi}; 163 }). 164 toArray(Object[][]::new); 165 } 166 167 @DataProvider 168 public Object[][] byteMaskProvider() { 169 return BOOLEAN_MASK_GENERATORS.stream(). 170 flatMap(fm -> BYTE_GENERATORS.stream().map(fa -> { 171 return new Object[] {fa, fm}; 172 })). 173 toArray(Object[][]::new); 174 } 175 176 @DataProvider 177 public Object[][] byteMaskProviderForIOOBE() { 178 var f = BYTE_GENERATORS.get(0); 179 return BOOLEAN_MASK_GENERATORS.stream(). 180 flatMap(fm -> INDEX_GENERATORS.stream().map(fi -> { 181 return new Object[] {f, fi, fm}; 182 })). 183 toArray(Object[][]::new); 184 } 185 186 @DataProvider 187 public Object[][] byteMemorySegmentProvider() { 188 return BYTE_GENERATORS.stream(). 189 flatMap(fa -> MEMORY_SEGMENT_GENERATORS.stream(). 190 flatMap(fb -> BYTE_ORDER_VALUES.stream().map(bo -> { 191 return new Object[]{fa, fb, bo}; 192 }))). 193 toArray(Object[][]::new); 194 } 195 196 @DataProvider 197 public Object[][] byteMemorySegmentMaskProvider() { 198 return BOOLEAN_MASK_GENERATORS.stream(). 199 flatMap(fm -> BYTE_GENERATORS.stream(). 200 flatMap(fa -> MEMORY_SEGMENT_GENERATORS.stream(). 201 flatMap(fb -> BYTE_ORDER_VALUES.stream().map(bo -> { 202 return new Object[]{fa, fb, fm, bo}; 203 })))). 204 toArray(Object[][]::new); 205 } 206 207 @DataProvider 208 public Object[][] byteByteProviderForIOOBE() { 209 var f = BYTE_GENERATORS.get(0); 210 return BYTE_INDEX_GENERATORS.stream().map(fi -> { 211 return new Object[] {f, fi}; 212 }). 213 toArray(Object[][]::new); 214 } 215 216 @DataProvider 217 public Object[][] byteByteMaskProviderForIOOBE() { 218 var f = BYTE_GENERATORS.get(0); 219 return BOOLEAN_MASK_GENERATORS.stream(). 220 flatMap(fm -> BYTE_INDEX_GENERATORS.stream().map(fi -> { 221 return new Object[] {f, fi, fm}; 222 })). 223 toArray(Object[][]::new); 224 } 225 226 static MemorySegment toSegment(byte[] a, IntFunction<MemorySegment> fb) { 227 MemorySegment ms = fb.apply(a.length * SPECIES.elementSize() / 8); 228 for (int i = 0; i < a.length; i++) { 229 ms.set(ValueLayout.JAVA_BYTE, i * SPECIES.elementSize() / 8 , a[i]); 230 } 231 return ms; 232 } 233 234 static byte[] segmentToArray(MemorySegment ms) { 235 return ms.toArray(ValueLayout.JAVA_BYTE); 236 } 237 238 239 interface ToByteF { 240 byte apply(int i); 241 } 242 243 static byte[] fill(int s , ToByteF f) { 244 return fill(new byte[s], f); 245 } 246 247 static byte[] fill(byte[] a, ToByteF f) { 248 for (int i = 0; i < a.length; i++) { 249 a[i] = f.apply(i); 250 } 251 return a; 252 } 253 254 @DontInline 255 static ByteVector fromArray(byte[] a, int i) { 256 return ByteVector.fromArray(SPECIES, a, i); 257 } 258 259 @DontInline 260 static ByteVector fromArray(byte[] a, int i, VectorMask<Byte> m) { 261 return ByteVector.fromArray(SPECIES, a, i, m); 262 } 263 264 @DontInline 265 static void intoArray(ByteVector v, byte[] a, int i) { 266 v.intoArray(a, i); 267 } 268 269 @DontInline 270 static void intoArray(ByteVector v, byte[] a, int i, VectorMask<Byte> m) { 271 v.intoArray(a, i, m); 272 } 273 274 @DontInline 275 static ByteVector fromMemorySegment(MemorySegment a, int i, ByteOrder bo) { 276 return ByteVector.fromMemorySegment(SPECIES, a, i, bo); 277 } 278 279 @DontInline 280 static ByteVector fromMemorySegment(MemorySegment a, int i, ByteOrder bo, VectorMask<Byte> m) { 281 return ByteVector.fromMemorySegment(SPECIES, a, i, bo, m); 282 } 283 284 @DontInline 285 static void intoMemorySegment(ByteVector v, MemorySegment a, int i, ByteOrder bo) { 286 v.intoMemorySegment(a, i, bo); 287 } 288 289 @DontInline 290 static void intoMemorySegment(ByteVector v, MemorySegment a, int i, ByteOrder bo, VectorMask<Byte> m) { 291 v.intoMemorySegment(a, i, bo, m); 292 } 293 294 @Test(dataProvider = "byteProvider") 295 static void loadStoreArray(IntFunction<byte[]> fa) { 296 byte[] a = fa.apply(SPECIES.length()); 297 byte[] r = new byte[a.length]; 298 299 for (int ic = 0; ic < INVOC_COUNT; ic++) { 300 for (int i = 0; i < a.length; i += SPECIES.length()) { 301 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 302 av.intoArray(r, i); 303 } 304 } 305 Assert.assertEquals(r, a); 306 } 307 308 @Test(dataProvider = "byteProviderForIOOBE") 309 static void loadArrayIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi) { 310 byte[] a = fa.apply(SPECIES.length()); 311 byte[] r = new byte[a.length]; 312 313 for (int ic = 0; ic < INVOC_COUNT; ic++) { 314 for (int i = 0; i < a.length; i += SPECIES.length()) { 315 ByteVector av = fromArray(a, i); 316 av.intoArray(r, i); 317 } 318 } 319 320 int index = fi.apply(a.length); 321 boolean shouldFail = isIndexOutOfBounds(SPECIES.length(), index, a.length); 322 try { 323 fromArray(a, index); 324 if (shouldFail) { 325 Assert.fail("Failed to throw IndexOutOfBoundsException"); 326 } 327 } catch (IndexOutOfBoundsException e) { 328 if (!shouldFail) { 329 Assert.fail("Unexpected IndexOutOfBoundsException"); 330 } 331 } 332 } 333 334 @Test(dataProvider = "byteProviderForIOOBE") 335 static void storeArrayIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi) { 336 byte[] a = fa.apply(SPECIES.length()); 337 byte[] r = new byte[a.length]; 338 339 for (int ic = 0; ic < INVOC_COUNT; ic++) { 340 for (int i = 0; i < a.length; i += SPECIES.length()) { 341 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 342 intoArray(av, r, i); 343 } 344 } 345 346 int index = fi.apply(a.length); 347 boolean shouldFail = isIndexOutOfBounds(SPECIES.length(), index, a.length); 348 try { 349 ByteVector av = ByteVector.fromArray(SPECIES, a, 0); 350 intoArray(av, r, index); 351 if (shouldFail) { 352 Assert.fail("Failed to throw IndexOutOfBoundsException"); 353 } 354 } catch (IndexOutOfBoundsException e) { 355 if (!shouldFail) { 356 Assert.fail("Unexpected IndexOutOfBoundsException"); 357 } 358 } 359 } 360 361 362 @Test(dataProvider = "byteMaskProvider") 363 static void loadStoreMaskArray(IntFunction<byte[]> fa, 364 IntFunction<boolean[]> fm) { 365 byte[] a = fa.apply(SPECIES.length()); 366 byte[] r = new byte[a.length]; 367 boolean[] mask = fm.apply(SPECIES.length()); 368 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 369 370 for (int ic = 0; ic < INVOC_COUNT; ic++) { 371 for (int i = 0; i < a.length; i += SPECIES.length()) { 372 ByteVector av = ByteVector.fromArray(SPECIES, a, i, vmask); 373 av.intoArray(r, i); 374 } 375 } 376 assertArraysEquals(r, a, mask); 377 378 379 r = new byte[a.length]; 380 381 for (int ic = 0; ic < INVOC_COUNT; ic++) { 382 for (int i = 0; i < a.length; i += SPECIES.length()) { 383 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 384 av.intoArray(r, i, vmask); 385 } 386 } 387 assertArraysEquals(r, a, mask); 388 } 389 390 @Test(dataProvider = "byteMaskProviderForIOOBE") 391 static void loadArrayMaskIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) { 392 byte[] a = fa.apply(SPECIES.length()); 393 byte[] r = new byte[a.length]; 394 boolean[] mask = fm.apply(SPECIES.length()); 395 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 396 397 for (int ic = 0; ic < INVOC_COUNT; ic++) { 398 for (int i = 0; i < a.length; i += SPECIES.length()) { 399 ByteVector av = fromArray(a, i, vmask); 400 av.intoArray(r, i); 401 } 402 } 403 404 int index = fi.apply(a.length); 405 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length); 406 try { 407 fromArray(a, index, vmask); 408 if (shouldFail) { 409 Assert.fail("Failed to throw IndexOutOfBoundsException"); 410 } 411 } catch (IndexOutOfBoundsException e) { 412 if (!shouldFail) { 413 Assert.fail("Unexpected IndexOutOfBoundsException"); 414 } 415 } 416 } 417 418 @Test(dataProvider = "byteMaskProviderForIOOBE") 419 static void storeArrayMaskIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) { 420 byte[] a = fa.apply(SPECIES.length()); 421 byte[] r = new byte[a.length]; 422 boolean[] mask = fm.apply(SPECIES.length()); 423 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 424 425 for (int ic = 0; ic < INVOC_COUNT; ic++) { 426 for (int i = 0; i < a.length; i += SPECIES.length()) { 427 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 428 intoArray(av, r, i, vmask); 429 } 430 } 431 432 int index = fi.apply(a.length); 433 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length); 434 try { 435 ByteVector av = ByteVector.fromArray(SPECIES, a, 0); 436 intoArray(av, a, index, vmask); 437 if (shouldFail) { 438 Assert.fail("Failed to throw IndexOutOfBoundsException"); 439 } 440 } catch (IndexOutOfBoundsException e) { 441 if (!shouldFail) { 442 Assert.fail("Unexpected IndexOutOfBoundsException"); 443 } 444 } 445 } 446 447 448 @Test(dataProvider = "byteMaskProvider") 449 static void loadStoreMask(IntFunction<byte[]> fa, 450 IntFunction<boolean[]> fm) { 451 boolean[] mask = fm.apply(SPECIES.length()); 452 boolean[] r = new boolean[mask.length]; 453 454 for (int ic = 0; ic < INVOC_COUNT; ic++) { 455 for (int i = 0; i < mask.length; i += SPECIES.length()) { 456 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, i); 457 vmask.intoArray(r, i); 458 } 459 } 460 Assert.assertEquals(r, mask); 461 } 462 463 464 @Test(dataProvider = "byteMemorySegmentProvider") 465 static void loadStoreMemorySegment(IntFunction<byte[]> fa, 466 IntFunction<MemorySegment> fb, 467 ByteOrder bo) { 468 MemorySegment a = toSegment(fa.apply(SPECIES.length()), fb); 469 MemorySegment r = fb.apply((int) a.byteSize()); 470 471 int l = (int) a.byteSize(); 472 int s = SPECIES.vectorByteSize(); 473 474 for (int ic = 0; ic < INVOC_COUNT; ic++) { 475 for (int i = 0; i < l; i += s) { 476 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, i, bo); 477 av.intoMemorySegment(r, i, bo); 478 } 479 } 480 long m = r.mismatch(a); 481 Assert.assertEquals(m, -1, "Segments not equal"); 482 } 483 484 @Test(dataProvider = "byteByteProviderForIOOBE") 485 static void loadMemorySegmentIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi) { 486 MemorySegment a = toSegment(fa.apply(SPECIES.length()), i -> MemorySegment.allocateNative(i, ResourceScope.newImplicitScope())); 487 MemorySegment r = MemorySegment.allocateNative(a.byteSize(), ResourceScope.newImplicitScope()); 488 489 int l = (int) a.byteSize(); 490 int s = SPECIES.vectorByteSize(); 491 492 for (int ic = 0; ic < INVOC_COUNT; ic++) { 493 for (int i = 0; i < l; i += s) { 494 ByteVector av = fromMemorySegment(a, i, ByteOrder.nativeOrder()); 495 av.intoMemorySegment(r, i, ByteOrder.nativeOrder()); 496 } 497 } 498 499 int index = fi.apply((int) a.byteSize()); 500 boolean shouldFail = isIndexOutOfBounds(SPECIES.vectorByteSize(), index, (int) a.byteSize()); 501 try { 502 fromMemorySegment(a, index, ByteOrder.nativeOrder()); 503 if (shouldFail) { 504 Assert.fail("Failed to throw IndexOutOfBoundsException"); 505 } 506 } catch (IndexOutOfBoundsException e) { 507 if (!shouldFail) { 508 Assert.fail("Unexpected IndexOutOfBoundsException"); 509 } 510 } 511 } 512 513 @Test(dataProvider = "byteByteProviderForIOOBE") 514 static void storeMemorySegmentIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi) { 515 MemorySegment a = toSegment(fa.apply(SPECIES.length()), i -> MemorySegment.allocateNative(i, ResourceScope.newImplicitScope())); 516 MemorySegment r = MemorySegment.allocateNative(a.byteSize(), ResourceScope.newImplicitScope()); 517 518 int l = (int) a.byteSize(); 519 int s = SPECIES.vectorByteSize(); 520 521 for (int ic = 0; ic < INVOC_COUNT; ic++) { 522 for (int i = 0; i < l; i += s) { 523 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, i, ByteOrder.nativeOrder()); 524 intoMemorySegment(av, r, i, ByteOrder.nativeOrder()); 525 } 526 } 527 528 int index = fi.apply((int) a.byteSize()); 529 boolean shouldFail = isIndexOutOfBounds(SPECIES.vectorByteSize(), index, (int) a.byteSize()); 530 try { 531 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, 0, ByteOrder.nativeOrder()); 532 intoMemorySegment(av, r, index, ByteOrder.nativeOrder()); 533 if (shouldFail) { 534 Assert.fail("Failed to throw IndexOutOfBoundsException"); 535 } 536 } catch (IndexOutOfBoundsException e) { 537 if (!shouldFail) { 538 Assert.fail("Unexpected IndexOutOfBoundsException"); 539 } 540 } 541 } 542 543 @Test(dataProvider = "byteMemorySegmentMaskProvider") 544 static void loadStoreMemorySegmentMask(IntFunction<byte[]> fa, 545 IntFunction<MemorySegment> fb, 546 IntFunction<boolean[]> fm, 547 ByteOrder bo) { 548 byte[] _a = fa.apply(SPECIES.length()); 549 MemorySegment a = toSegment(_a, fb); 550 MemorySegment r = fb.apply((int) a.byteSize()); 551 boolean[] mask = fm.apply(SPECIES.length()); 552 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 553 554 int l = (int) a.byteSize(); 555 int s = SPECIES.vectorByteSize(); 556 557 for (int ic = 0; ic < INVOC_COUNT; ic++) { 558 for (int i = 0; i < l; i += s) { 559 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, i, bo, vmask); 560 av.intoMemorySegment(r, i, bo); 561 } 562 } 563 assertArraysEquals(segmentToArray(r), _a, mask); 564 565 566 r = fb.apply((int) a.byteSize()); 567 568 for (int ic = 0; ic < INVOC_COUNT; ic++) { 569 for (int i = 0; i < l; i += s) { 570 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, i, bo); 571 av.intoMemorySegment(r, i, bo, vmask); 572 } 573 } 574 assertArraysEquals(segmentToArray(r), _a, mask); 575 } 576 577 @Test(dataProvider = "byteByteMaskProviderForIOOBE") 578 static void loadMemorySegmentMaskIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) { 579 MemorySegment a = toSegment(fa.apply(SPECIES.length()), i -> MemorySegment.allocateNative(i, ResourceScope.newImplicitScope())); 580 MemorySegment r = MemorySegment.allocateNative(a.byteSize(), ResourceScope.newImplicitScope()); 581 boolean[] mask = fm.apply(SPECIES.length()); 582 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 583 584 int l = (int) a.byteSize(); 585 int s = SPECIES.vectorByteSize(); 586 587 for (int ic = 0; ic < INVOC_COUNT; ic++) { 588 for (int i = 0; i < l; i += s) { 589 ByteVector av = fromMemorySegment(a, i, ByteOrder.nativeOrder(), vmask); 590 av.intoMemorySegment(r, i, ByteOrder.nativeOrder()); 591 } 592 } 593 594 int index = fi.apply((int) a.byteSize()); 595 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, (int) a.byteSize(), SPECIES.elementSize() / 8); 596 try { 597 fromMemorySegment(a, index, ByteOrder.nativeOrder(), vmask); 598 if (shouldFail) { 599 Assert.fail("Failed to throw IndexOutOfBoundsException"); 600 } 601 } catch (IndexOutOfBoundsException e) { 602 if (!shouldFail) { 603 Assert.fail("Unexpected IndexOutOfBoundsException"); 604 } 605 } 606 } 607 608 @Test(dataProvider = "byteByteMaskProviderForIOOBE") 609 static void storeMemorySegmentMaskIOOBE(IntFunction<byte[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) { 610 MemorySegment a = toSegment(fa.apply(SPECIES.length()), i -> MemorySegment.allocateNative(i, ResourceScope.newImplicitScope())); 611 MemorySegment r = MemorySegment.allocateNative(a.byteSize(), ResourceScope.newImplicitScope()); 612 boolean[] mask = fm.apply(SPECIES.length()); 613 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 614 615 int l = (int) a.byteSize(); 616 int s = SPECIES.vectorByteSize(); 617 618 for (int ic = 0; ic < INVOC_COUNT; ic++) { 619 for (int i = 0; i < l; i += s) { 620 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, i, ByteOrder.nativeOrder()); 621 intoMemorySegment(av, r, i, ByteOrder.nativeOrder(), vmask); 622 } 623 } 624 625 int index = fi.apply((int) a.byteSize()); 626 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, (int) a.byteSize(), SPECIES.elementSize() / 8); 627 try { 628 ByteVector av = ByteVector.fromMemorySegment(SPECIES, a, 0, ByteOrder.nativeOrder()); 629 intoMemorySegment(av, a, index, ByteOrder.nativeOrder(), vmask); 630 if (shouldFail) { 631 Assert.fail("Failed to throw IndexOutOfBoundsException"); 632 } 633 } catch (IndexOutOfBoundsException e) { 634 if (!shouldFail) { 635 Assert.fail("Unexpected IndexOutOfBoundsException"); 636 } 637 } 638 } 639 640 @Test(dataProvider = "byteMemorySegmentProvider") 641 static void loadStoreReadonlyMemorySegment(IntFunction<byte[]> fa, 642 IntFunction<MemorySegment> fb, 643 ByteOrder bo) { 644 MemorySegment a = toSegment(fa.apply(SPECIES.length()), fb).asReadOnly(); 645 646 Assert.assertThrows( 647 UnsupportedOperationException.class, 648 () -> SPECIES.zero().intoMemorySegment(a, 0, bo) 649 ); 650 651 Assert.assertThrows( 652 UnsupportedOperationException.class, 653 () -> SPECIES.zero().intoMemorySegment(a, 0, bo, SPECIES.maskAll(true)) 654 ); 655 656 Assert.assertThrows( 657 UnsupportedOperationException.class, 658 () -> SPECIES.zero().intoMemorySegment(a, 0, bo, SPECIES.maskAll(false)) 659 ); 660 661 VectorMask<Byte> m = SPECIES.shuffleFromOp(i -> i % 2 == 0 ? 1 : -1) 662 .laneIsValid(); 663 Assert.assertThrows( 664 UnsupportedOperationException.class, 665 () -> SPECIES.zero().intoMemorySegment(a, 0, bo, m) 666 ); 667 } 668 669 670 @Test(dataProvider = "maskProvider") 671 static void loadStoreMask(IntFunction<boolean[]> fm) { 672 boolean[] a = fm.apply(SPECIES.length()); 673 boolean[] r = new boolean[a.length]; 674 675 for (int ic = 0; ic < INVOC_COUNT; ic++) { 676 for (int i = 0; i < a.length; i += SPECIES.length()) { 677 VectorMask<Byte> vmask = SPECIES.loadMask(a, i); 678 vmask.intoArray(r, i); 679 } 680 } 681 Assert.assertEquals(r, a); 682 } 683 684 685 @Test 686 static void loadStoreShuffle() { 687 IntUnaryOperator fn = a -> a + 5; 688 for (int ic = 0; ic < INVOC_COUNT; ic++) { 689 var shuffle = VectorShuffle.fromOp(SPECIES, fn); 690 int [] r = shuffle.toArray(); 691 692 int [] a = expectedShuffle(SPECIES.length(), fn); 693 Assert.assertEquals(r, a); 694 } 695 } 696 697 698 699 static void assertArraysEquals(boolean[] r, byte[] a) { 700 int i = 0; 701 try { 702 for (; i < a.length; i++) { 703 Assert.assertEquals(r[i], (a[i] & 1) == 1); 704 } 705 } catch (AssertionError e) { 706 Assert.assertEquals(r[i], (a[i] & 1) == 1, "at index #" + i); 707 } 708 } 709 710 static void assertArraysEquals(boolean[] r, boolean[] a, boolean[] mask) { 711 int i = 0; 712 try { 713 for (; i < a.length; i++) { 714 Assert.assertEquals(r[i], mask[i % SPECIES.length()] && a[i]); 715 } 716 } catch (AssertionError e) { 717 Assert.assertEquals(r[i], mask[i % SPECIES.length()] && a[i], "at index #" + i); 718 } 719 } 720 721 static boolean[] convertToBooleanArray(byte[] a) { 722 boolean[] r = new boolean[a.length]; 723 724 for (int i = 0; i < a.length; i++) { 725 r[i] = (a[i] & 1) == 1; 726 } 727 728 return r; 729 } 730 731 @Test(dataProvider = "byteProvider") 732 static void loadByteStoreBooleanArray(IntFunction<byte[]> fa) { 733 byte[] a = fa.apply(SPECIES.length()); 734 boolean[] r = new boolean[a.length]; 735 736 for (int ic = 0; ic < INVOC_COUNT; ic++) { 737 for (int i = 0; i < a.length; i += SPECIES.length()) { 738 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 739 av.intoBooleanArray(r, i); 740 } 741 } 742 assertArraysEquals(r, a); 743 } 744 745 @Test(dataProvider = "byteProvider") 746 static void loadStoreBooleanArray(IntFunction<byte[]> fa) { 747 boolean[] a = convertToBooleanArray(fa.apply(SPECIES.length())); 748 boolean[] r = new boolean[a.length]; 749 750 for (int ic = 0; ic < INVOC_COUNT; ic++) { 751 for (int i = 0; i < a.length; i += SPECIES.length()) { 752 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i); 753 av.intoBooleanArray(r, i); 754 } 755 } 756 Assert.assertEquals(r, a); 757 } 758 759 @Test(dataProvider = "byteMaskProvider") 760 static void loadStoreMaskBooleanArray(IntFunction<byte[]> fa, 761 IntFunction<boolean[]> fm) { 762 boolean[] a = convertToBooleanArray(fa.apply(SPECIES.length())); 763 boolean[] r = new boolean[a.length]; 764 boolean[] mask = fm.apply(SPECIES.length()); 765 VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask); 766 767 for (int ic = 0; ic < INVOC_COUNT; ic++) { 768 for (int i = 0; i < a.length; i += SPECIES.length()) { 769 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i, vmask); 770 av.intoBooleanArray(r, i); 771 } 772 } 773 assertArraysEquals(r, a, mask); 774 775 776 r = new boolean[a.length]; 777 778 for (int ic = 0; ic < INVOC_COUNT; ic++) { 779 for (int i = 0; i < a.length; i += SPECIES.length()) { 780 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i); 781 av.intoBooleanArray(r, i, vmask); 782 } 783 } 784 assertArraysEquals(r, a, mask); 785 } 786 787 788 // Gather/Scatter load/store tests 789 790 static void assertGatherArraysEquals(byte[] r, byte[] a, int[] indexMap) { 791 int i = 0; 792 int j = 0; 793 try { 794 for (; i < a.length; i += SPECIES.length()) { 795 j = i; 796 for (; j < i + SPECIES.length(); j++) { 797 Assert.assertEquals(r[j], a[i + indexMap[j]]); 798 } 799 } 800 } catch (AssertionError e) { 801 Assert.assertEquals(r[j], a[i + indexMap[j]], "at index #" + j); 802 } 803 } 804 805 static void assertGatherArraysEquals(byte[] r, byte[] a, int[] indexMap, boolean[] mask) { 806 int i = 0; 807 int j = 0; 808 try { 809 for (; i < a.length; i += SPECIES.length()) { 810 j = i; 811 for (; j < i + SPECIES.length(); j++) { 812 Assert.assertEquals(r[j], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (byte) 0); 813 } 814 } 815 } catch (AssertionError e) { 816 Assert.assertEquals(r[i], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (byte) 0, "at index #" + j); 817 } 818 } 819 820 static void assertScatterArraysEquals(byte[] r, byte[] a, int[] indexMap, boolean[] mask) { 821 byte[] expected = new byte[r.length]; 822 823 // Store before checking, since the same location may be stored to more than once 824 for (int i = 0; i < a.length; i += SPECIES.length()) { 825 for (int j = i; j < i + SPECIES.length(); j++) { 826 if (mask[j % SPECIES.length()]) { 827 expected[i + indexMap[j]] = a[j]; 828 } 829 } 830 } 831 832 Assert.assertEquals(r, expected); 833 } 834 835 static void assertScatterArraysEquals(byte[] r, byte[] a, int[] indexMap) { 836 byte[] expected = new byte[r.length]; 837 838 // Store before checking, since the same location may be stored to more than once 839 for (int i = 0; i < a.length; i += SPECIES.length()) { 840 for (int j = i; j < i + SPECIES.length(); j++) { 841 expected[i + indexMap[j]] = a[j]; 842 } 843 } 844 845 Assert.assertEquals(r, expected); 846 } 847 848 @DataProvider 849 public Object[][] gatherScatterProvider() { 850 return INT_INDEX_GENERATORS.stream(). 851 flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> { 852 return new Object[] {fa, fs}; 853 })). 854 toArray(Object[][]::new); 855 } 856 857 @DataProvider 858 public Object[][] gatherScatterMaskProvider() { 859 return BOOLEAN_MASK_GENERATORS.stream(). 860 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm -> 861 BYTE_GENERATORS.stream().map(fa -> { 862 return new Object[] {fa, fm, fs}; 863 }))). 864 toArray(Object[][]::new); 865 } 866 867 868 @Test(dataProvider = "gatherScatterProvider") 869 static void gather(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs) { 870 byte[] a = fa.apply(SPECIES.length()); 871 int[] b = fs.apply(a.length, SPECIES.length()); 872 byte[] r = new byte[a.length]; 873 874 for (int ic = 0; ic < INVOC_COUNT; ic++) { 875 for (int i = 0; i < a.length; i += SPECIES.length()) { 876 ByteVector av = ByteVector.fromArray(SPECIES, a, i, b, i); 877 av.intoArray(r, i); 878 } 879 } 880 881 assertGatherArraysEquals(r, a, b); 882 } 883 884 @Test(dataProvider = "gatherScatterMaskProvider") 885 static void gatherMask(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) { 886 byte[] a = fa.apply(SPECIES.length()); 887 int[] b = fs.apply(a.length, SPECIES.length()); 888 byte[] r = new byte[a.length]; 889 boolean[] mask = fm.apply(SPECIES.length()); 890 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 891 892 for (int ic = 0; ic < INVOC_COUNT; ic++) { 893 for (int i = 0; i < a.length; i += SPECIES.length()) { 894 ByteVector av = ByteVector.fromArray(SPECIES, a, i, b, i, vmask); 895 av.intoArray(r, i); 896 } 897 } 898 899 assertGatherArraysEquals(r, a, b, mask); 900 } 901 902 @Test(dataProvider = "gatherScatterProvider") 903 static void scatter(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs) { 904 byte[] a = fa.apply(SPECIES.length()); 905 int[] b = fs.apply(a.length, SPECIES.length()); 906 byte[] r = new byte[a.length]; 907 908 for (int ic = 0; ic < INVOC_COUNT; ic++) { 909 for (int i = 0; i < a.length; i += SPECIES.length()) { 910 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 911 av.intoArray(r, i, b, i); 912 } 913 } 914 915 assertScatterArraysEquals(r, a, b); 916 } 917 918 @Test(dataProvider = "gatherScatterMaskProvider") 919 static void scatterMask(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) { 920 byte[] a = fa.apply(SPECIES.length()); 921 int[] b = fs.apply(a.length, SPECIES.length()); 922 byte[] r = new byte[a.length]; 923 boolean[] mask = fm.apply(SPECIES.length()); 924 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 925 926 for (int ic = 0; ic < INVOC_COUNT; ic++) { 927 for (int i = 0; i < a.length; i += SPECIES.length()) { 928 ByteVector av = ByteVector.fromArray(SPECIES, a, i); 929 av.intoArray(r, i, b, i, vmask); 930 } 931 } 932 933 assertScatterArraysEquals(r, a, b, mask); 934 } 935 936 937 static void assertGatherArraysEquals(boolean[] r, boolean[] a, int[] indexMap) { 938 int i = 0; 939 int j = 0; 940 try { 941 for (; i < a.length; i += SPECIES.length()) { 942 j = i; 943 for (; j < i + SPECIES.length(); j++) { 944 Assert.assertEquals(r[j], a[i + indexMap[j]]); 945 } 946 } 947 } catch (AssertionError e) { 948 Assert.assertEquals(r[j], a[i + indexMap[j]], "at index #" + j); 949 } 950 } 951 952 static void assertGatherArraysEquals(boolean[] r, boolean[] a, int[] indexMap, boolean[] mask) { 953 int i = 0; 954 int j = 0; 955 try { 956 for (; i < a.length; i += SPECIES.length()) { 957 j = i; 958 for (; j < i + SPECIES.length(); j++) { 959 Assert.assertEquals(r[j], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: false); 960 } 961 } 962 } catch (AssertionError e) { 963 Assert.assertEquals(r[i], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: false, "at index #" + j); 964 } 965 } 966 967 static void assertScatterArraysEquals(boolean[] r, boolean[] a, int[] indexMap, boolean[] mask) { 968 boolean[] expected = new boolean[r.length]; 969 970 // Store before checking, since the same location may be stored to more than once 971 for (int i = 0; i < a.length; i += SPECIES.length()) { 972 for (int j = i; j < i + SPECIES.length(); j++) { 973 if (mask[j % SPECIES.length()]) { 974 expected[i + indexMap[j]] = a[j]; 975 } 976 } 977 } 978 979 Assert.assertEquals(r, expected); 980 } 981 982 static void assertScatterArraysEquals(boolean[] r, boolean[] a, int[] indexMap) { 983 boolean[] expected = new boolean[r.length]; 984 985 // Store before checking, since the same location may be stored to more than once 986 for (int i = 0; i < a.length; i += SPECIES.length()) { 987 for (int j = i; j < i + SPECIES.length(); j++) { 988 expected[i + indexMap[j]] = a[j]; 989 } 990 } 991 992 Assert.assertEquals(r, expected); 993 } 994 995 @Test(dataProvider = "gatherScatterProvider") 996 static void booleanGather(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs) { 997 boolean[] a = convertToBooleanArray(fa.apply(SPECIES.length())); 998 int[] b = fs.apply(a.length, SPECIES.length()); 999 boolean[] r = new boolean[a.length]; 1000 1001 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1002 for (int i = 0; i < a.length; i += SPECIES.length()) { 1003 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i, b, i); 1004 av.intoBooleanArray(r, i); 1005 } 1006 } 1007 1008 assertGatherArraysEquals(r, a, b); 1009 } 1010 1011 @Test(dataProvider = "gatherScatterMaskProvider") 1012 static void booleanGatherMask(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) { 1013 boolean[] a = convertToBooleanArray(fa.apply(SPECIES.length())); 1014 int[] b = fs.apply(a.length, SPECIES.length()); 1015 boolean[] r = new boolean[a.length]; 1016 boolean[] mask = fm.apply(SPECIES.length()); 1017 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1018 1019 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1020 for (int i = 0; i < a.length; i += SPECIES.length()) { 1021 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i, b, i, vmask); 1022 av.intoBooleanArray(r, i); 1023 } 1024 } 1025 1026 assertGatherArraysEquals(r, a, b, mask); 1027 } 1028 1029 @Test(dataProvider = "gatherScatterProvider") 1030 static void booleanScatter(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs) { 1031 boolean[] a = convertToBooleanArray(fa.apply(SPECIES.length())); 1032 int[] b = fs.apply(a.length, SPECIES.length()); 1033 boolean[] r = new boolean[a.length]; 1034 1035 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1036 for (int i = 0; i < a.length; i += SPECIES.length()) { 1037 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i); 1038 av.intoBooleanArray(r, i, b, i); 1039 } 1040 } 1041 1042 assertScatterArraysEquals(r, a, b); 1043 } 1044 1045 @Test(dataProvider = "gatherScatterMaskProvider") 1046 static void booleanScatterMask(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) { 1047 boolean[] a = convertToBooleanArray(fa.apply(SPECIES.length())); 1048 int[] b = fs.apply(a.length, SPECIES.length()); 1049 boolean[] r = new boolean[a.length]; 1050 boolean[] mask = fm.apply(SPECIES.length()); 1051 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1052 1053 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1054 for (int i = 0; i < a.length; i += SPECIES.length()) { 1055 ByteVector av = ByteVector.fromBooleanArray(SPECIES, a, i); 1056 av.intoBooleanArray(r, i, b, i, vmask); 1057 } 1058 } 1059 1060 assertScatterArraysEquals(r, a, b, mask); 1061 } 1062 1063 }