rev 54658 : refactored mask and shuffle creation methods, moved classes to top-level

   1 /*
   2  * Copyright (c) 2018, 2019, 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
  21  * questions.
  22  */
  23 
  24 package benchmark.jdk.incubator.vector;
  25 
  26 import jdk.incubator.vector.Vector;
  27 import jdk.incubator.vector.Vector.Shape;
  28 import jdk.incubator.vector.Vector.Species;

  29 import jdk.incubator.vector.DoubleVector;
  30 
  31 import java.util.concurrent.TimeUnit;
  32 import java.util.function.BiFunction;
  33 import java.util.function.IntFunction;
  34 
  35 import org.openjdk.jmh.annotations.*;
  36 import org.openjdk.jmh.infra.Blackhole;
  37 
  38 @BenchmarkMode(Mode.Throughput)
  39 @OutputTimeUnit(TimeUnit.MILLISECONDS)
  40 @State(Scope.Benchmark)
  41 @Warmup(iterations = 3, time = 1)
  42 @Measurement(iterations = 5, time = 1)
  43 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
  44 public class Double64Vector extends AbstractVectorBenchmark {
  45     static final Species<Double> SPECIES = DoubleVector.SPECIES_64;
  46 
  47     static final int INVOC_COUNT = 1; // get rid of outer loop
  48 
  49     @Param("1024")
  50     int size;
  51 
  52     double[] fill(IntFunction<Double> f) {
  53         double[] array = new double[size];
  54         for (int i = 0; i < array.length; i++) {
  55             array[i] = f.apply(i);
  56         }
  57         return array;
  58     }
  59 
  60     double[] a, b, c, r;
  61     boolean[] m, rm;
  62     int[] s;
  63 
  64     @Setup
  65     public void init() {
  66         size += size % SPECIES.length(); // FIXME: add post-loops
  67 
  68         a = fill(i -> (double)(2*i));
  69         b = fill(i -> (double)(i+1));
  70         c = fill(i -> (double)(i+5));
  71         r = fill(i -> (double)0);
  72 
  73         m = fillMask(size, i -> (i % 2) == 0);
  74         rm = fillMask(size, i -> false);
  75 
  76         s = fillInt(size, i -> RANDOM.nextInt(SPECIES.length()));
  77     }
  78 
  79     final IntFunction<double[]> fa = vl -> a;
  80     final IntFunction<double[]> fb = vl -> b;
  81     final IntFunction<double[]> fc = vl -> c;
  82     final IntFunction<double[]> fr = vl -> r;
  83     final IntFunction<boolean[]> fm = vl -> m;
  84     final IntFunction<boolean[]> fmr = vl -> rm;
  85     final BiFunction<Integer,Integer,int[]> fs = (i,j) -> s;
  86 
  87 
  88     @Benchmark
  89     public void add(Blackhole bh) {
  90         double[] a = fa.apply(SPECIES.length());
  91         double[] b = fb.apply(SPECIES.length());
  92         double[] r = fr.apply(SPECIES.length());
  93 
  94         for (int ic = 0; ic < INVOC_COUNT; ic++) {
  95             for (int i = 0; i < a.length; i += SPECIES.length()) {
  96                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
  97                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
  98                 av.add(bv).intoArray(r, i);
  99             }
 100         }
 101 
 102         bh.consume(r);
 103     }
 104 
 105     @Benchmark
 106     public void addMasked(Blackhole bh) {
 107         double[] a = fa.apply(SPECIES.length());
 108         double[] b = fb.apply(SPECIES.length());
 109         double[] r = fr.apply(SPECIES.length());
 110         boolean[] mask = fm.apply(SPECIES.length());
 111         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
 112 
 113         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 114             for (int i = 0; i < a.length; i += SPECIES.length()) {
 115                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 116                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 117                 av.add(bv, vmask).intoArray(r, i);
 118             }
 119         }
 120 
 121         bh.consume(r);
 122     }
 123 
 124     @Benchmark
 125     public void sub(Blackhole bh) {
 126         double[] a = fa.apply(SPECIES.length());
 127         double[] b = fb.apply(SPECIES.length());
 128         double[] r = fr.apply(SPECIES.length());
 129 
 130         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 131             for (int i = 0; i < a.length; i += SPECIES.length()) {
 132                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 133                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 134                 av.sub(bv).intoArray(r, i);
 135             }
 136         }
 137 
 138         bh.consume(r);
 139     }
 140 
 141     @Benchmark
 142     public void subMasked(Blackhole bh) {
 143         double[] a = fa.apply(SPECIES.length());
 144         double[] b = fb.apply(SPECIES.length());
 145         double[] r = fr.apply(SPECIES.length());
 146         boolean[] mask = fm.apply(SPECIES.length());
 147         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
 148 
 149         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 150             for (int i = 0; i < a.length; i += SPECIES.length()) {
 151                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 152                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 153                 av.sub(bv, vmask).intoArray(r, i);
 154             }
 155         }
 156 
 157         bh.consume(r);
 158     }
 159 
 160 
 161     @Benchmark
 162     public void div(Blackhole bh) {
 163         double[] a = fa.apply(SPECIES.length());
 164         double[] b = fb.apply(SPECIES.length());
 165         double[] r = fr.apply(SPECIES.length());
 166 
 167         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 168             for (int i = 0; i < a.length; i += SPECIES.length()) {
 169                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 170                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 171                 av.div(bv).intoArray(r, i);
 172             }
 173         }
 174 
 175         bh.consume(r);
 176     }
 177 
 178 
 179 
 180     @Benchmark
 181     public void divMasked(Blackhole bh) {
 182         double[] a = fa.apply(SPECIES.length());
 183         double[] b = fb.apply(SPECIES.length());
 184         double[] r = fr.apply(SPECIES.length());
 185         boolean[] mask = fm.apply(SPECIES.length());
 186         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
 187 
 188         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 189             for (int i = 0; i < a.length; i += SPECIES.length()) {
 190                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 191                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 192                 av.div(bv, vmask).intoArray(r, i);
 193             }
 194         }
 195 
 196         bh.consume(r);
 197     }
 198 
 199 
 200     @Benchmark
 201     public void mul(Blackhole bh) {
 202         double[] a = fa.apply(SPECIES.length());
 203         double[] b = fb.apply(SPECIES.length());
 204         double[] r = fr.apply(SPECIES.length());
 205 
 206         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 207             for (int i = 0; i < a.length; i += SPECIES.length()) {
 208                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 209                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 210                 av.mul(bv).intoArray(r, i);
 211             }
 212         }
 213 
 214         bh.consume(r);
 215     }
 216 
 217     @Benchmark
 218     public void mulMasked(Blackhole bh) {
 219         double[] a = fa.apply(SPECIES.length());
 220         double[] b = fb.apply(SPECIES.length());
 221         double[] r = fr.apply(SPECIES.length());
 222         boolean[] mask = fm.apply(SPECIES.length());
 223         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
 224 
 225         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 226             for (int i = 0; i < a.length; i += SPECIES.length()) {
 227                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 228                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 229                 av.mul(bv, vmask).intoArray(r, i);
 230             }
 231         }
 232 
 233         bh.consume(r);
 234     }
 235 
 236 
 237 
 238 
 239 
 240 
 241 
 242 
 243 
 244 
 245 
 246 
 247 
 248 
 249 
 250 
 251 
 252 
 253 
 254 
 255 
 256 
 257 
 258 
 259 
 260 
 261 
 262 
 263 
 264 
 265 
 266     @Benchmark
 267     public void max(Blackhole bh) {
 268         double[] a = fa.apply(SPECIES.length());
 269         double[] b = fb.apply(SPECIES.length());
 270         double[] r = fr.apply(SPECIES.length());
 271 
 272         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 273             for (int i = 0; i < a.length; i += SPECIES.length()) {
 274                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 275                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 276                 av.max(bv).intoArray(r, i);
 277             }
 278         }
 279 
 280         bh.consume(r);
 281     }
 282 
 283     @Benchmark
 284     public void min(Blackhole bh) {
 285         double[] a = fa.apply(SPECIES.length());
 286         double[] b = fb.apply(SPECIES.length());
 287         double[] r = fr.apply(SPECIES.length());
 288 
 289         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 290             for (int i = 0; i < a.length; i += SPECIES.length()) {
 291                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 292                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 293                 av.min(bv).intoArray(r, i);
 294             }
 295         }
 296 
 297         bh.consume(r);
 298     }
 299 
 300 
 301 
 302 
 303     @Benchmark
 304     public void addAll(Blackhole bh) {
 305         double[] a = fa.apply(SPECIES.length());
 306         double ra = 0;
 307 
 308         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 309             ra = 0;
 310             for (int i = 0; i < a.length; i += SPECIES.length()) {
 311                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 312                 ra += av.addAll();
 313             }
 314         }
 315         bh.consume(ra);
 316     }
 317 
 318     @Benchmark
 319     public void mulAll(Blackhole bh) {
 320         double[] a = fa.apply(SPECIES.length());
 321         double ra = 1;
 322 
 323         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 324             ra = 1;
 325             for (int i = 0; i < a.length; i += SPECIES.length()) {
 326                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 327                 ra *= av.mulAll();
 328             }
 329         }
 330         bh.consume(ra);
 331     }
 332 
 333     @Benchmark
 334     public void minAll(Blackhole bh) {
 335         double[] a = fa.apply(SPECIES.length());
 336         double ra = Double.POSITIVE_INFINITY;
 337 
 338         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 339             ra = Double.POSITIVE_INFINITY;
 340             for (int i = 0; i < a.length; i += SPECIES.length()) {
 341                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 342                 ra = (double)Math.min(ra, av.minAll());
 343             }
 344         }
 345         bh.consume(ra);
 346     }
 347 
 348     @Benchmark
 349     public void maxAll(Blackhole bh) {
 350         double[] a = fa.apply(SPECIES.length());
 351         double ra = Double.NEGATIVE_INFINITY;
 352 
 353         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 354             ra = Double.NEGATIVE_INFINITY;
 355             for (int i = 0; i < a.length; i += SPECIES.length()) {
 356                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 357                 ra = (double)Math.max(ra, av.maxAll());
 358             }
 359         }
 360         bh.consume(ra);
 361     }
 362 
 363 
 364 
 365     @Benchmark
 366     public void with(Blackhole bh) {
 367         double[] a = fa.apply(SPECIES.length());
 368         double[] r = fr.apply(SPECIES.length());
 369 
 370         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 371             for (int i = 0; i < a.length; i += SPECIES.length()) {
 372                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 373                 av.with(0, (double)4).intoArray(r, i);
 374             }
 375         }
 376 
 377         bh.consume(r);
 378     }
 379 
 380     @Benchmark
 381     public Object lessThan() {
 382         double[] a = fa.apply(size);
 383         double[] b = fb.apply(size);
 384         boolean[] ms = fm.apply(size);
 385         Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0);
 386 
 387         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 388             for (int i = 0; i < a.length; i += SPECIES.length()) {
 389                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 390                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 391                 Vector.Mask<Double> mv = av.lessThan(bv);
 392 
 393                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 394             }
 395         }
 396         return m;
 397     }
 398 
 399 
 400     @Benchmark
 401     public Object greaterThan() {
 402         double[] a = fa.apply(size);
 403         double[] b = fb.apply(size);
 404         boolean[] ms = fm.apply(size);
 405         Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0);
 406 
 407         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 408             for (int i = 0; i < a.length; i += SPECIES.length()) {
 409                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 410                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 411                 Vector.Mask<Double> mv = av.greaterThan(bv);
 412 
 413                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 414             }
 415         }
 416         return m;
 417     }
 418 
 419 
 420     @Benchmark
 421     public Object equal() {
 422         double[] a = fa.apply(size);
 423         double[] b = fb.apply(size);
 424         boolean[] ms = fm.apply(size);
 425         Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0);
 426 
 427         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 428             for (int i = 0; i < a.length; i += SPECIES.length()) {
 429                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 430                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 431                 Vector.Mask<Double> mv = av.equal(bv);
 432 
 433                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 434             }
 435         }
 436         return m;
 437     }
 438 
 439 
 440     @Benchmark
 441     public Object notEqual() {
 442         double[] a = fa.apply(size);
 443         double[] b = fb.apply(size);
 444         boolean[] ms = fm.apply(size);
 445         Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0);
 446 
 447         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 448             for (int i = 0; i < a.length; i += SPECIES.length()) {
 449                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 450                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 451                 Vector.Mask<Double> mv = av.notEqual(bv);
 452 
 453                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 454             }
 455         }
 456         return m;
 457     }
 458 
 459 
 460     @Benchmark
 461     public Object lessThanEq() {
 462         double[] a = fa.apply(size);
 463         double[] b = fb.apply(size);
 464         boolean[] ms = fm.apply(size);
 465         Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0);
 466 
 467         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 468             for (int i = 0; i < a.length; i += SPECIES.length()) {
 469                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 470                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 471                 Vector.Mask<Double> mv = av.lessThanEq(bv);
 472 
 473                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 474             }
 475         }
 476         return m;
 477     }
 478 
 479 
 480     @Benchmark
 481     public Object greaterThanEq() {
 482         double[] a = fa.apply(size);
 483         double[] b = fb.apply(size);
 484         boolean[] ms = fm.apply(size);
 485         Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0);
 486 
 487         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 488             for (int i = 0; i < a.length; i += SPECIES.length()) {
 489                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 490                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 491                 Vector.Mask<Double> mv = av.greaterThanEq(bv);
 492 
 493                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 494             }
 495         }
 496         return m;
 497     }
 498 
 499 
 500     @Benchmark
 501     public void blend(Blackhole bh) {
 502         double[] a = fa.apply(SPECIES.length());
 503         double[] b = fb.apply(SPECIES.length());
 504         double[] r = fr.apply(SPECIES.length());
 505         boolean[] mask = fm.apply(SPECIES.length());
 506         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
 507 
 508         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 509             for (int i = 0; i < a.length; i += SPECIES.length()) {
 510                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 511                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 512                 av.blend(bv, vmask).intoArray(r, i);
 513             }
 514         }
 515 
 516         bh.consume(r);
 517     }
 518 
 519     @Benchmark
 520     public void rearrange(Blackhole bh) {
 521         double[] a = fa.apply(SPECIES.length());
 522         int[] order = fs.apply(a.length, SPECIES.length());
 523         double[] r = fr.apply(SPECIES.length());
 524 
 525         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 526             for (int i = 0; i < a.length; i += SPECIES.length()) {
 527                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 528                 av.rearrange(DoubleVector.shuffleFromArray(SPECIES, order, i)).intoArray(r, i);
 529             }
 530         }
 531 
 532         bh.consume(r);
 533     }
 534 
 535     @Benchmark
 536     public void extract(Blackhole bh) {
 537         double[] a = fa.apply(SPECIES.length());
 538         double[] r = fr.apply(SPECIES.length());
 539 
 540         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 541             for (int i = 0; i < a.length; i += SPECIES.length()) {
 542                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 543                 int num_lanes = SPECIES.length();
 544                 // Manually unroll because full unroll happens after intrinsification.
 545                 // Unroll is needed because get intrinsic requires for index to be a known constant.
 546                 if (num_lanes == 1) {
 547                     r[i]=av.get(0);
 548                 } else if (num_lanes == 2) {
 549                     r[i]=av.get(0);
 550                     r[i+1]=av.get(1);
 551                 } else if (num_lanes == 4) {
 552                     r[i]=av.get(0);
 553                     r[i+1]=av.get(1);
 554                     r[i+2]=av.get(2);
 555                     r[i+3]=av.get(3);
 556                 } else if (num_lanes == 8) {
 557                     r[i]=av.get(0);
 558                     r[i+1]=av.get(1);
 559                     r[i+2]=av.get(2);
 560                     r[i+3]=av.get(3);
 561                     r[i+4]=av.get(4);
 562                     r[i+5]=av.get(5);
 563                     r[i+6]=av.get(6);
 564                     r[i+7]=av.get(7);
 565                 } else if (num_lanes == 16) {
 566                     r[i]=av.get(0);
 567                     r[i+1]=av.get(1);
 568                     r[i+2]=av.get(2);
 569                     r[i+3]=av.get(3);
 570                     r[i+4]=av.get(4);
 571                     r[i+5]=av.get(5);
 572                     r[i+6]=av.get(6);
 573                     r[i+7]=av.get(7);
 574                     r[i+8]=av.get(8);
 575                     r[i+9]=av.get(9);
 576                     r[i+10]=av.get(10);
 577                     r[i+11]=av.get(11);
 578                     r[i+12]=av.get(12);
 579                     r[i+13]=av.get(13);
 580                     r[i+14]=av.get(14);
 581                     r[i+15]=av.get(15);
 582                 } else if (num_lanes == 32) {
 583                     r[i]=av.get(0);
 584                     r[i+1]=av.get(1);
 585                     r[i+2]=av.get(2);
 586                     r[i+3]=av.get(3);
 587                     r[i+4]=av.get(4);
 588                     r[i+5]=av.get(5);
 589                     r[i+6]=av.get(6);
 590                     r[i+7]=av.get(7);
 591                     r[i+8]=av.get(8);
 592                     r[i+9]=av.get(9);
 593                     r[i+10]=av.get(10);
 594                     r[i+11]=av.get(11);
 595                     r[i+12]=av.get(12);
 596                     r[i+13]=av.get(13);
 597                     r[i+14]=av.get(14);
 598                     r[i+15]=av.get(15);
 599                     r[i+16]=av.get(16);
 600                     r[i+17]=av.get(17);
 601                     r[i+18]=av.get(18);
 602                     r[i+19]=av.get(19);
 603                     r[i+20]=av.get(20);
 604                     r[i+21]=av.get(21);
 605                     r[i+22]=av.get(22);
 606                     r[i+23]=av.get(23);
 607                     r[i+24]=av.get(24);
 608                     r[i+25]=av.get(25);
 609                     r[i+26]=av.get(26);
 610                     r[i+27]=av.get(27);
 611                     r[i+28]=av.get(28);
 612                     r[i+29]=av.get(29);
 613                     r[i+30]=av.get(30);
 614                     r[i+31]=av.get(31);
 615                 } else if (num_lanes == 64) {
 616                     r[i]=av.get(0);
 617                     r[i+1]=av.get(1);
 618                     r[i+2]=av.get(2);
 619                     r[i+3]=av.get(3);
 620                     r[i+4]=av.get(4);
 621                     r[i+5]=av.get(5);
 622                     r[i+6]=av.get(6);
 623                     r[i+7]=av.get(7);
 624                     r[i+8]=av.get(8);
 625                     r[i+9]=av.get(9);
 626                     r[i+10]=av.get(10);
 627                     r[i+11]=av.get(11);
 628                     r[i+12]=av.get(12);
 629                     r[i+13]=av.get(13);
 630                     r[i+14]=av.get(14);
 631                     r[i+15]=av.get(15);
 632                     r[i+16]=av.get(16);
 633                     r[i+17]=av.get(17);
 634                     r[i+18]=av.get(18);
 635                     r[i+19]=av.get(19);
 636                     r[i+20]=av.get(20);
 637                     r[i+21]=av.get(21);
 638                     r[i+22]=av.get(22);
 639                     r[i+23]=av.get(23);
 640                     r[i+24]=av.get(24);
 641                     r[i+25]=av.get(25);
 642                     r[i+26]=av.get(26);
 643                     r[i+27]=av.get(27);
 644                     r[i+28]=av.get(28);
 645                     r[i+29]=av.get(29);
 646                     r[i+30]=av.get(30);
 647                     r[i+31]=av.get(31);
 648                     r[i+32]=av.get(32);
 649                     r[i+33]=av.get(33);
 650                     r[i+34]=av.get(34);
 651                     r[i+35]=av.get(35);
 652                     r[i+36]=av.get(36);
 653                     r[i+37]=av.get(37);
 654                     r[i+38]=av.get(38);
 655                     r[i+39]=av.get(39);
 656                     r[i+40]=av.get(40);
 657                     r[i+41]=av.get(41);
 658                     r[i+42]=av.get(42);
 659                     r[i+43]=av.get(43);
 660                     r[i+44]=av.get(44);
 661                     r[i+45]=av.get(45);
 662                     r[i+46]=av.get(46);
 663                     r[i+47]=av.get(47);
 664                     r[i+48]=av.get(48);
 665                     r[i+49]=av.get(49);
 666                     r[i+50]=av.get(50);
 667                     r[i+51]=av.get(51);
 668                     r[i+52]=av.get(52);
 669                     r[i+53]=av.get(53);
 670                     r[i+54]=av.get(54);
 671                     r[i+55]=av.get(55);
 672                     r[i+56]=av.get(56);
 673                     r[i+57]=av.get(57);
 674                     r[i+58]=av.get(58);
 675                     r[i+59]=av.get(59);
 676                     r[i+60]=av.get(60);
 677                     r[i+61]=av.get(61);
 678                     r[i+62]=av.get(62);
 679                     r[i+63]=av.get(63);
 680                 } else {
 681                     for (int j = 0; j < SPECIES.length(); j++) {
 682                         r[i+j]=av.get(j);
 683                     }
 684                 }
 685             }
 686         }
 687 
 688         bh.consume(r);
 689     }
 690 
 691 
 692     @Benchmark
 693     public void sin(Blackhole bh) {
 694         double[] a = fa.apply(SPECIES.length());
 695         double[] r = fr.apply(SPECIES.length());
 696 
 697         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 698             for (int i = 0; i < a.length; i += SPECIES.length()) {
 699                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 700                 av.sin().intoArray(r, i);
 701             }
 702         }
 703 
 704         bh.consume(r);
 705     }
 706 
 707 
 708 
 709     @Benchmark
 710     public void exp(Blackhole bh) {
 711         double[] a = fa.apply(SPECIES.length());
 712         double[] r = fr.apply(SPECIES.length());
 713 
 714         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 715             for (int i = 0; i < a.length; i += SPECIES.length()) {
 716                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 717                 av.exp().intoArray(r, i);
 718             }
 719         }
 720 
 721         bh.consume(r);
 722     }
 723 
 724 
 725 
 726     @Benchmark
 727     public void log1p(Blackhole bh) {
 728         double[] a = fa.apply(SPECIES.length());
 729         double[] r = fr.apply(SPECIES.length());
 730 
 731         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 732             for (int i = 0; i < a.length; i += SPECIES.length()) {
 733                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 734                 av.log1p().intoArray(r, i);
 735             }
 736         }
 737 
 738         bh.consume(r);
 739     }
 740 
 741 
 742 
 743     @Benchmark
 744     public void log(Blackhole bh) {
 745         double[] a = fa.apply(SPECIES.length());
 746         double[] r = fr.apply(SPECIES.length());
 747 
 748         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 749             for (int i = 0; i < a.length; i += SPECIES.length()) {
 750                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 751                 av.log().intoArray(r, i);
 752             }
 753         }
 754 
 755         bh.consume(r);
 756     }
 757 
 758 
 759 
 760     @Benchmark
 761     public void log10(Blackhole bh) {
 762         double[] a = fa.apply(SPECIES.length());
 763         double[] r = fr.apply(SPECIES.length());
 764 
 765         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 766             for (int i = 0; i < a.length; i += SPECIES.length()) {
 767                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 768                 av.log10().intoArray(r, i);
 769             }
 770         }
 771 
 772         bh.consume(r);
 773     }
 774 
 775 
 776 
 777     @Benchmark
 778     public void expm1(Blackhole bh) {
 779         double[] a = fa.apply(SPECIES.length());
 780         double[] r = fr.apply(SPECIES.length());
 781 
 782         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 783             for (int i = 0; i < a.length; i += SPECIES.length()) {
 784                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 785                 av.expm1().intoArray(r, i);
 786             }
 787         }
 788 
 789         bh.consume(r);
 790     }
 791 
 792 
 793 
 794     @Benchmark
 795     public void cos(Blackhole bh) {
 796         double[] a = fa.apply(SPECIES.length());
 797         double[] r = fr.apply(SPECIES.length());
 798 
 799         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 800             for (int i = 0; i < a.length; i += SPECIES.length()) {
 801                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 802                 av.cos().intoArray(r, i);
 803             }
 804         }
 805 
 806         bh.consume(r);
 807     }
 808 
 809 
 810 
 811     @Benchmark
 812     public void tan(Blackhole bh) {
 813         double[] a = fa.apply(SPECIES.length());
 814         double[] r = fr.apply(SPECIES.length());
 815 
 816         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 817             for (int i = 0; i < a.length; i += SPECIES.length()) {
 818                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 819                 av.tan().intoArray(r, i);
 820             }
 821         }
 822 
 823         bh.consume(r);
 824     }
 825 
 826 
 827 
 828     @Benchmark
 829     public void sinh(Blackhole bh) {
 830         double[] a = fa.apply(SPECIES.length());
 831         double[] r = fr.apply(SPECIES.length());
 832 
 833         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 834             for (int i = 0; i < a.length; i += SPECIES.length()) {
 835                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 836                 av.sinh().intoArray(r, i);
 837             }
 838         }
 839 
 840         bh.consume(r);
 841     }
 842 
 843 
 844 
 845     @Benchmark
 846     public void cosh(Blackhole bh) {
 847         double[] a = fa.apply(SPECIES.length());
 848         double[] r = fr.apply(SPECIES.length());
 849 
 850         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 851             for (int i = 0; i < a.length; i += SPECIES.length()) {
 852                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 853                 av.cosh().intoArray(r, i);
 854             }
 855         }
 856 
 857         bh.consume(r);
 858     }
 859 
 860 
 861 
 862     @Benchmark
 863     public void tanh(Blackhole bh) {
 864         double[] a = fa.apply(SPECIES.length());
 865         double[] r = fr.apply(SPECIES.length());
 866 
 867         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 868             for (int i = 0; i < a.length; i += SPECIES.length()) {
 869                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 870                 av.tanh().intoArray(r, i);
 871             }
 872         }
 873 
 874         bh.consume(r);
 875     }
 876 
 877 
 878 
 879     @Benchmark
 880     public void asin(Blackhole bh) {
 881         double[] a = fa.apply(SPECIES.length());
 882         double[] r = fr.apply(SPECIES.length());
 883 
 884         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 885             for (int i = 0; i < a.length; i += SPECIES.length()) {
 886                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 887                 av.asin().intoArray(r, i);
 888             }
 889         }
 890 
 891         bh.consume(r);
 892     }
 893 
 894 
 895 
 896     @Benchmark
 897     public void acos(Blackhole bh) {
 898         double[] a = fa.apply(SPECIES.length());
 899         double[] r = fr.apply(SPECIES.length());
 900 
 901         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 902             for (int i = 0; i < a.length; i += SPECIES.length()) {
 903                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 904                 av.acos().intoArray(r, i);
 905             }
 906         }
 907 
 908         bh.consume(r);
 909     }
 910 
 911 
 912 
 913     @Benchmark
 914     public void atan(Blackhole bh) {
 915         double[] a = fa.apply(SPECIES.length());
 916         double[] r = fr.apply(SPECIES.length());
 917 
 918         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 919             for (int i = 0; i < a.length; i += SPECIES.length()) {
 920                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 921                 av.atan().intoArray(r, i);
 922             }
 923         }
 924 
 925         bh.consume(r);
 926     }
 927 
 928 
 929 
 930     @Benchmark
 931     public void cbrt(Blackhole bh) {
 932         double[] a = fa.apply(SPECIES.length());
 933         double[] r = fr.apply(SPECIES.length());
 934 
 935         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 936             for (int i = 0; i < a.length; i += SPECIES.length()) {
 937                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 938                 av.cbrt().intoArray(r, i);
 939             }
 940         }
 941 
 942         bh.consume(r);
 943     }
 944 
 945 
 946 
 947     @Benchmark
 948     public void hypot(Blackhole bh) {
 949         double[] a = fa.apply(SPECIES.length());
 950         double[] b = fb.apply(SPECIES.length());
 951         double[] r = fr.apply(SPECIES.length());
 952 
 953         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 954             for (int i = 0; i < a.length; i += SPECIES.length()) {
 955                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 956                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 957                 av.hypot(bv).intoArray(r, i);
 958             }
 959         }
 960 
 961         bh.consume(r);
 962     }
 963 
 964 
 965 
 966     @Benchmark
 967     public void pow(Blackhole bh) {
 968         double[] a = fa.apply(SPECIES.length());
 969         double[] b = fb.apply(SPECIES.length());
 970         double[] r = fr.apply(SPECIES.length());
 971 
 972         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 973             for (int i = 0; i < a.length; i += SPECIES.length()) {
 974                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 975                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 976                 av.pow(bv).intoArray(r, i);
 977             }
 978         }
 979 
 980         bh.consume(r);
 981     }
 982 
 983 
 984 
 985     @Benchmark
 986     public void atan2(Blackhole bh) {
 987         double[] a = fa.apply(SPECIES.length());
 988         double[] b = fb.apply(SPECIES.length());
 989         double[] r = fr.apply(SPECIES.length());
 990 
 991         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 992             for (int i = 0; i < a.length; i += SPECIES.length()) {
 993                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
 994                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
 995                 av.atan2(bv).intoArray(r, i);
 996             }
 997         }
 998 
 999         bh.consume(r);
