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 }