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