1000     }
1001 
1002 
1003 
1004     @Benchmark
1005     public void fma(Blackhole bh) {
1006         double[] a = fa.apply(SPECIES.length());
1007         double[] b = fb.apply(SPECIES.length());
1008         double[] c = fc.apply(SPECIES.length());
1009         double[] r = fr.apply(SPECIES.length());
1010 
1011         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1012             for (int i = 0; i < a.length; i += SPECIES.length()) {
1013                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1014                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1015                 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
1016                 av.fma(bv, cv).intoArray(r, i);
1017             }
1018         }
1019 
1020         bh.consume(r);
1021     }
1022 
1023 
1024 
1025     @Benchmark
1026     public void fmaMasked(Blackhole bh) {
1027         double[] a = fa.apply(SPECIES.length());
1028         double[] b = fb.apply(SPECIES.length());
1029         double[] c = fc.apply(SPECIES.length());
1030         double[] r = fr.apply(SPECIES.length());
1031         boolean[] mask = fm.apply(SPECIES.length());
1032         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
1033 
1034         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1035             for (int i = 0; i < a.length; i += SPECIES.length()) {
1036                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1037                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1038                 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
1039                 av.fma(bv, cv, vmask).intoArray(r, i);
1040             }
1041         }
1042 
1043         bh.consume(r);
1044     }
1045 
1046 
1047     @Benchmark
1048     public void neg(Blackhole bh) {
1049         double[] a = fa.apply(SPECIES.length());
1050         double[] r = fr.apply(SPECIES.length());
1051 
1052         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1053             for (int i = 0; i < a.length; i += SPECIES.length()) {
1054                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1055                 av.neg().intoArray(r, i);
1056             }
1057         }
1058 
1059         bh.consume(r);
1060     }
1061 
1062     @Benchmark
1063     public void negMasked(Blackhole bh) {
1064         double[] a = fa.apply(SPECIES.length());
1065         double[] r = fr.apply(SPECIES.length());
1066         boolean[] mask = fm.apply(SPECIES.length());
1067         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
1068 
1069         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1070             for (int i = 0; i < a.length; i += SPECIES.length()) {
1071                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1072                 av.neg(vmask).intoArray(r, i);
1073             }
1074         }
1075 
1076         bh.consume(r);
1077     }
1078 
1079     @Benchmark
1080     public void abs(Blackhole bh) {
1081         double[] a = fa.apply(SPECIES.length());
1082         double[] r = fr.apply(SPECIES.length());
1083 
1084         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1085             for (int i = 0; i < a.length; i += SPECIES.length()) {
1086                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1087                 av.abs().intoArray(r, i);
1088             }
1089         }
1090 
1091         bh.consume(r);
1092     }
1093 
1094     @Benchmark
1095     public void absMasked(Blackhole bh) {
1096         double[] a = fa.apply(SPECIES.length());
1097         double[] r = fr.apply(SPECIES.length());
1098         boolean[] mask = fm.apply(SPECIES.length());
1099         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
1100 
1101         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1102             for (int i = 0; i < a.length; i += SPECIES.length()) {
1103                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1104                 av.abs(vmask).intoArray(r, i);
1105             }
1106         }
1107 
1108         bh.consume(r);
1109     }
1110 
1111 
1112 
1113 
1114     @Benchmark
1115     public void sqrt(Blackhole bh) {
1116         double[] a = fa.apply(SPECIES.length());
1117         double[] r = fr.apply(SPECIES.length());
1118 
1119         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1120             for (int i = 0; i < a.length; i += SPECIES.length()) {
1121                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1122                 av.sqrt().intoArray(r, i);
1123             }
1124         }
1125 
1126         bh.consume(r);
1127     }
1128 
1129 
1130 
1131     @Benchmark
1132     public void sqrtMasked(Blackhole bh) {
1133         double[] a = fa.apply(SPECIES.length());
1134         double[] r = fr.apply(SPECIES.length());
1135         boolean[] mask = fm.apply(SPECIES.length());
1136         Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask);
1137 
1138         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1139             for (int i = 0; i < a.length; i += SPECIES.length()) {
1140                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1141                 av.sqrt(vmask).intoArray(r, i);
1142             }
1143         }
1144 
1145         bh.consume(r);
1146     }
1147 
1148 
1149 
1150     @Benchmark
1151     public void gather(Blackhole bh) {
1152         double[] a = fa.apply(SPECIES.length());
1153         int[] b    = fs.apply(a.length, SPECIES.length());
1154         double[] r = new double[a.length];
1155 
1156         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1157             for (int i = 0; i < a.length; i += SPECIES.length()) {
1158                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i, b, i);
1159                 av.intoArray(r, i);
1160             }
1161         }
1162 
1163         bh.consume(r);
1164     }
1165 
1166 
1167 
1168     @Benchmark
1169     public void scatter(Blackhole bh) {
1170         double[] a = fa.apply(SPECIES.length());
1171         int[] b = fs.apply(a.length, SPECIES.length());
1172         double[] r = new double[a.length];
1173 
1174         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1175             for (int i = 0; i < a.length; i += SPECIES.length()) {
1176                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1177                 av.intoArray(r, i, b, i);
1178             }
1179         }
1180 
1181         bh.consume(r);
1182     }
1183 
1184 }
1185 
--- EOF ---