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 }