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