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