< prev index next >

test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Int128Vector.java

Print this page
rev 55894 : 8222897: [vector] Renaming of shift, rotate operations. Few other api changes.
Summary: Renaming of shift, rotate operations. Few other api changes.
Reviewed-by: jrose, briangoetz


   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.VectorShape;
  28 import jdk.incubator.vector.VectorSpecies;
  29 import jdk.incubator.vector.VectorShuffle;
  30 import jdk.incubator.vector.IntVector;
  31 
  32 import java.util.concurrent.TimeUnit;
  33 import java.util.function.BiFunction;
  34 import java.util.function.IntFunction;
  35 
  36 import org.openjdk.jmh.annotations.*;
  37 import org.openjdk.jmh.infra.Blackhole;
  38 
  39 @BenchmarkMode(Mode.Throughput)
  40 @OutputTimeUnit(TimeUnit.MILLISECONDS)
  41 @State(Scope.Benchmark)
  42 @Warmup(iterations = 3, time = 1)
  43 @Measurement(iterations = 5, time = 1)
  44 @Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
  45 public class Int128Vector extends AbstractVectorBenchmark {
  46     static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_128;


 301         int[] a = fa.apply(SPECIES.length());
 302         int[] b = fb.apply(SPECIES.length());
 303         int[] r = fr.apply(SPECIES.length());
 304         boolean[] mask = fm.apply(SPECIES.length());
 305         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 306 
 307         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 308             for (int i = 0; i < a.length; i += SPECIES.length()) {
 309                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 310                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 311                 av.xor(bv, vmask).intoArray(r, i);
 312             }
 313         }
 314 
 315         bh.consume(r);
 316     }
 317 
 318 
 319 
 320     @Benchmark
 321     public void shiftR(Blackhole bh) {
 322         int[] a = fa.apply(SPECIES.length());
 323         int[] b = fb.apply(SPECIES.length());
 324         int[] r = fr.apply(SPECIES.length());
 325 
 326         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 327             for (int i = 0; i < a.length; i += SPECIES.length()) {
 328                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 329                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 330                 av.shiftR(bv).intoArray(r, i);
 331             }
 332         }
 333 
 334         bh.consume(r);
 335     }
 336 
 337 
 338 
 339     @Benchmark
 340     public void shiftRMasked(Blackhole bh) {
 341         int[] a = fa.apply(SPECIES.length());
 342         int[] b = fb.apply(SPECIES.length());
 343         int[] r = fr.apply(SPECIES.length());
 344         boolean[] mask = fm.apply(SPECIES.length());
 345         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 346 
 347         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 348             for (int i = 0; i < a.length; i += SPECIES.length()) {
 349                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 350                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 351                 av.shiftR(bv, vmask).intoArray(r, i);
 352             }
 353         }
 354 
 355         bh.consume(r);
 356     }
 357 
 358 
 359 




 360     @Benchmark
 361     public void shiftL(Blackhole bh) {
 362         int[] a = fa.apply(SPECIES.length());
 363         int[] b = fb.apply(SPECIES.length());
 364         int[] r = fr.apply(SPECIES.length());
 365 
 366         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 367             for (int i = 0; i < a.length; i += SPECIES.length()) {
 368                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 369                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 370                 av.shiftL(bv).intoArray(r, i);
 371             }
 372         }
 373 
 374         bh.consume(r);
 375     }
 376 
 377 
 378 
 379     @Benchmark
 380     public void shiftLMasked(Blackhole bh) {
 381         int[] a = fa.apply(SPECIES.length());
 382         int[] b = fb.apply(SPECIES.length());
 383         int[] r = fr.apply(SPECIES.length());
 384         boolean[] mask = fm.apply(SPECIES.length());
 385         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 386 
 387         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 388             for (int i = 0; i < a.length; i += SPECIES.length()) {
 389                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 390                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 391                 av.shiftL(bv, vmask).intoArray(r, i);
 392             }
 393         }
 394 
 395         bh.consume(r);
 396     }
 397 
 398 
 399 




 400     @Benchmark
 401     public void aShiftR(Blackhole bh) {
 402         int[] a = fa.apply(SPECIES.length());
 403         int[] b = fb.apply(SPECIES.length());
 404         int[] r = fr.apply(SPECIES.length());
 405 
 406         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 407             for (int i = 0; i < a.length; i += SPECIES.length()) {
 408                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 409                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 410                 av.aShiftR(bv).intoArray(r, i);
 411             }
 412         }
 413 
 414         bh.consume(r);
 415     }
 416 
 417 
 418 
 419     @Benchmark
 420     public void aShiftRMasked(Blackhole bh) {
 421         int[] a = fa.apply(SPECIES.length());
 422         int[] b = fb.apply(SPECIES.length());
 423         int[] r = fr.apply(SPECIES.length());
 424         boolean[] mask = fm.apply(SPECIES.length());
 425         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 426 
 427         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 428             for (int i = 0; i < a.length; i += SPECIES.length()) {
 429                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 430                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 431                 av.aShiftR(bv, vmask).intoArray(r, i);
 432             }
 433         }
 434 
 435         bh.consume(r);
 436     }
 437 
 438 
 439 




 440     @Benchmark
 441     public void aShiftRShift(Blackhole bh) {
 442         int[] a = fa.apply(SPECIES.length());
 443         int[] b = fb.apply(SPECIES.length());
 444         int[] r = fr.apply(SPECIES.length());
 445 
 446         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 447             for (int i = 0; i < a.length; i += SPECIES.length()) {
 448                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 449                 av.aShiftR((int)b[i]).intoArray(r, i);
 450             }
 451         }
 452 
 453         bh.consume(r);
 454     }
 455 
 456 
 457 
 458     @Benchmark
 459     public void aShiftRMaskedShift(Blackhole bh) {
 460         int[] a = fa.apply(SPECIES.length());
 461         int[] b = fb.apply(SPECIES.length());
 462         int[] r = fr.apply(SPECIES.length());
 463         boolean[] mask = fm.apply(SPECIES.length());
 464         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 465 
 466         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 467             for (int i = 0; i < a.length; i += SPECIES.length()) {
 468                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 469                 av.aShiftR((int)b[i], vmask).intoArray(r, i);
 470             }
 471         }
 472 
 473         bh.consume(r);
 474     }
 475 
 476 
 477 




 478     @Benchmark
 479     public void shiftRShift(Blackhole bh) {
 480         int[] a = fa.apply(SPECIES.length());
 481         int[] b = fb.apply(SPECIES.length());
 482         int[] r = fr.apply(SPECIES.length());
 483 
 484         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 485             for (int i = 0; i < a.length; i += SPECIES.length()) {
 486                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 487                 av.shiftR((int)b[i]).intoArray(r, i);
 488             }
 489         }
 490 
 491         bh.consume(r);
 492     }
 493 
 494 
 495 
 496     @Benchmark
 497     public void shiftRMaskedShift(Blackhole bh) {
 498         int[] a = fa.apply(SPECIES.length());
 499         int[] b = fb.apply(SPECIES.length());
 500         int[] r = fr.apply(SPECIES.length());
 501         boolean[] mask = fm.apply(SPECIES.length());
 502         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 503 
 504         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 505             for (int i = 0; i < a.length; i += SPECIES.length()) {
 506                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 507                 av.shiftR((int)b[i], vmask).intoArray(r, i);
 508             }
 509         }
 510 
 511         bh.consume(r);
 512     }
 513 
 514 
 515 




 516     @Benchmark
 517     public void shiftLShift(Blackhole bh) {
 518         int[] a = fa.apply(SPECIES.length());
 519         int[] b = fb.apply(SPECIES.length());
 520         int[] r = fr.apply(SPECIES.length());
 521 
 522         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 523             for (int i = 0; i < a.length; i += SPECIES.length()) {
 524                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 525                 av.shiftL((int)b[i]).intoArray(r, i);
 526             }
 527         }
 528 
 529         bh.consume(r);
 530     }
 531 
 532 
 533 
 534     @Benchmark
 535     public void shiftLMaskedShift(Blackhole bh) {
 536         int[] a = fa.apply(SPECIES.length());
 537         int[] b = fb.apply(SPECIES.length());
 538         int[] r = fr.apply(SPECIES.length());
 539         boolean[] mask = fm.apply(SPECIES.length());
 540         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 541 
 542         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 543             for (int i = 0; i < a.length; i += SPECIES.length()) {
 544                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 545                 av.shiftL((int)b[i], vmask).intoArray(r, i);
 546             }
 547         }
 548 
 549         bh.consume(r);
 550     }
 551 
 552 
 553 
 554 
 555 
 556 
 557 
 558 
 559 
 560 
 561 
 562 
 563 
 564 
 565     @Benchmark
 566     public void max(Blackhole bh) {
 567         int[] a = fa.apply(SPECIES.length());
 568         int[] b = fb.apply(SPECIES.length());
 569         int[] r = fr.apply(SPECIES.length());
 570 
 571         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 572             for (int i = 0; i < a.length; i += SPECIES.length()) {
 573                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 574                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 575                 av.max(bv).intoArray(r, i);
 576             }
 577         }
 578 
 579         bh.consume(r);
 580     }
 581 
 582     @Benchmark
 583     public void min(Blackhole bh) {
 584         int[] a = fa.apply(SPECIES.length());
 585         int[] b = fb.apply(SPECIES.length());
 586         int[] r = fr.apply(SPECIES.length());
 587 
 588         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 589             for (int i = 0; i < a.length; i += SPECIES.length()) {
 590                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 591                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 592                 av.min(bv).intoArray(r, i);
 593             }
 594         }
 595 
 596         bh.consume(r);
 597     }
 598 
 599 
 600     @Benchmark
 601     public void andAll(Blackhole bh) {
 602         int[] a = fa.apply(SPECIES.length());
 603         int ra = -1;
 604 
 605         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 606             ra = -1;
 607             for (int i = 0; i < a.length; i += SPECIES.length()) {
 608                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 609                 ra &= av.andAll();
 610             }
 611         }
 612         bh.consume(ra);
 613     }
 614 
 615 
 616 
 617     @Benchmark
 618     public void orAll(Blackhole bh) {
 619         int[] a = fa.apply(SPECIES.length());
 620         int ra = 0;
 621 
 622         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 623             ra = 0;
 624             for (int i = 0; i < a.length; i += SPECIES.length()) {
 625                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 626                 ra |= av.orAll();
 627             }
 628         }
 629         bh.consume(ra);
 630     }
 631 
 632 
 633 
 634     @Benchmark
 635     public void xorAll(Blackhole bh) {
 636         int[] a = fa.apply(SPECIES.length());
 637         int ra = 0;
 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                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 643                 ra ^= av.xorAll();
 644             }
 645         }
 646         bh.consume(ra);
 647     }
 648 
 649 
 650     @Benchmark
 651     public void addAll(Blackhole bh) {
 652         int[] a = fa.apply(SPECIES.length());
 653         int ra = 0;
 654 
 655         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 656             ra = 0;
 657             for (int i = 0; i < a.length; i += SPECIES.length()) {
 658                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 659                 ra += av.addAll();
 660             }
 661         }
 662         bh.consume(ra);
 663     }
 664 
 665     @Benchmark
 666     public void mulAll(Blackhole bh) {
 667         int[] a = fa.apply(SPECIES.length());
 668         int ra = 1;
 669 
 670         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 671             ra = 1;
 672             for (int i = 0; i < a.length; i += SPECIES.length()) {
 673                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 674                 ra *= av.mulAll();
 675             }
 676         }
 677         bh.consume(ra);
 678     }
 679 
 680     @Benchmark
 681     public void minAll(Blackhole bh) {
 682         int[] a = fa.apply(SPECIES.length());
 683         int ra = Integer.MAX_VALUE;
 684 
 685         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 686             ra = Integer.MAX_VALUE;
 687             for (int i = 0; i < a.length; i += SPECIES.length()) {
 688                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 689                 ra = (int)Math.min(ra, av.minAll());
 690             }
 691         }
 692         bh.consume(ra);
 693     }
 694 
 695     @Benchmark
 696     public void maxAll(Blackhole bh) {
 697         int[] a = fa.apply(SPECIES.length());
 698         int ra = Integer.MIN_VALUE;
 699 
 700         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 701             ra = Integer.MIN_VALUE;
 702             for (int i = 0; i < a.length; i += SPECIES.length()) {
 703                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 704                 ra = (int)Math.max(ra, av.maxAll());
 705             }
 706         }
 707         bh.consume(ra);
 708     }
 709 
 710 
 711     @Benchmark
 712     public void anyTrue(Blackhole bh) {
 713         boolean[] mask = fm.apply(SPECIES.length());
 714         boolean[] r = fmr.apply(SPECIES.length());
 715 
 716         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 717             for (int i = 0; i < mask.length; i += SPECIES.length()) {
 718                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
 719                 r[i] = vmask.anyTrue();
 720             }
 721         }
 722 
 723         bh.consume(r);
 724     }


 744     @Benchmark
 745     public void with(Blackhole bh) {
 746         int[] a = fa.apply(SPECIES.length());
 747         int[] r = fr.apply(SPECIES.length());
 748 
 749         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 750             for (int i = 0; i < a.length; i += SPECIES.length()) {
 751                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 752                 av.with(0, (int)4).intoArray(r, i);
 753             }
 754         }
 755 
 756         bh.consume(r);
 757     }
 758 
 759     @Benchmark
 760     public Object lessThan() {
 761         int[] a = fa.apply(size);
 762         int[] b = fb.apply(size);
 763         boolean[] ms = fm.apply(size);
 764         VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
 765 
 766         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 767             for (int i = 0; i < a.length; i += SPECIES.length()) {
 768                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 769                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 770                 VectorMask<Integer> mv = av.lessThan(bv);
 771 
 772                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 773             }
 774         }
 775         return m;
 776     }
 777 
 778 
 779     @Benchmark
 780     public Object greaterThan() {
 781         int[] a = fa.apply(size);
 782         int[] b = fb.apply(size);
 783         boolean[] ms = fm.apply(size);
 784         VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
 785 
 786         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 787             for (int i = 0; i < a.length; i += SPECIES.length()) {
 788                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 789                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 790                 VectorMask<Integer> mv = av.greaterThan(bv);
 791 
 792                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 793             }
 794         }
 795         return m;
 796     }
 797 
 798 
 799     @Benchmark
 800     public Object equal() {
 801         int[] a = fa.apply(size);
 802         int[] b = fb.apply(size);
 803         boolean[] ms = fm.apply(size);
 804         VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
 805 
 806         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 807             for (int i = 0; i < a.length; i += SPECIES.length()) {
 808                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 809                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 810                 VectorMask<Integer> mv = av.equal(bv);
 811 
 812                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 813             }
 814         }
 815         return m;
 816     }
 817 
 818 
 819     @Benchmark
 820     public Object notEqual() {
 821         int[] a = fa.apply(size);
 822         int[] b = fb.apply(size);
 823         boolean[] ms = fm.apply(size);
 824         VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
 825 
 826         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 827             for (int i = 0; i < a.length; i += SPECIES.length()) {
 828                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 829                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 830                 VectorMask<Integer> mv = av.notEqual(bv);
 831 
 832                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 833             }
 834         }
 835         return m;
 836     }
 837 
 838 
 839     @Benchmark
 840     public Object lessThanEq() {
 841         int[] a = fa.apply(size);
 842         int[] b = fb.apply(size);
 843         boolean[] ms = fm.apply(size);
 844         VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
 845 
 846         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 847             for (int i = 0; i < a.length; i += SPECIES.length()) {
 848                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 849                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 850                 VectorMask<Integer> mv = av.lessThanEq(bv);
 851 
 852                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 853             }
 854         }
 855         return m;
 856     }
 857 
 858 
 859     @Benchmark
 860     public Object greaterThanEq() {
 861         int[] a = fa.apply(size);
 862         int[] b = fb.apply(size);
 863         boolean[] ms = fm.apply(size);
 864         VectorMask<Integer> m = VectorMask.maskFromArray(SPECIES, ms, 0);
 865 
 866         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 867             for (int i = 0; i < a.length; i += SPECIES.length()) {
 868                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 869                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 870                 VectorMask<Integer> mv = av.greaterThanEq(bv);
 871 
 872                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 873             }
 874         }
 875         return m;
 876     }
 877 
 878 
 879     @Benchmark
 880     public void blend(Blackhole bh) {
 881         int[] a = fa.apply(SPECIES.length());
 882         int[] b = fb.apply(SPECIES.length());
 883         int[] r = fr.apply(SPECIES.length());
 884         boolean[] mask = fm.apply(SPECIES.length());




   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.IntVector;
  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 Int128Vector extends AbstractVectorBenchmark {
  47     static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_128;


 302         int[] a = fa.apply(SPECIES.length());
 303         int[] b = fb.apply(SPECIES.length());
 304         int[] r = fr.apply(SPECIES.length());
 305         boolean[] mask = fm.apply(SPECIES.length());
 306         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 307 
 308         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 309             for (int i = 0; i < a.length; i += SPECIES.length()) {
 310                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 311                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 312                 av.xor(bv, vmask).intoArray(r, i);
 313             }
 314         }
 315 
 316         bh.consume(r);
 317     }
 318 
 319 
 320 
 321     @Benchmark
 322     public void shiftLeft(Blackhole bh) {
 323         int[] a = fa.apply(SPECIES.length());
 324         int[] b = fb.apply(SPECIES.length());
 325         int[] r = fr.apply(SPECIES.length());
 326 
 327         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 328             for (int i = 0; i < a.length; i += SPECIES.length()) {
 329                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 330                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 331                 av.shiftLeft(bv).intoArray(r, i);
 332             }
 333         }
 334 
 335         bh.consume(r);
 336     }
 337 
 338 
 339 
 340     @Benchmark
 341     public void shiftLeftMasked(Blackhole bh) {
 342         int[] a = fa.apply(SPECIES.length());
 343         int[] b = fb.apply(SPECIES.length());
 344         int[] r = fr.apply(SPECIES.length());
 345         boolean[] mask = fm.apply(SPECIES.length());
 346         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 347 
 348         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 349             for (int i = 0; i < a.length; i += SPECIES.length()) {
 350                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 351                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 352                 av.shiftLeft(bv, vmask).intoArray(r, i);
 353             }
 354         }
 355 
 356         bh.consume(r);
 357     }
 358 
 359 
 360 
 361 
 362 
 363 
 364 
 365     @Benchmark
 366     public void shiftRight(Blackhole bh) {
 367         int[] a = fa.apply(SPECIES.length());
 368         int[] b = fb.apply(SPECIES.length());
 369         int[] r = fr.apply(SPECIES.length());
 370 
 371         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 372             for (int i = 0; i < a.length; i += SPECIES.length()) {
 373                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 374                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 375                 av.shiftRight(bv).intoArray(r, i);
 376             }
 377         }
 378 
 379         bh.consume(r);
 380     }
 381 
 382 
 383 
 384     @Benchmark
 385     public void shiftRightMasked(Blackhole bh) {
 386         int[] a = fa.apply(SPECIES.length());
 387         int[] b = fb.apply(SPECIES.length());
 388         int[] r = fr.apply(SPECIES.length());
 389         boolean[] mask = fm.apply(SPECIES.length());
 390         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 391 
 392         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 393             for (int i = 0; i < a.length; i += SPECIES.length()) {
 394                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 395                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 396                 av.shiftRight(bv, vmask).intoArray(r, i);
 397             }
 398         }
 399 
 400         bh.consume(r);
 401     }
 402 
 403 
 404 
 405 
 406 
 407 
 408 
 409     @Benchmark
 410     public void shiftArithmeticRight(Blackhole bh) {
 411         int[] a = fa.apply(SPECIES.length());
 412         int[] b = fb.apply(SPECIES.length());
 413         int[] r = fr.apply(SPECIES.length());
 414 
 415         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 416             for (int i = 0; i < a.length; i += SPECIES.length()) {
 417                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 418                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 419                 av.shiftArithmeticRight(bv).intoArray(r, i);
 420             }
 421         }
 422 
 423         bh.consume(r);
 424     }
 425 
 426 
 427 
 428     @Benchmark
 429     public void shiftArithmeticRightMasked(Blackhole bh) {
 430         int[] a = fa.apply(SPECIES.length());
 431         int[] b = fb.apply(SPECIES.length());
 432         int[] r = fr.apply(SPECIES.length());
 433         boolean[] mask = fm.apply(SPECIES.length());
 434         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 435 
 436         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 437             for (int i = 0; i < a.length; i += SPECIES.length()) {
 438                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 439                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 440                 av.shiftArithmeticRight(bv, vmask).intoArray(r, i);
 441             }
 442         }
 443 
 444         bh.consume(r);
 445     }
 446 
 447 
 448 
 449 
 450 
 451 
 452 
 453     @Benchmark
 454     public void shiftLeftShift(Blackhole bh) {
 455         int[] a = fa.apply(SPECIES.length());
 456         int[] b = fb.apply(SPECIES.length());
 457         int[] r = fr.apply(SPECIES.length());
 458 
 459         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 460             for (int i = 0; i < a.length; i += SPECIES.length()) {
 461                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 462                 av.shiftLeft((int)b[i]).intoArray(r, i);
 463             }
 464         }
 465 
 466         bh.consume(r);
 467     }
 468 
 469 
 470 
 471     @Benchmark
 472     public void shiftLeftMaskedShift(Blackhole bh) {
 473         int[] a = fa.apply(SPECIES.length());
 474         int[] b = fb.apply(SPECIES.length());
 475         int[] r = fr.apply(SPECIES.length());
 476         boolean[] mask = fm.apply(SPECIES.length());
 477         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 478 
 479         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 480             for (int i = 0; i < a.length; i += SPECIES.length()) {
 481                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 482                 av.shiftLeft((int)b[i], vmask).intoArray(r, i);
 483             }
 484         }
 485 
 486         bh.consume(r);
 487     }
 488 
 489 
 490 
 491 
 492 
 493 
 494 
 495     @Benchmark
 496     public void shiftRightShift(Blackhole bh) {
 497         int[] a = fa.apply(SPECIES.length());
 498         int[] b = fb.apply(SPECIES.length());
 499         int[] r = fr.apply(SPECIES.length());
 500 
 501         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 502             for (int i = 0; i < a.length; i += SPECIES.length()) {
 503                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 504                 av.shiftRight((int)b[i]).intoArray(r, i);
 505             }
 506         }
 507 
 508         bh.consume(r);
 509     }
 510 
 511 
 512 
 513     @Benchmark
 514     public void shiftRightMaskedShift(Blackhole bh) {
 515         int[] a = fa.apply(SPECIES.length());
 516         int[] b = fb.apply(SPECIES.length());
 517         int[] r = fr.apply(SPECIES.length());
 518         boolean[] mask = fm.apply(SPECIES.length());
 519         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 520 
 521         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 522             for (int i = 0; i < a.length; i += SPECIES.length()) {
 523                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 524                 av.shiftRight((int)b[i], vmask).intoArray(r, i);
 525             }
 526         }
 527 
 528         bh.consume(r);
 529     }
 530 
 531 
 532 
 533 
 534 
 535 
 536 
 537     @Benchmark
 538     public void shiftArithmeticRightShift(Blackhole bh) {
 539         int[] a = fa.apply(SPECIES.length());
 540         int[] b = fb.apply(SPECIES.length());
 541         int[] r = fr.apply(SPECIES.length());
 542 
 543         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 544             for (int i = 0; i < a.length; i += SPECIES.length()) {
 545                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 546                 av.shiftArithmeticRight((int)b[i]).intoArray(r, i);
 547             }
 548         }
 549 
 550         bh.consume(r);
 551     }
 552 
 553 
 554 
 555     @Benchmark
 556     public void shiftArithmeticRightMaskedShift(Blackhole bh) {
 557         int[] a = fa.apply(SPECIES.length());
 558         int[] b = fb.apply(SPECIES.length());
 559         int[] r = fr.apply(SPECIES.length());
 560         boolean[] mask = fm.apply(SPECIES.length());
 561         VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
 562 
 563         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 564             for (int i = 0; i < a.length; i += SPECIES.length()) {
 565                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 566                 av.shiftArithmeticRight((int)b[i], vmask).intoArray(r, i);
 567             }
 568         }
 569 
 570         bh.consume(r);
 571     }
 572 
 573 
 574 
 575 
 576 
 577 








 578     @Benchmark
 579     public void max(Blackhole bh) {
 580         int[] a = fa.apply(SPECIES.length());
 581         int[] b = fb.apply(SPECIES.length());
 582         int[] r = fr.apply(SPECIES.length());
 583 
 584         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 585             for (int i = 0; i < a.length; i += SPECIES.length()) {
 586                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 587                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 588                 av.max(bv).intoArray(r, i);
 589             }
 590         }
 591 
 592         bh.consume(r);
 593     }
 594 
 595     @Benchmark
 596     public void min(Blackhole bh) {
 597         int[] a = fa.apply(SPECIES.length());
 598         int[] b = fb.apply(SPECIES.length());
 599         int[] r = fr.apply(SPECIES.length());
 600 
 601         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 602             for (int i = 0; i < a.length; i += SPECIES.length()) {
 603                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 604                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 605                 av.min(bv).intoArray(r, i);
 606             }
 607         }
 608 
 609         bh.consume(r);
 610     }
 611 
 612 
 613     @Benchmark
 614     public void andLanes(Blackhole bh) {
 615         int[] a = fa.apply(SPECIES.length());
 616         int ra = -1;
 617 
 618         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 619             ra = -1;
 620             for (int i = 0; i < a.length; i += SPECIES.length()) {
 621                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 622                 ra &= av.andLanes();
 623             }
 624         }
 625         bh.consume(ra);
 626     }
 627 
 628 
 629 
 630     @Benchmark
 631     public void orLanes(Blackhole bh) {
 632         int[] a = fa.apply(SPECIES.length());
 633         int ra = 0;
 634 
 635         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 636             ra = 0;
 637             for (int i = 0; i < a.length; i += SPECIES.length()) {
 638                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 639                 ra |= av.orLanes();
 640             }
 641         }
 642         bh.consume(ra);
 643     }
 644 
 645 
 646 
 647     @Benchmark
 648     public void xorLanes(Blackhole bh) {
 649         int[] a = fa.apply(SPECIES.length());
 650         int ra = 0;
 651 
 652         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 653             ra = 0;
 654             for (int i = 0; i < a.length; i += SPECIES.length()) {
 655                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 656                 ra ^= av.xorLanes();
 657             }
 658         }
 659         bh.consume(ra);
 660     }
 661 
 662 
 663     @Benchmark
 664     public void addLanes(Blackhole bh) {
 665         int[] a = fa.apply(SPECIES.length());
 666         int ra = 0;
 667 
 668         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 669             ra = 0;
 670             for (int i = 0; i < a.length; i += SPECIES.length()) {
 671                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 672                 ra += av.addLanes();
 673             }
 674         }
 675         bh.consume(ra);
 676     }
 677 
 678     @Benchmark
 679     public void mulLanes(Blackhole bh) {
 680         int[] a = fa.apply(SPECIES.length());
 681         int ra = 1;
 682 
 683         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 684             ra = 1;
 685             for (int i = 0; i < a.length; i += SPECIES.length()) {
 686                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 687                 ra *= av.mulLanes();
 688             }
 689         }
 690         bh.consume(ra);
 691     }
 692 
 693     @Benchmark
 694     public void minLanes(Blackhole bh) {
 695         int[] a = fa.apply(SPECIES.length());
 696         int ra = Integer.MAX_VALUE;
 697 
 698         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 699             ra = Integer.MAX_VALUE;
 700             for (int i = 0; i < a.length; i += SPECIES.length()) {
 701                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 702                 ra = (int)Math.min(ra, av.minLanes());
 703             }
 704         }
 705         bh.consume(ra);
 706     }
 707 
 708     @Benchmark
 709     public void maxLanes(Blackhole bh) {
 710         int[] a = fa.apply(SPECIES.length());
 711         int ra = Integer.MIN_VALUE;
 712 
 713         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 714             ra = Integer.MIN_VALUE;
 715             for (int i = 0; i < a.length; i += SPECIES.length()) {
 716                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 717                 ra = (int)Math.max(ra, av.maxLanes());
 718             }
 719         }
 720         bh.consume(ra);
 721     }
 722 
 723 
 724     @Benchmark
 725     public void anyTrue(Blackhole bh) {
 726         boolean[] mask = fm.apply(SPECIES.length());
 727         boolean[] r = fmr.apply(SPECIES.length());
 728 
 729         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 730             for (int i = 0; i < mask.length; i += SPECIES.length()) {
 731                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
 732                 r[i] = vmask.anyTrue();
 733             }
 734         }
 735 
 736         bh.consume(r);
 737     }


 757     @Benchmark
 758     public void with(Blackhole bh) {
 759         int[] a = fa.apply(SPECIES.length());
 760         int[] 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                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 765                 av.with(0, (int)4).intoArray(r, i);
 766             }
 767         }
 768 
 769         bh.consume(r);
 770     }
 771 
 772     @Benchmark
 773     public Object lessThan() {
 774         int[] a = fa.apply(size);
 775         int[] b = fb.apply(size);
 776         boolean[] ms = fm.apply(size);
 777         VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
 778 
 779         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 780             for (int i = 0; i < a.length; i += SPECIES.length()) {
 781                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 782                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 783                 VectorMask<Integer> mv = av.lessThan(bv);
 784 
 785                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 786             }
 787         }
 788         return m;
 789     }
 790 
 791 
 792     @Benchmark
 793     public Object greaterThan() {
 794         int[] a = fa.apply(size);
 795         int[] b = fb.apply(size);
 796         boolean[] ms = fm.apply(size);
 797         VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
 798 
 799         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 800             for (int i = 0; i < a.length; i += SPECIES.length()) {
 801                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 802                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 803                 VectorMask<Integer> mv = av.greaterThan(bv);
 804 
 805                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 806             }
 807         }
 808         return m;
 809     }
 810 
 811 
 812     @Benchmark
 813     public Object equal() {
 814         int[] a = fa.apply(size);
 815         int[] b = fb.apply(size);
 816         boolean[] ms = fm.apply(size);
 817         VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
 818 
 819         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 820             for (int i = 0; i < a.length; i += SPECIES.length()) {
 821                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 822                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 823                 VectorMask<Integer> mv = av.equal(bv);
 824 
 825                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 826             }
 827         }
 828         return m;
 829     }
 830 
 831 
 832     @Benchmark
 833     public Object notEqual() {
 834         int[] a = fa.apply(size);
 835         int[] b = fb.apply(size);
 836         boolean[] ms = fm.apply(size);
 837         VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
 838 
 839         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 840             for (int i = 0; i < a.length; i += SPECIES.length()) {
 841                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 842                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 843                 VectorMask<Integer> mv = av.notEqual(bv);
 844 
 845                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 846             }
 847         }
 848         return m;
 849     }
 850 
 851 
 852     @Benchmark
 853     public Object lessThanEq() {
 854         int[] a = fa.apply(size);
 855         int[] b = fb.apply(size);
 856         boolean[] ms = fm.apply(size);
 857         VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
 858 
 859         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 860             for (int i = 0; i < a.length; i += SPECIES.length()) {
 861                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 862                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 863                 VectorMask<Integer> mv = av.lessThanEq(bv);
 864 
 865                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 866             }
 867         }
 868         return m;
 869     }
 870 
 871 
 872     @Benchmark
 873     public Object greaterThanEq() {
 874         int[] a = fa.apply(size);
 875         int[] b = fb.apply(size);
 876         boolean[] ms = fm.apply(size);
 877         VectorMask<Integer> m = VectorMask.fromArray(SPECIES, ms, 0);
 878 
 879         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 880             for (int i = 0; i < a.length; i += SPECIES.length()) {
 881                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 882                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 883                 VectorMask<Integer> mv = av.greaterThanEq(bv);
 884 
 885                 m = m.and(mv); // accumulate results, so JIT can't eliminate relevant computations
 886             }
 887         }
 888         return m;
 889     }
 890 
 891 
 892     @Benchmark
 893     public void blend(Blackhole bh) {
 894         int[] a = fa.apply(SPECIES.length());
 895         int[] b = fb.apply(SPECIES.length());
 896         int[] r = fr.apply(SPECIES.length());
 897         boolean[] mask = fm.apply(SPECIES.length());


< prev index next >