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

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

*** 22,31 ****
--- 22,32 ----
   */
  
  package benchmark.jdk.incubator.vector;
  
  import jdk.incubator.vector.Vector;
+ import jdk.incubator.vector.VectorMask;
  import jdk.incubator.vector.VectorShape;
  import jdk.incubator.vector.VectorSpecies;
  import jdk.incubator.vector.VectorShuffle;
  import jdk.incubator.vector.DoubleVector;
  
*** 262,271 ****
--- 263,284 ----
  
  
  
  
  
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
      @Benchmark
      public void max(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double[] b = fb.apply(SPECIES.length());
          double[] r = fr.apply(SPECIES.length());
*** 300,363 ****
  
  
  
  
      @Benchmark
!     public void addAll(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = 0;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = 0;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra += av.addAll();
              }
          }
          bh.consume(ra);
      }
  
      @Benchmark
!     public void mulAll(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = 1;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = 1;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra *= av.mulAll();
              }
          }
          bh.consume(ra);
      }
  
      @Benchmark
!     public void minAll(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = Double.POSITIVE_INFINITY;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = Double.POSITIVE_INFINITY;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra = (double)Math.min(ra, av.minAll());
              }
          }
          bh.consume(ra);
      }
  
      @Benchmark
!     public void maxAll(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = Double.NEGATIVE_INFINITY;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = Double.NEGATIVE_INFINITY;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra = (double)Math.max(ra, av.maxAll());
              }
          }
          bh.consume(ra);
      }
  
--- 313,376 ----
  
  
  
  
      @Benchmark
!     public void addLanes(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = 0;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = 0;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra += av.addLanes();
              }
          }
          bh.consume(ra);
      }
  
      @Benchmark
!     public void mulLanes(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = 1;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = 1;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra *= av.mulLanes();
              }
          }
          bh.consume(ra);
      }
  
      @Benchmark
!     public void minLanes(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = Double.POSITIVE_INFINITY;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = Double.POSITIVE_INFINITY;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra = (double)Math.min(ra, av.minLanes());
              }
          }
          bh.consume(ra);
      }
  
      @Benchmark
!     public void maxLanes(Blackhole bh) {
          double[] a = fa.apply(SPECIES.length());
          double ra = Double.NEGATIVE_INFINITY;
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              ra = Double.NEGATIVE_INFINITY;
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
!                 ra = (double)Math.max(ra, av.maxLanes());
              }
          }
          bh.consume(ra);
      }
  
*** 381,391 ****
      @Benchmark
      public Object lessThan() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.maskFromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
--- 394,404 ----
      @Benchmark
      public Object lessThan() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.fromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
*** 401,411 ****
      @Benchmark
      public Object greaterThan() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.maskFromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
--- 414,424 ----
      @Benchmark
      public Object greaterThan() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.fromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
*** 421,431 ****
      @Benchmark
      public Object equal() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.maskFromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
--- 434,444 ----
      @Benchmark
      public Object equal() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.fromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
*** 441,451 ****
      @Benchmark
      public Object notEqual() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.maskFromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
--- 454,464 ----
      @Benchmark
      public Object notEqual() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.fromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
*** 461,471 ****
      @Benchmark
      public Object lessThanEq() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.maskFromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
--- 474,484 ----
      @Benchmark
      public Object lessThanEq() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.fromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
*** 481,491 ****
      @Benchmark
      public Object greaterThanEq() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.maskFromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
--- 494,504 ----
      @Benchmark
      public Object greaterThanEq() {
          double[] a = fa.apply(size);
          double[] b = fb.apply(size);
          boolean[] ms = fm.apply(size);
!         VectorMask<Double> m = VectorMask.fromArray(SPECIES, ms, 0);
  
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
              for (int i = 0; i < a.length; i += SPECIES.length()) {
                  DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
                  DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);