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