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.FloatVector; 35 36 import java.util.concurrent.TimeUnit; 37 import java.util.function.BiFunction; 38 import java.util.function.IntFunction; 39 40 import org.openjdk.jmh.annotations.*; 41 import org.openjdk.jmh.infra.Blackhole; 42 43 @BenchmarkMode(Mode.Throughput) 44 @OutputTimeUnit(TimeUnit.MILLISECONDS) 45 @State(Scope.Benchmark) 46 @Warmup(iterations = 3, time = 1) 47 @Measurement(iterations = 5, time = 1) 48 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"}) 49 public class Float512Vector extends AbstractVectorBenchmark { 50 static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_512; 51 52 static final int INVOC_COUNT = 1; // get rid of outer loop 53 54 55 @Param("1024") 56 int size; 57 58 float[] fill(IntFunction<Float> f) { 59 float[] array = new float[size]; 60 for (int i = 0; i < array.length; i++) { 61 array[i] = f.apply(i); 62 } 63 return array; 64 } 65 66 float[] 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 -> (float)(2*i)); 75 b = fill(i -> (float)(i+1)); 76 c = fill(i -> (float)(i+5)); 77 r = fill(i -> (float)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<float[]> fa = vl -> a; 87 final IntFunction<float[]> fb = vl -> b; 88 final IntFunction<float[]> fc = vl -> c; 89 final IntFunction<float[]> 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 float[] a = fa.apply(SPECIES.length()); 99 float[] b = fb.apply(SPECIES.length()); 100 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 105 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 116 float[] b = fb.apply(SPECIES.length()); 117 float[] r = fr.apply(SPECIES.length()); 118 boolean[] mask = fm.apply(SPECIES.length()); 119 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 124 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 135 float[] b = fb.apply(SPECIES.length()); 136 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 141 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 152 float[] b = fb.apply(SPECIES.length()); 153 float[] r = fr.apply(SPECIES.length()); 154 boolean[] mask = fm.apply(SPECIES.length()); 155 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 160 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 171 float[] b = fb.apply(SPECIES.length()); 172 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 177 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 188 float[] b = fb.apply(SPECIES.length()); 189 float[] r = fr.apply(SPECIES.length()); 190 boolean[] mask = fm.apply(SPECIES.length()); 191 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 196 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 208 float[] b = fb.apply(SPECIES.length()); 209 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 214 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 227 float[] b = fb.apply(SPECIES.length()); 228 float[] r = fr.apply(SPECIES.length()); 229 boolean[] mask = fm.apply(SPECIES.length()); 230 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 235 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 249 float[] b = fb.apply(SPECIES.length()); 250 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 255 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 266 float[] b = fb.apply(SPECIES.length()); 267 float[] r = fr.apply(SPECIES.length()); 268 boolean[] mask = fm.apply(SPECIES.length()); 269 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 274 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 329 float[] b = fb.apply(SPECIES.length()); 330 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 335 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 346 float[] b = fb.apply(SPECIES.length()); 347 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 352 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 369 float 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 384 boolean[] mask = fm.apply(SPECIES.length()); 385 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0); 386 float 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 401 float 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 416 boolean[] mask = fm.apply(SPECIES.length()); 417 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0); 418 float 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 433 float ra = Float.POSITIVE_INFINITY; 434 435 for (int ic = 0; ic < INVOC_COUNT; ic++) { 436 ra = Float.POSITIVE_INFINITY; 437 for (int i = 0; i < a.length; i += SPECIES.length()) { 438 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 439 ra = (float)Math.min(ra, av.reduceLanes(VectorOperators.MIN)); 440 } 441 } 442 bh.consume(ra); 443 } 444 445 @Benchmark 446 public void MINMaskedLanes(Blackhole bh) { 447 float[] a = fa.apply(SPECIES.length()); 448 boolean[] mask = fm.apply(SPECIES.length()); 449 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0); 450 float ra = Float.POSITIVE_INFINITY; 451 452 for (int ic = 0; ic < INVOC_COUNT; ic++) { 453 ra = Float.POSITIVE_INFINITY; 454 for (int i = 0; i < a.length; i += SPECIES.length()) { 455 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 456 ra = (float)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 float[] a = fa.apply(SPECIES.length()); 465 float ra = Float.NEGATIVE_INFINITY; 466 467 for (int ic = 0; ic < INVOC_COUNT; ic++) { 468 ra = Float.NEGATIVE_INFINITY; 469 for (int i = 0; i < a.length; i += SPECIES.length()) { 470 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 471 ra = (float)Math.max(ra, av.reduceLanes(VectorOperators.MAX)); 472 } 473 } 474 bh.consume(ra); 475 } 476 477 @Benchmark 478 public void MAXMaskedLanes(Blackhole bh) { 479 float[] a = fa.apply(SPECIES.length()); 480 boolean[] mask = fm.apply(SPECIES.length()); 481 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0); 482 float ra = Float.NEGATIVE_INFINITY; 483 484 for (int ic = 0; ic < INVOC_COUNT; ic++) { 485 ra = Float.NEGATIVE_INFINITY; 486 for (int i = 0; i < a.length; i += SPECIES.length()) { 487 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 488 ra = (float)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 float[] a = fa.apply(SPECIES.length()); 499 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 504 av.withLane(0, (float)4).intoArray(r, i); 505 } 506 } 507 508 bh.consume(r); 509 } 510 511 @Benchmark 512 public Object IS_DEFAULT() { 513 float[] a = fa.apply(size); 514 boolean[] ms = fmt.apply(size); 515 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0); 516 517 for (int ic = 0; ic < INVOC_COUNT; ic++) { 518 for (int i = 0; i < a.length; i += SPECIES.length()) { 519 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 520 521 // accumulate results, so JIT can't eliminate relevant computations 522 m = m.and(av.test(VectorOperators.IS_DEFAULT)); 523 } 524 } 525 526 return m; 527 } 528 529 @Benchmark 530 public Object IS_NEGATIVE() { 531 float[] a = fa.apply(size); 532 boolean[] ms = fmt.apply(size); 533 VectorMask<Float> m = VectorMask.fromArray(SPECIES, ms, 0); 534 535 for (int ic = 0; ic < INVOC_COUNT; ic++) { 536 for (int i = 0; i < a.length; i += SPECIES.length()) { 537 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 538 539 // accumulate results, so JIT can't eliminate relevant computations 540 m = m.and(av.test(VectorOperators.IS_NEGATIVE)); 541 } 542 } 543 544 return m; 545 } 546 547 548 @Benchmark 549 public Object IS_FINITE() { 550 float[] a = fa.apply(size); 551 boolean[] ms = fmt.apply(size); 552 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(size); 571 boolean[] ms = fmt.apply(size); 572 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(size); 591 boolean[] ms = fmt.apply(size); 592 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(size); 610 float[] b = fb.apply(size); 611 boolean[] ms = fmt.apply(size); 612 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 617 FloatVector bv = FloatVector.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 float[] a = fa.apply(size); 630 float[] b = fb.apply(size); 631 boolean[] ms = fmt.apply(size); 632 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 637 FloatVector bv = FloatVector.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 float[] a = fa.apply(size); 650 float[] b = fb.apply(size); 651 boolean[] ms = fmt.apply(size); 652 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 657 FloatVector bv = FloatVector.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 float[] a = fa.apply(size); 670 float[] b = fb.apply(size); 671 boolean[] ms = fmt.apply(size); 672 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 677 FloatVector bv = FloatVector.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 float[] a = fa.apply(size); 690 float[] b = fb.apply(size); 691 boolean[] ms = fmt.apply(size); 692 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 697 FloatVector bv = FloatVector.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 float[] a = fa.apply(size); 710 float[] b = fb.apply(size); 711 boolean[] ms = fmt.apply(size); 712 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 717 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 730 float[] b = fb.apply(SPECIES.length()); 731 float[] r = fr.apply(SPECIES.length()); 732 boolean[] mask = fm.apply(SPECIES.length()); 733 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 738 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 749 int[] order = fs.apply(a.length, SPECIES.length()); 750 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 765 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 921 float[] r = new float[a.length]; 922 923 for (int ic = 0; ic < INVOC_COUNT; ic++) { 924 for (int i = 0; i < a.length; i += SPECIES.length()) { 925 FloatVector.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 float[] a = fa.apply(SPECIES.length()); 935 float[] r = new float[a.length]; 936 937 for (int ic = 0; ic < INVOC_COUNT; ic++) { 938 for (int i = 0; i < a.length; i += SPECIES.length()) { 939 FloatVector.zero(SPECIES).intoArray(a, i); 940 } 941 } 942 943 bh.consume(r); 944 } 945 946 @Benchmark 947 public void sliceUnary(Blackhole bh) { 948 float[] a = fa.apply(SPECIES.length()); 949 float[] r = new float[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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 964 float[] b = fb.apply(SPECIES.length()); 965 float[] r = new float[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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 970 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 981 float[] b = fb.apply(SPECIES.length()); 982 boolean[] mask = fm.apply(SPECIES.length()); 983 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0); 984 985 float[] r = new float[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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 990 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1001 float[] r = new float[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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1016 float[] b = fb.apply(SPECIES.length()); 1017 float[] r = new float[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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1023 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1034 float[] b = fb.apply(SPECIES.length()); 1035 boolean[] mask = fm.apply(SPECIES.length()); 1036 VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 0); 1037 float[] r = new float[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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1043 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1055 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1072 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1089 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1106 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1123 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1140 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1157 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1174 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1191 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1208 float[] r = fr.apply(SPECIES.length()); 1209 1210 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1211 for (int i = 0; i < a.length; i += SPECIES.length()) { 1212 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1213 av.lanewise(VectorOperators.COSH).intoArray(r, i); 1214 } 1215 } 1216 1217 bh.consume(r); 1218 } 1219 1220 1221 1222 @Benchmark 1223 public void TANH(Blackhole bh) { 1224 float[] a = fa.apply(SPECIES.length()); 1225 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1242 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1259 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1276 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1293 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1310 float[] b = fb.apply(SPECIES.length()); 1311 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1316 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1329 float[] b = fb.apply(SPECIES.length()); 1330 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1335 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1348 float[] b = fb.apply(SPECIES.length()); 1349 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1354 FloatVector bv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1367 float[] b = fb.apply(SPECIES.length()); 1368 float[] c = fc.apply(SPECIES.length()); 1369 float[] 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1374 FloatVector bv = FloatVector.fromArray(SPECIES, b, i); 1375 FloatVector cv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1388 float[] b = fb.apply(SPECIES.length()); 1389 float[] c = fc.apply(SPECIES.length()); 1390 float[] r = fr.apply(SPECIES.length()); 1391 boolean[] mask = fm.apply(SPECIES.length()); 1392 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1397 FloatVector bv = FloatVector.fromArray(SPECIES, b, i); 1398 FloatVector cv = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1412 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1427 float[] r = fr.apply(SPECIES.length()); 1428 boolean[] mask = fm.apply(SPECIES.length()); 1429 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1444 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1459 float[] r = fr.apply(SPECIES.length()); 1460 boolean[] mask = fm.apply(SPECIES.length()); 1461 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1481 float[] 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1498 float[] r = fr.apply(SPECIES.length()); 1499 boolean[] mask = fm.apply(SPECIES.length()); 1500 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1516 int[] b = fs.apply(a.length, SPECIES.length()); 1517 float[] r = new float[a.length]; 1518 1519 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1520 for (int i = 0; i < a.length; i += SPECIES.length()) { 1521 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1532 int[] b = fs.apply(a.length, SPECIES.length()); 1533 float[] r = new float[a.length]; 1534 boolean[] mask = fm.apply(SPECIES.length()); 1535 VectorMask<Float> 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 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1550 int[] b = fs.apply(a.length, SPECIES.length()); 1551 float[] r = new float[a.length]; 1552 1553 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1554 for (int i = 0; i < a.length; i += SPECIES.length()) { 1555 FloatVector av = FloatVector.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 float[] a = fa.apply(SPECIES.length()); 1566 int[] b = fs.apply(a.length, SPECIES.length()); 1567 float[] r = fb.apply(SPECIES.length()); 1568 boolean[] mask = fm.apply(SPECIES.length()); 1569 VectorMask<Float> 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 FloatVector av = FloatVector.fromArray(SPECIES, a, i); 1574 av.intoArray(r, i, b, i, vmask); 1575 } 1576 } 1577 1578 bh.consume(r); 1579 } 1580 } 1581