1 import jdk.incubator.vector.*;
2 import jdk.internal.vm.annotation.ForceInline;
3 import org.testng.Assert;
4 import org.testng.annotations.Test;
5 import org.testng.annotations.DataProvider;
6
7 import java.util.Arrays;
8 import java.util.List;
9 import java.util.function.IntFunction;
10
11 /**
12 * @test
13 * @modules jdk.incubator.vector
14 * @modules java.base/jdk.internal.vm.annotation
15 * @run testng VectorReshapeTests
16 */
17
18 @Test
19 public class VectorReshapeTests {
20 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
21 static final int NUM_ITER = 200 * INVOC_COUNT;
22
23 static final IntVector.IntSpecies<Shapes.S64Bit> ispec64 = IntVector.speciesInstance(Shapes.S_64_BIT);
24 static final FloatVector.FloatSpecies<Shapes.S64Bit> fspec64 = FloatVector.speciesInstance(Shapes.S_64_BIT);
25 static final LongVector.LongSpecies<Shapes.S64Bit> lspec64 = LongVector.speciesInstance(Shapes.S_64_BIT);
26 static final DoubleVector.DoubleSpecies<Shapes.S64Bit> dspec64 = DoubleVector.speciesInstance(Shapes.S_64_BIT);
27 static final ByteVector.ByteSpecies<Shapes.S64Bit> bspec64 = ByteVector.speciesInstance(Shapes.S_64_BIT);
28 static final ShortVector.ShortSpecies<Shapes.S64Bit> sspec64 = ShortVector.speciesInstance(Shapes.S_64_BIT);
29
30 static final IntVector.IntSpecies<Shapes.S128Bit> ispec128 = IntVector.speciesInstance(Shapes.S_128_BIT);
31 static final FloatVector.FloatSpecies<Shapes.S128Bit> fspec128 = FloatVector.speciesInstance(Shapes.S_128_BIT);
32 static final LongVector.LongSpecies<Shapes.S128Bit> lspec128 = LongVector.speciesInstance(Shapes.S_128_BIT);
33 static final DoubleVector.DoubleSpecies<Shapes.S128Bit> dspec128 = DoubleVector.speciesInstance(Shapes.S_128_BIT);
34 static final ByteVector.ByteSpecies<Shapes.S128Bit> bspec128 = ByteVector.speciesInstance(Shapes.S_128_BIT);
35 static final ShortVector.ShortSpecies<Shapes.S128Bit> sspec128 = ShortVector.speciesInstance(Shapes.S_128_BIT);
36
37 static final IntVector.IntSpecies<Shapes.S256Bit> ispec256 = IntVector.speciesInstance(Shapes.S_256_BIT);
38 static final FloatVector.FloatSpecies<Shapes.S256Bit> fspec256 = FloatVector.speciesInstance(Shapes.S_256_BIT);
39 static final LongVector.LongSpecies<Shapes.S256Bit> lspec256 = LongVector.speciesInstance(Shapes.S_256_BIT);
40 static final DoubleVector.DoubleSpecies<Shapes.S256Bit> dspec256 = DoubleVector.speciesInstance(Shapes.S_256_BIT);
41 static final ByteVector.ByteSpecies<Shapes.S256Bit> bspec256 = ByteVector.speciesInstance(Shapes.S_256_BIT);
42 static final ShortVector.ShortSpecies<Shapes.S256Bit> sspec256 = ShortVector.speciesInstance(Shapes.S_256_BIT);
43
44 static final IntVector.IntSpecies<Shapes.S512Bit> ispec512 = IntVector.speciesInstance(Shapes.S_512_BIT);
45 static final FloatVector.FloatSpecies<Shapes.S512Bit> fspec512 = FloatVector.speciesInstance(Shapes.S_512_BIT);
46 static final LongVector.LongSpecies<Shapes.S512Bit> lspec512 = LongVector.speciesInstance(Shapes.S_512_BIT);
47 static final DoubleVector.DoubleSpecies<Shapes.S512Bit> dspec512 = DoubleVector.speciesInstance(Shapes.S_512_BIT);
48 static final ByteVector.ByteSpecies<Shapes.S512Bit> bspec512 = ByteVector.speciesInstance(Shapes.S_512_BIT);
49 static final ShortVector.ShortSpecies<Shapes.S512Bit> sspec512 = ShortVector.speciesInstance(Shapes.S_512_BIT);
50
51 static <T> IntFunction<T> withToString(String s, IntFunction<T> f) {
52 return new IntFunction<T>() {
53 @Override
54 public T apply(int v) {
55 return f.apply(v);
56 }
57
58 @Override
59 public String toString() {
60 return s;
61 }
62 };
63 }
64
65 interface ToByteF {
66 byte apply(int i);
67 }
68
69 static byte[] fill_byte(int s , ToByteF f) {
70 return fill_byte(new byte[s], f);
71 }
72
73 static byte[] fill_byte(byte[] a, ToByteF f) {
74 for (int i = 0; i < a.length; i++) {
75 a[i] = f.apply(i);
76 }
77 return a;
78 }
79
80 interface ToBoolF {
81 boolean apply(int i);
82 }
83
84 static boolean[] fill_bool(int s , ToBoolF f) {
85 return fill_bool(new boolean[s], f);
86 }
87
88 static boolean[] fill_bool(boolean[] a, ToBoolF f) {
89 for (int i = 0; i < a.length; i++) {
90 a[i] = f.apply(i);
91 }
92 return a;
93 }
94
95 static final List<IntFunction<byte[]>> BYTE_GENERATORS = List.of(
96 withToString("byte(i)", (int s) -> {
97 return fill_byte(s, i -> (byte)i);
98 })
99 );
100
101 @DataProvider
102 public Object[][] byteUnaryOpProvider() {
103 return BYTE_GENERATORS.stream().
104 map(f -> new Object[]{f}).
105 toArray(Object[][]::new);
106 }
107
108 static final List<IntFunction<boolean[]>> BOOL_GENERATORS = List.of(
109 withToString("boolean(i%3)", (int s) -> {
110 return fill_bool(s, i -> i % 3 == 0);
111 })
112 );
113
114 @DataProvider
115 public Object[][] booleanUnaryOpProvider() {
116 return BOOL_GENERATORS.stream().
117 map(f -> new Object[]{f}).
118 toArray(Object[][]::new);
119 }
120
121 @ForceInline
122 static <E,S extends Vector.Shape,T extends Vector.Shape>
123 void testVectorResize(Vector.Species<E,S> a, Vector.Species<E,T> b, byte[] input, byte[] output) {
124 Vector<E, S> av = a.fromByteArray(input, 0);
125 Vector<E, T> bv = b.resize(av);
126 bv.intoByteArray(output, 0);
127
128 byte[] expected = Arrays.copyOf(input, output.length);
129
130
131 Assert.assertEquals(expected, output);
132 }
133
134 @Test(dataProvider = "byteUnaryOpProvider")
135 static void testResizeByte(IntFunction<byte[]> fa) {
136 byte[] bin64 = fa.apply(64/Byte.SIZE);
137 byte[] bin128 = fa.apply(128/Byte.SIZE);
138 byte[] bin256 = fa.apply(256/Byte.SIZE);
139 byte[] bin512 = fa.apply(512/Byte.SIZE);
140 byte[] bout64 = new byte[bin64.length];
141 byte[] bout128 = new byte[bin128.length];
142 byte[] bout256 = new byte[bin256.length];
143 byte[] bout512 = new byte[bin512.length];
144
145 for (int i = 0; i < NUM_ITER; i++) {
146 testVectorResize(bspec64, bspec64, bin64, bout64);
147 testVectorResize(bspec64, bspec128, bin64, bout128);
148 testVectorResize(bspec64, bspec256, bin64, bout256);
149 testVectorResize(bspec64, bspec512, bin64, bout512);
150
151 testVectorResize(bspec128, bspec64, bin128, bout64);
152 testVectorResize(bspec128, bspec128, bin128, bout128);
153 testVectorResize(bspec128, bspec256, bin128, bout256);
154 testVectorResize(bspec128, bspec512, bin128, bout512);
155
156 testVectorResize(bspec256, bspec64, bin256, bout64);
157 testVectorResize(bspec256, bspec128, bin256, bout128);
158 testVectorResize(bspec256, bspec256, bin256, bout256);
159 testVectorResize(bspec256, bspec512, bin256, bout512);
160
161 testVectorResize(bspec512, bspec64, bin512, bout64);
162 testVectorResize(bspec512, bspec128, bin512, bout128);
163 testVectorResize(bspec512, bspec256, bin512, bout256);
164 testVectorResize(bspec512, bspec512, bin512, bout512);
165 }
166 }
167
168 @Test(dataProvider = "byteUnaryOpProvider")
169 static void testResizeShort(IntFunction<byte[]> fa) {
170 byte[] bin64 = fa.apply(64/Byte.SIZE);
171 byte[] bin128 = fa.apply(128/Byte.SIZE);
172 byte[] bin256 = fa.apply(256/Byte.SIZE);
173 byte[] bin512 = fa.apply(512/Byte.SIZE);
174 byte[] bout64 = new byte[bin64.length];
175 byte[] bout128 = new byte[bin128.length];
176 byte[] bout256 = new byte[bin256.length];
177 byte[] bout512 = new byte[bin512.length];
178
179 for (int i = 0; i < NUM_ITER; i++) {
180 testVectorResize(sspec64, sspec64, bin64, bout64);
181 testVectorResize(sspec64, sspec128, bin64, bout128);
182 testVectorResize(sspec64, sspec256, bin64, bout256);
183 testVectorResize(sspec64, sspec512, bin64, bout512);
184
185 testVectorResize(sspec128, sspec64, bin128, bout64);
186 testVectorResize(sspec128, sspec128, bin128, bout128);
187 testVectorResize(sspec128, sspec256, bin128, bout256);
188 testVectorResize(sspec128, sspec512, bin128, bout512);
189
190 testVectorResize(sspec256, sspec64, bin256, bout64);
191 testVectorResize(sspec256, sspec128, bin256, bout128);
192 testVectorResize(sspec256, sspec256, bin256, bout256);
193 testVectorResize(sspec256, sspec512, bin256, bout512);
194
195 testVectorResize(sspec512, sspec64, bin512, bout64);
196 testVectorResize(sspec512, sspec128, bin512, bout128);
197 testVectorResize(sspec512, sspec256, bin512, bout256);
198 testVectorResize(sspec512, sspec512, bin512, bout512);
199 }
200 }
201
202 @Test(dataProvider = "byteUnaryOpProvider")
203 static void testResizeInt(IntFunction<byte[]> fa) {
204 byte[] bin64 = fa.apply(64/Byte.SIZE);
205 byte[] bin128 = fa.apply(128/Byte.SIZE);
206 byte[] bin256 = fa.apply(256/Byte.SIZE);
207 byte[] bin512 = fa.apply(512/Byte.SIZE);
208 byte[] bout64 = new byte[bin64.length];
209 byte[] bout128 = new byte[bin128.length];
210 byte[] bout256 = new byte[bin256.length];
211 byte[] bout512 = new byte[bin512.length];
212
213 for (int i = 0; i < NUM_ITER; i++) {
214 testVectorResize(ispec64, ispec64, bin64, bout64);
215 testVectorResize(ispec64, ispec128, bin64, bout128);
216 testVectorResize(ispec64, ispec256, bin64, bout256);
217 testVectorResize(ispec64, ispec512, bin64, bout512);
218
219 testVectorResize(ispec128, ispec64, bin128, bout64);
220 testVectorResize(ispec128, ispec128, bin128, bout128);
221 testVectorResize(ispec128, ispec256, bin128, bout256);
222 testVectorResize(ispec128, ispec512, bin128, bout512);
223
224 testVectorResize(ispec256, ispec64, bin256, bout64);
225 testVectorResize(ispec256, ispec128, bin256, bout128);
226 testVectorResize(ispec256, ispec256, bin256, bout256);
227 testVectorResize(ispec256, ispec512, bin256, bout512);
228
229 testVectorResize(ispec512, ispec64, bin512, bout64);
230 testVectorResize(ispec512, ispec128, bin512, bout128);
231 testVectorResize(ispec512, ispec256, bin512, bout256);
232 testVectorResize(ispec512, ispec512, bin512, bout512);
233 }
234 }
235
236 @Test(dataProvider = "byteUnaryOpProvider")
237 static void testResizeLong(IntFunction<byte[]> fa) {
238 byte[] bin64 = fa.apply(64/Byte.SIZE);
239 byte[] bin128 = fa.apply(128/Byte.SIZE);
240 byte[] bin256 = fa.apply(256/Byte.SIZE);
241 byte[] bin512 = fa.apply(512/Byte.SIZE);
242 byte[] bout64 = new byte[bin64.length];
243 byte[] bout128 = new byte[bin128.length];
244 byte[] bout256 = new byte[bin256.length];
245 byte[] bout512 = new byte[bin512.length];
246
247 for (int i = 0; i < NUM_ITER; i++) {
248 testVectorResize(lspec64, lspec64, bin64, bout64);
249 testVectorResize(lspec64, lspec128, bin64, bout128);
250 testVectorResize(lspec64, lspec256, bin64, bout256);
251 testVectorResize(lspec64, lspec512, bin64, bout512);
252
253 testVectorResize(lspec128, lspec64, bin128, bout64);
254 testVectorResize(lspec128, lspec128, bin128, bout128);
255 testVectorResize(lspec128, lspec256, bin128, bout256);
256 testVectorResize(lspec128, lspec512, bin128, bout512);
257
258 testVectorResize(lspec256, lspec64, bin256, bout64);
259 testVectorResize(lspec256, lspec128, bin256, bout128);
260 testVectorResize(lspec256, lspec256, bin256, bout256);
261 testVectorResize(lspec256, lspec512, bin256, bout512);
262
263 testVectorResize(lspec512, lspec64, bin512, bout64);
264 testVectorResize(lspec512, lspec128, bin512, bout128);
265 testVectorResize(lspec512, lspec256, bin512, bout256);
266 testVectorResize(lspec512, lspec512, bin512, bout512);
267 }
268 }
269
270 @Test(dataProvider = "byteUnaryOpProvider")
271 static void testResizeFloat(IntFunction<byte[]> fa) {
272 byte[] bin64 = fa.apply(64/Byte.SIZE);
273 byte[] bin128 = fa.apply(128/Byte.SIZE);
274 byte[] bin256 = fa.apply(256/Byte.SIZE);
275 byte[] bin512 = fa.apply(512/Byte.SIZE);
276 byte[] bout64 = new byte[bin64.length];
277 byte[] bout128 = new byte[bin128.length];
278 byte[] bout256 = new byte[bin256.length];
279 byte[] bout512 = new byte[bin512.length];
280
281 for (int i = 0; i < NUM_ITER; i++) {
282 testVectorResize(fspec64, fspec64, bin64, bout64);
283 testVectorResize(fspec64, fspec128, bin64, bout128);
284 testVectorResize(fspec64, fspec256, bin64, bout256);
285 testVectorResize(fspec64, fspec512, bin64, bout512);
286
287 testVectorResize(fspec128, fspec64, bin128, bout64);
288 testVectorResize(fspec128, fspec128, bin128, bout128);
289 testVectorResize(fspec128, fspec256, bin128, bout256);
290 testVectorResize(fspec128, fspec512, bin128, bout512);
291
292 testVectorResize(fspec256, fspec64, bin256, bout64);
293 testVectorResize(fspec256, fspec128, bin256, bout128);
294 testVectorResize(fspec256, fspec256, bin256, bout256);
295 testVectorResize(fspec256, fspec512, bin256, bout512);
296
297 testVectorResize(fspec512, fspec64, bin512, bout64);
298 testVectorResize(fspec512, fspec128, bin512, bout128);
299 testVectorResize(fspec512, fspec256, bin512, bout256);
300 testVectorResize(fspec512, fspec512, bin512, bout512);
301 }
302 }
303
304 @Test(dataProvider = "byteUnaryOpProvider")
305 static void testResizeDouble(IntFunction<byte[]> fa) {
306 byte[] bin64 = fa.apply(64/Byte.SIZE);
307 byte[] bin128 = fa.apply(128/Byte.SIZE);
308 byte[] bin256 = fa.apply(256/Byte.SIZE);
309 byte[] bin512 = fa.apply(512/Byte.SIZE);
310 byte[] bout64 = new byte[bin64.length];
311 byte[] bout128 = new byte[bin128.length];
312 byte[] bout256 = new byte[bin256.length];
313 byte[] bout512 = new byte[bin512.length];
314
315 for (int i = 0; i < NUM_ITER; i++) {
316 testVectorResize(dspec64, dspec64, bin64, bout64);
317 testVectorResize(dspec64, dspec128, bin64, bout128);
318 testVectorResize(dspec64, dspec256, bin64, bout256);
319 testVectorResize(dspec64, dspec512, bin64, bout512);
320
321 testVectorResize(dspec128, dspec64, bin128, bout64);
322 testVectorResize(dspec128, dspec128, bin128, bout128);
323 testVectorResize(dspec128, dspec256, bin128, bout256);
324 testVectorResize(dspec128, dspec512, bin128, bout512);
325
326 testVectorResize(dspec256, dspec64, bin256, bout64);
327 testVectorResize(dspec256, dspec128, bin256, bout128);
328 testVectorResize(dspec256, dspec256, bin256, bout256);
329 testVectorResize(dspec256, dspec512, bin256, bout512);
330
331 testVectorResize(dspec512, dspec64, bin512, bout64);
332 testVectorResize(dspec512, dspec128, bin512, bout128);
333 testVectorResize(dspec512, dspec256, bin512, bout256);
334 testVectorResize(dspec512, dspec512, bin512, bout512);
335 }
336 }
337
338 @ForceInline
339 static <E,F,S extends Vector.Shape>
340 void testVectorRebracket(Vector.Species<E,S> a, Vector.Species<F,S> b, byte[] input, byte[] output) {
341 assert(input.length == output.length);
342
343 Vector<E, S> av = a.fromByteArray(input, 0);
344 Vector<F, S> bv = b.rebracket(av);
345 bv.intoByteArray(output, 0);
346
347 Assert.assertEquals(input, output);
348 }
349
350 @Test(dataProvider = "byteUnaryOpProvider")
351 static void testRebracket64(IntFunction<byte[]> fa) {
352 byte[] barr = fa.apply(64/Byte.SIZE);
353 byte[] bout = new byte[barr.length];
354 for (int i = 0; i < NUM_ITER; i++) {
355 testVectorRebracket(bspec64, bspec64, barr, bout);
356 testVectorRebracket(bspec64, sspec64, barr, bout);
357 testVectorRebracket(bspec64, ispec64, barr, bout);
358 testVectorRebracket(bspec64, lspec64, barr, bout);
359 testVectorRebracket(bspec64, fspec64, barr, bout);
360 testVectorRebracket(bspec64, dspec64, barr, bout);
361
362 testVectorRebracket(sspec64, bspec64, barr, bout);
363 testVectorRebracket(sspec64, sspec64, barr, bout);
364 testVectorRebracket(sspec64, ispec64, barr, bout);
365 testVectorRebracket(sspec64, lspec64, barr, bout);
366 testVectorRebracket(sspec64, fspec64, barr, bout);
367 testVectorRebracket(sspec64, dspec64, barr, bout);
368
369 testVectorRebracket(ispec64, bspec64, barr, bout);
370 testVectorRebracket(ispec64, sspec64, barr, bout);
371 testVectorRebracket(ispec64, ispec64, barr, bout);
372 testVectorRebracket(ispec64, lspec64, barr, bout);
373 testVectorRebracket(ispec64, fspec64, barr, bout);
374 testVectorRebracket(ispec64, dspec64, barr, bout);
375
376 testVectorRebracket(lspec64, bspec64, barr, bout);
377 testVectorRebracket(lspec64, sspec64, barr, bout);
378 testVectorRebracket(lspec64, ispec64, barr, bout);
379 testVectorRebracket(lspec64, lspec64, barr, bout);
380 testVectorRebracket(lspec64, fspec64, barr, bout);
381 testVectorRebracket(lspec64, dspec64, barr, bout);
382
383 testVectorRebracket(fspec64, bspec64, barr, bout);
384 testVectorRebracket(fspec64, sspec64, barr, bout);
385 testVectorRebracket(fspec64, ispec64, barr, bout);
386 testVectorRebracket(fspec64, lspec64, barr, bout);
387 testVectorRebracket(fspec64, fspec64, barr, bout);
388 testVectorRebracket(fspec64, dspec64, barr, bout);
389
390 testVectorRebracket(dspec64, bspec64, barr, bout);
391 testVectorRebracket(dspec64, sspec64, barr, bout);
392 testVectorRebracket(dspec64, ispec64, barr, bout);
393 testVectorRebracket(dspec64, lspec64, barr, bout);
394 testVectorRebracket(dspec64, fspec64, barr, bout);
395 testVectorRebracket(dspec64, dspec64, barr, bout);
396 }
397 }
398
399 @Test(dataProvider = "byteUnaryOpProvider")
400 static void testRebracket128(IntFunction<byte[]> fa) {
401 byte[] barr = fa.apply(128/Byte.SIZE);
402 byte[] bout = new byte[barr.length];
403 for (int i = 0; i < NUM_ITER; i++) {
404 testVectorRebracket(bspec128, bspec128, barr, bout);
405 testVectorRebracket(bspec128, sspec128, barr, bout);
406 testVectorRebracket(bspec128, ispec128, barr, bout);
407 testVectorRebracket(bspec128, lspec128, barr, bout);
408 testVectorRebracket(bspec128, fspec128, barr, bout);
409 testVectorRebracket(bspec128, dspec128, barr, bout);
410
411 testVectorRebracket(sspec128, bspec128, barr, bout);
412 testVectorRebracket(sspec128, sspec128, barr, bout);
413 testVectorRebracket(sspec128, ispec128, barr, bout);
414 testVectorRebracket(sspec128, lspec128, barr, bout);
415 testVectorRebracket(sspec128, fspec128, barr, bout);
416 testVectorRebracket(sspec128, dspec128, barr, bout);
417
418 testVectorRebracket(ispec128, bspec128, barr, bout);
419 testVectorRebracket(ispec128, sspec128, barr, bout);
420 testVectorRebracket(ispec128, ispec128, barr, bout);
421 testVectorRebracket(ispec128, lspec128, barr, bout);
422 testVectorRebracket(ispec128, fspec128, barr, bout);
423 testVectorRebracket(ispec128, dspec128, barr, bout);
424
425 testVectorRebracket(lspec128, bspec128, barr, bout);
426 testVectorRebracket(lspec128, sspec128, barr, bout);
427 testVectorRebracket(lspec128, ispec128, barr, bout);
428 testVectorRebracket(lspec128, lspec128, barr, bout);
429 testVectorRebracket(lspec128, fspec128, barr, bout);
430 testVectorRebracket(lspec128, dspec128, barr, bout);
431
432 testVectorRebracket(fspec128, bspec128, barr, bout);
433 testVectorRebracket(fspec128, sspec128, barr, bout);
434 testVectorRebracket(fspec128, ispec128, barr, bout);
435 testVectorRebracket(fspec128, lspec128, barr, bout);
436 testVectorRebracket(fspec128, fspec128, barr, bout);
437 testVectorRebracket(fspec128, dspec128, barr, bout);
438
439 testVectorRebracket(dspec128, bspec128, barr, bout);
440 testVectorRebracket(dspec128, sspec128, barr, bout);
441 testVectorRebracket(dspec128, ispec128, barr, bout);
442 testVectorRebracket(dspec128, lspec128, barr, bout);
443 testVectorRebracket(dspec128, fspec128, barr, bout);
444 testVectorRebracket(dspec128, dspec128, barr, bout);
445 }
446 }
447
448 @Test(dataProvider = "byteUnaryOpProvider")
449 static void testRebracket256(IntFunction<byte[]> fa) {
450 byte[] barr = fa.apply(256/Byte.SIZE);
451 byte[] bout = new byte[barr.length];
452 for (int i = 0; i < NUM_ITER; i++) {
453 testVectorRebracket(bspec256, bspec256, barr, bout);
454 testVectorRebracket(bspec256, sspec256, barr, bout);
455 testVectorRebracket(bspec256, ispec256, barr, bout);
456 testVectorRebracket(bspec256, lspec256, barr, bout);
457 testVectorRebracket(bspec256, fspec256, barr, bout);
458 testVectorRebracket(bspec256, dspec256, barr, bout);
459
460 testVectorRebracket(sspec256, bspec256, barr, bout);
461 testVectorRebracket(sspec256, sspec256, barr, bout);
462 testVectorRebracket(sspec256, ispec256, barr, bout);
463 testVectorRebracket(sspec256, lspec256, barr, bout);
464 testVectorRebracket(sspec256, fspec256, barr, bout);
465 testVectorRebracket(sspec256, dspec256, barr, bout);
466
467 testVectorRebracket(ispec256, bspec256, barr, bout);
468 testVectorRebracket(ispec256, sspec256, barr, bout);
469 testVectorRebracket(ispec256, ispec256, barr, bout);
470 testVectorRebracket(ispec256, lspec256, barr, bout);
471 testVectorRebracket(ispec256, fspec256, barr, bout);
472 testVectorRebracket(ispec256, dspec256, barr, bout);
473
474 testVectorRebracket(lspec256, bspec256, barr, bout);
475 testVectorRebracket(lspec256, sspec256, barr, bout);
476 testVectorRebracket(lspec256, ispec256, barr, bout);
477 testVectorRebracket(lspec256, lspec256, barr, bout);
478 testVectorRebracket(lspec256, fspec256, barr, bout);
479 testVectorRebracket(lspec256, dspec256, barr, bout);
480
481 testVectorRebracket(fspec256, bspec256, barr, bout);
482 testVectorRebracket(fspec256, sspec256, barr, bout);
483 testVectorRebracket(fspec256, ispec256, barr, bout);
484 testVectorRebracket(fspec256, lspec256, barr, bout);
485 testVectorRebracket(fspec256, fspec256, barr, bout);
486 testVectorRebracket(fspec256, dspec256, barr, bout);
487
488 testVectorRebracket(dspec256, bspec256, barr, bout);
489 testVectorRebracket(dspec256, sspec256, barr, bout);
490 testVectorRebracket(dspec256, ispec256, barr, bout);
491 testVectorRebracket(dspec256, lspec256, barr, bout);
492 testVectorRebracket(dspec256, fspec256, barr, bout);
493 testVectorRebracket(dspec256, dspec256, barr, bout);
494 }
495 }
496
497 @Test(dataProvider = "byteUnaryOpProvider")
498 static void testRebracket512(IntFunction<byte[]> fa) {
499 byte[] barr = fa.apply(512/Byte.SIZE);
500 byte[] bout = new byte[barr.length];
501 for (int i = 0; i < NUM_ITER; i++) {
502 testVectorRebracket(bspec512, bspec512, barr, bout);
503 testVectorRebracket(bspec512, sspec512, barr, bout);
504 testVectorRebracket(bspec512, ispec512, barr, bout);
505 testVectorRebracket(bspec512, lspec512, barr, bout);
506 testVectorRebracket(bspec512, fspec512, barr, bout);
507 testVectorRebracket(bspec512, dspec512, barr, bout);
508
509 testVectorRebracket(sspec512, bspec512, barr, bout);
510 testVectorRebracket(sspec512, sspec512, barr, bout);
511 testVectorRebracket(sspec512, ispec512, barr, bout);
512 testVectorRebracket(sspec512, lspec512, barr, bout);
513 testVectorRebracket(sspec512, fspec512, barr, bout);
514 testVectorRebracket(sspec512, dspec512, barr, bout);
515
516 testVectorRebracket(ispec512, bspec512, barr, bout);
517 testVectorRebracket(ispec512, sspec512, barr, bout);
518 testVectorRebracket(ispec512, ispec512, barr, bout);
519 testVectorRebracket(ispec512, lspec512, barr, bout);
520 testVectorRebracket(ispec512, fspec512, barr, bout);
521 testVectorRebracket(ispec512, dspec512, barr, bout);
522
523 testVectorRebracket(lspec512, bspec512, barr, bout);
524 testVectorRebracket(lspec512, sspec512, barr, bout);
525 testVectorRebracket(lspec512, ispec512, barr, bout);
526 testVectorRebracket(lspec512, lspec512, barr, bout);
527 testVectorRebracket(lspec512, fspec512, barr, bout);
528 testVectorRebracket(lspec512, dspec512, barr, bout);
529
530 testVectorRebracket(fspec512, bspec512, barr, bout);
531 testVectorRebracket(fspec512, sspec512, barr, bout);
532 testVectorRebracket(fspec512, ispec512, barr, bout);
533 testVectorRebracket(fspec512, lspec512, barr, bout);
534 testVectorRebracket(fspec512, fspec512, barr, bout);
535 testVectorRebracket(fspec512, dspec512, barr, bout);
536
537 testVectorRebracket(dspec512, bspec512, barr, bout);
538 testVectorRebracket(dspec512, sspec512, barr, bout);
539 testVectorRebracket(dspec512, ispec512, barr, bout);
540 testVectorRebracket(dspec512, lspec512, barr, bout);
541 testVectorRebracket(dspec512, fspec512, barr, bout);
542 testVectorRebracket(dspec512, dspec512, barr, bout);
543 }
544 }
545 }