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