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