1 /*
2 * Copyright (c) 2015, 2022, 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" | os.arch=="riscv64"
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
42 package compiler.loopopts.superword;
43
44 public 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 }