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.FloatVector;
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 Float128Vector extends AbstractVectorBenchmark {
50 static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_128;
51
52 static final int INVOC_COUNT = 1; // get rid of outer loop
53
54
55 static float firstNonZero(float a, float b) {
56 return Float.compare(a, (float) 0) != 0 ? a : b;
57 }
58
59
60 @Param("1024")
61 int size;
62
63 float[] fill(IntFunction<Float> f) {
64 float[] array = new float[size];
65 for (int i = 0; i < array.length; i++) {
66 array[i] = f.apply(i);
67 }
68 return array;
69 }
70
71 float[] a, b, c, r;
72 boolean[] m, mt, rm;
73 int[] s;
74
75 @Setup
76 public void init() {
77 size += size % SPECIES.length(); // FIXME: add post-loops
78
79 a = fill(i -> (float)(2*i));
80 b = fill(i -> (float)(i+1));
81 c = fill(i -> (float)(i+5));
82 r = fill(i -> (float)0);
83
84 m = fillMask(size, i -> (i % 2) == 0);
85 mt = fillMask(size, i -> true);
86 rm = fillMask(size, i -> false);
87
88 s = fillInt(size, i -> RAND.nextInt(SPECIES.length()));
89 }
90
91 final IntFunction<float[]> fa = vl -> a;
92 final IntFunction<float[]> fb = vl -> b;
93 final IntFunction<float[]> fc = vl -> c;
94 final IntFunction<float[]> fr = vl -> r;
95 final IntFunction<boolean[]> fm = vl -> m;
96 final IntFunction<boolean[]> fmt = vl -> mt;
97 final IntFunction<boolean[]> fmr = vl -> rm;
98 final BiFunction<Integer,Integer,int[]> fs = (i,j) -> s;
99
100
101 @Benchmark
102 public void ADD(Blackhole bh) {
103 float[] a = fa.apply(SPECIES.length());
104 float[] b = fb.apply(SPECIES.length());
105 float[] r = fr.apply(SPECIES.length());
106
107 for (int ic = 0; ic < INVOC_COUNT; ic++) {
108 for (int i = 0; i < a.length; i += SPECIES.length()) {
109 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
110 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
111 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
112 }
113 }
114
115 bh.consume(r);
116 }
117
118 @Benchmark
119 public void ADDMasked(Blackhole bh) {
120 float[] a = fa.apply(SPECIES.length());
121 float[] b = fb.apply(SPECIES.length());
122 float[] r = fr.apply(SPECIES.length());
123 boolean[] mask = fm.apply(SPECIES.length());
124 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
125
126 for (int ic = 0; ic < INVOC_COUNT; ic++) {
127 for (int i = 0; i < a.length; i += SPECIES.length()) {
128 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
129 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
130 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
131 }
132 }
133
134 bh.consume(r);
135 }
136
137 @Benchmark
138 public void SUB(Blackhole bh) {
139 float[] a = fa.apply(SPECIES.length());
140 float[] b = fb.apply(SPECIES.length());
141 float[] r = fr.apply(SPECIES.length());
142
143 for (int ic = 0; ic < INVOC_COUNT; ic++) {
144 for (int i = 0; i < a.length; i += SPECIES.length()) {
145 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
146 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
147 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
148 }
149 }
150
151 bh.consume(r);
152 }
153
154 @Benchmark
155 public void SUBMasked(Blackhole bh) {
156 float[] a = fa.apply(SPECIES.length());
157 float[] b = fb.apply(SPECIES.length());
158 float[] r = fr.apply(SPECIES.length());
159 boolean[] mask = fm.apply(SPECIES.length());
160 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
161
162 for (int ic = 0; ic < INVOC_COUNT; ic++) {
163 for (int i = 0; i < a.length; i += SPECIES.length()) {
164 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
165 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
166 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
167 }
168 }
169
170 bh.consume(r);
171 }
172
173 @Benchmark
174 public void MUL(Blackhole bh) {
175 float[] a = fa.apply(SPECIES.length());
176 float[] b = fb.apply(SPECIES.length());
177 float[] r = fr.apply(SPECIES.length());
178
179 for (int ic = 0; ic < INVOC_COUNT; ic++) {
180 for (int i = 0; i < a.length; i += SPECIES.length()) {
181 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
182 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
183 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
184 }
185 }
186
187 bh.consume(r);
188 }
189
190 @Benchmark
191 public void MULMasked(Blackhole bh) {
192 float[] a = fa.apply(SPECIES.length());
193 float[] b = fb.apply(SPECIES.length());
194 float[] r = fr.apply(SPECIES.length());
195 boolean[] mask = fm.apply(SPECIES.length());
196 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
197
198 for (int ic = 0; ic < INVOC_COUNT; ic++) {
199 for (int i = 0; i < a.length; i += SPECIES.length()) {
200 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
201 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
202 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
203 }
204 }
205
206 bh.consume(r);
207 }
208
209 @Benchmark
210 public void DIV(Blackhole bh) {
211 float[] a = fa.apply(SPECIES.length());
212 float[] b = fb.apply(SPECIES.length());
213 float[] r = fr.apply(SPECIES.length());
214
215 for (int ic = 0; ic < INVOC_COUNT; ic++) {
216 for (int i = 0; i < a.length; i += SPECIES.length()) {
217 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
218 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
219 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
220 }
221 }
222
223 bh.consume(r);
224 }
225
226 @Benchmark
227 public void DIVMasked(Blackhole bh) {
228 float[] a = fa.apply(SPECIES.length());
229 float[] b = fb.apply(SPECIES.length());
230 float[] r = fr.apply(SPECIES.length());
231 boolean[] mask = fm.apply(SPECIES.length());
232 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
233
234 for (int ic = 0; ic < INVOC_COUNT; ic++) {
235 for (int i = 0; i < a.length; i += SPECIES.length()) {
236 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
237 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
238 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
239 }
240 }
241
242 bh.consume(r);
243 }
244
245 @Benchmark
246 public void FIRST_NONZERO(Blackhole bh) {
247 float[] a = fa.apply(SPECIES.length());
248 float[] b = fb.apply(SPECIES.length());
249 float[] r = fr.apply(SPECIES.length());
250
251 for (int ic = 0; ic < INVOC_COUNT; ic++) {
252 for (int i = 0; i < a.length; i += SPECIES.length()) {
253 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
254 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
255 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
256 }
257 }
258
259 bh.consume(r);
260 }
261
262 @Benchmark
263 public void FIRST_NONZEROMasked(Blackhole bh) {
264 float[] a = fa.apply(SPECIES.length());
265 float[] b = fb.apply(SPECIES.length());
266 float[] r = fr.apply(SPECIES.length());
267 boolean[] mask = fm.apply(SPECIES.length());
268 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
269
270 for (int ic = 0; ic < INVOC_COUNT; ic++) {
271 for (int i = 0; i < a.length; i += SPECIES.length()) {
272 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
273 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
274 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
275 }
276 }
277
278 bh.consume(r);
279 }
280
281 @Benchmark
282 public void MIN(Blackhole bh) {
283 float[] a = fa.apply(SPECIES.length());
284 float[] b = fb.apply(SPECIES.length());
285 float[] r = fr.apply(SPECIES.length());
286
287 for (int ic = 0; ic < INVOC_COUNT; ic++) {
288 for (int i = 0; i < a.length; i += SPECIES.length()) {
289 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
290 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
291 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
292 }
293 }
294
295 bh.consume(r);
296 }
297
298 @Benchmark
299 public void MAX(Blackhole bh) {
300 float[] a = fa.apply(SPECIES.length());
301 float[] b = fb.apply(SPECIES.length());
302 float[] r = fr.apply(SPECIES.length());
303
304 for (int ic = 0; ic < INVOC_COUNT; ic++) {
305 for (int i = 0; i < a.length; i += SPECIES.length()) {
306 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
307 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
308 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
309 }
310 }
311
312 bh.consume(r);
313 }
314
315 @Benchmark
316 public void ADDLanes(Blackhole bh) {
317 float[] a = fa.apply(SPECIES.length());
318 float ra = 0;
319
320 for (int ic = 0; ic < INVOC_COUNT; ic++) {
321 ra = 0;
322 for (int i = 0; i < a.length; i += SPECIES.length()) {
323 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
324 ra += av.reduceLanes(VectorOperators.ADD);
325 }
326 }
327 bh.consume(ra);
328 }
329
330 @Benchmark
331 public void ADDMaskedLanes(Blackhole bh) {
332 float[] a = fa.apply(SPECIES.length());
333 boolean[] mask = fm.apply(SPECIES.length());
334 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
335 float ra = 0;
336
337 for (int ic = 0; ic < INVOC_COUNT; ic++) {
338 ra = 0;
339 for (int i = 0; i < a.length; i += SPECIES.length()) {
340 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
341 ra += av.reduceLanes(VectorOperators.ADD, vmask);
342 }
343 }
344 bh.consume(ra);
345 }
346
347 @Benchmark
348 public void MULLanes(Blackhole bh) {
349 float[] a = fa.apply(SPECIES.length());
350 float ra = 1;
351
352 for (int ic = 0; ic < INVOC_COUNT; ic++) {
353 ra = 1;
354 for (int i = 0; i < a.length; i += SPECIES.length()) {
355 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
356 ra *= av.reduceLanes(VectorOperators.MUL);
357 }
358 }
359 bh.consume(ra);
360 }
361
362 @Benchmark
363 public void MULMaskedLanes(Blackhole bh) {
364 float[] a = fa.apply(SPECIES.length());
365 boolean[] mask = fm.apply(SPECIES.length());
366 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
367 float ra = 1;
368
369 for (int ic = 0; ic < INVOC_COUNT; ic++) {
370 ra = 1;
371 for (int i = 0; i < a.length; i += SPECIES.length()) {
372 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
373 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
374 }
375 }
376 bh.consume(ra);
377 }
378
379 @Benchmark
380 public void MINLanes(Blackhole bh) {
381 float[] a = fa.apply(SPECIES.length());
382 float ra = Float.POSITIVE_INFINITY;
383
384 for (int ic = 0; ic < INVOC_COUNT; ic++) {
385 ra = Float.POSITIVE_INFINITY;
386 for (int i = 0; i < a.length; i += SPECIES.length()) {
387 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
388 ra = (float) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
389 }
390 }
391 bh.consume(ra);
392 }
393
394 @Benchmark
395 public void MINMaskedLanes(Blackhole bh) {
396 float[] a = fa.apply(SPECIES.length());
397 boolean[] mask = fm.apply(SPECIES.length());
398 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
399 float ra = Float.POSITIVE_INFINITY;
400
401 for (int ic = 0; ic < INVOC_COUNT; ic++) {
402 ra = Float.POSITIVE_INFINITY;
403 for (int i = 0; i < a.length; i += SPECIES.length()) {
404 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
405 ra = (float) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
406 }
407 }
408 bh.consume(ra);
409 }
410
411 @Benchmark
412 public void MAXLanes(Blackhole bh) {
413 float[] a = fa.apply(SPECIES.length());
414 float ra = Float.NEGATIVE_INFINITY;
415
416 for (int ic = 0; ic < INVOC_COUNT; ic++) {
417 ra = Float.NEGATIVE_INFINITY;
418 for (int i = 0; i < a.length; i += SPECIES.length()) {
419 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
420 ra = (float) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
421 }
422 }
423 bh.consume(ra);
424 }
425
426 @Benchmark
427 public void MAXMaskedLanes(Blackhole bh) {
428 float[] a = fa.apply(SPECIES.length());
429 boolean[] mask = fm.apply(SPECIES.length());
430 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
431 float ra = Float.NEGATIVE_INFINITY;
432
433 for (int ic = 0; ic < INVOC_COUNT; ic++) {
434 ra = Float.NEGATIVE_INFINITY;
435 for (int i = 0; i < a.length; i += SPECIES.length()) {
436 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
437 ra = (float) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
438 }
439 }
440 bh.consume(ra);
441 }
442
443 @Benchmark
444 public void FIRST_NONZEROLanes(Blackhole bh) {
445 float[] a = fa.apply(SPECIES.length());
446 float ra = (float) 0;
447
448 for (int ic = 0; ic < INVOC_COUNT; ic++) {
449 ra = (float) 0;
450 for (int i = 0; i < a.length; i += SPECIES.length()) {
451 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
452 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
453 }
454 }
455 bh.consume(ra);
456 }
457
458 @Benchmark
459 public void FIRST_NONZEROMaskedLanes(Blackhole bh) {
460 float[] a = fa.apply(SPECIES.length());
461 boolean[] mask = fm.apply(SPECIES.length());
462 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
463 float ra = (float) 0;
464
465 for (int ic = 0; ic < INVOC_COUNT; ic++) {
466 ra = (float) 0;
467 for (int i = 0; i < a.length; i += SPECIES.length()) {
468 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
469 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
470 }
471 }
472 bh.consume(ra);
473 }
474
475 @Benchmark
476 public void withLane(Blackhole bh) {
477 float[] a = fa.apply(SPECIES.length());
478 float[] b = fb.apply(SPECIES.length());
479 float[] r = fr.apply(SPECIES.length());
480
481 for (int ic = 0; ic < INVOC_COUNT; ic++) {
482 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
483 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
484 av.withLane(j, b[i + j]).intoArray(r, i);
485 a[i + j] = b[i + j];
486 j = (j + 1) & (SPECIES.length() - 1);
487 }
488 }
489
490 bh.consume(r);
491 }
492
493 @Benchmark
494 public Object IS_DEFAULT() {
495 float[] a = fa.apply(size);
496 boolean[] ms = fmt.apply(size);
497 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
498
499 for (int ic = 0; ic < INVOC_COUNT; ic++) {
500 for (int i = 0; i < a.length; i += SPECIES.length()) {
501 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
502
503 // accumulate results, so JIT can't eliminate relevant computations
504 m = m.and(av.test(VectorOperators.IS_DEFAULT));
505 }
506 }
507
508 return m;
509 }
510
511 @Benchmark
512 public Object IS_NEGATIVE() {
513 float[] a = fa.apply(size);
514 boolean[] ms = fmt.apply(size);
515 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
516
517 for (int ic = 0; ic < INVOC_COUNT; ic++) {
518 for (int i = 0; i < a.length; i += SPECIES.length()) {
519 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
520
521 // accumulate results, so JIT can't eliminate relevant computations
522 m = m.and(av.test(VectorOperators.IS_NEGATIVE));
523 }
524 }
525
526 return m;
527 }
528
529 @Benchmark
530 public Object IS_FINITE() {
531 float[] a = fa.apply(size);
532 boolean[] ms = fmt.apply(size);
533 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
534
535 for (int ic = 0; ic < INVOC_COUNT; ic++) {
536 for (int i = 0; i < a.length; i += SPECIES.length()) {
537 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
538
539 // accumulate results, so JIT can't eliminate relevant computations
540 m = m.and(av.test(VectorOperators.IS_FINITE));
541 }
542 }
543
544 return m;
545 }
546
547 @Benchmark
548 public Object IS_NAN() {
549 float[] a = fa.apply(size);
550 boolean[] ms = fmt.apply(size);
551 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
552
553 for (int ic = 0; ic < INVOC_COUNT; ic++) {
554 for (int i = 0; i < a.length; i += SPECIES.length()) {
555 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
556
557 // accumulate results, so JIT can't eliminate relevant computations
558 m = m.and(av.test(VectorOperators.IS_NAN));
559 }
560 }
561
562 return m;
563 }
564
565 @Benchmark
566 public Object IS_INFINITE() {
567 float[] a = fa.apply(size);
568 boolean[] ms = fmt.apply(size);
569 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
570
571 for (int ic = 0; ic < INVOC_COUNT; ic++) {
572 for (int i = 0; i < a.length; i += SPECIES.length()) {
573 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
574
575 // accumulate results, so JIT can't eliminate relevant computations
576 m = m.and(av.test(VectorOperators.IS_INFINITE));
577 }
578 }
579
580 return m;
581 }
582 @Benchmark
583 public Object LT() {
584 float[] a = fa.apply(size);
585 float[] b = fb.apply(size);
586 boolean[] ms = fmt.apply(size);
587 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
588
589 for (int ic = 0; ic < INVOC_COUNT; ic++) {
590 for (int i = 0; i < a.length; i += SPECIES.length()) {
591 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
592 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
593
594 // accumulate results, so JIT can't eliminate relevant computations
595 m = m.and(av.compare(VectorOperators.LT, bv));
596 }
597 }
598
599 return m;
600 }
601 @Benchmark
602 public Object GT() {
603 float[] a = fa.apply(size);
604 float[] b = fb.apply(size);
605 boolean[] ms = fmt.apply(size);
606 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
607
608 for (int ic = 0; ic < INVOC_COUNT; ic++) {
609 for (int i = 0; i < a.length; i += SPECIES.length()) {
610 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
611 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
612
613 // accumulate results, so JIT can't eliminate relevant computations
614 m = m.and(av.compare(VectorOperators.GT, bv));
615 }
616 }
617
618 return m;
619 }
620 @Benchmark
621 public Object EQ() {
622 float[] a = fa.apply(size);
623 float[] b = fb.apply(size);
624 boolean[] ms = fmt.apply(size);
625 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
626
627 for (int ic = 0; ic < INVOC_COUNT; ic++) {
628 for (int i = 0; i < a.length; i += SPECIES.length()) {
629 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
630 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
631
632 // accumulate results, so JIT can't eliminate relevant computations
633 m = m.and(av.compare(VectorOperators.EQ, bv));
634 }
635 }
636
637 return m;
638 }
639 @Benchmark
640 public Object NE() {
641 float[] a = fa.apply(size);
642 float[] b = fb.apply(size);
643 boolean[] ms = fmt.apply(size);
644 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
645
646 for (int ic = 0; ic < INVOC_COUNT; ic++) {
647 for (int i = 0; i < a.length; i += SPECIES.length()) {
648 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
649 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
650
651 // accumulate results, so JIT can't eliminate relevant computations
652 m = m.and(av.compare(VectorOperators.NE, bv));
653 }
654 }
655
656 return m;
657 }
658 @Benchmark
659 public Object LE() {
660 float[] a = fa.apply(size);
661 float[] b = fb.apply(size);
662 boolean[] ms = fmt.apply(size);
663 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
664
665 for (int ic = 0; ic < INVOC_COUNT; ic++) {
666 for (int i = 0; i < a.length; i += SPECIES.length()) {
667 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
668 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
669
670 // accumulate results, so JIT can't eliminate relevant computations
671 m = m.and(av.compare(VectorOperators.LE, bv));
672 }
673 }
674
675 return m;
676 }
677 @Benchmark
678 public Object GE() {
679 float[] a = fa.apply(size);
680 float[] b = fb.apply(size);
681 boolean[] ms = fmt.apply(size);
682 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
683
684 for (int ic = 0; ic < INVOC_COUNT; ic++) {
685 for (int i = 0; i < a.length; i += SPECIES.length()) {
686 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
687 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
688
689 // accumulate results, so JIT can't eliminate relevant computations
690 m = m.and(av.compare(VectorOperators.GE, bv));
691 }
692 }
693
694 return m;
695 }
696
697 @Benchmark
698 public void blend(Blackhole bh) {
699 float[] a = fa.apply(SPECIES.length());
700 float[] b = fb.apply(SPECIES.length());
701 float[] r = fr.apply(SPECIES.length());
702 boolean[] mask = fm.apply(SPECIES.length());
703 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
704
705 for (int ic = 0; ic < INVOC_COUNT; ic++) {
706 for (int i = 0; i < a.length; i += SPECIES.length()) {
707 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
708 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
709 av.blend(bv, vmask).intoArray(r, i);
710 }
711 }
712
713 bh.consume(r);
714 }
715
716 @Benchmark
717 public void rearrange(Blackhole bh) {
718 float[] a = fa.apply(SPECIES.length());
719 int[] order = fs.apply(a.length, SPECIES.length());
720 float[] r = fr.apply(SPECIES.length());
721
722 for (int ic = 0; ic < INVOC_COUNT; ic++) {
723 for (int i = 0; i < a.length; i += SPECIES.length()) {
724 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
725 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
726 }
727 }
728
729 bh.consume(r);
730 }
731 @Benchmark
732 public Object compress() {
733 float[] a = fa.apply(size);
734 float[] r = fb.apply(size);
735 boolean[] ms = fmt.apply(size);
736 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
737
738 for (int ic = 0; ic < INVOC_COUNT; ic++) {
739 for (int i = 0; i < a.length; i += SPECIES.length()) {
740 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
741 av.compress(m).intoArray(r, i);
742 }
743 }
744
745 return r;
746 }
747
748 @Benchmark
749 public Object expand() {
750 float[] a = fa.apply(size);
751 float[] r = fb.apply(size);
752 boolean[] ms = fmt.apply(size);
753 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0);
754
755 for (int ic = 0; ic < INVOC_COUNT; ic++) {
756 for (int i = 0; i < a.length; i += SPECIES.length()) {
757 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
758 av.expand(m).intoArray(r, i);
759 }
760 }
761
762 return r;
763 }
764
765 @Benchmark
766 public Object maskCompress() {
767 boolean[] ms = fmt.apply(size);
768 boolean[] rs = fmt.apply(size);
769
770 for (int ic = 0; ic < INVOC_COUNT; ic++) {
771 for (int i = 0, j = 0; i < ms.length; i += SPECIES.length()) {
772 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, i);
773 m.compress().intoArray(rs, j);
774 j += m.trueCount();
775 }
776 }
777
778 return rs;
779 }
780
781 @Benchmark
782 public void laneextract(Blackhole bh) {
783 float[] a = fa.apply(SPECIES.length());
784 float[] r = fr.apply(SPECIES.length());
785
786 for (int ic = 0; ic < INVOC_COUNT; ic++) {
787 for (int i = 0; i < a.length; i += SPECIES.length()) {
788 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
789 int num_lanes = SPECIES.length();
790 // Manually unroll because full unroll happens after intrinsification.
791 // Unroll is needed because get intrinsic requires for index to be a known constant.
792 if (num_lanes == 1) {
793 r[i]=av.lane(0);
794 } else if (num_lanes == 2) {
795 r[i]=av.lane(0);
796 r[i+1]=av.lane(1);
797 } else if (num_lanes == 4) {
798 r[i]=av.lane(0);
799 r[i+1]=av.lane(1);
800 r[i+2]=av.lane(2);
801 r[i+3]=av.lane(3);
802 } else if (num_lanes == 8) {
803 r[i]=av.lane(0);
804 r[i+1]=av.lane(1);
805 r[i+2]=av.lane(2);
806 r[i+3]=av.lane(3);
807 r[i+4]=av.lane(4);
808 r[i+5]=av.lane(5);
809 r[i+6]=av.lane(6);
810 r[i+7]=av.lane(7);
811 } else if (num_lanes == 16) {
812 r[i]=av.lane(0);
813 r[i+1]=av.lane(1);
814 r[i+2]=av.lane(2);
815 r[i+3]=av.lane(3);
816 r[i+4]=av.lane(4);
817 r[i+5]=av.lane(5);
818 r[i+6]=av.lane(6);
819 r[i+7]=av.lane(7);
820 r[i+8]=av.lane(8);
821 r[i+9]=av.lane(9);
822 r[i+10]=av.lane(10);
823 r[i+11]=av.lane(11);
824 r[i+12]=av.lane(12);
825 r[i+13]=av.lane(13);
826 r[i+14]=av.lane(14);
827 r[i+15]=av.lane(15);
828 } else if (num_lanes == 32) {
829 r[i]=av.lane(0);
830 r[i+1]=av.lane(1);
831 r[i+2]=av.lane(2);
832 r[i+3]=av.lane(3);
833 r[i+4]=av.lane(4);
834 r[i+5]=av.lane(5);
835 r[i+6]=av.lane(6);
836 r[i+7]=av.lane(7);
837 r[i+8]=av.lane(8);
838 r[i+9]=av.lane(9);
839 r[i+10]=av.lane(10);
840 r[i+11]=av.lane(11);
841 r[i+12]=av.lane(12);
842 r[i+13]=av.lane(13);
843 r[i+14]=av.lane(14);
844 r[i+15]=av.lane(15);
845 r[i+16]=av.lane(16);
846 r[i+17]=av.lane(17);
847 r[i+18]=av.lane(18);
848 r[i+19]=av.lane(19);
849 r[i+20]=av.lane(20);
850 r[i+21]=av.lane(21);
851 r[i+22]=av.lane(22);
852 r[i+23]=av.lane(23);
853 r[i+24]=av.lane(24);
854 r[i+25]=av.lane(25);
855 r[i+26]=av.lane(26);
856 r[i+27]=av.lane(27);
857 r[i+28]=av.lane(28);
858 r[i+29]=av.lane(29);
859 r[i+30]=av.lane(30);
860 r[i+31]=av.lane(31);
861 } else if (num_lanes == 64) {
862 r[i]=av.lane(0);
863 r[i+1]=av.lane(1);
864 r[i+2]=av.lane(2);
865 r[i+3]=av.lane(3);
866 r[i+4]=av.lane(4);
867 r[i+5]=av.lane(5);
868 r[i+6]=av.lane(6);
869 r[i+7]=av.lane(7);
870 r[i+8]=av.lane(8);
871 r[i+9]=av.lane(9);
872 r[i+10]=av.lane(10);
873 r[i+11]=av.lane(11);
874 r[i+12]=av.lane(12);
875 r[i+13]=av.lane(13);
876 r[i+14]=av.lane(14);
877 r[i+15]=av.lane(15);
878 r[i+16]=av.lane(16);
879 r[i+17]=av.lane(17);
880 r[i+18]=av.lane(18);
881 r[i+19]=av.lane(19);
882 r[i+20]=av.lane(20);
883 r[i+21]=av.lane(21);
884 r[i+22]=av.lane(22);
885 r[i+23]=av.lane(23);
886 r[i+24]=av.lane(24);
887 r[i+25]=av.lane(25);
888 r[i+26]=av.lane(26);
889 r[i+27]=av.lane(27);
890 r[i+28]=av.lane(28);
891 r[i+29]=av.lane(29);
892 r[i+30]=av.lane(30);
893 r[i+31]=av.lane(31);
894 r[i+32]=av.lane(32);
895 r[i+33]=av.lane(33);
896 r[i+34]=av.lane(34);
897 r[i+35]=av.lane(35);
898 r[i+36]=av.lane(36);
899 r[i+37]=av.lane(37);
900 r[i+38]=av.lane(38);
901 r[i+39]=av.lane(39);
902 r[i+40]=av.lane(40);
903 r[i+41]=av.lane(41);
904 r[i+42]=av.lane(42);
905 r[i+43]=av.lane(43);
906 r[i+44]=av.lane(44);
907 r[i+45]=av.lane(45);
908 r[i+46]=av.lane(46);
909 r[i+47]=av.lane(47);
910 r[i+48]=av.lane(48);
911 r[i+49]=av.lane(49);
912 r[i+50]=av.lane(50);
913 r[i+51]=av.lane(51);
914 r[i+52]=av.lane(52);
915 r[i+53]=av.lane(53);
916 r[i+54]=av.lane(54);
917 r[i+55]=av.lane(55);
918 r[i+56]=av.lane(56);
919 r[i+57]=av.lane(57);
920 r[i+58]=av.lane(58);
921 r[i+59]=av.lane(59);
922 r[i+60]=av.lane(60);
923 r[i+61]=av.lane(61);
924 r[i+62]=av.lane(62);
925 r[i+63]=av.lane(63);
926 } else {
927 for (int j = 0; j < SPECIES.length(); j++) {
928 r[i+j]=av.lane(j);
929 }
930 }
931 }
932 }
933
934 bh.consume(r);
935 }
936
937 @Benchmark
938 public void broadcast(Blackhole bh) {
939 float[] a = fa.apply(SPECIES.length());
940 float[] r = new float[a.length];
941
942 for (int ic = 0; ic < INVOC_COUNT; ic++) {
943 for (int i = 0; i < a.length; i += SPECIES.length()) {
944 FloatVector.broadcast(SPECIES, a[i]).intoArray(r, i);
945 }
946 }
947
948 bh.consume(r);
949 }
950
951 @Benchmark
952 public void zero(Blackhole bh) {
953 float[] a = fa.apply(SPECIES.length());
954 float[] r = new float[a.length];
955
956 for (int ic = 0; ic < INVOC_COUNT; ic++) {
957 for (int i = 0; i < a.length; i += SPECIES.length()) {
958 FloatVector.zero(SPECIES).intoArray(a, i);
959 }
960 }
961
962 bh.consume(r);
963 }
964
965 @Benchmark
966 public void sliceUnary(Blackhole bh) {
967 float[] a = fa.apply(SPECIES.length());
968 float[] r = new float[a.length];
969 int origin = RAND.nextInt(SPECIES.length());
970 for (int ic = 0; ic < INVOC_COUNT; ic++) {
971 for (int i = 0; i < a.length; i += SPECIES.length()) {
972 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
973 av.slice(origin).intoArray(r, i);
974 }
975 }
976
977 bh.consume(r);
978 }
979
980 @Benchmark
981 public void sliceBinary(Blackhole bh) {
982 float[] a = fa.apply(SPECIES.length());
983 float[] b = fb.apply(SPECIES.length());
984 float[] r = new float[a.length];
985 int origin = RAND.nextInt(SPECIES.length());
986 for (int ic = 0; ic < INVOC_COUNT; ic++) {
987 for (int i = 0; i < a.length; i += SPECIES.length()) {
988 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
989 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
990 av.slice(origin, bv).intoArray(r, i);
991 }
992 }
993
994 bh.consume(r);
995 }
996
997 @Benchmark
998 public void sliceMasked(Blackhole bh) {
999 float[] a = fa.apply(SPECIES.length());
1000 float[] b = fb.apply(SPECIES.length());
1001 boolean[] mask = fm.apply(SPECIES.length());
1002 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1003
1004 float[] r = new float[a.length];
1005 int origin = RAND.nextInt(SPECIES.length());
1006 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1007 for (int i = 0; i < a.length; i += SPECIES.length()) {
1008 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1009 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1010 av.slice(origin, bv, vmask).intoArray(r, i);
1011 }
1012 }
1013
1014 bh.consume(r);
1015 }
1016
1017 @Benchmark
1018 public void unsliceUnary(Blackhole bh) {
1019 float[] a = fa.apply(SPECIES.length());
1020 float[] r = new float[a.length];
1021 int origin = RAND.nextInt(SPECIES.length());
1022 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1023 for (int i = 0; i < a.length; i += SPECIES.length()) {
1024 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1025 av.unslice(origin).intoArray(r, i);
1026 }
1027 }
1028
1029 bh.consume(r);
1030 }
1031
1032 @Benchmark
1033 public void unsliceBinary(Blackhole bh) {
1034 float[] a = fa.apply(SPECIES.length());
1035 float[] b = fb.apply(SPECIES.length());
1036 float[] r = new float[a.length];
1037 int origin = RAND.nextInt(SPECIES.length());
1038 int part = RAND.nextInt(2);
1039 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1040 for (int i = 0; i < a.length; i += SPECIES.length()) {
1041 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1042 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1043 av.unslice(origin, bv, part).intoArray(r, i);
1044 }
1045 }
1046
1047 bh.consume(r);
1048 }
1049
1050 @Benchmark
1051 public void unsliceMasked(Blackhole bh) {
1052 float[] a = fa.apply(SPECIES.length());
1053 float[] b = fb.apply(SPECIES.length());
1054 boolean[] mask = fm.apply(SPECIES.length());
1055 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1056 float[] r = new float[a.length];
1057 int origin = RAND.nextInt(SPECIES.length());
1058 int part = RAND.nextInt(2);
1059 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1060 for (int i = 0; i < a.length; i += SPECIES.length()) {
1061 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1062 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1063 av.unslice(origin, bv, part, vmask).intoArray(r, i);
1064 }
1065 }
1066
1067 bh.consume(r);
1068 }
1069
1070 @Benchmark
1071 public void SIN(Blackhole bh) {
1072 float[] a = fa.apply(SPECIES.length());
1073 float[] r = fr.apply(SPECIES.length());
1074
1075 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1076 for (int i = 0; i < a.length; i += SPECIES.length()) {
1077 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1078 av.lanewise(VectorOperators.SIN).intoArray(r, i);
1079 }
1080 }
1081
1082 bh.consume(r);
1083 }
1084
1085 @Benchmark
1086 public void EXP(Blackhole bh) {
1087 float[] a = fa.apply(SPECIES.length());
1088 float[] r = fr.apply(SPECIES.length());
1089
1090 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1091 for (int i = 0; i < a.length; i += SPECIES.length()) {
1092 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1093 av.lanewise(VectorOperators.EXP).intoArray(r, i);
1094 }
1095 }
1096
1097 bh.consume(r);
1098 }
1099
1100 @Benchmark
1101 public void LOG1P(Blackhole bh) {
1102 float[] a = fa.apply(SPECIES.length());
1103 float[] r = fr.apply(SPECIES.length());
1104
1105 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1106 for (int i = 0; i < a.length; i += SPECIES.length()) {
1107 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1108 av.lanewise(VectorOperators.LOG1P).intoArray(r, i);
1109 }
1110 }
1111
1112 bh.consume(r);
1113 }
1114
1115 @Benchmark
1116 public void LOG(Blackhole bh) {
1117 float[] a = fa.apply(SPECIES.length());
1118 float[] r = fr.apply(SPECIES.length());
1119
1120 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1121 for (int i = 0; i < a.length; i += SPECIES.length()) {
1122 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1123 av.lanewise(VectorOperators.LOG).intoArray(r, i);
1124 }
1125 }
1126
1127 bh.consume(r);
1128 }
1129
1130 @Benchmark
1131 public void LOG10(Blackhole bh) {
1132 float[] a = fa.apply(SPECIES.length());
1133 float[] r = fr.apply(SPECIES.length());
1134
1135 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1136 for (int i = 0; i < a.length; i += SPECIES.length()) {
1137 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1138 av.lanewise(VectorOperators.LOG10).intoArray(r, i);
1139 }
1140 }
1141
1142 bh.consume(r);
1143 }
1144
1145 @Benchmark
1146 public void EXPM1(Blackhole bh) {
1147 float[] a = fa.apply(SPECIES.length());
1148 float[] r = fr.apply(SPECIES.length());
1149
1150 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1151 for (int i = 0; i < a.length; i += SPECIES.length()) {
1152 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1153 av.lanewise(VectorOperators.EXPM1).intoArray(r, i);
1154 }
1155 }
1156
1157 bh.consume(r);
1158 }
1159
1160 @Benchmark
1161 public void COS(Blackhole bh) {
1162 float[] a = fa.apply(SPECIES.length());
1163 float[] r = fr.apply(SPECIES.length());
1164
1165 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1166 for (int i = 0; i < a.length; i += SPECIES.length()) {
1167 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1168 av.lanewise(VectorOperators.COS).intoArray(r, i);
1169 }
1170 }
1171
1172 bh.consume(r);
1173 }
1174
1175 @Benchmark
1176 public void TAN(Blackhole bh) {
1177 float[] a = fa.apply(SPECIES.length());
1178 float[] r = fr.apply(SPECIES.length());
1179
1180 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1181 for (int i = 0; i < a.length; i += SPECIES.length()) {
1182 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1183 av.lanewise(VectorOperators.TAN).intoArray(r, i);
1184 }
1185 }
1186
1187 bh.consume(r);
1188 }
1189
1190 @Benchmark
1191 public void SINH(Blackhole bh) {
1192 float[] a = fa.apply(SPECIES.length());
1193 float[] r = fr.apply(SPECIES.length());
1194
1195 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1196 for (int i = 0; i < a.length; i += SPECIES.length()) {
1197 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1198 av.lanewise(VectorOperators.SINH).intoArray(r, i);
1199 }
1200 }
1201
1202 bh.consume(r);
1203 }
1204
1205 @Benchmark
1206 public void COSH(Blackhole bh) {
1207 float[] a = fa.apply(SPECIES.length());
1208 float[] r = fr.apply(SPECIES.length());
1209
1210 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1211 for (int i = 0; i < a.length; i += SPECIES.length()) {
1212 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1213 av.lanewise(VectorOperators.COSH).intoArray(r, i);
1214 }
1215 }
1216
1217 bh.consume(r);
1218 }
1219
1220 @Benchmark
1221 public void TANH(Blackhole bh) {
1222 float[] a = fa.apply(SPECIES.length());
1223 float[] r = fr.apply(SPECIES.length());
1224
1225 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1226 for (int i = 0; i < a.length; i += SPECIES.length()) {
1227 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1228 av.lanewise(VectorOperators.TANH).intoArray(r, i);
1229 }
1230 }
1231
1232 bh.consume(r);
1233 }
1234
1235 @Benchmark
1236 public void ASIN(Blackhole bh) {
1237 float[] a = fa.apply(SPECIES.length());
1238 float[] r = fr.apply(SPECIES.length());
1239
1240 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1241 for (int i = 0; i < a.length; i += SPECIES.length()) {
1242 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1243 av.lanewise(VectorOperators.ASIN).intoArray(r, i);
1244 }
1245 }
1246
1247 bh.consume(r);
1248 }
1249
1250 @Benchmark
1251 public void ACOS(Blackhole bh) {
1252 float[] a = fa.apply(SPECIES.length());
1253 float[] r = fr.apply(SPECIES.length());
1254
1255 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1256 for (int i = 0; i < a.length; i += SPECIES.length()) {
1257 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1258 av.lanewise(VectorOperators.ACOS).intoArray(r, i);
1259 }
1260 }
1261
1262 bh.consume(r);
1263 }
1264
1265 @Benchmark
1266 public void ATAN(Blackhole bh) {
1267 float[] a = fa.apply(SPECIES.length());
1268 float[] r = fr.apply(SPECIES.length());
1269
1270 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1271 for (int i = 0; i < a.length; i += SPECIES.length()) {
1272 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1273 av.lanewise(VectorOperators.ATAN).intoArray(r, i);
1274 }
1275 }
1276
1277 bh.consume(r);
1278 }
1279
1280 @Benchmark
1281 public void CBRT(Blackhole bh) {
1282 float[] a = fa.apply(SPECIES.length());
1283 float[] r = fr.apply(SPECIES.length());
1284
1285 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1286 for (int i = 0; i < a.length; i += SPECIES.length()) {
1287 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1288 av.lanewise(VectorOperators.CBRT).intoArray(r, i);
1289 }
1290 }
1291
1292 bh.consume(r);
1293 }
1294
1295 @Benchmark
1296 public void HYPOT(Blackhole bh) {
1297 float[] a = fa.apply(SPECIES.length());
1298 float[] b = fb.apply(SPECIES.length());
1299 float[] r = fr.apply(SPECIES.length());
1300
1301 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1302 for (int i = 0; i < a.length; i += SPECIES.length()) {
1303 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1304 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1305 av.lanewise(VectorOperators.HYPOT, bv).intoArray(r, i);
1306 }
1307 }
1308
1309 bh.consume(r);
1310 }
1311
1312 @Benchmark
1313 public void POW(Blackhole bh) {
1314 float[] a = fa.apply(SPECIES.length());
1315 float[] b = fb.apply(SPECIES.length());
1316 float[] r = fr.apply(SPECIES.length());
1317
1318 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1319 for (int i = 0; i < a.length; i += SPECIES.length()) {
1320 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1321 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1322 av.lanewise(VectorOperators.POW, bv).intoArray(r, i);
1323 }
1324 }
1325
1326 bh.consume(r);
1327 }
1328
1329 @Benchmark
1330 public void ATAN2(Blackhole bh) {
1331 float[] a = fa.apply(SPECIES.length());
1332 float[] b = fb.apply(SPECIES.length());
1333 float[] r = fr.apply(SPECIES.length());
1334
1335 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1336 for (int i = 0; i < a.length; i += SPECIES.length()) {
1337 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1338 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1339 av.lanewise(VectorOperators.ATAN2, bv).intoArray(r, i);
1340 }
1341 }
1342
1343 bh.consume(r);
1344 }
1345
1346 @Benchmark
1347 public void FMA(Blackhole bh) {
1348 float[] a = fa.apply(SPECIES.length());
1349 float[] b = fb.apply(SPECIES.length());
1350 float[] c = fc.apply(SPECIES.length());
1351 float[] r = fr.apply(SPECIES.length());
1352
1353 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1354 for (int i = 0; i < a.length; i += SPECIES.length()) {
1355 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1356 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1357 FloatVector cv = FloatVector.fromArray(SPECIES, c, i);
1358 av.lanewise(VectorOperators.FMA, bv, cv).intoArray(r, i);
1359 }
1360 }
1361
1362 bh.consume(r);
1363 }
1364
1365 @Benchmark
1366 public void FMAMasked(Blackhole bh) {
1367 float[] a = fa.apply(SPECIES.length());
1368 float[] b = fb.apply(SPECIES.length());
1369 float[] c = fc.apply(SPECIES.length());
1370 float[] r = fr.apply(SPECIES.length());
1371 boolean[] mask = fm.apply(SPECIES.length());
1372 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1373
1374 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1375 for (int i = 0; i < a.length; i += SPECIES.length()) {
1376 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1377 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1378 FloatVector cv = FloatVector.fromArray(SPECIES, c, i);
1379 av.lanewise(VectorOperators.FMA, bv, cv, vmask).intoArray(r, i);
1380 }
1381 }
1382
1383 bh.consume(r);
1384 }
1385
1386 @Benchmark
1387 public void NEG(Blackhole bh) {
1388 float[] a = fa.apply(SPECIES.length());
1389 float[] r = fr.apply(SPECIES.length());
1390
1391 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1392 for (int i = 0; i < a.length; i += SPECIES.length()) {
1393 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1394 av.lanewise(VectorOperators.NEG).intoArray(r, i);
1395 }
1396 }
1397
1398 bh.consume(r);
1399 }
1400
1401 @Benchmark
1402 public void NEGMasked(Blackhole bh) {
1403 float[] a = fa.apply(SPECIES.length());
1404 float[] r = fr.apply(SPECIES.length());
1405 boolean[] mask = fm.apply(SPECIES.length());
1406 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1407
1408 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1409 for (int i = 0; i < a.length; i += SPECIES.length()) {
1410 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1411 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
1412 }
1413 }
1414
1415 bh.consume(r);
1416 }
1417
1418 @Benchmark
1419 public void ABS(Blackhole bh) {
1420 float[] a = fa.apply(SPECIES.length());
1421 float[] r = fr.apply(SPECIES.length());
1422
1423 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1424 for (int i = 0; i < a.length; i += SPECIES.length()) {
1425 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1426 av.lanewise(VectorOperators.ABS).intoArray(r, i);
1427 }
1428 }
1429
1430 bh.consume(r);
1431 }
1432
1433 @Benchmark
1434 public void ABSMasked(Blackhole bh) {
1435 float[] a = fa.apply(SPECIES.length());
1436 float[] r = fr.apply(SPECIES.length());
1437 boolean[] mask = fm.apply(SPECIES.length());
1438 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1439
1440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1441 for (int i = 0; i < a.length; i += SPECIES.length()) {
1442 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1443 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
1444 }
1445 }
1446
1447 bh.consume(r);
1448 }
1449
1450 @Benchmark
1451 public void SQRT(Blackhole bh) {
1452 float[] a = fa.apply(SPECIES.length());
1453 float[] r = fr.apply(SPECIES.length());
1454
1455 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1456 for (int i = 0; i < a.length; i += SPECIES.length()) {
1457 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1458 av.lanewise(VectorOperators.SQRT).intoArray(r, i);
1459 }
1460 }
1461
1462 bh.consume(r);
1463 }
1464
1465 @Benchmark
1466 public void SQRTMasked(Blackhole bh) {
1467 float[] a = fa.apply(SPECIES.length());
1468 float[] r = fr.apply(SPECIES.length());
1469 boolean[] mask = fm.apply(SPECIES.length());
1470 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1471
1472 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1473 for (int i = 0; i < a.length; i += SPECIES.length()) {
1474 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1475 av.lanewise(VectorOperators.SQRT, vmask).intoArray(r, i);
1476 }
1477 }
1478
1479 bh.consume(r);
1480 }
1481 }