1 /*
   2  * Copyright (c) 2015, 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 any
  21  * questions.
  22  *
  23  */
  24 
  25 /**
  26  * @test
  27  * @bug 8074981
  28  * @summary Add C2 x86 Superword support for scalar product reduction optimizations : int test
  29  * @requires os.arch=="x86" | os.arch=="i386" | os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
  30  *
  31  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+SuperWordReductions -XX:LoopUnrollLimit=250 -XX:CompileThresholdScaling=0.1 -XX:CompileCommand=exclude,ReductionPerf::main ReductionPerf
  32  * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-SuperWordReductions -XX:LoopUnrollLimit=250 -XX:CompileThresholdScaling=0.1 -XX:CompileCommand=exclude,ReductionPerf::main ReductionPerf
  33  */
  34 
  35 public class ReductionPerf {
  36   public static void main(String[] args) throws Exception {
  37     int[] a1 = new int[8*1024];
  38     int[] a2 = new int[8*1024];
  39     int[] a3 = new int[8*1024];
  40     long[] b1 = new long[8*1024];
  41     long[] b2 = new long[8*1024];
  42     long[] b3 = new long[8*1024];
  43     float[] c1 = new float[8*1024];
  44     float[] c2 = new float[8*1024];
  45     float[] c3 = new float[8*1024];
  46     double[] d1 = new double[8*1024];
  47     double[] d2 = new double[8*1024];
  48     double[] d3 = new double[8*1024];
  49 
  50     ReductionInit(a1,a2,a3,b1,b2,b3,c1,c2,c3,d1,d2,d3);
  51 
  52     int    sumIv = sumInt(a1,a2,a3);
  53     long   sumLv = sumLong(b1,b2,b3);
  54     float  sumFv = sumFloat(c1,c2,c3);
  55     double sumDv = sumDouble(d1,d2,d3);
  56     int    mulIv = prodInt(a1,a2,a3);
  57     long   mulLv = prodLong(b1,b2,b3);
  58     float  mulFv = prodFloat(c1,c2,c3);
  59     double mulDv = prodDouble(d1,d2,d3);
  60 
  61     int    sumI = 0;
  62     long   sumL = 0;
  63     float  sumF = 0.f;
  64     double sumD = 0.;
  65     int    mulI = 0;
  66     long   mulL = 0;
  67     float  mulF = 0.f;
  68     double mulD = 0.;
  69 
  70     System.out.println("Warmup ...");
  71     long  start = System.currentTimeMillis();
  72 
  73     for(int j = 0; j < 2000; j++) {
  74       sumI = sumInt(a1,a2,a3);
  75       sumL = sumLong(b1,b2,b3);
  76       sumF = sumFloat(c1,c2,c3);
  77       sumD = sumDouble(d1,d2,d3);
  78       mulI = prodInt(a1,a2,a3);
  79       mulL = prodLong(b1,b2,b3);
  80       mulF = prodFloat(c1,c2,c3);
  81       mulD = prodDouble(d1,d2,d3);
  82     }
  83 
  84     long stop = System.currentTimeMillis();
  85     System.out.println(" Warmup is done in " + (stop - start) + " msec");
  86 
  87     if (sumIv != sumI) {
  88       System.out.println("sum int:    " + sumIv + " != " + sumI);
  89     }
  90     if (sumLv != sumL) {
  91       System.out.println("sum long:   " + sumLv + " != " + sumL);
  92     }
  93     if (sumFv != sumF) {
  94       System.out.println("sum float:  " + sumFv + " != " + sumF);
  95     }
  96     if (sumDv != sumD) {
  97       System.out.println("sum double: " + sumDv + " != " + sumD);
  98     }
  99     if (mulIv != mulI) {
 100       System.out.println("prod int:    " + mulIv + " != " + mulI);
 101     }
 102     if (mulLv != mulL) {
 103       System.out.println("prod long:   " + mulLv + " != " + mulL);
 104     }
 105     if (mulFv != mulF) {
 106       System.out.println("prod float:  " + mulFv + " != " + mulF);
 107     }
 108     if (mulDv != mulD) {
 109       System.out.println("prod double: " + mulDv + " != " + mulD);
 110     }
 111 
 112     start = System.currentTimeMillis();
 113     for (int j = 0; j < 5000; j++) {
 114       sumI = sumInt(a1, a2 ,a3);
 115     }
 116     stop = System.currentTimeMillis();
 117     System.out.println("sum int:    " + (stop - start));
 118 
 119     start = System.currentTimeMillis();
 120     for (int j = 0; j < 5000; j++) {
 121       sumL = sumLong(b1, b2, b3);
 122     }
 123     stop = System.currentTimeMillis();
 124     System.out.println("sum long:   " + (stop - start));
 125 
 126     start = System.currentTimeMillis();
 127     for (int j = 0; j < 5000; j++) {
 128       sumF = sumFloat(c1, c2, c3);
 129     }
 130     stop = System.currentTimeMillis();
 131     System.out.println("sum float:  " + (stop - start));
 132 
 133     start = System.currentTimeMillis();
 134     for (int j = 0; j < 5000; j++) {
 135       sumD = sumDouble(d1, d2, d3);
 136     }
 137     stop = System.currentTimeMillis();
 138     System.out.println("sum double: " + (stop - start));
 139 
 140     start = System.currentTimeMillis();
 141     for (int j = 0; j < 5000; j++) {
 142       mulI = prodInt(a1, a2, a3);
 143     }
 144     stop = System.currentTimeMillis();
 145     System.out.println("prod int:    " + (stop - start));
 146 
 147     start = System.currentTimeMillis();
 148     for (int j = 0; j < 5000; j++) {
 149       mulL = prodLong(b1, b2 ,b3);
 150     }
 151     stop = System.currentTimeMillis();
 152     System.out.println("prod long:   " + (stop - start));
 153 
 154     start = System.currentTimeMillis();
 155     for (int j = 0; j < 5000; j++) {
 156       mulF = prodFloat(c1, c2, c3);
 157     }
 158     stop = System.currentTimeMillis();
 159     System.out.println("prod float:  " + (stop - start));
 160 
 161     start = System.currentTimeMillis();
 162     for (int j = 0; j < 5000; j++) {
 163       mulD = prodDouble(d1, d2, d3);
 164     }
 165     stop = System.currentTimeMillis();
 166     System.out.println("prod double: " + (stop - start));
 167 
 168   }
 169 
 170   public static void ReductionInit(int[]    a1, int[]    a2, int[]    a3,
 171                                    long[]   b1, long[]   b2, long[]   b3,
 172                                    float[]  c1, float[]  c2, float[]  c3,
 173                                    double[] d1, double[] d2, double[] d3 ) {
 174     for(int i = 0; i < a1.length; i++) {
 175       a1[i] =          (i + 0);
 176       a2[i] =          (i + 1);
 177       a3[i] =          (i + 2);
 178       b1[i] =   (long) (i + 0);
 179       b2[i] =   (long) (i + 1);
 180       b3[i] =   (long) (i + 2);
 181       c1[i] =  (float) (i + 0);
 182       c2[i] =  (float) (i + 1);
 183       c3[i] =  (float) (i + 2);
 184       d1[i] = (double) (i + 0);
 185       d2[i] = (double) (i + 1);
 186       d3[i] = (double) (i + 2);
 187     }
 188   }
 189 
 190   public static int sumInt(int[] a1, int[] a2, int[] a3) {
 191     int total = 0;
 192     for(int i = 0; i < a1.length; i++) {
 193       total += (a1[i] * a2[i]) + (a1[i] * a3[i]) + (a2[i] * a3[i]);
 194     }
 195     return total;
 196   }
 197 
 198   public static long sumLong(long[] b1, long[] b2, long[] b3) {
 199     long total = 0;
 200     for(int i = 0; i < b1.length; i++) {
 201       total += (b1[i] * b2[i]) + (b1[i] * b3[i]) + (b2[i] * b3[i]);
 202     }
 203     return total;
 204   }
 205 
 206   public static float sumFloat(float[] c1, float[] c2, float[] c3) {
 207     float total = 0;
 208     for(int i = 0; i < c1.length; i++) {
 209       total += (c1[i] * c2[i]) + (c1[i] * c3[i]) + (c2[i] * c3[i]);
 210     }
 211     return total;
 212   }
 213 
 214   public static double sumDouble(double[] d1, double[] d2, double[] d3) {
 215     double total = 0;
 216     for(int i = 0; i < d1.length; i++) {
 217       total += (d1[i] * d2[i]) + (d1[i] * d3[i]) + (d2[i] * d3[i]);
 218     }
 219     return total;
 220   }
 221 
 222   public static int prodInt(int[] a1, int[] a2, int[] a3) {
 223     int total = 1;
 224     for(int i = 0; i < a1.length; i++) {
 225       total *= (a1[i] * a2[i]) + (a1[i] * a3[i]) + (a2[i] * a3[i]);
 226     }
 227     return total;
 228   }
 229 
 230   public static long prodLong(long[] b1, long[] b2, long[] b3) {
 231     long total = 1;
 232     for(int i = 0; i < b1.length; i++) {
 233       total *= (b1[i] * b2[i]) + (b1[i] * b3[i]) + (b2[i] * b3[i]);
 234     }
 235     return total;
 236   }
 237 
 238   public static float prodFloat(float[] c1, float[] c2, float[] c3) {
 239     float total = 1;
 240     for(int i = 0; i < c1.length; i++) {
 241       total *= (c1[i] * c2[i]) + (c1[i] * c3[i]) + (c2[i] * c3[i]);
 242     }
 243     return total;
 244   }
 245 
 246   public static double prodDouble(double[] d1, double[] d2, double[] d3) {
 247     double total = 1;
 248     for(int i = 0; i < d1.length; i++) {
 249       total *= (d1[i] * d2[i]) + (d1[i] * d3[i]) + (d2[i] * d3[i]);
 250     }
 251     return total;
 252   }
 253 }