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