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 FloatMaxVector extends AbstractVectorBenchmark {
  50     static final VectorSpecies<Float> SPECIES = FloatVector.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     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 extract(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