1 /*
2 * Copyright (c) 2018, 2021, 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 -XX:-TieredCompilation Short128VectorLoadStoreTests
28 *
29 */
30
31 // -- This file was mechanically generated: Do not edit! -- //
32
33 import jdk.incubator.vector.ShortVector;
34 import jdk.incubator.vector.VectorMask;
35 import jdk.incubator.vector.VectorSpecies;
36 import jdk.incubator.vector.VectorShuffle;
37 import jdk.internal.vm.annotation.DontInline;
38 import org.testng.Assert;
39 import org.testng.annotations.DataProvider;
40 import org.testng.annotations.Test;
41
42 import java.nio.ByteBuffer;
43 import java.nio.ShortBuffer;
44 import java.nio.ByteOrder;
45 import java.nio.ReadOnlyBufferException;
46 import java.util.List;
47 import java.util.function.*;
48
49 @Test
50 public class Short128VectorLoadStoreTests extends AbstractVectorLoadStoreTest {
51 static final VectorSpecies<Short> SPECIES =
52 ShortVector.SPECIES_128;
53
54 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
55
56
57 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128);
58
59 static void assertArraysEquals(short[] r, short[] a, boolean[] mask) {
60 int i = 0;
61 try {
62 for (; i < a.length; i++) {
63 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? a[i] : (short) 0);
64 }
65 } catch (AssertionError e) {
66 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? a[i] : (short) 0, "at index #" + i);
67 }
68 }
69
70 static void assertArraysEquals(byte[] r, byte[] a, boolean[] mask) {
71 int i = 0;
72 try {
73 for (; i < a.length; i++) {
74 Assert.assertEquals(r[i], mask[(i*8/SPECIES.elementSize()) % SPECIES.length()] ? a[i] : (byte) 0);
75 }
76 } catch (AssertionError e) {
77 Assert.assertEquals(r[i], mask[(i*8/SPECIES.elementSize()) % SPECIES.length()] ? a[i] : (byte) 0, "at index #" + i);
78 }
79 }
80
81 static final List<IntFunction<short[]>> SHORT_GENERATORS = List.of(
82 withToString("short[i * 5]", (int s) -> {
83 return fill(s * BUFFER_REPS,
84 i -> (short)(i * 5));
85 }),
86 withToString("short[i + 1]", (int s) -> {
87 return fill(s * BUFFER_REPS,
88 i -> (((short)(i + 1) == 0) ? 1 : (short)(i + 1)));
89 })
90 );
91
92 // Relative to array.length
93 static final List<IntFunction<Integer>> INDEX_GENERATORS = List.of(
94 withToString("-1", (int l) -> {
95 return -1;
96 }),
97 withToString("l", (int l) -> {
98 return l;
99 }),
100 withToString("l - 1", (int l) -> {
101 return l - 1;
102 }),
103 withToString("l + 1", (int l) -> {
104 return l + 1;
105 }),
106 withToString("l - speciesl + 1", (int l) -> {
107 return l - SPECIES.length() + 1;
108 }),
109 withToString("l + speciesl - 1", (int l) -> {
110 return l + SPECIES.length() - 1;
111 }),
112 withToString("l + speciesl", (int l) -> {
113 return l + SPECIES.length();
114 }),
115 withToString("l + speciesl + 1", (int l) -> {
116 return l + SPECIES.length() + 1;
117 })
118 );
119
120 // Relative to byte[] array.length or ByteBuffer.limit()
121 static final List<IntFunction<Integer>> BYTE_INDEX_GENERATORS = List.of(
122 withToString("-1", (int l) -> {
123 return -1;
124 }),
125 withToString("l", (int l) -> {
126 return l;
127 }),
128 withToString("l - 1", (int l) -> {
129 return l - 1;
130 }),
131 withToString("l + 1", (int l) -> {
132 return l + 1;
133 }),
134 withToString("l - speciesl*ebsize + 1", (int l) -> {
135 return l - SPECIES.vectorByteSize() + 1;
136 }),
137 withToString("l + speciesl*ebsize - 1", (int l) -> {
138 return l + SPECIES.vectorByteSize() - 1;
139 }),
140 withToString("l + speciesl*ebsize", (int l) -> {
141 return l + SPECIES.vectorByteSize();
142 }),
143 withToString("l + speciesl*ebsize + 1", (int l) -> {
144 return l + SPECIES.vectorByteSize() + 1;
145 })
146 );
147
148 @DataProvider
149 public Object[][] shortProvider() {
150 return SHORT_GENERATORS.stream().
151 map(f -> new Object[]{f}).
152 toArray(Object[][]::new);
153 }
154
155 @DataProvider
156 public Object[][] maskProvider() {
157 return BOOLEAN_MASK_GENERATORS.stream().
158 map(f -> new Object[]{f}).
159 toArray(Object[][]::new);
160 }
161
162 @DataProvider
163 public Object[][] shortProviderForIOOBE() {
164 var f = SHORT_GENERATORS.get(0);
165 return INDEX_GENERATORS.stream().map(fi -> {
166 return new Object[] {f, fi};
167 }).
168 toArray(Object[][]::new);
169 }
170
171 @DataProvider
172 public Object[][] shortMaskProvider() {
173 return BOOLEAN_MASK_GENERATORS.stream().
174 flatMap(fm -> SHORT_GENERATORS.stream().map(fa -> {
175 return new Object[] {fa, fm};
176 })).
177 toArray(Object[][]::new);
178 }
179
180 @DataProvider
181 public Object[][] shortMaskProviderForIOOBE() {
182 var f = SHORT_GENERATORS.get(0);
183 return BOOLEAN_MASK_GENERATORS.stream().
184 flatMap(fm -> INDEX_GENERATORS.stream().map(fi -> {
185 return new Object[] {f, fi, fm};
186 })).
187 toArray(Object[][]::new);
188 }
189
190 @DataProvider
191 public Object[][] shortByteBufferProvider() {
192 return SHORT_GENERATORS.stream().
193 flatMap(fa -> BYTE_BUFFER_GENERATORS.stream().
194 flatMap(fb -> BYTE_ORDER_VALUES.stream().map(bo -> {
195 return new Object[]{fa, fb, bo};
196 }))).
197 toArray(Object[][]::new);
198 }
199
200 @DataProvider
201 public Object[][] shortByteBufferMaskProvider() {
202 return BOOLEAN_MASK_GENERATORS.stream().
203 flatMap(fm -> SHORT_GENERATORS.stream().
204 flatMap(fa -> BYTE_BUFFER_GENERATORS.stream().
205 flatMap(fb -> BYTE_ORDER_VALUES.stream().map(bo -> {
206 return new Object[]{fa, fb, fm, bo};
207 })))).
208 toArray(Object[][]::new);
209 }
210
211 @DataProvider
212 public Object[][] shortByteArrayProvider() {
213 return SHORT_GENERATORS.stream().
214 flatMap(fa -> BYTE_ORDER_VALUES.stream().map(bo -> {
215 return new Object[]{fa, bo};
216 })).
217 toArray(Object[][]::new);
218 }
219
220 @DataProvider
221 public Object[][] shortByteArrayMaskProvider() {
222 return BOOLEAN_MASK_GENERATORS.stream().
223 flatMap(fm -> SHORT_GENERATORS.stream().
224 flatMap(fa -> BYTE_ORDER_VALUES.stream().map(bo -> {
225 return new Object[]{fa, fm, bo};
226 }))).
227 toArray(Object[][]::new);
228 }
229
230 @DataProvider
231 public Object[][] shortByteProviderForIOOBE() {
232 var f = SHORT_GENERATORS.get(0);
233 return BYTE_INDEX_GENERATORS.stream().map(fi -> {
234 return new Object[] {f, fi};
235 }).
236 toArray(Object[][]::new);
237 }
238
239 @DataProvider
240 public Object[][] shortByteMaskProviderForIOOBE() {
241 var f = SHORT_GENERATORS.get(0);
242 return BOOLEAN_MASK_GENERATORS.stream().
243 flatMap(fm -> BYTE_INDEX_GENERATORS.stream().map(fi -> {
244 return new Object[] {f, fi, fm};
245 })).
246 toArray(Object[][]::new);
247 }
248
249 static ByteBuffer toBuffer(short[] a, IntFunction<ByteBuffer> fb) {
250 ByteBuffer bb = fb.apply(a.length * SPECIES.elementSize() / 8);
251 for (short v : a) {
252 bb.putShort(v);
253 }
254 return bb.clear();
255 }
256
257 static short[] bufferToArray(ByteBuffer bb) {
258 ShortBuffer db = bb.asShortBuffer();
259 short[] d = new short[db.capacity()];
260 db.get(0, d);
261 return d;
262 }
263
264 static byte[] toByteArray(short[] a, IntFunction<byte[]> fb, ByteOrder bo) {
265 byte[] b = fb.apply(a.length * SPECIES.elementSize() / 8);
266 ShortBuffer bb = ByteBuffer.wrap(b, 0, b.length).order(bo).asShortBuffer();
267 for (short v : a) {
268 bb.put(v);
269 }
270 return b;
271 }
272
273
274 interface ToShortF {
275 short apply(int i);
276 }
277
278 static short[] fill(int s , ToShortF f) {
279 return fill(new short[s], f);
280 }
281
282 static short[] fill(short[] a, ToShortF f) {
283 for (int i = 0; i < a.length; i++) {
284 a[i] = f.apply(i);
285 }
286 return a;
287 }
288
289 @DontInline
290 static ShortVector fromArray(short[] a, int i) {
291 return ShortVector.fromArray(SPECIES, a, i);
292 }
293
294 @DontInline
295 static ShortVector fromArray(short[] a, int i, VectorMask<Short> m) {
296 return ShortVector.fromArray(SPECIES, a, i, m);
297 }
298
299 @DontInline
300 static void intoArray(ShortVector v, short[] a, int i) {
301 v.intoArray(a, i);
302 }
303
304 @DontInline
305 static void intoArray(ShortVector v, short[] a, int i, VectorMask<Short> m) {
306 v.intoArray(a, i, m);
307 }
308
309 @DontInline
310 static ShortVector fromByteArray(byte[] a, int i, ByteOrder bo) {
311 return ShortVector.fromByteArray(SPECIES, a, i, bo);
312 }
313
314 @DontInline
315 static ShortVector fromByteArray(byte[] a, int i, ByteOrder bo, VectorMask<Short> m) {
316 return ShortVector.fromByteArray(SPECIES, a, i, bo, m);
317 }
318
319 @DontInline
320 static void intoByteArray(ShortVector v, byte[] a, int i, ByteOrder bo) {
321 v.intoByteArray(a, i, bo);
322 }
323
324 @DontInline
325 static void intoByteArray(ShortVector v, byte[] a, int i, ByteOrder bo, VectorMask<Short> m) {
326 v.intoByteArray(a, i, bo, m);
327 }
328
329 @DontInline
330 static ShortVector fromByteBuffer(ByteBuffer a, int i, ByteOrder bo) {
331 return ShortVector.fromByteBuffer(SPECIES, a, i, bo);
332 }
333
334 @DontInline
335 static ShortVector fromByteBuffer(ByteBuffer a, int i, ByteOrder bo, VectorMask<Short> m) {
336 return ShortVector.fromByteBuffer(SPECIES, a, i, bo, m);
337 }
338
339 @DontInline
340 static void intoByteBuffer(ShortVector v, ByteBuffer a, int i, ByteOrder bo) {
341 v.intoByteBuffer(a, i, bo);
342 }
343
344 @DontInline
345 static void intoByteBuffer(ShortVector v, ByteBuffer a, int i, ByteOrder bo, VectorMask<Short> m) {
346 v.intoByteBuffer(a, i, bo, m);
347 }
348
349
350 @Test(dataProvider = "shortProvider")
351 static void loadStoreArray(IntFunction<short[]> fa) {
352 short[] a = fa.apply(SPECIES.length());
353 short[] r = new short[a.length];
354
355 for (int ic = 0; ic < INVOC_COUNT; ic++) {
356 for (int i = 0; i < a.length; i += SPECIES.length()) {
357 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
358 av.intoArray(r, i);
359 }
360 }
361 Assert.assertEquals(r, a);
362 }
363
364 @Test(dataProvider = "shortProviderForIOOBE")
365 static void loadArrayIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi) {
366 short[] a = fa.apply(SPECIES.length());
367 short[] r = new short[a.length];
368
369 for (int ic = 0; ic < INVOC_COUNT; ic++) {
370 for (int i = 0; i < a.length; i += SPECIES.length()) {
371 ShortVector av = fromArray(a, i);
372 av.intoArray(r, i);
373 }
374 }
375
376 int index = fi.apply(a.length);
377 boolean shouldFail = isIndexOutOfBounds(SPECIES.length(), index, a.length);
378 try {
379 fromArray(a, index);
380 if (shouldFail) {
381 Assert.fail("Failed to throw IndexOutOfBoundsException");
382 }
383 } catch (IndexOutOfBoundsException e) {
384 if (!shouldFail) {
385 Assert.fail("Unexpected IndexOutOfBoundsException");
386 }
387 }
388 }
389
390 @Test(dataProvider = "shortProviderForIOOBE")
391 static void storeArrayIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi) {
392 short[] a = fa.apply(SPECIES.length());
393 short[] r = new short[a.length];
394
395 for (int ic = 0; ic < INVOC_COUNT; ic++) {
396 for (int i = 0; i < a.length; i += SPECIES.length()) {
397 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
398 intoArray(av, r, i);
399 }
400 }
401
402 int index = fi.apply(a.length);
403 boolean shouldFail = isIndexOutOfBounds(SPECIES.length(), index, a.length);
404 try {
405 ShortVector av = ShortVector.fromArray(SPECIES, a, 0);
406 intoArray(av, r, index);
407 if (shouldFail) {
408 Assert.fail("Failed to throw IndexOutOfBoundsException");
409 }
410 } catch (IndexOutOfBoundsException e) {
411 if (!shouldFail) {
412 Assert.fail("Unexpected IndexOutOfBoundsException");
413 }
414 }
415 }
416
417
418 @Test(dataProvider = "shortMaskProvider")
419 static void loadStoreMaskArray(IntFunction<short[]> fa,
420 IntFunction<boolean[]> fm) {
421 short[] a = fa.apply(SPECIES.length());
422 short[] r = new short[a.length];
423 boolean[] mask = fm.apply(SPECIES.length());
424 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
425
426 for (int ic = 0; ic < INVOC_COUNT; ic++) {
427 for (int i = 0; i < a.length; i += SPECIES.length()) {
428 ShortVector av = ShortVector.fromArray(SPECIES, a, i, vmask);
429 av.intoArray(r, i);
430 }
431 }
432 assertArraysEquals(r, a, mask);
433
434
435 r = new short[a.length];
436
437 for (int ic = 0; ic < INVOC_COUNT; ic++) {
438 for (int i = 0; i < a.length; i += SPECIES.length()) {
439 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
440 av.intoArray(r, i, vmask);
441 }
442 }
443 assertArraysEquals(r, a, mask);
444 }
445
446 @Test(dataProvider = "shortMaskProviderForIOOBE")
447 static void loadArrayMaskIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
448 short[] a = fa.apply(SPECIES.length());
449 short[] r = new short[a.length];
450 boolean[] mask = fm.apply(SPECIES.length());
451 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
452
453 for (int ic = 0; ic < INVOC_COUNT; ic++) {
454 for (int i = 0; i < a.length; i += SPECIES.length()) {
455 ShortVector av = fromArray(a, i, vmask);
456 av.intoArray(r, i);
457 }
458 }
459
460 int index = fi.apply(a.length);
461 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length);
462 try {
463 fromArray(a, index, vmask);
464 if (shouldFail) {
465 Assert.fail("Failed to throw IndexOutOfBoundsException");
466 }
467 } catch (IndexOutOfBoundsException e) {
468 if (!shouldFail) {
469 Assert.fail("Unexpected IndexOutOfBoundsException");
470 }
471 }
472 }
473
474 @Test(dataProvider = "shortMaskProviderForIOOBE")
475 static void storeArrayMaskIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
476 short[] a = fa.apply(SPECIES.length());
477 short[] r = new short[a.length];
478 boolean[] mask = fm.apply(SPECIES.length());
479 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
480
481 for (int ic = 0; ic < INVOC_COUNT; ic++) {
482 for (int i = 0; i < a.length; i += SPECIES.length()) {
483 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
484 intoArray(av, r, i, vmask);
485 }
486 }
487
488 int index = fi.apply(a.length);
489 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length);
490 try {
491 ShortVector av = ShortVector.fromArray(SPECIES, a, 0);
492 intoArray(av, a, index, vmask);
493 if (shouldFail) {
494 Assert.fail("Failed to throw IndexOutOfBoundsException");
495 }
496 } catch (IndexOutOfBoundsException e) {
497 if (!shouldFail) {
498 Assert.fail("Unexpected IndexOutOfBoundsException");
499 }
500 }
501 }
502
503
504 @Test(dataProvider = "shortMaskProvider")
505 static void loadStoreMask(IntFunction<short[]> fa,
506 IntFunction<boolean[]> fm) {
507 boolean[] mask = fm.apply(SPECIES.length());
508 boolean[] r = new boolean[mask.length];
509
510 for (int ic = 0; ic < INVOC_COUNT; ic++) {
511 for (int i = 0; i < mask.length; i += SPECIES.length()) {
512 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
513 vmask.intoArray(r, i);
514 }
515 }
516 Assert.assertEquals(r, mask);
517 }
518
519
520 @Test(dataProvider = "shortByteBufferProvider")
521 static void loadStoreByteBuffer(IntFunction<short[]> fa,
522 IntFunction<ByteBuffer> fb,
523 ByteOrder bo) {
524 ByteBuffer a = toBuffer(fa.apply(SPECIES.length()), fb);
525 ByteBuffer r = fb.apply(a.limit());
526
527 int l = a.limit();
528 int s = SPECIES.vectorByteSize();
529
530 for (int ic = 0; ic < INVOC_COUNT; ic++) {
531 for (int i = 0; i < l; i += s) {
532 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, i, bo);
533 av.intoByteBuffer(r, i, bo);
534 }
535 }
536 Assert.assertEquals(a.position(), 0, "Input buffer position changed");
537 Assert.assertEquals(a.limit(), l, "Input buffer limit changed");
538 Assert.assertEquals(r.position(), 0, "Result buffer position changed");
539 Assert.assertEquals(r.limit(), l, "Result buffer limit changed");
540 Assert.assertEquals(r, a, "Buffers not equal");
541 }
542
543 @Test(dataProvider = "shortByteProviderForIOOBE")
544 static void loadByteBufferIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi) {
545 ByteBuffer a = toBuffer(fa.apply(SPECIES.length()), ByteBuffer::allocateDirect);
546 ByteBuffer r = ByteBuffer.allocateDirect(a.limit());
547
548 int l = a.limit();
549 int s = SPECIES.vectorByteSize();
550
551 for (int ic = 0; ic < INVOC_COUNT; ic++) {
552 for (int i = 0; i < l; i += s) {
553 ShortVector av = fromByteBuffer(a, i, ByteOrder.nativeOrder());
554 av.intoByteBuffer(r, i, ByteOrder.nativeOrder());
555 }
556 }
557
558 int index = fi.apply(a.limit());
559 boolean shouldFail = isIndexOutOfBounds(SPECIES.vectorByteSize(), index, a.limit());
560 try {
561 fromByteBuffer(a, index, ByteOrder.nativeOrder());
562 if (shouldFail) {
563 Assert.fail("Failed to throw IndexOutOfBoundsException");
564 }
565 } catch (IndexOutOfBoundsException e) {
566 if (!shouldFail) {
567 Assert.fail("Unexpected IndexOutOfBoundsException");
568 }
569 }
570 }
571
572 @Test(dataProvider = "shortByteProviderForIOOBE")
573 static void storeByteBufferIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi) {
574 ByteBuffer a = toBuffer(fa.apply(SPECIES.length()), ByteBuffer::allocateDirect);
575 ByteBuffer r = ByteBuffer.allocateDirect(a.limit());
576
577 int l = a.limit();
578 int s = SPECIES.vectorByteSize();
579
580 for (int ic = 0; ic < INVOC_COUNT; ic++) {
581 for (int i = 0; i < l; i += s) {
582 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, i, ByteOrder.nativeOrder());
583 intoByteBuffer(av, r, i, ByteOrder.nativeOrder());
584 }
585 }
586
587 int index = fi.apply(a.limit());
588 boolean shouldFail = isIndexOutOfBounds(SPECIES.vectorByteSize(), index, a.limit());
589 try {
590 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, 0, ByteOrder.nativeOrder());
591 intoByteBuffer(av, r, index, ByteOrder.nativeOrder());
592 if (shouldFail) {
593 Assert.fail("Failed to throw IndexOutOfBoundsException");
594 }
595 } catch (IndexOutOfBoundsException e) {
596 if (!shouldFail) {
597 Assert.fail("Unexpected IndexOutOfBoundsException");
598 }
599 }
600 }
601
602
603 @Test(dataProvider = "shortByteBufferMaskProvider")
604 static void loadStoreByteBufferMask(IntFunction<short[]> fa,
605 IntFunction<ByteBuffer> fb,
606 IntFunction<boolean[]> fm,
607 ByteOrder bo) {
608 short[] _a = fa.apply(SPECIES.length());
609 ByteBuffer a = toBuffer(_a, fb);
610 ByteBuffer r = fb.apply(a.limit());
611 boolean[] mask = fm.apply(SPECIES.length());
612 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
613
614 int l = a.limit();
615 int s = SPECIES.vectorByteSize();
616
617 for (int ic = 0; ic < INVOC_COUNT; ic++) {
618 for (int i = 0; i < l; i += s) {
619 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, i, bo, vmask);
620 av.intoByteBuffer(r, i, bo);
621 }
622 }
623 Assert.assertEquals(a.position(), 0, "Input buffer position changed");
624 Assert.assertEquals(a.limit(), l, "Input buffer limit changed");
625 Assert.assertEquals(r.position(), 0, "Result buffer position changed");
626 Assert.assertEquals(r.limit(), l, "Result buffer limit changed");
627 assertArraysEquals(bufferToArray(r), _a, mask);
628
629
630 r = fb.apply(a.limit());
631
632 for (int ic = 0; ic < INVOC_COUNT; ic++) {
633 for (int i = 0; i < l; i += s) {
634 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, i, bo);
635 av.intoByteBuffer(r, i, bo, vmask);
636 }
637 }
638 Assert.assertEquals(a.position(), 0, "Input buffer position changed");
639 Assert.assertEquals(a.limit(), l, "Input buffer limit changed");
640 Assert.assertEquals(r.position(), 0, "Result buffer position changed");
641 Assert.assertEquals(r.limit(), l, "Result buffer limit changed");
642 assertArraysEquals(bufferToArray(r), _a, mask);
643 }
644
645 @Test(dataProvider = "shortByteMaskProviderForIOOBE")
646 static void loadByteBufferMaskIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
647 ByteBuffer a = toBuffer(fa.apply(SPECIES.length()), ByteBuffer::allocateDirect);
648 ByteBuffer r = ByteBuffer.allocateDirect(a.limit());
649 boolean[] mask = fm.apply(SPECIES.length());
650 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
651
652 int l = a.limit();
653 int s = SPECIES.vectorByteSize();
654
655 for (int ic = 0; ic < INVOC_COUNT; ic++) {
656 for (int i = 0; i < l; i += s) {
657 ShortVector av = fromByteBuffer(a, i, ByteOrder.nativeOrder(), vmask);
658 av.intoByteBuffer(r, i, ByteOrder.nativeOrder());
659 }
660 }
661
662 int index = fi.apply(a.limit());
663 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.limit(), SPECIES.elementSize() / 8);
664 try {
665 fromByteBuffer(a, index, ByteOrder.nativeOrder(), vmask);
666 if (shouldFail) {
667 Assert.fail("Failed to throw IndexOutOfBoundsException");
668 }
669 } catch (IndexOutOfBoundsException e) {
670 if (!shouldFail) {
671 Assert.fail("Unexpected IndexOutOfBoundsException");
672 }
673 }
674 }
675
676 @Test(dataProvider = "shortByteMaskProviderForIOOBE")
677 static void storeByteBufferMaskIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
678 ByteBuffer a = toBuffer(fa.apply(SPECIES.length()), ByteBuffer::allocateDirect);
679 ByteBuffer r = ByteBuffer.allocateDirect(a.limit());
680 boolean[] mask = fm.apply(SPECIES.length());
681 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
682
683 int l = a.limit();
684 int s = SPECIES.vectorByteSize();
685
686 for (int ic = 0; ic < INVOC_COUNT; ic++) {
687 for (int i = 0; i < l; i += s) {
688 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, i, ByteOrder.nativeOrder());
689 intoByteBuffer(av, r, i, ByteOrder.nativeOrder(), vmask);
690 }
691 }
692
693 int index = fi.apply(a.limit());
694 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.limit(), SPECIES.elementSize() / 8);
695 try {
696 ShortVector av = ShortVector.fromByteBuffer(SPECIES, a, 0, ByteOrder.nativeOrder());
697 intoByteBuffer(av, a, index, ByteOrder.nativeOrder(), vmask);
698 if (shouldFail) {
699 Assert.fail("Failed to throw IndexOutOfBoundsException");
700 }
701 } catch (IndexOutOfBoundsException e) {
702 if (!shouldFail) {
703 Assert.fail("Unexpected IndexOutOfBoundsException");
704 }
705 }
706 }
707
708
709 @Test(dataProvider = "shortByteBufferProvider")
710 static void loadStoreReadonlyByteBuffer(IntFunction<short[]> fa,
711 IntFunction<ByteBuffer> fb,
712 ByteOrder bo) {
713 ByteBuffer a = toBuffer(fa.apply(SPECIES.length()), fb).asReadOnlyBuffer();
714
715 try {
716 SPECIES.zero().intoByteBuffer(a, 0, bo);
717 Assert.fail("ReadOnlyBufferException expected");
718 } catch (ReadOnlyBufferException e) {
719 }
720
721 try {
722 SPECIES.zero().intoByteBuffer(a, 0, bo, SPECIES.maskAll(true));
723 Assert.fail("ReadOnlyBufferException expected");
724 } catch (ReadOnlyBufferException e) {
725 }
726
727 try {
728 SPECIES.zero().intoByteBuffer(a, 0, bo, SPECIES.maskAll(false));
729 Assert.fail("ReadOnlyBufferException expected");
730 } catch (ReadOnlyBufferException e) {
731 }
732
733 try {
734 VectorMask<Short> m = SPECIES.shuffleFromOp(i -> i % 2 == 0 ? 1 : -1)
735 .laneIsValid();
736 SPECIES.zero().intoByteBuffer(a, 0, bo, m);
737 Assert.fail("ReadOnlyBufferException expected");
738 } catch (ReadOnlyBufferException e) {
739 }
740 }
741
742
743 @Test(dataProvider = "shortByteArrayProvider")
744 static void loadStoreByteArray(IntFunction<short[]> fa,
745 ByteOrder bo) {
746 byte[] a = toByteArray(fa.apply(SPECIES.length()), byte[]::new, bo);
747 byte[] r = new byte[a.length];
748
749 int s = SPECIES.vectorByteSize();
750 int l = a.length;
751
752 for (int ic = 0; ic < INVOC_COUNT; ic++) {
753 for (int i = 0; i < l; i += s) {
754 ShortVector av = ShortVector.fromByteArray(SPECIES, a, i, bo);
755 av.intoByteArray(r, i, bo);
756 }
757 }
758 Assert.assertEquals(r, a, "Byte arrays not equal");
759 }
760
761 @Test(dataProvider = "shortByteProviderForIOOBE")
762 static void loadByteArrayIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi) {
763 byte[] a = toByteArray(fa.apply(SPECIES.length()), byte[]::new, ByteOrder.nativeOrder());
764 byte[] r = new byte[a.length];
765
766 int s = SPECIES.vectorByteSize();
767 int l = a.length;
768
769 for (int ic = 0; ic < INVOC_COUNT; ic++) {
770 for (int i = 0; i < l; i += s) {
771 ShortVector av = fromByteArray(a, i, ByteOrder.nativeOrder());
772 av.intoByteArray(r, i, ByteOrder.nativeOrder());
773 }
774 }
775
776 int index = fi.apply(a.length);
777 boolean shouldFail = isIndexOutOfBounds(SPECIES.vectorByteSize(), index, a.length);
778 try {
779 fromByteArray(a, index, ByteOrder.nativeOrder());
780 if (shouldFail) {
781 Assert.fail("Failed to throw IndexOutOfBoundsException");
782 }
783 } catch (IndexOutOfBoundsException e) {
784 if (!shouldFail) {
785 Assert.fail("Unexpected IndexOutOfBoundsException");
786 }
787 }
788 }
789
790 @Test(dataProvider = "shortByteProviderForIOOBE")
791 static void storeByteArrayIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi) {
792 byte[] a = toByteArray(fa.apply(SPECIES.length()), byte[]::new, ByteOrder.nativeOrder());
793 byte[] r = new byte[a.length];
794
795 int s = SPECIES.vectorByteSize();
796 int l = a.length;
797
798 for (int ic = 0; ic < INVOC_COUNT; ic++) {
799 for (int i = 0; i < l; i += s) {
800 ShortVector av = ShortVector.fromByteArray(SPECIES, a, i, ByteOrder.nativeOrder());
801 intoByteArray(av, r, i, ByteOrder.nativeOrder());
802 }
803 }
804
805 int index = fi.apply(a.length);
806 boolean shouldFail = isIndexOutOfBounds(SPECIES.vectorByteSize(), index, a.length);
807 try {
808 ShortVector av = ShortVector.fromByteArray(SPECIES, a, 0, ByteOrder.nativeOrder());
809 intoByteArray(av, r, index, ByteOrder.nativeOrder());
810 if (shouldFail) {
811 Assert.fail("Failed to throw IndexOutOfBoundsException");
812 }
813 } catch (IndexOutOfBoundsException e) {
814 if (!shouldFail) {
815 Assert.fail("Unexpected IndexOutOfBoundsException");
816 }
817 }
818 }
819
820
821 @Test(dataProvider = "shortByteArrayMaskProvider")
822 static void loadStoreByteArrayMask(IntFunction<short[]> fa,
823 IntFunction<boolean[]> fm,
824 ByteOrder bo) {
825 byte[] a = toByteArray(fa.apply(SPECIES.length()), byte[]::new, bo);
826 byte[] r = new byte[a.length];
827 boolean[] mask = fm.apply(SPECIES.length());
828 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
829
830 int s = SPECIES.vectorByteSize();
831 int l = a.length;
832
833 for (int ic = 0; ic < INVOC_COUNT; ic++) {
834 for (int i = 0; i < l; i += s) {
835 ShortVector av = ShortVector.fromByteArray(SPECIES, a, i, bo, vmask);
836 av.intoByteArray(r, i, bo);
837 }
838 }
839 assertArraysEquals(r, a, mask);
840
841
842 r = new byte[a.length];
843
844 for (int ic = 0; ic < INVOC_COUNT; ic++) {
845 for (int i = 0; i < l; i += s) {
846 ShortVector av = ShortVector.fromByteArray(SPECIES, a, i, bo);
847 av.intoByteArray(r, i, bo, vmask);
848 }
849 }
850 assertArraysEquals(r, a, mask);
851 }
852
853 @Test(dataProvider = "shortByteMaskProviderForIOOBE")
854 static void loadByteArrayMaskIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
855 byte[] a = toByteArray(fa.apply(SPECIES.length()), byte[]::new, ByteOrder.nativeOrder());
856 byte[] r = new byte[a.length];
857 boolean[] mask = fm.apply(SPECIES.length());
858 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
859
860 int s = SPECIES.vectorByteSize();
861 int l = a.length;
862
863 for (int ic = 0; ic < INVOC_COUNT; ic++) {
864 for (int i = 0; i < l; i += s) {
865 ShortVector av = fromByteArray(a, i, ByteOrder.nativeOrder(), vmask);
866 av.intoByteArray(r, i, ByteOrder.nativeOrder());
867 }
868 }
869
870 int index = fi.apply(a.length);
871 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length, SPECIES.elementSize() / 8);
872 try {
873 fromByteArray(a, index, ByteOrder.nativeOrder(), vmask);
874 if (shouldFail) {
875 Assert.fail("Failed to throw IndexOutOfBoundsException");
876 }
877 } catch (IndexOutOfBoundsException e) {
878 if (!shouldFail) {
879 Assert.fail("Unexpected IndexOutOfBoundsException");
880 }
881 }
882 }
883
884 @Test(dataProvider = "shortByteMaskProviderForIOOBE")
885 static void storeByteArrayMaskIOOBE(IntFunction<short[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
886 byte[] a = toByteArray(fa.apply(SPECIES.length()), byte[]::new, ByteOrder.nativeOrder());
887 byte[] r = new byte[a.length];
888 boolean[] mask = fm.apply(SPECIES.length());
889 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
890
891 int s = SPECIES.vectorByteSize();
892 int l = a.length;
893
894 for (int ic = 0; ic < INVOC_COUNT; ic++) {
895 for (int i = 0; i < l; i += s) {
896 ShortVector av = ShortVector.fromByteArray(SPECIES, a, i, ByteOrder.nativeOrder());
897 intoByteArray(av, r, i, ByteOrder.nativeOrder(), vmask);
898 }
899 }
900
901 int index = fi.apply(a.length);
902 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length, SPECIES.elementSize() / 8);
903 try {
904 ShortVector av = ShortVector.fromByteArray(SPECIES, a, 0, ByteOrder.nativeOrder());
905 intoByteArray(av, a, index, ByteOrder.nativeOrder(), vmask);
906 if (shouldFail) {
907 Assert.fail("Failed to throw IndexOutOfBoundsException");
908 }
909 } catch (IndexOutOfBoundsException e) {
910 if (!shouldFail) {
911 Assert.fail("Unexpected IndexOutOfBoundsException");
912 }
913 }
914 }
915
916 @Test(dataProvider = "maskProvider")
917 static void loadStoreMask(IntFunction<boolean[]> fm) {
918 boolean[] a = fm.apply(SPECIES.length());
919 boolean[] r = new boolean[a.length];
920
921 for (int ic = 0; ic < INVOC_COUNT; ic++) {
922 for (int i = 0; i < a.length; i += SPECIES.length()) {
923 VectorMask<Short> vmask = SPECIES.loadMask(a, i);
924 vmask.intoArray(r, i);
925 }
926 }
927 Assert.assertEquals(r, a);
928 }
929
930 @Test
931 static void loadStoreShuffle() {
932 IntUnaryOperator fn = a -> a + 5;
933 for (int ic = 0; ic < INVOC_COUNT; ic++) {
934 var shuffle = VectorShuffle.fromOp(SPECIES, fn);
935 int [] r = shuffle.toArray();
936
937 int [] a = expectedShuffle(SPECIES.length(), fn);
938 Assert.assertEquals(r, a);
939 }
940 }
941
942
943 static void assertArraysEquals(char[] a, char[] r, boolean[] mask) {
944 int i = 0;
945 try {
946 for (; i < a.length; i++) {
947 Assert.assertEquals(mask[i % SPECIES.length()] ? a[i] : (char) 0, r[i]);
948 }
949 } catch (AssertionError e) {
950 Assert.assertEquals(mask[i % SPECIES.length()] ? a[i] : (char) 0, r[i], "at index #" + i);
951 }
952 }
953
954 static final List<IntFunction<char[]>> CHAR_GENERATORS = List.of(
955 withToString("char[i * 5]", (int s) -> {
956 return fillChar(s * BUFFER_REPS,
957 i -> (char)(i * 5));
958 }),
959 withToString("char[i + 1]", (int s) -> {
960 return fillChar(s * BUFFER_REPS,
961 i -> (((char)(i + 1) == 0) ? 1 : (char)(i + 1)));
962 })
963 );
964
965 @DataProvider
966 public Object[][] charProvider() {
967 return CHAR_GENERATORS.stream().
968 map(f -> new Object[]{f}).
969 toArray(Object[][]::new);
970 }
971
972 @DataProvider
973 public Object[][] charProviderForIOOBE() {
974 var f = CHAR_GENERATORS.get(0);
975 return INDEX_GENERATORS.stream().map(fi -> {
976 return new Object[] {f, fi};
977 }).
978 toArray(Object[][]::new);
979 }
980
981 @DataProvider
982 public Object[][] charMaskProvider() {
983 return BOOLEAN_MASK_GENERATORS.stream().
984 flatMap(fm -> CHAR_GENERATORS.stream().map(fa -> {
985 return new Object[] {fa, fm};
986 })).
987 toArray(Object[][]::new);
988 }
989
990 @DataProvider
991 public Object[][] charMaskProviderForIOOBE() {
992 var f = CHAR_GENERATORS.get(0);
993 return BOOLEAN_MASK_GENERATORS.stream().
994 flatMap(fm -> INDEX_GENERATORS.stream().map(fi -> {
995 return new Object[] {f, fi, fm};
996 })).
997 toArray(Object[][]::new);
998 }
999
1000 interface ToCharF {
1001 char apply(int i);
1002 }
1003
1004 static char[] fillChar(int s , ToCharF f) {
1005 return fillChar(new char[s], f);
1006 }
1007
1008 static char[] fillChar(char[] a, ToCharF f) {
1009 for (int i = 0; i < a.length; i++) {
1010 a[i] = f.apply(i);
1011 }
1012 return a;
1013 }
1014
1015 @DontInline
1016 static ShortVector fromCharArray(char[] a, int i) {
1017 return ShortVector.fromCharArray(SPECIES, a, i);
1018 }
1019
1020 @DontInline
1021 static ShortVector fromCharArray(char[] a, int i, VectorMask<Short> m) {
1022 return ShortVector.fromCharArray(SPECIES, a, i, m);
1023 }
1024
1025 @DontInline
1026 static void intoCharArray(ShortVector v, char[] a, int i) {
1027 v.intoCharArray(a, i);
1028 }
1029
1030 @DontInline
1031 static void intoCharArray(ShortVector v, char[] a, int i, VectorMask<Short> m) {
1032 v.intoCharArray(a, i, m);
1033 }
1034
1035 @Test(dataProvider = "charProvider")
1036 static void loadStoreCharArray(IntFunction<char[]> fa) {
1037 char[] a = fa.apply(SPECIES.length());
1038 char[] r = new char[a.length];
1039
1040 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1041 for (int i = 0; i < a.length; i += SPECIES.length()) {
1042 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i);
1043 av.intoCharArray(r, i);
1044 }
1045 }
1046 Assert.assertEquals(a, r);
1047 }
1048
1049 @Test(dataProvider = "charProviderForIOOBE")
1050 static void loadCharArrayIOOBE(IntFunction<char[]> fa, IntFunction<Integer> fi) {
1051 char[] a = fa.apply(SPECIES.length());
1052 char[] r = new char[a.length];
1053
1054 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1055 for (int i = 0; i < a.length; i += SPECIES.length()) {
1056 ShortVector av = fromCharArray(a, i);
1057 av.intoCharArray(r, i);
1058 }
1059 }
1060
1061 int index = fi.apply(a.length);
1062 boolean shouldFail = isIndexOutOfBounds(SPECIES.length(), index, a.length);
1063 try {
1064 fromCharArray(a, index);
1065 if (shouldFail) {
1066 Assert.fail("Failed to throw IndexOutOfBoundsException");
1067 }
1068 } catch (IndexOutOfBoundsException e) {
1069 if (!shouldFail) {
1070 Assert.fail("Unexpected IndexOutOfBoundsException");
1071 }
1072 }
1073 }
1074
1075 @Test(dataProvider = "charProviderForIOOBE")
1076 static void storeCharArrayIOOBE(IntFunction<char[]> fa, IntFunction<Integer> fi) {
1077 char[] a = fa.apply(SPECIES.length());
1078 char[] r = new char[a.length];
1079
1080 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1081 for (int i = 0; i < a.length; i += SPECIES.length()) {
1082 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i);
1083 intoCharArray(av, r, i);
1084 }
1085 }
1086
1087 int index = fi.apply(a.length);
1088 boolean shouldFail = isIndexOutOfBounds(SPECIES.length(), index, a.length);
1089 try {
1090 ShortVector av = ShortVector.fromCharArray(SPECIES, a, 0);
1091 intoCharArray(av, r, index);
1092 if (shouldFail) {
1093 Assert.fail("Failed to throw IndexOutOfBoundsException");
1094 }
1095 } catch (IndexOutOfBoundsException e) {
1096 if (!shouldFail) {
1097 Assert.fail("Unexpected IndexOutOfBoundsException");
1098 }
1099 }
1100 }
1101
1102 @Test(dataProvider = "charMaskProvider")
1103 static void loadStoreMaskCharArray(IntFunction<char[]> fa,
1104 IntFunction<boolean[]> fm) {
1105 char[] a = fa.apply(SPECIES.length());
1106 char[] r = new char[a.length];
1107 boolean[] mask = fm.apply(SPECIES.length());
1108 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
1109
1110 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1111 for (int i = 0; i < a.length; i += SPECIES.length()) {
1112 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i, vmask);
1113 av.intoCharArray(r, i);
1114 }
1115 }
1116 assertArraysEquals(a, r, mask);
1117
1118
1119 r = new char[a.length];
1120
1121 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1122 for (int i = 0; i < a.length; i += SPECIES.length()) {
1123 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i);
1124 av.intoCharArray(r, i, vmask);
1125 }
1126 }
1127 assertArraysEquals(a, r, mask);
1128 }
1129
1130 @Test(dataProvider = "charMaskProviderForIOOBE")
1131 static void loadCharArrayMaskIOOBE(IntFunction<char[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
1132 char[] a = fa.apply(SPECIES.length());
1133 char[] r = new char[a.length];
1134 boolean[] mask = fm.apply(SPECIES.length());
1135 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
1136
1137 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1138 for (int i = 0; i < a.length; i += SPECIES.length()) {
1139 ShortVector av = fromCharArray(a, i, vmask);
1140 av.intoCharArray(r, i);
1141 }
1142 }
1143
1144 int index = fi.apply(a.length);
1145 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length);
1146 try {
1147 fromCharArray(a, index, vmask);
1148 if (shouldFail) {
1149 Assert.fail("Failed to throw IndexOutOfBoundsException");
1150 }
1151 } catch (IndexOutOfBoundsException e) {
1152 if (!shouldFail) {
1153 Assert.fail("Unexpected IndexOutOfBoundsException");
1154 }
1155 }
1156 }
1157
1158 @Test(dataProvider = "charMaskProviderForIOOBE")
1159 static void storeCharArrayMaskIOOBE(IntFunction<char[]> fa, IntFunction<Integer> fi, IntFunction<boolean[]> fm) {
1160 char[] a = fa.apply(SPECIES.length());
1161 char[] r = new char[a.length];
1162 boolean[] mask = fm.apply(SPECIES.length());
1163 VectorMask<Short> vmask = VectorMask.fromValues(SPECIES, mask);
1164
1165 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1166 for (int i = 0; i < a.length; i += SPECIES.length()) {
1167 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i);
1168 intoCharArray(av, r, i, vmask);
1169 }
1170 }
1171
1172 int index = fi.apply(a.length);
1173 boolean shouldFail = isIndexOutOfBoundsForMask(mask, index, a.length);
1174 try {
1175 ShortVector av = ShortVector.fromCharArray(SPECIES, a, 0);
1176 intoCharArray(av, a, index, vmask);
1177 if (shouldFail) {
1178 Assert.fail("Failed to throw IndexOutOfBoundsException");
1179 }
1180 } catch (IndexOutOfBoundsException e) {
1181 if (!shouldFail) {
1182 Assert.fail("Unexpected IndexOutOfBoundsException");
1183 }
1184 }
1185 }
1186
1187
1188
1189
1190 // Gather/Scatter load/store tests
1191
1192 static void assertGatherArraysEquals(short[] r, short[] a, int[] indexMap) {
1193 int i = 0;
1194 int j = 0;
1195 try {
1196 for (; i < a.length; i += SPECIES.length()) {
1197 j = i;
1198 for (; j < i + SPECIES.length(); j++) {
1199 Assert.assertEquals(r[j], a[i + indexMap[j]]);
1200 }
1201 }
1202 } catch (AssertionError e) {
1203 Assert.assertEquals(r[j], a[i + indexMap[j]], "at index #" + j);
1204 }
1205 }
1206
1207 static void assertGatherArraysEquals(short[] r, short[] a, int[] indexMap, boolean[] mask) {
1208 int i = 0;
1209 int j = 0;
1210 try {
1211 for (; i < a.length; i += SPECIES.length()) {
1212 j = i;
1213 for (; j < i + SPECIES.length(); j++) {
1214 Assert.assertEquals(r[j], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (short) 0);
1215 }
1216 }
1217 } catch (AssertionError e) {
1218 Assert.assertEquals(r[i], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (short) 0, "at index #" + j);
1219 }
1220 }
1221
1222 static void assertScatterArraysEquals(short[] r, short[] a, int[] indexMap, boolean[] mask) {
1223 short[] expected = new short[r.length];
1224
1225 // Store before checking, since the same location may be stored to more than once
1226 for (int i = 0; i < a.length; i += SPECIES.length()) {
1227 for (int j = i; j < i + SPECIES.length(); j++) {
1228 if (mask[j % SPECIES.length()]) {
1229 expected[i + indexMap[j]] = a[j];
1230 }
1231 }
1232 }
1233
1234 Assert.assertEquals(r, expected);
1235 }
1236
1237 static void assertScatterArraysEquals(short[] r, short[] a, int[] indexMap) {
1238 short[] expected = new short[r.length];
1239
1240 // Store before checking, since the same location may be stored to more than once
1241 for (int i = 0; i < a.length; i += SPECIES.length()) {
1242 for (int j = i; j < i + SPECIES.length(); j++) {
1243 expected[i + indexMap[j]] = a[j];
1244 }
1245 }
1246
1247 Assert.assertEquals(r, expected);
1248 }
1249
1250 @DataProvider
1251 public Object[][] gatherScatterProvider() {
1252 return INT_INDEX_GENERATORS.stream().
1253 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1254 return new Object[] {fa, fs};
1255 })).
1256 toArray(Object[][]::new);
1257 }
1258
1259 @DataProvider
1260 public Object[][] gatherScatterMaskProvider() {
1261 return BOOLEAN_MASK_GENERATORS.stream().
1262 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
1263 SHORT_GENERATORS.stream().map(fa -> {
1264 return new Object[] {fa, fm, fs};
1265 }))).
1266 toArray(Object[][]::new);
1267 }
1268
1269
1270 @Test(dataProvider = "gatherScatterProvider")
1271 static void gather(IntFunction<short[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1272 short[] a = fa.apply(SPECIES.length());
1273 int[] b = fs.apply(a.length, SPECIES.length());
1274 short[] r = new short[a.length];
1275
1276 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1277 for (int i = 0; i < a.length; i += SPECIES.length()) {
1278 ShortVector av = ShortVector.fromArray(SPECIES, a, i, b, i);
1279 av.intoArray(r, i);
1280 }
1281 }
1282
1283 assertGatherArraysEquals(r, a, b);
1284 }
1285
1286 @Test(dataProvider = "gatherScatterMaskProvider")
1287 static void gatherMask(IntFunction<short[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
1288 short[] a = fa.apply(SPECIES.length());
1289 int[] b = fs.apply(a.length, SPECIES.length());
1290 short[] r = new short[a.length];
1291 boolean[] mask = fm.apply(SPECIES.length());
1292 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1293
1294 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1295 for (int i = 0; i < a.length; i += SPECIES.length()) {
1296 ShortVector av = ShortVector.fromArray(SPECIES, a, i, b, i, vmask);
1297 av.intoArray(r, i);
1298 }
1299 }
1300
1301 assertGatherArraysEquals(r, a, b, mask);
1302 }
1303
1304 @Test(dataProvider = "gatherScatterProvider")
1305 static void scatter(IntFunction<short[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1306 short[] a = fa.apply(SPECIES.length());
1307 int[] b = fs.apply(a.length, SPECIES.length());
1308 short[] r = new short[a.length];
1309
1310 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1311 for (int i = 0; i < a.length; i += SPECIES.length()) {
1312 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1313 av.intoArray(r, i, b, i);
1314 }
1315 }
1316
1317 assertScatterArraysEquals(r, a, b);
1318 }
1319
1320 @Test(dataProvider = "gatherScatterMaskProvider")
1321 static void scatterMask(IntFunction<short[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
1322 short[] a = fa.apply(SPECIES.length());
1323 int[] b = fs.apply(a.length, SPECIES.length());
1324 short[] r = new short[a.length];
1325 boolean[] mask = fm.apply(SPECIES.length());
1326 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1327
1328 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1329 for (int i = 0; i < a.length; i += SPECIES.length()) {
1330 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1331 av.intoArray(r, i, b, i, vmask);
1332 }
1333 }
1334
1335 assertScatterArraysEquals(r, a, b, mask);
1336 }
1337
1338 static void assertGatherArraysEquals(char[] r, char[] a, int[] indexMap) {
1339 int i = 0;
1340 int j = 0;
1341 try {
1342 for (; i < a.length; i += SPECIES.length()) {
1343 j = i;
1344 for (; j < i + SPECIES.length(); j++) {
1345 Assert.assertEquals(r[j], a[i + indexMap[j]]);
1346 }
1347 }
1348 } catch (AssertionError e) {
1349 Assert.assertEquals(r[j], a[i + indexMap[j]], "at index #" + j);
1350 }
1351 }
1352
1353 static void assertGatherArraysEquals(char[] r, char[] a, int[] indexMap, boolean[] mask) {
1354 int i = 0;
1355 int j = 0;
1356 try {
1357 for (; i < a.length; i += SPECIES.length()) {
1358 j = i;
1359 for (; j < i + SPECIES.length(); j++) {
1360 Assert.assertEquals(r[j], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (char) 0);
1361 }
1362 }
1363 } catch (AssertionError e) {
1364 Assert.assertEquals(r[i], mask[j % SPECIES.length()] ? a[i + indexMap[j]]: (char) 0, "at index #" + j);
1365 }
1366 }
1367
1368 static void assertScatterArraysEquals(char[] r, char[] a, int[] indexMap, boolean[] mask) {
1369 char[] expected = new char[r.length];
1370
1371 // Store before checking, since the same location may be stored to more than once
1372 for (int i = 0; i < a.length; i += SPECIES.length()) {
1373 for (int j = i; j < i + SPECIES.length(); j++) {
1374 if (mask[j % SPECIES.length()]) {
1375 expected[i + indexMap[j]] = a[j];
1376 }
1377 }
1378 }
1379
1380 Assert.assertEquals(r, expected);
1381 }
1382
1383 static void assertScatterArraysEquals(char[] r, char[] a, int[] indexMap) {
1384 char[] expected = new char[r.length];
1385
1386 // Store before checking, since the same location may be stored to more than once
1387 for (int i = 0; i < a.length; i += SPECIES.length()) {
1388 for (int j = i; j < i + SPECIES.length(); j++) {
1389 expected[i + indexMap[j]] = a[j];
1390 }
1391 }
1392
1393 Assert.assertEquals(r, expected);
1394 }
1395
1396 @DataProvider
1397 public Object[][] charGatherScatterProvider() {
1398 return INT_INDEX_GENERATORS.stream().
1399 flatMap(fs -> CHAR_GENERATORS.stream().map(fa -> {
1400 return new Object[] {fa, fs};
1401 })).
1402 toArray(Object[][]::new);
1403 }
1404
1405 @DataProvider
1406 public Object[][] charGatherScatterMaskProvider() {
1407 return BOOLEAN_MASK_GENERATORS.stream().
1408 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
1409 CHAR_GENERATORS.stream().map(fa -> {
1410 return new Object[] {fa, fm, fs};
1411 }))).
1412 toArray(Object[][]::new);
1413 }
1414
1415
1416 @Test(dataProvider = "charGatherScatterProvider")
1417 static void charGather(IntFunction<char[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1418 char[] a = fa.apply(SPECIES.length());
1419 int[] b = fs.apply(a.length, SPECIES.length());
1420 char[] r = new char[a.length];
1421
1422 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1423 for (int i = 0; i < a.length; i += SPECIES.length()) {
1424 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i, b, i);
1425 av.intoCharArray(r, i);
1426 }
1427 }
1428
1429 assertGatherArraysEquals(r, a, b);
1430 }
1431
1432 @Test(dataProvider = "charGatherScatterMaskProvider")
1433 static void charGatherMask(IntFunction<char[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
1434 char[] a = fa.apply(SPECIES.length());
1435 int[] b = fs.apply(a.length, SPECIES.length());
1436 char[] r = new char[a.length];
1437 boolean[] mask = fm.apply(SPECIES.length());
1438 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1439
1440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1441 for (int i = 0; i < a.length; i += SPECIES.length()) {
1442 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i, b, i, vmask);
1443 av.intoCharArray(r, i);
1444 }
1445 }
1446
1447 assertGatherArraysEquals(r, a, b, mask);
1448 }
1449
1450 @Test(dataProvider = "charGatherScatterProvider")
1451 static void charScatter(IntFunction<char[]> fa, BiFunction<Integer,Integer,int[]> fs) {
1452 char[] a = fa.apply(SPECIES.length());
1453 int[] b = fs.apply(a.length, SPECIES.length());
1454 char[] r = new char[a.length];
1455
1456 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1457 for (int i = 0; i < a.length; i += SPECIES.length()) {
1458 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i);
1459 av.intoCharArray(r, i, b, i);
1460 }
1461 }
1462
1463 assertScatterArraysEquals(r, a, b);
1464 }
1465
1466 @Test(dataProvider = "charGatherScatterMaskProvider")
1467 static void charScatterMask(IntFunction<char[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
1468 char[] a = fa.apply(SPECIES.length());
1469 int[] b = fs.apply(a.length, SPECIES.length());
1470 char[] r = new char[a.length];
1471 boolean[] mask = fm.apply(SPECIES.length());
1472 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1473
1474 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1475 for (int i = 0; i < a.length; i += SPECIES.length()) {
1476 ShortVector av = ShortVector.fromCharArray(SPECIES, a, i);
1477 av.intoCharArray(r, i, b, i, vmask);
1478 }
1479 }
1480
1481 assertScatterArraysEquals(r, a, b, mask);
1482 }
1483
1484
1485 }