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 LongMaxVectorLoadStoreTests 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.LongVector; 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 LongMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { 53 static final VectorSpecies<Long> SPECIES = 54 LongVector.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(long[] r, long[] 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] : (long) 0); 71 } 72 } catch (AssertionError e) { 73 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? a[i] : (long) 0, "at index #" + i); 74 } 75 } 76 77 static final List<IntFunction<long[]>> LONG_GENERATORS = List.of( 78 withToString("long[i * 5]", (int s) -> { 79 return fill(s * BUFFER_REPS, 80 i -> (long)(i * 5)); 81 }), 82 withToString("long[i + 1]", (int s) -> { 83 return fill(s * BUFFER_REPS, 84 i -> (((long)(i + 1) == 0) ? 1 : (long)(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[][] longProvider() { 146 return LONG_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[][] longProviderForIOOBE() { 160 var f = LONG_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[][] longMaskProvider() { 169 return BOOLEAN_MASK_GENERATORS.stream(). 170 flatMap(fm -> LONG_GENERATORS.stream().map(fa -> { 171 return new Object[] {fa, fm}; 172 })). 173 toArray(Object[][]::new); 174 } 175 176 @DataProvider 177 public Object[][] longMaskProviderForIOOBE() { 178 var f = LONG_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[][] longMemorySegmentProvider() { 188 return LONG_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[][] longMemorySegmentMaskProvider() { 198 return BOOLEAN_MASK_GENERATORS.stream(). 199 flatMap(fm -> LONG_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[][] longByteProviderForIOOBE() { 209 var f = LONG_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[][] longByteMaskProviderForIOOBE() { 218 var f = LONG_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(long[] 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_LONG, i * SPECIES.elementSize() / 8 , a[i]); 230 } 231 return ms; 232 } 233 234 static long[] segmentToArray(MemorySegment ms) { 235 return ms.toArray(ValueLayout.JAVA_LONG); 236 } 237 238 239 interface ToLongF { 240 long apply(int i); 241 } 242 243 static long[] fill(int s , ToLongF f) { 244 return fill(new long[s], f); 245 } 246 247 static long[] fill(long[] a, ToLongF 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 LongVector fromArray(long[] a, int i) { 256 return LongVector.fromArray(SPECIES, a, i); 257 } 258 259 @DontInline 260 static LongVector fromArray(long[] a, int i, VectorMask<Long> m) { 261 return LongVector.fromArray(SPECIES, a, i, m); 262 } 263 264 @DontInline 265 static void intoArray(LongVector v, long[] a, int i) { 266 v.intoArray(a, i); 267 } 268 269 @DontInline 270 static void intoArray(LongVector v, long[] a, int i, VectorMask<Long> m) { 271 v.intoArray(a, i, m); 272 } 273 274 @DontInline 275 static LongVector fromMemorySegment(MemorySegment a, int i, ByteOrder bo) { 276 return LongVector.fromMemorySegment(SPECIES, a, i, bo); 277 } 278 279 @DontInline 280 static LongVector fromMemorySegment(MemorySegment a, int i, ByteOrder bo, VectorMask<Long> m) { 281 return LongVector.fromMemorySegment(SPECIES, a, i, bo, m); 282 } 283 284 @DontInline 285 static void intoMemorySegment(LongVector v, MemorySegment a, int i, ByteOrder bo) { 286 v.intoMemorySegment(a, i, bo); 287 } 288 289 @DontInline 290 static void intoMemorySegment(LongVector v, MemorySegment a, int i, ByteOrder bo, VectorMask<Long> m) { 291 v.intoMemorySegment(a, i, bo, m); 292 } 293 294 @Test(dataProvider = "longProvider") 295 static void loadStoreArray(IntFunction<long[]> fa) { 296 long[] a = fa.apply(SPECIES.length()); 297 long[] r = new long[a.length]; 298 299 for (int ic = 0; ic < INVOC_COUNT; ic++) { 300 for (int i = 0; i < a.length; i += SPECIES.length()) { 301 LongVector av = LongVector.fromArray(SPECIES, a, i); 302 av.intoArray(r, i); 303 } 304 } 305 Assert.assertEquals(r, a); 306 } 307 308 @Test(dataProvider = "longProviderForIOOBE") 309 static void loadArrayIOOBE(IntFunction<long[]> fa, IntFunction<Integer> fi) { 310 long[] a = fa.apply(SPECIES.length()); 311 long[] r = new long[a.length]; 312 313 for (int ic = 0; ic < INVOC_COUNT; ic++) { 314 for (int i = 0; i < a.length; i += SPECIES.length()) { 315 LongVector 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 = "longProviderForIOOBE") 335 static void storeArrayIOOBE(IntFunction<long[]> fa, IntFunction<Integer> fi) { 336 long[] a = fa.apply(SPECIES.length()); 337 long[] r = new long[a.length]; 338 339 for (int ic = 0; ic < INVOC_COUNT; ic++) { 340 for (int i = 0; i < a.length; i += SPECIES.length()) { 341 LongVector av = LongVector.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 LongVector av = LongVector.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 = "longMaskProvider") 363 static void loadStoreMaskArray(IntFunction<long[]> fa, 364 IntFunction<boolean[]> fm) { 365 long[] a = fa.apply(SPECIES.length()); 366 long[] r = new long[a.length]; 367 boolean[] mask = fm.apply(SPECIES.length()); 368 VectorMask<Long> 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 LongVector av = LongVector.fromArray(SPECIES, a, i, vmask); 373 av.intoArray(r, i); 374 } 375 } 376 assertArraysEquals(r, a, mask); 377 378 379 r = new long[a.length]; 380 381 for (int ic = 0; ic < INVOC_COUNT; ic++) { 382 for (int i = 0; i < a.length; i += SPECIES.length()) { 383 LongVector av = LongVector.fromArray(SPECIES, a, i); 384 av.intoArray(r, i, vmask); 385 } 386 } 387 assertArraysEquals(r, a, mask); 388 } 389 390 @Test(dataProvider = "longMaskProviderForIOOBE") 391 static void loadArrayMaskIOOBE(IntFunction<long[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) { 392 long[] a = fa.apply(SPECIES.length()); 393 long[] r = new long[a.length]; 394 boolean[] mask = fm.apply(SPECIES.length()); 395 VectorMask<Long> 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 LongVector 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 = "longMaskProviderForIOOBE") 419 static void storeArrayMaskIOOBE(IntFunction<long[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) { 420 long[] a = fa.apply(SPECIES.length()); 421 long[] r = new long[a.length]; 422 boolean[] mask = fm.apply(SPECIES.length()); 423 VectorMask<Long> 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 LongVector av = LongVector.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 LongVector av = LongVector.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 = "longMaskProvider") 449 static void loadStoreMask(IntFunction<long[]> 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<Long> vmask = VectorMask.fromArray(SPECIES, mask, i); 457 vmask.intoArray(r, i); 458 } 459 } 460 Assert.assertEquals(r, mask); 461 } 462 463 464 @Test(dataProvider = "longMemorySegmentProvider") 465 static void loadStoreMemorySegment(IntFunction<long[]> 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 LongVector av = LongVector.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 = "longByteProviderForIOOBE") 485 static void loadMemorySegmentIOOBE(IntFunction<long[]> 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 LongVector 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 = "longByteProviderForIOOBE") 514 static void storeMemorySegmentIOOBE(IntFunction<long[]> 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 LongVector av = LongVector.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 LongVector av = LongVector.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 = "longMemorySegmentMaskProvider") 544 static void loadStoreMemorySegmentMask(IntFunction<long[]> fa, 545 IntFunction<MemorySegment> fb, 546 IntFunction<boolean[]> fm, 547 ByteOrder bo) { 548 long[] _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<Long> 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 LongVector av = LongVector.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 LongVector av = LongVector.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 = "longByteMaskProviderForIOOBE") 578 static void loadMemorySegmentMaskIOOBE(IntFunction<long[]> 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<Long> 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 LongVector 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 = "longByteMaskProviderForIOOBE") 609 static void storeMemorySegmentMaskIOOBE(IntFunction<long[]> 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<Long> 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 LongVector av = LongVector.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 LongVector av = LongVector.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 = "longMemorySegmentProvider") 641 static void loadStoreReadonlyMemorySegment(IntFunction<long[]> 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<Long> 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<Long> 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 700 701 // Gather/Scatter load/store tests 702 703 static void assertGatherArraysEquals(long[] r, long[] a, int[] indexMap) { 704 int i = 0; 705 int j = 0; 706 try { 707 for (; i < a.length; i += SPECIES.length()) { 708 j = i; 709 for (; j < i + SPECIES.length(); j++) { 710 Assert.assertEquals(r[j], a[i + indexMap[j]]); 711 } 712 } 713 } catch (AssertionError e) { 714 Assert.assertEquals(r[j], a[i + indexMap[j]], "at index #" + j); 715 } 716 } 717 718 static void assertGatherArraysEquals(long[] r, long[] a, int[] indexMap, boolean[] mask) { 719 int i = 0; 720 int j = 0; 721 try { 722 for (; i < a.length; i += SPECIES.length()) { 723 j = i; 724 for (; j < i + SPECIES.length(); j++) { 725 Assert.assertEquals(r[j], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (long) 0); 726 } 727 } 728 } catch (AssertionError e) { 729 Assert.assertEquals(r[i], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (long) 0, "at index #" + j); 730 } 731 } 732 733 static void assertScatterArraysEquals(long[] r, long[] a, int[] indexMap, boolean[] mask) { 734 long[] expected = new long[r.length]; 735 736 // Store before checking, since the same location may be stored to more than once 737 for (int i = 0; i < a.length; i += SPECIES.length()) { 738 for (int j = i; j < i + SPECIES.length(); j++) { 739 if (mask[j % SPECIES.length()]) { 740 expected[i + indexMap[j]] = a[j]; 741 } 742 } 743 } 744 745 Assert.assertEquals(r, expected); 746 } 747 748 static void assertScatterArraysEquals(long[] r, long[] a, int[] indexMap) { 749 long[] expected = new long[r.length]; 750 751 // Store before checking, since the same location may be stored to more than once 752 for (int i = 0; i < a.length; i += SPECIES.length()) { 753 for (int j = i; j < i + SPECIES.length(); j++) { 754 expected[i + indexMap[j]] = a[j]; 755 } 756 } 757 758 Assert.assertEquals(r, expected); 759 } 760 761 @DataProvider 762 public Object[][] gatherScatterProvider() { 763 return INT_INDEX_GENERATORS.stream(). 764 flatMap(fs -> LONG_GENERATORS.stream().map(fa -> { 765 return new Object[] {fa, fs}; 766 })). 767 toArray(Object[][]::new); 768 } 769 770 @DataProvider 771 public Object[][] gatherScatterMaskProvider() { 772 return BOOLEAN_MASK_GENERATORS.stream(). 773 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm -> 774 LONG_GENERATORS.stream().map(fa -> { 775 return new Object[] {fa, fm, fs}; 776 }))). 777 toArray(Object[][]::new); 778 } 779 780 781 @Test(dataProvider = "gatherScatterProvider") 782 static void gather(IntFunction<long[]> fa, BiFunction<Integer,Integer,int[]> fs) { 783 long[] a = fa.apply(SPECIES.length()); 784 int[] b = fs.apply(a.length, SPECIES.length()); 785 long[] r = new long[a.length]; 786 787 for (int ic = 0; ic < INVOC_COUNT; ic++) { 788 for (int i = 0; i < a.length; i += SPECIES.length()) { 789 LongVector av = LongVector.fromArray(SPECIES, a, i, b, i); 790 av.intoArray(r, i); 791 } 792 } 793 794 assertGatherArraysEquals(r, a, b); 795 } 796 797 @Test(dataProvider = "gatherScatterMaskProvider") 798 static void gatherMask(IntFunction<long[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) { 799 long[] a = fa.apply(SPECIES.length()); 800 int[] b = fs.apply(a.length, SPECIES.length()); 801 long[] r = new long[a.length]; 802 boolean[] mask = fm.apply(SPECIES.length()); 803 VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0); 804 805 for (int ic = 0; ic < INVOC_COUNT; ic++) { 806 for (int i = 0; i < a.length; i += SPECIES.length()) { 807 LongVector av = LongVector.fromArray(SPECIES, a, i, b, i, vmask); 808 av.intoArray(r, i); 809 } 810 } 811 812 assertGatherArraysEquals(r, a, b, mask); 813 } 814 815 @Test(dataProvider = "gatherScatterProvider") 816 static void scatter(IntFunction<long[]> fa, BiFunction<Integer,Integer,int[]> fs) { 817 long[] a = fa.apply(SPECIES.length()); 818 int[] b = fs.apply(a.length, SPECIES.length()); 819 long[] r = new long[a.length]; 820 821 for (int ic = 0; ic < INVOC_COUNT; ic++) { 822 for (int i = 0; i < a.length; i += SPECIES.length()) { 823 LongVector av = LongVector.fromArray(SPECIES, a, i); 824 av.intoArray(r, i, b, i); 825 } 826 } 827 828 assertScatterArraysEquals(r, a, b); 829 } 830 831 @Test(dataProvider = "gatherScatterMaskProvider") 832 static void scatterMask(IntFunction<long[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) { 833 long[] a = fa.apply(SPECIES.length()); 834 int[] b = fs.apply(a.length, SPECIES.length()); 835 long[] r = new long[a.length]; 836 boolean[] mask = fm.apply(SPECIES.length()); 837 VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0); 838 839 for (int ic = 0; ic < INVOC_COUNT; ic++) { 840 for (int i = 0; i < a.length; i += SPECIES.length()) { 841 LongVector av = LongVector.fromArray(SPECIES, a, i); 842 av.intoArray(r, i, b, i, vmask); 843 } 844 } 845 846 assertScatterArraysEquals(r, a, b, mask); 847 } 848 849 850 851 }