1 /*
2 * Copyright (c) 2018, 2024, 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 package org.openjdk.bench.jdk.incubator.vector.operation;
25
26 // -- This file was mechanically generated: Do not edit! -- //
27
28 import jdk.incubator.vector.Vector;
29 import jdk.incubator.vector.VectorMask;
30 import jdk.incubator.vector.VectorOperators;
31 import jdk.incubator.vector.VectorShape;
32 import jdk.incubator.vector.VectorSpecies;
33 import jdk.incubator.vector.VectorShuffle;
34 import jdk.incubator.vector.ShortVector;
35
36 import java.util.concurrent.TimeUnit;
37 import java.util.function.BiFunction;
38 import java.util.function.IntFunction;
39
40 import org.openjdk.jmh.annotations.*;
41 import org.openjdk.jmh.infra.Blackhole;
42
43 @BenchmarkMode(Mode.Throughput)
44 @OutputTimeUnit(TimeUnit.MILLISECONDS)
45 @State(Scope.Benchmark)
46 @Warmup(iterations = 3, time = 1)
47 @Measurement(iterations = 5, time = 1)
48 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
49 public class ShortMaxVector extends AbstractVectorBenchmark {
50 static final VectorSpecies<Short> SPECIES = ShortVector.SPECIES_MAX;
51
52 static final int INVOC_COUNT = 1; // get rid of outer loop
53
54 static void replaceZero(short[] a, short v) {
55 for (int i = 0; i < a.length; i++) {
56 if (a[i] == 0) {
57 a[i] = v;
58 }
59 }
60 }
61
62 static void replaceZero(short[] a, boolean[] mask, short v) {
63 for (int i = 0; i < a.length; i++) {
64 if (mask[i % mask.length] && a[i] == 0) {
65 a[i] = v;
66 }
67 }
68 }
69
70 static short firstNonZero(short a, short b) {
71 return Short.compare(a, (short) 0) != 0 ? a : b;
72 }
73
74 private static final short CONST_SHIFT = Short.SIZE / 2;
75
76 @Param("1024")
77 int size;
78
79 short[] fill(IntFunction<Short> f) {
80 short[] array = new short[size];
81 for (int i = 0; i < array.length; i++) {
82 array[i] = f.apply(i);
83 }
84 return array;
85 }
86
87 short[] a, b, c, r;
88 boolean[] m, mt, rm;
89 int[] s;
90
91 @Setup
92 public void init() {
93 size += size % SPECIES.length(); // FIXME: add post-loops
94
95 a = fill(i -> (short)(2*i));
96 b = fill(i -> (short)(i+1));
97 c = fill(i -> (short)(i+5));
98 r = fill(i -> (short)0);
99
100 m = fillMask(size, i -> (i % 2) == 0);
101 mt = fillMask(size, i -> true);
102 rm = fillMask(size, i -> false);
103
104 s = fillInt(size, i -> RAND.nextInt(SPECIES.length()));
105 }
106
107 final IntFunction<short[]> fa = vl -> a;
108 final IntFunction<short[]> fb = vl -> b;
109 final IntFunction<short[]> fc = vl -> c;
110 final IntFunction<short[]> fr = vl -> r;
111 final IntFunction<boolean[]> fm = vl -> m;
112 final IntFunction<boolean[]> fmt = vl -> mt;
113 final IntFunction<boolean[]> fmr = vl -> rm;
114 final BiFunction<Integer,Integer,int[]> fs = (i,j) -> s;
115
116
117 @Benchmark
118 public void ADD(Blackhole bh) {
119 short[] a = fa.apply(SPECIES.length());
120 short[] b = fb.apply(SPECIES.length());
121 short[] r = fr.apply(SPECIES.length());
122
123 for (int ic = 0; ic < INVOC_COUNT; ic++) {
124 for (int i = 0; i < a.length; i += SPECIES.length()) {
125 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
126 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
127 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
128 }
129 }
130
131 bh.consume(r);
132 }
133
134 @Benchmark
135 public void ADDMasked(Blackhole bh) {
136 short[] a = fa.apply(SPECIES.length());
137 short[] b = fb.apply(SPECIES.length());
138 short[] r = fr.apply(SPECIES.length());
139 boolean[] mask = fm.apply(SPECIES.length());
140 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
141
142 for (int ic = 0; ic < INVOC_COUNT; ic++) {
143 for (int i = 0; i < a.length; i += SPECIES.length()) {
144 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
145 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
146 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
147 }
148 }
149
150 bh.consume(r);
151 }
152
153 @Benchmark
154 public void SUB(Blackhole bh) {
155 short[] a = fa.apply(SPECIES.length());
156 short[] b = fb.apply(SPECIES.length());
157 short[] r = fr.apply(SPECIES.length());
158
159 for (int ic = 0; ic < INVOC_COUNT; ic++) {
160 for (int i = 0; i < a.length; i += SPECIES.length()) {
161 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
162 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
163 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
164 }
165 }
166
167 bh.consume(r);
168 }
169
170 @Benchmark
171 public void SUBMasked(Blackhole bh) {
172 short[] a = fa.apply(SPECIES.length());
173 short[] b = fb.apply(SPECIES.length());
174 short[] r = fr.apply(SPECIES.length());
175 boolean[] mask = fm.apply(SPECIES.length());
176 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
177
178 for (int ic = 0; ic < INVOC_COUNT; ic++) {
179 for (int i = 0; i < a.length; i += SPECIES.length()) {
180 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
181 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
182 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
183 }
184 }
185
186 bh.consume(r);
187 }
188
189 @Benchmark
190 public void MUL(Blackhole bh) {
191 short[] a = fa.apply(SPECIES.length());
192 short[] b = fb.apply(SPECIES.length());
193 short[] r = fr.apply(SPECIES.length());
194
195 for (int ic = 0; ic < INVOC_COUNT; ic++) {
196 for (int i = 0; i < a.length; i += SPECIES.length()) {
197 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
198 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
199 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
200 }
201 }
202
203 bh.consume(r);
204 }
205
206 @Benchmark
207 public void MULMasked(Blackhole bh) {
208 short[] a = fa.apply(SPECIES.length());
209 short[] b = fb.apply(SPECIES.length());
210 short[] r = fr.apply(SPECIES.length());
211 boolean[] mask = fm.apply(SPECIES.length());
212 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
213
214 for (int ic = 0; ic < INVOC_COUNT; ic++) {
215 for (int i = 0; i < a.length; i += SPECIES.length()) {
216 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
217 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
218 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
219 }
220 }
221
222 bh.consume(r);
223 }
224
225 @Benchmark
226 public void DIV(Blackhole bh) {
227 short[] a = fa.apply(SPECIES.length());
228 short[] b = fb.apply(SPECIES.length());
229 short[] r = fr.apply(SPECIES.length());
230
231 replaceZero(b, (short) 1);
232
233 for (int ic = 0; ic < INVOC_COUNT; ic++) {
234 for (int i = 0; i < a.length; i += SPECIES.length()) {
235 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
236 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
237 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
238 }
239 }
240
241 bh.consume(r);
242 }
243
244 @Benchmark
245 public void DIVMasked(Blackhole bh) {
246 short[] a = fa.apply(SPECIES.length());
247 short[] b = fb.apply(SPECIES.length());
248 short[] r = fr.apply(SPECIES.length());
249 boolean[] mask = fm.apply(SPECIES.length());
250 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
251
252 replaceZero(b, mask, (short) 1);
253
254 for (int ic = 0; ic < INVOC_COUNT; ic++) {
255 for (int i = 0; i < a.length; i += SPECIES.length()) {
256 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
257 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
258 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
259 }
260 }
261
262 bh.consume(r);
263 }
264
265 @Benchmark
266 public void FIRST_NONZERO(Blackhole bh) {
267 short[] a = fa.apply(SPECIES.length());
268 short[] b = fb.apply(SPECIES.length());
269 short[] r = fr.apply(SPECIES.length());
270
271 for (int ic = 0; ic < INVOC_COUNT; ic++) {
272 for (int i = 0; i < a.length; i += SPECIES.length()) {
273 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
274 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
275 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
276 }
277 }
278
279 bh.consume(r);
280 }
281
282 @Benchmark
283 public void FIRST_NONZEROMasked(Blackhole bh) {
284 short[] a = fa.apply(SPECIES.length());
285 short[] b = fb.apply(SPECIES.length());
286 short[] r = fr.apply(SPECIES.length());
287 boolean[] mask = fm.apply(SPECIES.length());
288 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
289
290 for (int ic = 0; ic < INVOC_COUNT; ic++) {
291 for (int i = 0; i < a.length; i += SPECIES.length()) {
292 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
293 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
294 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
295 }
296 }
297
298 bh.consume(r);
299 }
300
301 @Benchmark
302 public void AND(Blackhole bh) {
303 short[] a = fa.apply(SPECIES.length());
304 short[] b = fb.apply(SPECIES.length());
305 short[] r = fr.apply(SPECIES.length());
306
307 for (int ic = 0; ic < INVOC_COUNT; ic++) {
308 for (int i = 0; i < a.length; i += SPECIES.length()) {
309 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
310 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
311 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
312 }
313 }
314
315 bh.consume(r);
316 }
317
318 @Benchmark
319 public void ANDMasked(Blackhole bh) {
320 short[] a = fa.apply(SPECIES.length());
321 short[] b = fb.apply(SPECIES.length());
322 short[] r = fr.apply(SPECIES.length());
323 boolean[] mask = fm.apply(SPECIES.length());
324 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
325
326 for (int ic = 0; ic < INVOC_COUNT; ic++) {
327 for (int i = 0; i < a.length; i += SPECIES.length()) {
328 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
329 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
330 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
331 }
332 }
333
334 bh.consume(r);
335 }
336
337 @Benchmark
338 public void AND_NOT(Blackhole bh) {
339 short[] a = fa.apply(SPECIES.length());
340 short[] b = fb.apply(SPECIES.length());
341 short[] r = fr.apply(SPECIES.length());
342
343 for (int ic = 0; ic < INVOC_COUNT; ic++) {
344 for (int i = 0; i < a.length; i += SPECIES.length()) {
345 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
346 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
347 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
348 }
349 }
350
351 bh.consume(r);
352 }
353
354 @Benchmark
355 public void AND_NOTMasked(Blackhole bh) {
356 short[] a = fa.apply(SPECIES.length());
357 short[] b = fb.apply(SPECIES.length());
358 short[] r = fr.apply(SPECIES.length());
359 boolean[] mask = fm.apply(SPECIES.length());
360 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
361
362 for (int ic = 0; ic < INVOC_COUNT; ic++) {
363 for (int i = 0; i < a.length; i += SPECIES.length()) {
364 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
365 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
366 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
367 }
368 }
369
370 bh.consume(r);
371 }
372
373 @Benchmark
374 public void OR(Blackhole bh) {
375 short[] a = fa.apply(SPECIES.length());
376 short[] b = fb.apply(SPECIES.length());
377 short[] r = fr.apply(SPECIES.length());
378
379 for (int ic = 0; ic < INVOC_COUNT; ic++) {
380 for (int i = 0; i < a.length; i += SPECIES.length()) {
381 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
382 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
383 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
384 }
385 }
386
387 bh.consume(r);
388 }
389
390 @Benchmark
391 public void ORMasked(Blackhole bh) {
392 short[] a = fa.apply(SPECIES.length());
393 short[] b = fb.apply(SPECIES.length());
394 short[] r = fr.apply(SPECIES.length());
395 boolean[] mask = fm.apply(SPECIES.length());
396 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
397
398 for (int ic = 0; ic < INVOC_COUNT; ic++) {
399 for (int i = 0; i < a.length; i += SPECIES.length()) {
400 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
401 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
402 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
403 }
404 }
405
406 bh.consume(r);
407 }
408
409 @Benchmark
410 public void XOR(Blackhole bh) {
411 short[] a = fa.apply(SPECIES.length());
412 short[] b = fb.apply(SPECIES.length());
413 short[] r = fr.apply(SPECIES.length());
414
415 for (int ic = 0; ic < INVOC_COUNT; ic++) {
416 for (int i = 0; i < a.length; i += SPECIES.length()) {
417 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
418 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
419 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
420 }
421 }
422
423 bh.consume(r);
424 }
425
426 @Benchmark
427 public void XORMasked(Blackhole bh) {
428 short[] a = fa.apply(SPECIES.length());
429 short[] b = fb.apply(SPECIES.length());
430 short[] r = fr.apply(SPECIES.length());
431 boolean[] mask = fm.apply(SPECIES.length());
432 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
433
434 for (int ic = 0; ic < INVOC_COUNT; ic++) {
435 for (int i = 0; i < a.length; i += SPECIES.length()) {
436 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
437 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
438 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
439 }
440 }
441
442 bh.consume(r);
443 }
444
445 @Benchmark
446 public void LSHL(Blackhole bh) {
447 short[] a = fa.apply(SPECIES.length());
448 short[] b = fb.apply(SPECIES.length());
449 short[] r = fr.apply(SPECIES.length());
450
451 for (int ic = 0; ic < INVOC_COUNT; ic++) {
452 for (int i = 0; i < a.length; i += SPECIES.length()) {
453 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
454 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
455 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
456 }
457 }
458
459 bh.consume(r);
460 }
461
462 @Benchmark
463 public void LSHLMasked(Blackhole bh) {
464 short[] a = fa.apply(SPECIES.length());
465 short[] b = fb.apply(SPECIES.length());
466 short[] r = fr.apply(SPECIES.length());
467 boolean[] mask = fm.apply(SPECIES.length());
468 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
469
470 for (int ic = 0; ic < INVOC_COUNT; ic++) {
471 for (int i = 0; i < a.length; i += SPECIES.length()) {
472 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
473 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
474 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
475 }
476 }
477
478 bh.consume(r);
479 }
480
481 @Benchmark
482 public void ASHR(Blackhole bh) {
483 short[] a = fa.apply(SPECIES.length());
484 short[] b = fb.apply(SPECIES.length());
485 short[] r = fr.apply(SPECIES.length());
486
487 for (int ic = 0; ic < INVOC_COUNT; ic++) {
488 for (int i = 0; i < a.length; i += SPECIES.length()) {
489 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
490 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
491 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
492 }
493 }
494
495 bh.consume(r);
496 }
497
498 @Benchmark
499 public void ASHRMasked(Blackhole bh) {
500 short[] a = fa.apply(SPECIES.length());
501 short[] b = fb.apply(SPECIES.length());
502 short[] r = fr.apply(SPECIES.length());
503 boolean[] mask = fm.apply(SPECIES.length());
504 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
505
506 for (int ic = 0; ic < INVOC_COUNT; ic++) {
507 for (int i = 0; i < a.length; i += SPECIES.length()) {
508 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
509 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
510 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
511 }
512 }
513
514 bh.consume(r);
515 }
516
517 @Benchmark
518 public void LSHR(Blackhole bh) {
519 short[] a = fa.apply(SPECIES.length());
520 short[] b = fb.apply(SPECIES.length());
521 short[] r = fr.apply(SPECIES.length());
522
523 for (int ic = 0; ic < INVOC_COUNT; ic++) {
524 for (int i = 0; i < a.length; i += SPECIES.length()) {
525 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
526 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
527 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
528 }
529 }
530
531 bh.consume(r);
532 }
533
534 @Benchmark
535 public void LSHRMasked(Blackhole bh) {
536 short[] a = fa.apply(SPECIES.length());
537 short[] b = fb.apply(SPECIES.length());
538 short[] r = fr.apply(SPECIES.length());
539 boolean[] mask = fm.apply(SPECIES.length());
540 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
541
542 for (int ic = 0; ic < INVOC_COUNT; ic++) {
543 for (int i = 0; i < a.length; i += SPECIES.length()) {
544 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
545 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
546 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
547 }
548 }
549
550 bh.consume(r);
551 }
552
553 @Benchmark
554 public void LSHLShift(Blackhole bh) {
555 short[] a = fa.apply(SPECIES.length());
556 short[] b = fb.apply(SPECIES.length());
557 short[] r = fr.apply(SPECIES.length());
558
559 for (int ic = 0; ic < INVOC_COUNT; ic++) {
560 for (int i = 0; i < a.length; i += SPECIES.length()) {
561 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
562 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
563 }
564 }
565
566 bh.consume(r);
567 }
568
569 @Benchmark
570 public void LSHLMaskedShift(Blackhole bh) {
571 short[] a = fa.apply(SPECIES.length());
572 short[] b = fb.apply(SPECIES.length());
573 short[] r = fr.apply(SPECIES.length());
574 boolean[] mask = fm.apply(SPECIES.length());
575 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
576
577 for (int ic = 0; ic < INVOC_COUNT; ic++) {
578 for (int i = 0; i < a.length; i += SPECIES.length()) {
579 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
580 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
581 }
582 }
583
584 bh.consume(r);
585 }
586
587 @Benchmark
588 public void LSHRShift(Blackhole bh) {
589 short[] a = fa.apply(SPECIES.length());
590 short[] b = fb.apply(SPECIES.length());
591 short[] r = fr.apply(SPECIES.length());
592
593 for (int ic = 0; ic < INVOC_COUNT; ic++) {
594 for (int i = 0; i < a.length; i += SPECIES.length()) {
595 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
596 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
597 }
598 }
599
600 bh.consume(r);
601 }
602
603 @Benchmark
604 public void LSHRMaskedShift(Blackhole bh) {
605 short[] a = fa.apply(SPECIES.length());
606 short[] b = fb.apply(SPECIES.length());
607 short[] r = fr.apply(SPECIES.length());
608 boolean[] mask = fm.apply(SPECIES.length());
609 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
610
611 for (int ic = 0; ic < INVOC_COUNT; ic++) {
612 for (int i = 0; i < a.length; i += SPECIES.length()) {
613 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
614 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
615 }
616 }
617
618 bh.consume(r);
619 }
620
621 @Benchmark
622 public void ASHRShift(Blackhole bh) {
623 short[] a = fa.apply(SPECIES.length());
624 short[] b = fb.apply(SPECIES.length());
625 short[] r = fr.apply(SPECIES.length());
626
627 for (int ic = 0; ic < INVOC_COUNT; ic++) {
628 for (int i = 0; i < a.length; i += SPECIES.length()) {
629 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
630 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
631 }
632 }
633
634 bh.consume(r);
635 }
636
637 @Benchmark
638 public void ASHRMaskedShift(Blackhole bh) {
639 short[] a = fa.apply(SPECIES.length());
640 short[] b = fb.apply(SPECIES.length());
641 short[] r = fr.apply(SPECIES.length());
642 boolean[] mask = fm.apply(SPECIES.length());
643 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
644
645 for (int ic = 0; ic < INVOC_COUNT; ic++) {
646 for (int i = 0; i < a.length; i += SPECIES.length()) {
647 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
648 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
649 }
650 }
651
652 bh.consume(r);
653 }
654
655 @Benchmark
656 public void ROR(Blackhole bh) {
657 short[] a = fa.apply(SPECIES.length());
658 short[] b = fb.apply(SPECIES.length());
659 short[] r = fr.apply(SPECIES.length());
660
661 for (int ic = 0; ic < INVOC_COUNT; ic++) {
662 for (int i = 0; i < a.length; i += SPECIES.length()) {
663 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
664 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
665 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
666 }
667 }
668
669 bh.consume(r);
670 }
671
672 @Benchmark
673 public void RORMasked(Blackhole bh) {
674 short[] a = fa.apply(SPECIES.length());
675 short[] b = fb.apply(SPECIES.length());
676 short[] r = fr.apply(SPECIES.length());
677 boolean[] mask = fm.apply(SPECIES.length());
678 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
679
680 for (int ic = 0; ic < INVOC_COUNT; ic++) {
681 for (int i = 0; i < a.length; i += SPECIES.length()) {
682 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
683 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
684 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
685 }
686 }
687
688 bh.consume(r);
689 }
690
691 @Benchmark
692 public void ROL(Blackhole bh) {
693 short[] a = fa.apply(SPECIES.length());
694 short[] b = fb.apply(SPECIES.length());
695 short[] r = fr.apply(SPECIES.length());
696
697 for (int ic = 0; ic < INVOC_COUNT; ic++) {
698 for (int i = 0; i < a.length; i += SPECIES.length()) {
699 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
700 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
701 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
702 }
703 }
704
705 bh.consume(r);
706 }
707
708 @Benchmark
709 public void ROLMasked(Blackhole bh) {
710 short[] a = fa.apply(SPECIES.length());
711 short[] b = fb.apply(SPECIES.length());
712 short[] r = fr.apply(SPECIES.length());
713 boolean[] mask = fm.apply(SPECIES.length());
714 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
715
716 for (int ic = 0; ic < INVOC_COUNT; ic++) {
717 for (int i = 0; i < a.length; i += SPECIES.length()) {
718 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
719 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
720 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
721 }
722 }
723
724 bh.consume(r);
725 }
726
727 @Benchmark
728 public void RORShift(Blackhole bh) {
729 short[] a = fa.apply(SPECIES.length());
730 short[] b = fb.apply(SPECIES.length());
731 short[] r = fr.apply(SPECIES.length());
732
733 for (int ic = 0; ic < INVOC_COUNT; ic++) {
734 for (int i = 0; i < a.length; i += SPECIES.length()) {
735 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
736 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
737 }
738 }
739
740 bh.consume(r);
741 }
742
743 @Benchmark
744 public void RORMaskedShift(Blackhole bh) {
745 short[] a = fa.apply(SPECIES.length());
746 short[] b = fb.apply(SPECIES.length());
747 short[] r = fr.apply(SPECIES.length());
748 boolean[] mask = fm.apply(SPECIES.length());
749 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
750
751 for (int ic = 0; ic < INVOC_COUNT; ic++) {
752 for (int i = 0; i < a.length; i += SPECIES.length()) {
753 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
754 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
755 }
756 }
757
758 bh.consume(r);
759 }
760
761 @Benchmark
762 public void ROLShift(Blackhole bh) {
763 short[] a = fa.apply(SPECIES.length());
764 short[] b = fb.apply(SPECIES.length());
765 short[] r = fr.apply(SPECIES.length());
766
767 for (int ic = 0; ic < INVOC_COUNT; ic++) {
768 for (int i = 0; i < a.length; i += SPECIES.length()) {
769 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
770 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
771 }
772 }
773
774 bh.consume(r);
775 }
776
777 @Benchmark
778 public void ROLMaskedShift(Blackhole bh) {
779 short[] a = fa.apply(SPECIES.length());
780 short[] b = fb.apply(SPECIES.length());
781 short[] r = fr.apply(SPECIES.length());
782 boolean[] mask = fm.apply(SPECIES.length());
783 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
784
785 for (int ic = 0; ic < INVOC_COUNT; ic++) {
786 for (int i = 0; i < a.length; i += SPECIES.length()) {
787 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
788 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
789 }
790 }
791
792 bh.consume(r);
793 }
794
795 @Benchmark
796 public void LSHRShiftConst(Blackhole bh) {
797 short[] a = fa.apply(SPECIES.length());
798 short[] r = fr.apply(SPECIES.length());
799
800 for (int ic = 0; ic < INVOC_COUNT; ic++) {
801 for (int i = 0; i < a.length; i += SPECIES.length()) {
802 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
803 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
804 }
805 }
806
807 bh.consume(r);
808 }
809
810 @Benchmark
811 public void LSHRMaskedShiftConst(Blackhole bh) {
812 short[] a = fa.apply(SPECIES.length());
813 short[] r = fr.apply(SPECIES.length());
814 boolean[] mask = fm.apply(SPECIES.length());
815 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
816
817 for (int ic = 0; ic < INVOC_COUNT; ic++) {
818 for (int i = 0; i < a.length; i += SPECIES.length()) {
819 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
820 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
821 }
822 }
823
824 bh.consume(r);
825 }
826
827 @Benchmark
828 public void LSHLShiftConst(Blackhole bh) {
829 short[] a = fa.apply(SPECIES.length());
830 short[] r = fr.apply(SPECIES.length());
831
832 for (int ic = 0; ic < INVOC_COUNT; ic++) {
833 for (int i = 0; i < a.length; i += SPECIES.length()) {
834 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
835 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
836 }
837 }
838
839 bh.consume(r);
840 }
841
842 @Benchmark
843 public void LSHLMaskedShiftConst(Blackhole bh) {
844 short[] a = fa.apply(SPECIES.length());
845 short[] r = fr.apply(SPECIES.length());
846 boolean[] mask = fm.apply(SPECIES.length());
847 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
848
849 for (int ic = 0; ic < INVOC_COUNT; ic++) {
850 for (int i = 0; i < a.length; i += SPECIES.length()) {
851 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
852 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
853 }
854 }
855
856 bh.consume(r);
857 }
858
859 @Benchmark
860 public void ASHRShiftConst(Blackhole bh) {
861 short[] a = fa.apply(SPECIES.length());
862 short[] r = fr.apply(SPECIES.length());
863
864 for (int ic = 0; ic < INVOC_COUNT; ic++) {
865 for (int i = 0; i < a.length; i += SPECIES.length()) {
866 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
867 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
868 }
869 }
870
871 bh.consume(r);
872 }
873
874 @Benchmark
875 public void ASHRMaskedShiftConst(Blackhole bh) {
876 short[] a = fa.apply(SPECIES.length());
877 short[] r = fr.apply(SPECIES.length());
878 boolean[] mask = fm.apply(SPECIES.length());
879 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
880
881 for (int ic = 0; ic < INVOC_COUNT; ic++) {
882 for (int i = 0; i < a.length; i += SPECIES.length()) {
883 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
884 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
885 }
886 }
887
888 bh.consume(r);
889 }
890
891 @Benchmark
892 public void RORShiftConst(Blackhole bh) {
893 short[] a = fa.apply(SPECIES.length());
894 short[] r = fr.apply(SPECIES.length());
895
896 for (int ic = 0; ic < INVOC_COUNT; ic++) {
897 for (int i = 0; i < a.length; i += SPECIES.length()) {
898 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
899 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
900 }
901 }
902
903 bh.consume(r);
904 }
905
906 @Benchmark
907 public void RORMaskedShiftConst(Blackhole bh) {
908 short[] a = fa.apply(SPECIES.length());
909 short[] r = fr.apply(SPECIES.length());
910 boolean[] mask = fm.apply(SPECIES.length());
911 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
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.fromArray(SPECIES, a, i);
916 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
917 }
918 }
919
920 bh.consume(r);
921 }
922
923 @Benchmark
924 public void ROLShiftConst(Blackhole bh) {
925 short[] a = fa.apply(SPECIES.length());
926 short[] r = fr.apply(SPECIES.length());
927
928 for (int ic = 0; ic < INVOC_COUNT; ic++) {
929 for (int i = 0; i < a.length; i += SPECIES.length()) {
930 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
931 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
932 }
933 }
934
935 bh.consume(r);
936 }
937
938 @Benchmark
939 public void ROLMaskedShiftConst(Blackhole bh) {
940 short[] a = fa.apply(SPECIES.length());
941 short[] r = fr.apply(SPECIES.length());
942 boolean[] mask = fm.apply(SPECIES.length());
943 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
944
945 for (int ic = 0; ic < INVOC_COUNT; ic++) {
946 for (int i = 0; i < a.length; i += SPECIES.length()) {
947 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
948 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
949 }
950 }
951
952 bh.consume(r);
953 }
954
955 @Benchmark
956 public void MIN(Blackhole bh) {
957 short[] a = fa.apply(SPECIES.length());
958 short[] b = fb.apply(SPECIES.length());
959 short[] r = fr.apply(SPECIES.length());
960
961 for (int ic = 0; ic < INVOC_COUNT; ic++) {
962 for (int i = 0; i < a.length; i += SPECIES.length()) {
963 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
964 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
965 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
966 }
967 }
968
969 bh.consume(r);
970 }
971
972 @Benchmark
973 public void MAX(Blackhole bh) {
974 short[] a = fa.apply(SPECIES.length());
975 short[] b = fb.apply(SPECIES.length());
976 short[] r = fr.apply(SPECIES.length());
977
978 for (int ic = 0; ic < INVOC_COUNT; ic++) {
979 for (int i = 0; i < a.length; i += SPECIES.length()) {
980 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
981 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
982 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
983 }
984 }
985
986 bh.consume(r);
987 }
988
989 @Benchmark
990 public void UMIN(Blackhole bh) {
991 short[] a = fa.apply(SPECIES.length());
992 short[] b = fb.apply(SPECIES.length());
993 short[] r = fr.apply(SPECIES.length());
994
995 for (int ic = 0; ic < INVOC_COUNT; ic++) {
996 for (int i = 0; i < a.length; i += SPECIES.length()) {
997 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
998 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
999 av.lanewise(VectorOperators.UMIN, bv).intoArray(r, i);
1000 }
1001 }
1002
1003 bh.consume(r);
1004 }
1005
1006 @Benchmark
1007 public void UMINMasked(Blackhole bh) {
1008 short[] a = fa.apply(SPECIES.length());
1009 short[] b = fb.apply(SPECIES.length());
1010 short[] r = fr.apply(SPECIES.length());
1011 boolean[] mask = fm.apply(SPECIES.length());
1012 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1013
1014 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1015 for (int i = 0; i < a.length; i += SPECIES.length()) {
1016 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1017 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1018 av.lanewise(VectorOperators.UMIN, bv, vmask).intoArray(r, i);
1019 }
1020 }
1021
1022 bh.consume(r);
1023 }
1024
1025 @Benchmark
1026 public void UMAX(Blackhole bh) {
1027 short[] a = fa.apply(SPECIES.length());
1028 short[] b = fb.apply(SPECIES.length());
1029 short[] r = fr.apply(SPECIES.length());
1030
1031 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1032 for (int i = 0; i < a.length; i += SPECIES.length()) {
1033 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1034 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1035 av.lanewise(VectorOperators.UMAX, bv).intoArray(r, i);
1036 }
1037 }
1038
1039 bh.consume(r);
1040 }
1041
1042 @Benchmark
1043 public void UMAXMasked(Blackhole bh) {
1044 short[] a = fa.apply(SPECIES.length());
1045 short[] b = fb.apply(SPECIES.length());
1046 short[] r = fr.apply(SPECIES.length());
1047 boolean[] mask = fm.apply(SPECIES.length());
1048 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1049
1050 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1051 for (int i = 0; i < a.length; i += SPECIES.length()) {
1052 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1053 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1054 av.lanewise(VectorOperators.UMAX, bv, vmask).intoArray(r, i);
1055 }
1056 }
1057
1058 bh.consume(r);
1059 }
1060
1061 @Benchmark
1062 public void SADD(Blackhole bh) {
1063 short[] a = fa.apply(SPECIES.length());
1064 short[] b = fb.apply(SPECIES.length());
1065 short[] r = fr.apply(SPECIES.length());
1066
1067 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1068 for (int i = 0; i < a.length; i += SPECIES.length()) {
1069 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1070 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1071 av.lanewise(VectorOperators.SADD, bv).intoArray(r, i);
1072 }
1073 }
1074
1075 bh.consume(r);
1076 }
1077
1078 @Benchmark
1079 public void SADDMasked(Blackhole bh) {
1080 short[] a = fa.apply(SPECIES.length());
1081 short[] b = fb.apply(SPECIES.length());
1082 short[] r = fr.apply(SPECIES.length());
1083 boolean[] mask = fm.apply(SPECIES.length());
1084 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1085
1086 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1087 for (int i = 0; i < a.length; i += SPECIES.length()) {
1088 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1089 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1090 av.lanewise(VectorOperators.SADD, bv, vmask).intoArray(r, i);
1091 }
1092 }
1093
1094 bh.consume(r);
1095 }
1096
1097 @Benchmark
1098 public void SSUB(Blackhole bh) {
1099 short[] a = fa.apply(SPECIES.length());
1100 short[] b = fb.apply(SPECIES.length());
1101 short[] r = fr.apply(SPECIES.length());
1102
1103 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1104 for (int i = 0; i < a.length; i += SPECIES.length()) {
1105 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1106 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1107 av.lanewise(VectorOperators.SSUB, bv).intoArray(r, i);
1108 }
1109 }
1110
1111 bh.consume(r);
1112 }
1113
1114 @Benchmark
1115 public void SSUBMasked(Blackhole bh) {
1116 short[] a = fa.apply(SPECIES.length());
1117 short[] b = fb.apply(SPECIES.length());
1118 short[] r = fr.apply(SPECIES.length());
1119 boolean[] mask = fm.apply(SPECIES.length());
1120 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1121
1122 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1123 for (int i = 0; i < a.length; i += SPECIES.length()) {
1124 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1125 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1126 av.lanewise(VectorOperators.SSUB, bv, vmask).intoArray(r, i);
1127 }
1128 }
1129
1130 bh.consume(r);
1131 }
1132
1133 @Benchmark
1134 public void SUADD(Blackhole bh) {
1135 short[] a = fa.apply(SPECIES.length());
1136 short[] b = fb.apply(SPECIES.length());
1137 short[] r = fr.apply(SPECIES.length());
1138
1139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1140 for (int i = 0; i < a.length; i += SPECIES.length()) {
1141 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1142 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1143 av.lanewise(VectorOperators.SUADD, bv).intoArray(r, i);
1144 }
1145 }
1146
1147 bh.consume(r);
1148 }
1149
1150 @Benchmark
1151 public void SUADDMasked(Blackhole bh) {
1152 short[] a = fa.apply(SPECIES.length());
1153 short[] b = fb.apply(SPECIES.length());
1154 short[] r = fr.apply(SPECIES.length());
1155 boolean[] mask = fm.apply(SPECIES.length());
1156 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1157
1158 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1159 for (int i = 0; i < a.length; i += SPECIES.length()) {
1160 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1161 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1162 av.lanewise(VectorOperators.SUADD, bv, vmask).intoArray(r, i);
1163 }
1164 }
1165
1166 bh.consume(r);
1167 }
1168
1169 @Benchmark
1170 public void SUSUB(Blackhole bh) {
1171 short[] a = fa.apply(SPECIES.length());
1172 short[] b = fb.apply(SPECIES.length());
1173 short[] r = fr.apply(SPECIES.length());
1174
1175 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1176 for (int i = 0; i < a.length; i += SPECIES.length()) {
1177 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1178 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1179 av.lanewise(VectorOperators.SUSUB, bv).intoArray(r, i);
1180 }
1181 }
1182
1183 bh.consume(r);
1184 }
1185
1186 @Benchmark
1187 public void SUSUBMasked(Blackhole bh) {
1188 short[] a = fa.apply(SPECIES.length());
1189 short[] b = fb.apply(SPECIES.length());
1190 short[] r = fr.apply(SPECIES.length());
1191 boolean[] mask = fm.apply(SPECIES.length());
1192 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1193
1194 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1195 for (int i = 0; i < a.length; i += SPECIES.length()) {
1196 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1197 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1198 av.lanewise(VectorOperators.SUSUB, bv, vmask).intoArray(r, i);
1199 }
1200 }
1201
1202 bh.consume(r);
1203 }
1204
1205 @Benchmark
1206 public void ANDLanes(Blackhole bh) {
1207 short[] a = fa.apply(SPECIES.length());
1208 short ra = -1;
1209
1210 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1211 ra = -1;
1212 for (int i = 0; i < a.length; i += SPECIES.length()) {
1213 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1214 ra &= av.reduceLanes(VectorOperators.AND);
1215 }
1216 }
1217 bh.consume(ra);
1218 }
1219
1220 @Benchmark
1221 public void ANDMaskedLanes(Blackhole bh) {
1222 short[] a = fa.apply(SPECIES.length());
1223 boolean[] mask = fm.apply(SPECIES.length());
1224 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1225 short ra = -1;
1226
1227 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1228 ra = -1;
1229 for (int i = 0; i < a.length; i += SPECIES.length()) {
1230 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1231 ra &= av.reduceLanes(VectorOperators.AND, vmask);
1232 }
1233 }
1234 bh.consume(ra);
1235 }
1236
1237 @Benchmark
1238 public void ORLanes(Blackhole bh) {
1239 short[] a = fa.apply(SPECIES.length());
1240 short ra = 0;
1241
1242 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1243 ra = 0;
1244 for (int i = 0; i < a.length; i += SPECIES.length()) {
1245 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1246 ra |= av.reduceLanes(VectorOperators.OR);
1247 }
1248 }
1249 bh.consume(ra);
1250 }
1251
1252 @Benchmark
1253 public void ORMaskedLanes(Blackhole bh) {
1254 short[] a = fa.apply(SPECIES.length());
1255 boolean[] mask = fm.apply(SPECIES.length());
1256 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1257 short ra = 0;
1258
1259 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1260 ra = 0;
1261 for (int i = 0; i < a.length; i += SPECIES.length()) {
1262 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1263 ra |= av.reduceLanes(VectorOperators.OR, vmask);
1264 }
1265 }
1266 bh.consume(ra);
1267 }
1268
1269 @Benchmark
1270 public void XORLanes(Blackhole bh) {
1271 short[] a = fa.apply(SPECIES.length());
1272 short ra = 0;
1273
1274 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1275 ra = 0;
1276 for (int i = 0; i < a.length; i += SPECIES.length()) {
1277 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1278 ra ^= av.reduceLanes(VectorOperators.XOR);
1279 }
1280 }
1281 bh.consume(ra);
1282 }
1283
1284 @Benchmark
1285 public void XORMaskedLanes(Blackhole bh) {
1286 short[] a = fa.apply(SPECIES.length());
1287 boolean[] mask = fm.apply(SPECIES.length());
1288 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1289 short ra = 0;
1290
1291 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1292 ra = 0;
1293 for (int i = 0; i < a.length; i += SPECIES.length()) {
1294 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1295 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
1296 }
1297 }
1298 bh.consume(ra);
1299 }
1300
1301 @Benchmark
1302 public void ADDLanes(Blackhole bh) {
1303 short[] a = fa.apply(SPECIES.length());
1304 short ra = 0;
1305
1306 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1307 ra = 0;
1308 for (int i = 0; i < a.length; i += SPECIES.length()) {
1309 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1310 ra += av.reduceLanes(VectorOperators.ADD);
1311 }
1312 }
1313 bh.consume(ra);
1314 }
1315
1316 @Benchmark
1317 public void ADDMaskedLanes(Blackhole bh) {
1318 short[] a = fa.apply(SPECIES.length());
1319 boolean[] mask = fm.apply(SPECIES.length());
1320 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1321 short ra = 0;
1322
1323 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1324 ra = 0;
1325 for (int i = 0; i < a.length; i += SPECIES.length()) {
1326 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1327 ra += av.reduceLanes(VectorOperators.ADD, vmask);
1328 }
1329 }
1330 bh.consume(ra);
1331 }
1332
1333 @Benchmark
1334 public void MULLanes(Blackhole bh) {
1335 short[] a = fa.apply(SPECIES.length());
1336 short ra = 1;
1337
1338 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1339 ra = 1;
1340 for (int i = 0; i < a.length; i += SPECIES.length()) {
1341 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1342 ra *= av.reduceLanes(VectorOperators.MUL);
1343 }
1344 }
1345 bh.consume(ra);
1346 }
1347
1348 @Benchmark
1349 public void MULMaskedLanes(Blackhole bh) {
1350 short[] a = fa.apply(SPECIES.length());
1351 boolean[] mask = fm.apply(SPECIES.length());
1352 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1353 short ra = 1;
1354
1355 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1356 ra = 1;
1357 for (int i = 0; i < a.length; i += SPECIES.length()) {
1358 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1359 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
1360 }
1361 }
1362 bh.consume(ra);
1363 }
1364
1365 @Benchmark
1366 public void MINLanes(Blackhole bh) {
1367 short[] a = fa.apply(SPECIES.length());
1368 short ra = Short.MAX_VALUE;
1369
1370 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1371 ra = Short.MAX_VALUE;
1372 for (int i = 0; i < a.length; i += SPECIES.length()) {
1373 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1374 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
1375 }
1376 }
1377 bh.consume(ra);
1378 }
1379
1380 @Benchmark
1381 public void MINMaskedLanes(Blackhole bh) {
1382 short[] a = fa.apply(SPECIES.length());
1383 boolean[] mask = fm.apply(SPECIES.length());
1384 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1385 short ra = Short.MAX_VALUE;
1386
1387 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1388 ra = Short.MAX_VALUE;
1389 for (int i = 0; i < a.length; i += SPECIES.length()) {
1390 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1391 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
1392 }
1393 }
1394 bh.consume(ra);
1395 }
1396
1397 @Benchmark
1398 public void MAXLanes(Blackhole bh) {
1399 short[] a = fa.apply(SPECIES.length());
1400 short ra = Short.MIN_VALUE;
1401
1402 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1403 ra = Short.MIN_VALUE;
1404 for (int i = 0; i < a.length; i += SPECIES.length()) {
1405 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1406 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
1407 }
1408 }
1409 bh.consume(ra);
1410 }
1411
1412 @Benchmark
1413 public void MAXMaskedLanes(Blackhole bh) {
1414 short[] a = fa.apply(SPECIES.length());
1415 boolean[] mask = fm.apply(SPECIES.length());
1416 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1417 short ra = Short.MIN_VALUE;
1418
1419 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1420 ra = Short.MIN_VALUE;
1421 for (int i = 0; i < a.length; i += SPECIES.length()) {
1422 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1423 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
1424 }
1425 }
1426 bh.consume(ra);
1427 }
1428
1429 @Benchmark
1430 public void FIRST_NONZEROLanes(Blackhole bh) {
1431 short[] a = fa.apply(SPECIES.length());
1432 short ra = (short) 0;
1433
1434 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1435 ra = (short) 0;
1436 for (int i = 0; i < a.length; i += SPECIES.length()) {
1437 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1438 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
1439 }
1440 }
1441 bh.consume(ra);
1442 }
1443
1444 @Benchmark
1445 public void FIRST_NONZEROMaskedLanes(Blackhole bh) {
1446 short[] a = fa.apply(SPECIES.length());
1447 boolean[] mask = fm.apply(SPECIES.length());
1448 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1449 short ra = (short) 0;
1450
1451 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1452 ra = (short) 0;
1453 for (int i = 0; i < a.length; i += SPECIES.length()) {
1454 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1455 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
1456 }
1457 }
1458 bh.consume(ra);
1459 }
1460
1461 @Benchmark
1462 public void anyTrue(Blackhole bh) {
1463 boolean[] mask = fm.apply(SPECIES.length());
1464 boolean[] r = fmr.apply(SPECIES.length());
1465
1466 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1467 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1468 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
1469 r[i] = vmask.anyTrue();
1470 }
1471 }
1472
1473 bh.consume(r);
1474 }
1475
1476 @Benchmark
1477 public void allTrue(Blackhole bh) {
1478 boolean[] mask = fm.apply(SPECIES.length());
1479 boolean[] r = fmr.apply(SPECIES.length());
1480
1481 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1482 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1483 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
1484 r[i] = vmask.allTrue();
1485 }
1486 }
1487
1488 bh.consume(r);
1489 }
1490
1491 @Benchmark
1492 public void withLane(Blackhole bh) {
1493 short[] a = fa.apply(SPECIES.length());
1494 short[] b = fb.apply(SPECIES.length());
1495 short[] r = fr.apply(SPECIES.length());
1496
1497 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1498 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
1499 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1500 av.withLane(j, b[i + j]).intoArray(r, i);
1501 a[i + j] = b[i + j];
1502 j = (j + 1) & (SPECIES.length() - 1);
1503 }
1504 }
1505
1506 bh.consume(r);
1507 }
1508
1509 @Benchmark
1510 public Object IS_DEFAULT() {
1511 short[] a = fa.apply(size);
1512 boolean[] ms = fmt.apply(size);
1513 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1514
1515 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1516 for (int i = 0; i < a.length; i += SPECIES.length()) {
1517 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1518
1519 // accumulate results, so JIT can't eliminate relevant computations
1520 m = m.and(av.test(VectorOperators.IS_DEFAULT));
1521 }
1522 }
1523
1524 return m;
1525 }
1526
1527 @Benchmark
1528 public Object IS_NEGATIVE() {
1529 short[] a = fa.apply(size);
1530 boolean[] ms = fmt.apply(size);
1531 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1532
1533 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1534 for (int i = 0; i < a.length; i += SPECIES.length()) {
1535 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1536
1537 // accumulate results, so JIT can't eliminate relevant computations
1538 m = m.and(av.test(VectorOperators.IS_NEGATIVE));
1539 }
1540 }
1541
1542 return m;
1543 }
1544 @Benchmark
1545 public Object LT() {
1546 short[] a = fa.apply(size);
1547 short[] b = fb.apply(size);
1548 boolean[] ms = fmt.apply(size);
1549 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1550
1551 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1552 for (int i = 0; i < a.length; i += SPECIES.length()) {
1553 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1554 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1555
1556 // accumulate results, so JIT can't eliminate relevant computations
1557 m = m.and(av.compare(VectorOperators.LT, bv));
1558 }
1559 }
1560
1561 return m;
1562 }
1563 @Benchmark
1564 public Object GT() {
1565 short[] a = fa.apply(size);
1566 short[] b = fb.apply(size);
1567 boolean[] ms = fmt.apply(size);
1568 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1569
1570 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1571 for (int i = 0; i < a.length; i += SPECIES.length()) {
1572 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1573 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1574
1575 // accumulate results, so JIT can't eliminate relevant computations
1576 m = m.and(av.compare(VectorOperators.GT, bv));
1577 }
1578 }
1579
1580 return m;
1581 }
1582 @Benchmark
1583 public Object EQ() {
1584 short[] a = fa.apply(size);
1585 short[] b = fb.apply(size);
1586 boolean[] ms = fmt.apply(size);
1587 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1588
1589 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1590 for (int i = 0; i < a.length; i += SPECIES.length()) {
1591 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1592 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1593
1594 // accumulate results, so JIT can't eliminate relevant computations
1595 m = m.and(av.compare(VectorOperators.EQ, bv));
1596 }
1597 }
1598
1599 return m;
1600 }
1601 @Benchmark
1602 public Object NE() {
1603 short[] a = fa.apply(size);
1604 short[] b = fb.apply(size);
1605 boolean[] ms = fmt.apply(size);
1606 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1607
1608 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1609 for (int i = 0; i < a.length; i += SPECIES.length()) {
1610 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1611 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1612
1613 // accumulate results, so JIT can't eliminate relevant computations
1614 m = m.and(av.compare(VectorOperators.NE, bv));
1615 }
1616 }
1617
1618 return m;
1619 }
1620 @Benchmark
1621 public Object LE() {
1622 short[] a = fa.apply(size);
1623 short[] b = fb.apply(size);
1624 boolean[] ms = fmt.apply(size);
1625 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1626
1627 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1628 for (int i = 0; i < a.length; i += SPECIES.length()) {
1629 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1630 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1631
1632 // accumulate results, so JIT can't eliminate relevant computations
1633 m = m.and(av.compare(VectorOperators.LE, bv));
1634 }
1635 }
1636
1637 return m;
1638 }
1639 @Benchmark
1640 public Object GE() {
1641 short[] a = fa.apply(size);
1642 short[] b = fb.apply(size);
1643 boolean[] ms = fmt.apply(size);
1644 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1645
1646 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1647 for (int i = 0; i < a.length; i += SPECIES.length()) {
1648 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1649 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1650
1651 // accumulate results, so JIT can't eliminate relevant computations
1652 m = m.and(av.compare(VectorOperators.GE, bv));
1653 }
1654 }
1655
1656 return m;
1657 }
1658 @Benchmark
1659 public Object ULT() {
1660 short[] a = fa.apply(size);
1661 short[] b = fb.apply(size);
1662 boolean[] ms = fmt.apply(size);
1663 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1664
1665 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1666 for (int i = 0; i < a.length; i += SPECIES.length()) {
1667 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1668 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1669
1670 // accumulate results, so JIT can't eliminate relevant computations
1671 m = m.and(av.compare(VectorOperators.ULT, bv));
1672 }
1673 }
1674
1675 return m;
1676 }
1677 @Benchmark
1678 public Object UGT() {
1679 short[] a = fa.apply(size);
1680 short[] b = fb.apply(size);
1681 boolean[] ms = fmt.apply(size);
1682 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1683
1684 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1685 for (int i = 0; i < a.length; i += SPECIES.length()) {
1686 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1687 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1688
1689 // accumulate results, so JIT can't eliminate relevant computations
1690 m = m.and(av.compare(VectorOperators.UGT, bv));
1691 }
1692 }
1693
1694 return m;
1695 }
1696 @Benchmark
1697 public Object ULE() {
1698 short[] a = fa.apply(size);
1699 short[] b = fb.apply(size);
1700 boolean[] ms = fmt.apply(size);
1701 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1702
1703 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1704 for (int i = 0; i < a.length; i += SPECIES.length()) {
1705 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1706 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1707
1708 // accumulate results, so JIT can't eliminate relevant computations
1709 m = m.and(av.compare(VectorOperators.ULE, bv));
1710 }
1711 }
1712
1713 return m;
1714 }
1715 @Benchmark
1716 public Object UGE() {
1717 short[] a = fa.apply(size);
1718 short[] b = fb.apply(size);
1719 boolean[] ms = fmt.apply(size);
1720 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1721
1722 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1723 for (int i = 0; i < a.length; i += SPECIES.length()) {
1724 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1725 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1726
1727 // accumulate results, so JIT can't eliminate relevant computations
1728 m = m.and(av.compare(VectorOperators.UGE, bv));
1729 }
1730 }
1731
1732 return m;
1733 }
1734
1735 @Benchmark
1736 public void blend(Blackhole bh) {
1737 short[] a = fa.apply(SPECIES.length());
1738 short[] b = fb.apply(SPECIES.length());
1739 short[] r = fr.apply(SPECIES.length());
1740 boolean[] mask = fm.apply(SPECIES.length());
1741 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1742
1743 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1744 for (int i = 0; i < a.length; i += SPECIES.length()) {
1745 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1746 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1747 av.blend(bv, vmask).intoArray(r, i);
1748 }
1749 }
1750
1751 bh.consume(r);
1752 }
1753
1754 @Benchmark
1755 public void rearrange(Blackhole bh) {
1756 short[] a = fa.apply(SPECIES.length());
1757 int[] order = fs.apply(a.length, SPECIES.length());
1758 short[] r = fr.apply(SPECIES.length());
1759
1760 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1761 for (int i = 0; i < a.length; i += SPECIES.length()) {
1762 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1763 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
1764 }
1765 }
1766
1767 bh.consume(r);
1768 }
1769 @Benchmark
1770 public Object compress() {
1771 short[] a = fa.apply(size);
1772 short[] r = fb.apply(size);
1773 boolean[] ms = fmt.apply(size);
1774 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1775
1776 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1777 for (int i = 0; i < a.length; i += SPECIES.length()) {
1778 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1779 av.compress(m).intoArray(r, i);
1780 }
1781 }
1782
1783 return r;
1784 }
1785
1786 @Benchmark
1787 public Object expand() {
1788 short[] a = fa.apply(size);
1789 short[] r = fb.apply(size);
1790 boolean[] ms = fmt.apply(size);
1791 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, 0);
1792
1793 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1794 for (int i = 0; i < a.length; i += SPECIES.length()) {
1795 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1796 av.expand(m).intoArray(r, i);
1797 }
1798 }
1799
1800 return r;
1801 }
1802
1803 @Benchmark
1804 public Object maskCompress() {
1805 boolean[] ms = fmt.apply(size);
1806 boolean[] rs = fmt.apply(size);
1807
1808 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1809 for (int i = 0, j = 0; i < ms.length; i += SPECIES.length()) {
1810 VectorMask<Short> m = VectorMask.fromArray(SPECIES, ms, i);
1811 m.compress().intoArray(rs, j);
1812 j += m.trueCount();
1813 }
1814 }
1815
1816 return rs;
1817 }
1818
1819 @Benchmark
1820 public void laneextract(Blackhole bh) {
1821 short[] a = fa.apply(SPECIES.length());
1822 short[] r = fr.apply(SPECIES.length());
1823
1824 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1825 for (int i = 0; i < a.length; i += SPECIES.length()) {
1826 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1827 int num_lanes = SPECIES.length();
1828 // Manually unroll because full unroll happens after intrinsification.
1829 // Unroll is needed because get intrinsic requires for index to be a known constant.
1830 if (num_lanes == 1) {
1831 r[i]=av.lane(0);
1832 } else if (num_lanes == 2) {
1833 r[i]=av.lane(0);
1834 r[i+1]=av.lane(1);
1835 } else if (num_lanes == 4) {
1836 r[i]=av.lane(0);
1837 r[i+1]=av.lane(1);
1838 r[i+2]=av.lane(2);
1839 r[i+3]=av.lane(3);
1840 } else if (num_lanes == 8) {
1841 r[i]=av.lane(0);
1842 r[i+1]=av.lane(1);
1843 r[i+2]=av.lane(2);
1844 r[i+3]=av.lane(3);
1845 r[i+4]=av.lane(4);
1846 r[i+5]=av.lane(5);
1847 r[i+6]=av.lane(6);
1848 r[i+7]=av.lane(7);
1849 } else if (num_lanes == 16) {
1850 r[i]=av.lane(0);
1851 r[i+1]=av.lane(1);
1852 r[i+2]=av.lane(2);
1853 r[i+3]=av.lane(3);
1854 r[i+4]=av.lane(4);
1855 r[i+5]=av.lane(5);
1856 r[i+6]=av.lane(6);
1857 r[i+7]=av.lane(7);
1858 r[i+8]=av.lane(8);
1859 r[i+9]=av.lane(9);
1860 r[i+10]=av.lane(10);
1861 r[i+11]=av.lane(11);
1862 r[i+12]=av.lane(12);
1863 r[i+13]=av.lane(13);
1864 r[i+14]=av.lane(14);
1865 r[i+15]=av.lane(15);
1866 } else if (num_lanes == 32) {
1867 r[i]=av.lane(0);
1868 r[i+1]=av.lane(1);
1869 r[i+2]=av.lane(2);
1870 r[i+3]=av.lane(3);
1871 r[i+4]=av.lane(4);
1872 r[i+5]=av.lane(5);
1873 r[i+6]=av.lane(6);
1874 r[i+7]=av.lane(7);
1875 r[i+8]=av.lane(8);
1876 r[i+9]=av.lane(9);
1877 r[i+10]=av.lane(10);
1878 r[i+11]=av.lane(11);
1879 r[i+12]=av.lane(12);
1880 r[i+13]=av.lane(13);
1881 r[i+14]=av.lane(14);
1882 r[i+15]=av.lane(15);
1883 r[i+16]=av.lane(16);
1884 r[i+17]=av.lane(17);
1885 r[i+18]=av.lane(18);
1886 r[i+19]=av.lane(19);
1887 r[i+20]=av.lane(20);
1888 r[i+21]=av.lane(21);
1889 r[i+22]=av.lane(22);
1890 r[i+23]=av.lane(23);
1891 r[i+24]=av.lane(24);
1892 r[i+25]=av.lane(25);
1893 r[i+26]=av.lane(26);
1894 r[i+27]=av.lane(27);
1895 r[i+28]=av.lane(28);
1896 r[i+29]=av.lane(29);
1897 r[i+30]=av.lane(30);
1898 r[i+31]=av.lane(31);
1899 } else if (num_lanes == 64) {
1900 r[i]=av.lane(0);
1901 r[i+1]=av.lane(1);
1902 r[i+2]=av.lane(2);
1903 r[i+3]=av.lane(3);
1904 r[i+4]=av.lane(4);
1905 r[i+5]=av.lane(5);
1906 r[i+6]=av.lane(6);
1907 r[i+7]=av.lane(7);
1908 r[i+8]=av.lane(8);
1909 r[i+9]=av.lane(9);
1910 r[i+10]=av.lane(10);
1911 r[i+11]=av.lane(11);
1912 r[i+12]=av.lane(12);
1913 r[i+13]=av.lane(13);
1914 r[i+14]=av.lane(14);
1915 r[i+15]=av.lane(15);
1916 r[i+16]=av.lane(16);
1917 r[i+17]=av.lane(17);
1918 r[i+18]=av.lane(18);
1919 r[i+19]=av.lane(19);
1920 r[i+20]=av.lane(20);
1921 r[i+21]=av.lane(21);
1922 r[i+22]=av.lane(22);
1923 r[i+23]=av.lane(23);
1924 r[i+24]=av.lane(24);
1925 r[i+25]=av.lane(25);
1926 r[i+26]=av.lane(26);
1927 r[i+27]=av.lane(27);
1928 r[i+28]=av.lane(28);
1929 r[i+29]=av.lane(29);
1930 r[i+30]=av.lane(30);
1931 r[i+31]=av.lane(31);
1932 r[i+32]=av.lane(32);
1933 r[i+33]=av.lane(33);
1934 r[i+34]=av.lane(34);
1935 r[i+35]=av.lane(35);
1936 r[i+36]=av.lane(36);
1937 r[i+37]=av.lane(37);
1938 r[i+38]=av.lane(38);
1939 r[i+39]=av.lane(39);
1940 r[i+40]=av.lane(40);
1941 r[i+41]=av.lane(41);
1942 r[i+42]=av.lane(42);
1943 r[i+43]=av.lane(43);
1944 r[i+44]=av.lane(44);
1945 r[i+45]=av.lane(45);
1946 r[i+46]=av.lane(46);
1947 r[i+47]=av.lane(47);
1948 r[i+48]=av.lane(48);
1949 r[i+49]=av.lane(49);
1950 r[i+50]=av.lane(50);
1951 r[i+51]=av.lane(51);
1952 r[i+52]=av.lane(52);
1953 r[i+53]=av.lane(53);
1954 r[i+54]=av.lane(54);
1955 r[i+55]=av.lane(55);
1956 r[i+56]=av.lane(56);
1957 r[i+57]=av.lane(57);
1958 r[i+58]=av.lane(58);
1959 r[i+59]=av.lane(59);
1960 r[i+60]=av.lane(60);
1961 r[i+61]=av.lane(61);
1962 r[i+62]=av.lane(62);
1963 r[i+63]=av.lane(63);
1964 } else {
1965 for (int j = 0; j < SPECIES.length(); j++) {
1966 r[i+j]=av.lane(j);
1967 }
1968 }
1969 }
1970 }
1971
1972 bh.consume(r);
1973 }
1974
1975 @Benchmark
1976 public void broadcast(Blackhole bh) {
1977 short[] a = fa.apply(SPECIES.length());
1978 short[] r = new short[a.length];
1979
1980 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1981 for (int i = 0; i < a.length; i += SPECIES.length()) {
1982 ShortVector.broadcast(SPECIES, a[i]).intoArray(r, i);
1983 }
1984 }
1985
1986 bh.consume(r);
1987 }
1988
1989 @Benchmark
1990 public void zero(Blackhole bh) {
1991 short[] a = fa.apply(SPECIES.length());
1992 short[] r = new short[a.length];
1993
1994 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1995 for (int i = 0; i < a.length; i += SPECIES.length()) {
1996 ShortVector.zero(SPECIES).intoArray(a, i);
1997 }
1998 }
1999
2000 bh.consume(r);
2001 }
2002
2003 @Benchmark
2004 public void sliceUnary(Blackhole bh) {
2005 short[] a = fa.apply(SPECIES.length());
2006 short[] r = new short[a.length];
2007 int origin = RAND.nextInt(SPECIES.length());
2008 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2009 for (int i = 0; i < a.length; i += SPECIES.length()) {
2010 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2011 av.slice(origin).intoArray(r, i);
2012 }
2013 }
2014
2015 bh.consume(r);
2016 }
2017
2018 @Benchmark
2019 public void sliceBinary(Blackhole bh) {
2020 short[] a = fa.apply(SPECIES.length());
2021 short[] b = fb.apply(SPECIES.length());
2022 short[] r = new short[a.length];
2023 int origin = RAND.nextInt(SPECIES.length());
2024 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2025 for (int i = 0; i < a.length; i += SPECIES.length()) {
2026 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2027 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2028 av.slice(origin, bv).intoArray(r, i);
2029 }
2030 }
2031
2032 bh.consume(r);
2033 }
2034
2035 @Benchmark
2036 public void sliceMasked(Blackhole bh) {
2037 short[] a = fa.apply(SPECIES.length());
2038 short[] b = fb.apply(SPECIES.length());
2039 boolean[] mask = fm.apply(SPECIES.length());
2040 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2041
2042 short[] r = new short[a.length];
2043 int origin = RAND.nextInt(SPECIES.length());
2044 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2045 for (int i = 0; i < a.length; i += SPECIES.length()) {
2046 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2047 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2048 av.slice(origin, bv, vmask).intoArray(r, i);
2049 }
2050 }
2051
2052 bh.consume(r);
2053 }
2054
2055 @Benchmark
2056 public void unsliceUnary(Blackhole bh) {
2057 short[] a = fa.apply(SPECIES.length());
2058 short[] r = new short[a.length];
2059 int origin = RAND.nextInt(SPECIES.length());
2060 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2061 for (int i = 0; i < a.length; i += SPECIES.length()) {
2062 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2063 av.unslice(origin).intoArray(r, i);
2064 }
2065 }
2066
2067 bh.consume(r);
2068 }
2069
2070 @Benchmark
2071 public void unsliceBinary(Blackhole bh) {
2072 short[] a = fa.apply(SPECIES.length());
2073 short[] b = fb.apply(SPECIES.length());
2074 short[] r = new short[a.length];
2075 int origin = RAND.nextInt(SPECIES.length());
2076 int part = RAND.nextInt(2);
2077 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2078 for (int i = 0; i < a.length; i += SPECIES.length()) {
2079 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2080 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2081 av.unslice(origin, bv, part).intoArray(r, i);
2082 }
2083 }
2084
2085 bh.consume(r);
2086 }
2087
2088 @Benchmark
2089 public void unsliceMasked(Blackhole bh) {
2090 short[] a = fa.apply(SPECIES.length());
2091 short[] b = fb.apply(SPECIES.length());
2092 boolean[] mask = fm.apply(SPECIES.length());
2093 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2094 short[] r = new short[a.length];
2095 int origin = RAND.nextInt(SPECIES.length());
2096 int part = RAND.nextInt(2);
2097 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2098 for (int i = 0; i < a.length; i += SPECIES.length()) {
2099 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2100 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2101 av.unslice(origin, bv, part, vmask).intoArray(r, i);
2102 }
2103 }
2104
2105 bh.consume(r);
2106 }
2107
2108 @Benchmark
2109 public void BITWISE_BLEND(Blackhole bh) {
2110 short[] a = fa.apply(SPECIES.length());
2111 short[] b = fb.apply(SPECIES.length());
2112 short[] c = fc.apply(SPECIES.length());
2113 short[] r = fr.apply(SPECIES.length());
2114
2115 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2116 for (int i = 0; i < a.length; i += SPECIES.length()) {
2117 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2118 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2119 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
2120 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
2121 }
2122 }
2123
2124 bh.consume(r);
2125 }
2126
2127 @Benchmark
2128 public void BITWISE_BLENDMasked(Blackhole bh) {
2129 short[] a = fa.apply(SPECIES.length());
2130 short[] b = fb.apply(SPECIES.length());
2131 short[] c = fc.apply(SPECIES.length());
2132 short[] r = fr.apply(SPECIES.length());
2133 boolean[] mask = fm.apply(SPECIES.length());
2134 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2135
2136 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2137 for (int i = 0; i < a.length; i += SPECIES.length()) {
2138 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2139 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2140 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
2141 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
2142 }
2143 }
2144
2145 bh.consume(r);
2146 }
2147
2148 @Benchmark
2149 public void NEG(Blackhole bh) {
2150 short[] a = fa.apply(SPECIES.length());
2151 short[] r = fr.apply(SPECIES.length());
2152
2153 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2154 for (int i = 0; i < a.length; i += SPECIES.length()) {
2155 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2156 av.lanewise(VectorOperators.NEG).intoArray(r, i);
2157 }
2158 }
2159
2160 bh.consume(r);
2161 }
2162
2163 @Benchmark
2164 public void NEGMasked(Blackhole bh) {
2165 short[] a = fa.apply(SPECIES.length());
2166 short[] r = fr.apply(SPECIES.length());
2167 boolean[] mask = fm.apply(SPECIES.length());
2168 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2169
2170 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2171 for (int i = 0; i < a.length; i += SPECIES.length()) {
2172 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2173 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
2174 }
2175 }
2176
2177 bh.consume(r);
2178 }
2179
2180 @Benchmark
2181 public void ABS(Blackhole bh) {
2182 short[] a = fa.apply(SPECIES.length());
2183 short[] r = fr.apply(SPECIES.length());
2184
2185 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2186 for (int i = 0; i < a.length; i += SPECIES.length()) {
2187 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2188 av.lanewise(VectorOperators.ABS).intoArray(r, i);
2189 }
2190 }
2191
2192 bh.consume(r);
2193 }
2194
2195 @Benchmark
2196 public void ABSMasked(Blackhole bh) {
2197 short[] a = fa.apply(SPECIES.length());
2198 short[] r = fr.apply(SPECIES.length());
2199 boolean[] mask = fm.apply(SPECIES.length());
2200 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2201
2202 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2203 for (int i = 0; i < a.length; i += SPECIES.length()) {
2204 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2205 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
2206 }
2207 }
2208
2209 bh.consume(r);
2210 }
2211
2212 @Benchmark
2213 public void NOT(Blackhole bh) {
2214 short[] a = fa.apply(SPECIES.length());
2215 short[] r = fr.apply(SPECIES.length());
2216
2217 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2218 for (int i = 0; i < a.length; i += SPECIES.length()) {
2219 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2220 av.lanewise(VectorOperators.NOT).intoArray(r, i);
2221 }
2222 }
2223
2224 bh.consume(r);
2225 }
2226
2227 @Benchmark
2228 public void NOTMasked(Blackhole bh) {
2229 short[] a = fa.apply(SPECIES.length());
2230 short[] r = fr.apply(SPECIES.length());
2231 boolean[] mask = fm.apply(SPECIES.length());
2232 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2233
2234 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2235 for (int i = 0; i < a.length; i += SPECIES.length()) {
2236 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2237 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
2238 }
2239 }
2240
2241 bh.consume(r);
2242 }
2243
2244 @Benchmark
2245 public void ZOMO(Blackhole bh) {
2246 short[] a = fa.apply(SPECIES.length());
2247 short[] r = fr.apply(SPECIES.length());
2248
2249 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2250 for (int i = 0; i < a.length; i += SPECIES.length()) {
2251 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2252 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
2253 }
2254 }
2255
2256 bh.consume(r);
2257 }
2258
2259 @Benchmark
2260 public void ZOMOMasked(Blackhole bh) {
2261 short[] a = fa.apply(SPECIES.length());
2262 short[] r = fr.apply(SPECIES.length());
2263 boolean[] mask = fm.apply(SPECIES.length());
2264 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2265
2266 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2267 for (int i = 0; i < a.length; i += SPECIES.length()) {
2268 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2269 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
2270 }
2271 }
2272
2273 bh.consume(r);
2274 }
2275
2276 @Benchmark
2277 public void BIT_COUNT(Blackhole bh) {
2278 short[] a = fa.apply(SPECIES.length());
2279 short[] r = fr.apply(SPECIES.length());
2280
2281 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2282 for (int i = 0; i < a.length; i += SPECIES.length()) {
2283 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2284 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
2285 }
2286 }
2287
2288 bh.consume(r);
2289 }
2290
2291 @Benchmark
2292 public void BIT_COUNTMasked(Blackhole bh) {
2293 short[] a = fa.apply(SPECIES.length());
2294 short[] r = fr.apply(SPECIES.length());
2295 boolean[] mask = fm.apply(SPECIES.length());
2296 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2297
2298 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2299 for (int i = 0; i < a.length; i += SPECIES.length()) {
2300 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2301 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
2302 }
2303 }
2304
2305 bh.consume(r);
2306 }
2307
2308 @Benchmark
2309 public void TRAILING_ZEROS_COUNT(Blackhole bh) {
2310 short[] a = fa.apply(SPECIES.length());
2311 short[] r = fr.apply(SPECIES.length());
2312
2313 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2314 for (int i = 0; i < a.length; i += SPECIES.length()) {
2315 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2316 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
2317 }
2318 }
2319
2320 bh.consume(r);
2321 }
2322
2323 @Benchmark
2324 public void TRAILING_ZEROS_COUNTMasked(Blackhole bh) {
2325 short[] a = fa.apply(SPECIES.length());
2326 short[] r = fr.apply(SPECIES.length());
2327 boolean[] mask = fm.apply(SPECIES.length());
2328 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2329
2330 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2331 for (int i = 0; i < a.length; i += SPECIES.length()) {
2332 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2333 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
2334 }
2335 }
2336
2337 bh.consume(r);
2338 }
2339
2340 @Benchmark
2341 public void LEADING_ZEROS_COUNT(Blackhole bh) {
2342 short[] a = fa.apply(SPECIES.length());
2343 short[] r = fr.apply(SPECIES.length());
2344
2345 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2346 for (int i = 0; i < a.length; i += SPECIES.length()) {
2347 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2348 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
2349 }
2350 }
2351
2352 bh.consume(r);
2353 }
2354
2355 @Benchmark
2356 public void LEADING_ZEROS_COUNTMasked(Blackhole bh) {
2357 short[] a = fa.apply(SPECIES.length());
2358 short[] r = fr.apply(SPECIES.length());
2359 boolean[] mask = fm.apply(SPECIES.length());
2360 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2361
2362 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2363 for (int i = 0; i < a.length; i += SPECIES.length()) {
2364 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2365 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
2366 }
2367 }
2368
2369 bh.consume(r);
2370 }
2371
2372 @Benchmark
2373 public void REVERSE(Blackhole bh) {
2374 short[] a = fa.apply(SPECIES.length());
2375 short[] r = fr.apply(SPECIES.length());
2376
2377 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2378 for (int i = 0; i < a.length; i += SPECIES.length()) {
2379 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2380 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
2381 }
2382 }
2383
2384 bh.consume(r);
2385 }
2386
2387 @Benchmark
2388 public void REVERSEMasked(Blackhole bh) {
2389 short[] a = fa.apply(SPECIES.length());
2390 short[] r = fr.apply(SPECIES.length());
2391 boolean[] mask = fm.apply(SPECIES.length());
2392 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2393
2394 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2395 for (int i = 0; i < a.length; i += SPECIES.length()) {
2396 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2397 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
2398 }
2399 }
2400
2401 bh.consume(r);
2402 }
2403
2404 @Benchmark
2405 public void REVERSE_BYTES(Blackhole bh) {
2406 short[] a = fa.apply(SPECIES.length());
2407 short[] r = fr.apply(SPECIES.length());
2408
2409 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2410 for (int i = 0; i < a.length; i += SPECIES.length()) {
2411 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2412 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
2413 }
2414 }
2415
2416 bh.consume(r);
2417 }
2418
2419 @Benchmark
2420 public void REVERSE_BYTESMasked(Blackhole bh) {
2421 short[] a = fa.apply(SPECIES.length());
2422 short[] r = fr.apply(SPECIES.length());
2423 boolean[] mask = fm.apply(SPECIES.length());
2424 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2425
2426 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2427 for (int i = 0; i < a.length; i += SPECIES.length()) {
2428 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2429 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
2430 }
2431 }
2432
2433 bh.consume(r);
2434 }
2435 }