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 DoubleMaxVector extends AbstractVectorBenchmark { 50 static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_MAX; 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 laneextract(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