1 /* 2 * Copyright (c) 2018, 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[] r = fr.apply(SPECIES.length()); 307 double ra = 0; 308 309 for (int ic = 0; ic < INVOC_COUNT; ic++) { 310 for (int i = 0; i < a.length; i += SPECIES.length()) { 311 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 312 r[i] = av.addAll(); 313 } 314 } 315 316 for (int ic = 0; ic < INVOC_COUNT; ic++) { 317 ra = 0; 318 for (int i = 0; i < a.length; i += SPECIES.length()) { 319 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 320 ra += av.addAll(); 321 } 322 } 323 324 bh.consume(ra); 325 bh.consume(r); 326 } 327 328 @Benchmark 329 public void mulAll(Blackhole bh) { 330 double[] a = fa.apply(SPECIES.length()); 331 double[] r = fr.apply(SPECIES.length()); 332 double ra = 1; 333 334 for (int ic = 0; ic < INVOC_COUNT; ic++) { 335 for (int i = 0; i < a.length; i += SPECIES.length()) { 336 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 337 r[i] = av.mulAll(); 338 } 339 } 340 341 for (int ic = 0; ic < INVOC_COUNT; ic++) { 342 ra = 1; 343 for (int i = 0; i < a.length; i += SPECIES.length()) { 344 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 345 ra *= av.mulAll(); 346 } 347 } 348 349 bh.consume(ra); 350 bh.consume(r); 351 } 352 353 @Benchmark 354 public void minAll(Blackhole bh) { 355 double[] a = fa.apply(SPECIES.length()); 356 double[] r = fr.apply(SPECIES.length()); 357 double ra = Double.MAX_VALUE; 358 359 for (int ic = 0; ic < INVOC_COUNT; ic++) { 360 for (int i = 0; i < a.length; i += SPECIES.length()) { 361 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 362 r[i] = av.minAll(); 363 } 364 } 365 366 for (int ic = 0; ic < INVOC_COUNT; ic++) { 367 ra = Double.MAX_VALUE; 368 for (int i = 0; i < a.length; i += SPECIES.length()) { 369 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 370 ra = (double)Math.min(ra, av.minAll()); 371 } 372 } 373 374 bh.consume(ra); 375 bh.consume(r); 376 } 377 378 @Benchmark 379 public void maxAll(Blackhole bh) { 380 double[] a = fa.apply(SPECIES.length()); 381 double[] r = fr.apply(SPECIES.length()); 382 double ra = Double.MIN_VALUE; 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 r[i] = av.maxAll(); 388 } 389 } 390 391 for (int ic = 0; ic < INVOC_COUNT; ic++) { 392 ra = Double.MIN_VALUE; 393 for (int i = 0; i < a.length; i += SPECIES.length()) { 394 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 395 ra = (double)Math.max(ra, av.maxAll()); 396 } 397 } 398 399 bh.consume(ra); 400 bh.consume(r); 401 } 402 403 404 405 @Benchmark 406 public void with(Blackhole bh) { 407 double[] a = fa.apply(SPECIES.length()); 408 double[] r = fr.apply(SPECIES.length()); 409 410 for (int ic = 0; ic < INVOC_COUNT; ic++) { 411 for (int i = 0; i < a.length; i += SPECIES.length()) { 412 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 413 av.with(0, (double)4).intoArray(r, i); 414 } 415 } 416 417 bh.consume(r); 418 } 419 420 @Benchmark 421 public Object lessThan() { 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.lessThan(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 greaterThan() { 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.greaterThan(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 equal() { 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.equal(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 notEqual() { 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.notEqual(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 Object lessThanEq() { 502 double[] a = fa.apply(size); 503 double[] b = fb.apply(size); 504 boolean[] ms = fm.apply(size); 505 Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0); 506 507 for (int ic = 0; ic < INVOC_COUNT; ic++) { 508 for (int i = 0; i < a.length; i += SPECIES.length()) { 509 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 510 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 511 Vector.Mask<Double> mv = av.lessThanEq(bv); 512 513 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations 514 } 515 } 516 return m; 517 } 518 519 520 @Benchmark 521 public Object greaterThanEq() { 522 double[] a = fa.apply(size); 523 double[] b = fb.apply(size); 524 boolean[] ms = fm.apply(size); 525 Vector.Mask<Double> m = DoubleVector.maskFromArray(SPECIES, ms, 0); 526 527 for (int ic = 0; ic < INVOC_COUNT; ic++) { 528 for (int i = 0; i < a.length; i += SPECIES.length()) { 529 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 530 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 531 Vector.Mask<Double> mv = av.greaterThanEq(bv); 532 533 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations 534 } 535 } 536 return m; 537 } 538 539 540 @Benchmark 541 public void blend(Blackhole bh) { 542 double[] a = fa.apply(SPECIES.length()); 543 double[] b = fb.apply(SPECIES.length()); 544 double[] r = fr.apply(SPECIES.length()); 545 boolean[] mask = fm.apply(SPECIES.length()); 546 Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask); 547 548 for (int ic = 0; ic < INVOC_COUNT; ic++) { 549 for (int i = 0; i < a.length; i += SPECIES.length()) { 550 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 551 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 552 av.blend(bv, vmask).intoArray(r, i); 553 } 554 } 555 556 bh.consume(r); 557 } 558 559 @Benchmark 560 public void rearrange(Blackhole bh) { 561 double[] a = fa.apply(SPECIES.length()); 562 int[] order = fs.apply(a.length, SPECIES.length()); 563 double[] r = fr.apply(SPECIES.length()); 564 565 for (int ic = 0; ic < INVOC_COUNT; ic++) { 566 for (int i = 0; i < a.length; i += SPECIES.length()) { 567 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 568 av.rearrange(DoubleVector.shuffleFromArray(SPECIES, order, i)).intoArray(r, i); 569 } 570 } 571 572 bh.consume(r); 573 } 574 575 @Benchmark 576 public void extract(Blackhole bh) { 577 double[] a = fa.apply(SPECIES.length()); 578 double[] r = fr.apply(SPECIES.length()); 579 580 for (int ic = 0; ic < INVOC_COUNT; ic++) { 581 for (int i = 0; i < a.length; i += SPECIES.length()) { 582 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 583 int num_lanes = SPECIES.length(); 584 // Manually unroll because full unroll happens after intrinsification. 585 // Unroll is needed because get intrinsic requires for index to be a known constant. 586 if (num_lanes == 1) { 587 r[i]=av.get(0); 588 } else if (num_lanes == 2) { 589 r[i]=av.get(0); 590 r[i+1]=av.get(1); 591 } else if (num_lanes == 4) { 592 r[i]=av.get(0); 593 r[i+1]=av.get(1); 594 r[i+2]=av.get(2); 595 r[i+3]=av.get(3); 596 } else if (num_lanes == 8) { 597 r[i]=av.get(0); 598 r[i+1]=av.get(1); 599 r[i+2]=av.get(2); 600 r[i+3]=av.get(3); 601 r[i+4]=av.get(4); 602 r[i+5]=av.get(5); 603 r[i+6]=av.get(6); 604 r[i+7]=av.get(7); 605 } else if (num_lanes == 16) { 606 r[i]=av.get(0); 607 r[i+1]=av.get(1); 608 r[i+2]=av.get(2); 609 r[i+3]=av.get(3); 610 r[i+4]=av.get(4); 611 r[i+5]=av.get(5); 612 r[i+6]=av.get(6); 613 r[i+7]=av.get(7); 614 r[i+8]=av.get(8); 615 r[i+9]=av.get(9); 616 r[i+10]=av.get(10); 617 r[i+11]=av.get(11); 618 r[i+12]=av.get(12); 619 r[i+13]=av.get(13); 620 r[i+14]=av.get(14); 621 r[i+15]=av.get(15); 622 } else if (num_lanes == 32) { 623 r[i]=av.get(0); 624 r[i+1]=av.get(1); 625 r[i+2]=av.get(2); 626 r[i+3]=av.get(3); 627 r[i+4]=av.get(4); 628 r[i+5]=av.get(5); 629 r[i+6]=av.get(6); 630 r[i+7]=av.get(7); 631 r[i+8]=av.get(8); 632 r[i+9]=av.get(9); 633 r[i+10]=av.get(10); 634 r[i+11]=av.get(11); 635 r[i+12]=av.get(12); 636 r[i+13]=av.get(13); 637 r[i+14]=av.get(14); 638 r[i+15]=av.get(15); 639 r[i+16]=av.get(16); 640 r[i+17]=av.get(17); 641 r[i+18]=av.get(18); 642 r[i+19]=av.get(19); 643 r[i+20]=av.get(20); 644 r[i+21]=av.get(21); 645 r[i+22]=av.get(22); 646 r[i+23]=av.get(23); 647 r[i+24]=av.get(24); 648 r[i+25]=av.get(25); 649 r[i+26]=av.get(26); 650 r[i+27]=av.get(27); 651 r[i+28]=av.get(28); 652 r[i+29]=av.get(29); 653 r[i+30]=av.get(30); 654 r[i+31]=av.get(31); 655 } else if (num_lanes == 64) { 656 r[i]=av.get(0); 657 r[i+1]=av.get(1); 658 r[i+2]=av.get(2); 659 r[i+3]=av.get(3); 660 r[i+4]=av.get(4); 661 r[i+5]=av.get(5); 662 r[i+6]=av.get(6); 663 r[i+7]=av.get(7); 664 r[i+8]=av.get(8); 665 r[i+9]=av.get(9); 666 r[i+10]=av.get(10); 667 r[i+11]=av.get(11); 668 r[i+12]=av.get(12); 669 r[i+13]=av.get(13); 670 r[i+14]=av.get(14); 671 r[i+15]=av.get(15); 672 r[i+16]=av.get(16); 673 r[i+17]=av.get(17); 674 r[i+18]=av.get(18); 675 r[i+19]=av.get(19); 676 r[i+20]=av.get(20); 677 r[i+21]=av.get(21); 678 r[i+22]=av.get(22); 679 r[i+23]=av.get(23); 680 r[i+24]=av.get(24); 681 r[i+25]=av.get(25); 682 r[i+26]=av.get(26); 683 r[i+27]=av.get(27); 684 r[i+28]=av.get(28); 685 r[i+29]=av.get(29); 686 r[i+30]=av.get(30); 687 r[i+31]=av.get(31); 688 r[i+32]=av.get(32); 689 r[i+33]=av.get(33); 690 r[i+34]=av.get(34); 691 r[i+35]=av.get(35); 692 r[i+36]=av.get(36); 693 r[i+37]=av.get(37); 694 r[i+38]=av.get(38); 695 r[i+39]=av.get(39); 696 r[i+40]=av.get(40); 697 r[i+41]=av.get(41); 698 r[i+42]=av.get(42); 699 r[i+43]=av.get(43); 700 r[i+44]=av.get(44); 701 r[i+45]=av.get(45); 702 r[i+46]=av.get(46); 703 r[i+47]=av.get(47); 704 r[i+48]=av.get(48); 705 r[i+49]=av.get(49); 706 r[i+50]=av.get(50); 707 r[i+51]=av.get(51); 708 r[i+52]=av.get(52); 709 r[i+53]=av.get(53); 710 r[i+54]=av.get(54); 711 r[i+55]=av.get(55); 712 r[i+56]=av.get(56); 713 r[i+57]=av.get(57); 714 r[i+58]=av.get(58); 715 r[i+59]=av.get(59); 716 r[i+60]=av.get(60); 717 r[i+61]=av.get(61); 718 r[i+62]=av.get(62); 719 r[i+63]=av.get(63); 720 } else { 721 for (int j = 0; j < SPECIES.length(); j++) { 722 r[i+j]=av.get(j); 723 } 724 } 725 } 726 } 727 728 bh.consume(r); 729 } 730 731 732 @Benchmark 733 public void sin(Blackhole bh) { 734 double[] a = fa.apply(SPECIES.length()); 735 double[] r = fr.apply(SPECIES.length()); 736 737 for (int ic = 0; ic < INVOC_COUNT; ic++) { 738 for (int i = 0; i < a.length; i += SPECIES.length()) { 739 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 740 av.sin().intoArray(r, i); 741 } 742 } 743 744 bh.consume(r); 745 } 746 747 748 749 @Benchmark 750 public void exp(Blackhole bh) { 751 double[] a = fa.apply(SPECIES.length()); 752 double[] r = fr.apply(SPECIES.length()); 753 754 for (int ic = 0; ic < INVOC_COUNT; ic++) { 755 for (int i = 0; i < a.length; i += SPECIES.length()) { 756 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 757 av.exp().intoArray(r, i); 758 } 759 } 760 761 bh.consume(r); 762 } 763 764 765 766 @Benchmark 767 public void log1p(Blackhole bh) { 768 double[] a = fa.apply(SPECIES.length()); 769 double[] r = fr.apply(SPECIES.length()); 770 771 for (int ic = 0; ic < INVOC_COUNT; ic++) { 772 for (int i = 0; i < a.length; i += SPECIES.length()) { 773 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 774 av.log1p().intoArray(r, i); 775 } 776 } 777 778 bh.consume(r); 779 } 780 781 782 783 @Benchmark 784 public void log(Blackhole bh) { 785 double[] a = fa.apply(SPECIES.length()); 786 double[] r = fr.apply(SPECIES.length()); 787 788 for (int ic = 0; ic < INVOC_COUNT; ic++) { 789 for (int i = 0; i < a.length; i += SPECIES.length()) { 790 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 791 av.log().intoArray(r, i); 792 } 793 } 794 795 bh.consume(r); 796 } 797 798 799 800 @Benchmark 801 public void log10(Blackhole bh) { 802 double[] a = fa.apply(SPECIES.length()); 803 double[] r = fr.apply(SPECIES.length()); 804 805 for (int ic = 0; ic < INVOC_COUNT; ic++) { 806 for (int i = 0; i < a.length; i += SPECIES.length()) { 807 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 808 av.log10().intoArray(r, i); 809 } 810 } 811 812 bh.consume(r); 813 } 814 815 816 817 @Benchmark 818 public void expm1(Blackhole bh) { 819 double[] a = fa.apply(SPECIES.length()); 820 double[] r = fr.apply(SPECIES.length()); 821 822 for (int ic = 0; ic < INVOC_COUNT; ic++) { 823 for (int i = 0; i < a.length; i += SPECIES.length()) { 824 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 825 av.expm1().intoArray(r, i); 826 } 827 } 828 829 bh.consume(r); 830 } 831 832 833 834 @Benchmark 835 public void cos(Blackhole bh) { 836 double[] a = fa.apply(SPECIES.length()); 837 double[] r = fr.apply(SPECIES.length()); 838 839 for (int ic = 0; ic < INVOC_COUNT; ic++) { 840 for (int i = 0; i < a.length; i += SPECIES.length()) { 841 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 842 av.cos().intoArray(r, i); 843 } 844 } 845 846 bh.consume(r); 847 } 848 849 850 851 @Benchmark 852 public void tan(Blackhole bh) { 853 double[] a = fa.apply(SPECIES.length()); 854 double[] r = fr.apply(SPECIES.length()); 855 856 for (int ic = 0; ic < INVOC_COUNT; ic++) { 857 for (int i = 0; i < a.length; i += SPECIES.length()) { 858 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 859 av.tan().intoArray(r, i); 860 } 861 } 862 863 bh.consume(r); 864 } 865 866 867 868 @Benchmark 869 public void sinh(Blackhole bh) { 870 double[] a = fa.apply(SPECIES.length()); 871 double[] r = fr.apply(SPECIES.length()); 872 873 for (int ic = 0; ic < INVOC_COUNT; ic++) { 874 for (int i = 0; i < a.length; i += SPECIES.length()) { 875 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 876 av.sinh().intoArray(r, i); 877 } 878 } 879 880 bh.consume(r); 881 } 882 883 884 885 @Benchmark 886 public void cosh(Blackhole bh) { 887 double[] a = fa.apply(SPECIES.length()); 888 double[] r = fr.apply(SPECIES.length()); 889 890 for (int ic = 0; ic < INVOC_COUNT; ic++) { 891 for (int i = 0; i < a.length; i += SPECIES.length()) { 892 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 893 av.cosh().intoArray(r, i); 894 } 895 } 896 897 bh.consume(r); 898 } 899 900 901 902 @Benchmark 903 public void tanh(Blackhole bh) { 904 double[] a = fa.apply(SPECIES.length()); 905 double[] r = fr.apply(SPECIES.length()); 906 907 for (int ic = 0; ic < INVOC_COUNT; ic++) { 908 for (int i = 0; i < a.length; i += SPECIES.length()) { 909 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 910 av.tanh().intoArray(r, i); 911 } 912 } 913 914 bh.consume(r); 915 } 916 917 918 919 @Benchmark 920 public void asin(Blackhole bh) { 921 double[] a = fa.apply(SPECIES.length()); 922 double[] r = fr.apply(SPECIES.length()); 923 924 for (int ic = 0; ic < INVOC_COUNT; ic++) { 925 for (int i = 0; i < a.length; i += SPECIES.length()) { 926 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 927 av.asin().intoArray(r, i); 928 } 929 } 930 931 bh.consume(r); 932 } 933 934 935 936 @Benchmark 937 public void acos(Blackhole bh) { 938 double[] a = fa.apply(SPECIES.length()); 939 double[] r = fr.apply(SPECIES.length()); 940 941 for (int ic = 0; ic < INVOC_COUNT; ic++) { 942 for (int i = 0; i < a.length; i += SPECIES.length()) { 943 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 944 av.acos().intoArray(r, i); 945 } 946 } 947 948 bh.consume(r); 949 } 950 951 952 953 @Benchmark 954 public void atan(Blackhole bh) { 955 double[] a = fa.apply(SPECIES.length()); 956 double[] r = fr.apply(SPECIES.length()); 957 958 for (int ic = 0; ic < INVOC_COUNT; ic++) { 959 for (int i = 0; i < a.length; i += SPECIES.length()) { 960 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 961 av.atan().intoArray(r, i); 962 } 963 } 964 965 bh.consume(r); 966 } 967 968 969 970 @Benchmark 971 public void cbrt(Blackhole bh) { 972 double[] a = fa.apply(SPECIES.length()); 973 double[] r = fr.apply(SPECIES.length()); 974 975 for (int ic = 0; ic < INVOC_COUNT; ic++) { 976 for (int i = 0; i < a.length; i += SPECIES.length()) { 977 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 978 av.cbrt().intoArray(r, i); 979 } 980 } 981 982 bh.consume(r); 983 } 984 985 986 987 @Benchmark 988 public void hypot(Blackhole bh) { 989 double[] a = fa.apply(SPECIES.length()); 990 double[] b = fb.apply(SPECIES.length()); 991 double[] r = fr.apply(SPECIES.length()); 992 993 for (int ic = 0; ic < INVOC_COUNT; ic++) { 994 for (int i = 0; i < a.length; i += SPECIES.length()) { 995 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 996 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 997 av.hypot(bv).intoArray(r, i); 998 } 999 } 1000 1001 bh.consume(r); 1002 } 1003 1004 1005 1006 @Benchmark 1007 public void pow(Blackhole bh) { 1008 double[] a = fa.apply(SPECIES.length()); 1009 double[] b = fb.apply(SPECIES.length()); 1010 double[] r = fr.apply(SPECIES.length()); 1011 1012 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1013 for (int i = 0; i < a.length; i += SPECIES.length()) { 1014 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1015 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1016 av.pow(bv).intoArray(r, i); 1017 } 1018 } 1019 1020 bh.consume(r); 1021 } 1022 1023 1024 1025 @Benchmark 1026 public void atan2(Blackhole bh) { 1027 double[] a = fa.apply(SPECIES.length()); 1028 double[] b = fb.apply(SPECIES.length()); 1029 double[] r = fr.apply(SPECIES.length()); 1030 1031 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1032 for (int i = 0; i < a.length; i += SPECIES.length()) { 1033 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1034 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1035 av.atan2(bv).intoArray(r, i); 1036 } 1037 } 1038 1039 bh.consume(r); 1040 } 1041 1042 1043 1044 @Benchmark 1045 public void fma(Blackhole bh) { 1046 double[] a = fa.apply(SPECIES.length()); 1047 double[] b = fb.apply(SPECIES.length()); 1048 double[] c = fc.apply(SPECIES.length()); 1049 double[] r = fr.apply(SPECIES.length()); 1050 1051 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1052 for (int i = 0; i < a.length; i += SPECIES.length()) { 1053 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1054 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1055 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); 1056 av.fma(bv, cv).intoArray(r, i); 1057 } 1058 } 1059 1060 bh.consume(r); 1061 } 1062 1063 1064 1065 @Benchmark 1066 public void fmaMasked(Blackhole bh) { 1067 double[] a = fa.apply(SPECIES.length()); 1068 double[] b = fb.apply(SPECIES.length()); 1069 double[] c = fc.apply(SPECIES.length()); 1070 double[] r = fr.apply(SPECIES.length()); 1071 boolean[] mask = fm.apply(SPECIES.length()); 1072 Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask); 1073 1074 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1075 for (int i = 0; i < a.length; i += SPECIES.length()) { 1076 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1077 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1078 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); 1079 av.fma(bv, cv, vmask).intoArray(r, i); 1080 } 1081 } 1082 1083 bh.consume(r); 1084 } 1085 1086 1087 @Benchmark 1088 public void neg(Blackhole bh) { 1089 double[] a = fa.apply(SPECIES.length()); 1090 double[] r = fr.apply(SPECIES.length()); 1091 1092 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1093 for (int i = 0; i < a.length; i += SPECIES.length()) { 1094 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1095 av.neg().intoArray(r, i); 1096 } 1097 } 1098 1099 bh.consume(r); 1100 } 1101 1102 @Benchmark 1103 public void negMasked(Blackhole bh) { 1104 double[] a = fa.apply(SPECIES.length()); 1105 double[] r = fr.apply(SPECIES.length()); 1106 boolean[] mask = fm.apply(SPECIES.length()); 1107 Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask); 1108 1109 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1110 for (int i = 0; i < a.length; i += SPECIES.length()) { 1111 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1112 av.neg(vmask).intoArray(r, i); 1113 } 1114 } 1115 1116 bh.consume(r); 1117 } 1118 1119 @Benchmark 1120 public void abs(Blackhole bh) { 1121 double[] a = fa.apply(SPECIES.length()); 1122 double[] r = fr.apply(SPECIES.length()); 1123 1124 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1125 for (int i = 0; i < a.length; i += SPECIES.length()) { 1126 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1127 av.abs().intoArray(r, i); 1128 } 1129 } 1130 1131 bh.consume(r); 1132 } 1133 1134 @Benchmark 1135 public void absMasked(Blackhole bh) { 1136 double[] a = fa.apply(SPECIES.length()); 1137 double[] r = fr.apply(SPECIES.length()); 1138 boolean[] mask = fm.apply(SPECIES.length()); 1139 Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask); 1140 1141 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1142 for (int i = 0; i < a.length; i += SPECIES.length()) { 1143 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1144 av.abs(vmask).intoArray(r, i); 1145 } 1146 } 1147 1148 bh.consume(r); 1149 } 1150 1151 1152 1153 1154 @Benchmark 1155 public void sqrt(Blackhole bh) { 1156 double[] a = fa.apply(SPECIES.length()); 1157 double[] r = fr.apply(SPECIES.length()); 1158 1159 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1160 for (int i = 0; i < a.length; i += SPECIES.length()) { 1161 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1162 av.sqrt().intoArray(r, i); 1163 } 1164 } 1165 1166 bh.consume(r); 1167 } 1168 1169 1170 1171 @Benchmark 1172 public void sqrtMasked(Blackhole bh) { 1173 double[] a = fa.apply(SPECIES.length()); 1174 double[] r = fr.apply(SPECIES.length()); 1175 boolean[] mask = fm.apply(SPECIES.length()); 1176 Vector.Mask<Double> vmask = DoubleVector.maskFromValues(SPECIES, mask); 1177 1178 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1179 for (int i = 0; i < a.length; i += SPECIES.length()) { 1180 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1181 av.sqrt(vmask).intoArray(r, i); 1182 } 1183 } 1184 1185 bh.consume(r); 1186 } 1187 1188 1189 1190 @Benchmark 1191 public void gather(Blackhole bh) { 1192 double[] a = fa.apply(SPECIES.length()); 1193 int[] b = fs.apply(a.length, SPECIES.length()); 1194 double[] r = new double[a.length]; 1195 1196 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1197 for (int i = 0; i < a.length; i += SPECIES.length()) { 1198 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i, b, i); 1199 av.intoArray(r, i); 1200 } 1201 } 1202 1203 bh.consume(r); 1204 } 1205 1206 1207 1208 @Benchmark 1209 public void scatter(Blackhole bh) { 1210 double[] a = fa.apply(SPECIES.length()); 1211 int[] b = fs.apply(a.length, SPECIES.length()); 1212 double[] r = new double[a.length]; 1213 1214 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1215 for (int i = 0; i < a.length; i += SPECIES.length()) { 1216 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1217 av.intoArray(r, i, b, i); 1218 } 1219 } 1220 1221 bh.consume(r); 1222 } 1223 1224 } 1225