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