1 /*
2 * Copyright (c) 2012, 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 6340864
27 * @summary Implement vectorization optimizations in hotspot-server
28 *
29 * @run main/othervm/timeout=400 -Xbatch -Xmx128m compiler.c2.cr6340864.TestFloatVect
30 * @run main/othervm/timeout=400 -Xbatch -Xmx128m -XX:MaxVectorSize=8 compiler.c2.cr6340864.TestFloatVect
31 * @run main/othervm/timeout=400 -Xbatch -Xmx128m -XX:MaxVectorSize=16 compiler.c2.cr6340864.TestFloatVect
32 * @run main/othervm/timeout=400 -Xbatch -Xmx128m -XX:MaxVectorSize=32 compiler.c2.cr6340864.TestFloatVect
33 */
34
35 package compiler.c2.cr6340864;
36
37 public class TestFloatVect {
38 private static final int ARRLEN = 997;
39 private static final int ITERS = 11000;
40 private static final float ADD_INIT = -7500.f;
41 private static final float VALUE = 15.f;
42
43 public static void main(String args[]) {
44 System.out.println("Testing Float vectors");
45 int errn = test();
46 if (errn > 0) {
47 System.err.println("FAILED: " + errn + " errors");
48 System.exit(97);
49 }
50 System.out.println("PASSED");
51 }
52
53 static int test() {
54 float[] a0 = new float[ARRLEN];
55 float[] a1 = new float[ARRLEN];
56 float[] a2 = new float[ARRLEN];
57 float[] a3 = new float[ARRLEN];
58 // Initialize
59 float gold_sum = 0;
60 for (int i=0; i<ARRLEN; i++) {
61 float val = ADD_INIT+(float)i;
62 gold_sum += val;
63 a1[i] = val;
64 a2[i] = VALUE;
65 a3[i] = -VALUE;
66 }
67
68 System.out.println("Warmup");
69 for (int i=0; i<ITERS; i++) {
70 test_sum(a1);
71 test_addc(a0, a1);
72 test_addv(a0, a1, VALUE);
73 test_adda(a0, a1, a2);
74 test_subc(a0, a1);
75 test_subv(a0, a1, VALUE);
76 test_suba(a0, a1, a2);
77 test_mulc(a0, a1);
78 test_mulv(a0, a1, VALUE);
79 test_mula(a0, a1, a2);
80 test_divc(a0, a1);
81 test_divv(a0, a1, VALUE);
82 test_diva(a0, a1, a2);
83 test_mulc_n(a0, a1);
84 test_mulv(a0, a1, -VALUE);
85 test_mula(a0, a1, a3);
86 test_divc_n(a0, a1);
87 test_divv(a0, a1, -VALUE);
88 test_diva(a0, a1, a3);
89 }
90 // Test and verify results
91 System.out.println("Verification");
92 int errn = 0;
93 {
94 float sum = test_sum(a1);
95 if (sum != gold_sum) {
96 System.err.println("test_sum: " + sum + " != " + gold_sum);
97 errn++;
98 }
99 // Overwrite with NaN values
100 a1[0] = Float.NaN;
101 a1[1] = Float.POSITIVE_INFINITY;
102 a1[2] = Float.NEGATIVE_INFINITY;
103 a1[3] = Float.MAX_VALUE;
104 a1[4] = Float.MIN_VALUE;
105 a1[5] = Float.MIN_NORMAL;
106
107 a2[6] = a1[0];
108 a2[7] = a1[1];
109 a2[8] = a1[2];
110 a2[9] = a1[3];
111 a2[10] = a1[4];
112 a2[11] = a1[5];
113
114 a3[6] = -a2[6];
115 a3[7] = -a2[7];
116 a3[8] = -a2[8];
117 a3[9] = -a2[9];
118 a3[10] = -a2[10];
119 a3[11] = -a2[11];
120
121 test_addc(a0, a1);
122 errn += verify("test_addc: ", 0, a0[0], (Float.NaN+VALUE));
123 errn += verify("test_addc: ", 1, a0[1], (Float.POSITIVE_INFINITY+VALUE));
124 errn += verify("test_addc: ", 2, a0[2], (Float.NEGATIVE_INFINITY+VALUE));
125 errn += verify("test_addc: ", 3, a0[3], (Float.MAX_VALUE+VALUE));
126 errn += verify("test_addc: ", 4, a0[4], (Float.MIN_VALUE+VALUE));
127 errn += verify("test_addc: ", 5, a0[5], (Float.MIN_NORMAL+VALUE));
128 for (int i=6; i<ARRLEN; i++) {
129 errn += verify("test_addc: ", i, a0[i], ((ADD_INIT+i)+VALUE));
130 }
131 test_addv(a0, a1, VALUE);
132 errn += verify("test_addv: ", 0, a0[0], (Float.NaN+VALUE));
133 errn += verify("test_addv: ", 1, a0[1], (Float.POSITIVE_INFINITY+VALUE));
134 errn += verify("test_addv: ", 2, a0[2], (Float.NEGATIVE_INFINITY+VALUE));
135 errn += verify("test_addv: ", 3, a0[3], (Float.MAX_VALUE+VALUE));
136 errn += verify("test_addv: ", 4, a0[4], (Float.MIN_VALUE+VALUE));
137 errn += verify("test_addv: ", 5, a0[5], (Float.MIN_NORMAL+VALUE));
138 for (int i=6; i<ARRLEN; i++) {
139 errn += verify("test_addv: ", i, a0[i], ((ADD_INIT+i)+VALUE));
140 }
141 test_adda(a0, a1, a2);
142 errn += verify("test_adda: ", 0, a0[0], (Float.NaN+VALUE));
143 errn += verify("test_adda: ", 1, a0[1], (Float.POSITIVE_INFINITY+VALUE));
144 errn += verify("test_adda: ", 2, a0[2], (Float.NEGATIVE_INFINITY+VALUE));
145 errn += verify("test_adda: ", 3, a0[3], (Float.MAX_VALUE+VALUE));
146 errn += verify("test_adda: ", 4, a0[4], (Float.MIN_VALUE+VALUE));
147 errn += verify("test_adda: ", 5, a0[5], (Float.MIN_NORMAL+VALUE));
148 errn += verify("test_adda: ", 6, a0[6], ((ADD_INIT+6)+Float.NaN));
149 errn += verify("test_adda: ", 7, a0[7], ((ADD_INIT+7)+Float.POSITIVE_INFINITY));
150 errn += verify("test_adda: ", 8, a0[8], ((ADD_INIT+8)+Float.NEGATIVE_INFINITY));
151 errn += verify("test_adda: ", 9, a0[9], ((ADD_INIT+9)+Float.MAX_VALUE));
152 errn += verify("test_adda: ", 10, a0[10], ((ADD_INIT+10)+Float.MIN_VALUE));
153 errn += verify("test_adda: ", 11, a0[11], ((ADD_INIT+11)+Float.MIN_NORMAL));
154 for (int i=12; i<ARRLEN; i++) {
155 errn += verify("test_adda: ", i, a0[i], ((ADD_INIT+i)+VALUE));
156 }
157
158 test_subc(a0, a1);
159 errn += verify("test_subc: ", 0, a0[0], (Float.NaN-VALUE));
160 errn += verify("test_subc: ", 1, a0[1], (Float.POSITIVE_INFINITY-VALUE));
161 errn += verify("test_subc: ", 2, a0[2], (Float.NEGATIVE_INFINITY-VALUE));
162 errn += verify("test_subc: ", 3, a0[3], (Float.MAX_VALUE-VALUE));
163 errn += verify("test_subc: ", 4, a0[4], (Float.MIN_VALUE-VALUE));
164 errn += verify("test_subc: ", 5, a0[5], (Float.MIN_NORMAL-VALUE));
165 for (int i=6; i<ARRLEN; i++) {
166 errn += verify("test_subc: ", i, a0[i], ((ADD_INIT+i)-VALUE));
167 }
168 test_subv(a0, a1, VALUE);
169 errn += verify("test_subv: ", 0, a0[0], (Float.NaN-VALUE));
170 errn += verify("test_subv: ", 1, a0[1], (Float.POSITIVE_INFINITY-VALUE));
171 errn += verify("test_subv: ", 2, a0[2], (Float.NEGATIVE_INFINITY-VALUE));
172 errn += verify("test_subv: ", 3, a0[3], (Float.MAX_VALUE-VALUE));
173 errn += verify("test_subv: ", 4, a0[4], (Float.MIN_VALUE-VALUE));
174 errn += verify("test_subv: ", 5, a0[5], (Float.MIN_NORMAL-VALUE));
175 for (int i=6; i<ARRLEN; i++) {
176 errn += verify("test_subv: ", i, a0[i], ((ADD_INIT+i)-VALUE));
177 }
178 test_suba(a0, a1, a2);
179 errn += verify("test_suba: ", 0, a0[0], (Float.NaN-VALUE));
180 errn += verify("test_suba: ", 1, a0[1], (Float.POSITIVE_INFINITY-VALUE));
181 errn += verify("test_suba: ", 2, a0[2], (Float.NEGATIVE_INFINITY-VALUE));
182 errn += verify("test_suba: ", 3, a0[3], (Float.MAX_VALUE-VALUE));
183 errn += verify("test_suba: ", 4, a0[4], (Float.MIN_VALUE-VALUE));
184 errn += verify("test_suba: ", 5, a0[5], (Float.MIN_NORMAL-VALUE));
185 errn += verify("test_suba: ", 6, a0[6], ((ADD_INIT+6)-Float.NaN));
186 errn += verify("test_suba: ", 7, a0[7], ((ADD_INIT+7)-Float.POSITIVE_INFINITY));
187 errn += verify("test_suba: ", 8, a0[8], ((ADD_INIT+8)-Float.NEGATIVE_INFINITY));
188 errn += verify("test_suba: ", 9, a0[9], ((ADD_INIT+9)-Float.MAX_VALUE));
189 errn += verify("test_suba: ", 10, a0[10], ((ADD_INIT+10)-Float.MIN_VALUE));
190 errn += verify("test_suba: ", 11, a0[11], ((ADD_INIT+11)-Float.MIN_NORMAL));
191 for (int i=12; i<ARRLEN; i++) {
192 errn += verify("test_suba: ", i, a0[i], ((ADD_INIT+i)-VALUE));
193 }
194
195 test_mulc(a0, a1);
196 errn += verify("test_mulc: ", 0, a0[0], (Float.NaN*VALUE));
197 errn += verify("test_mulc: ", 1, a0[1], (Float.POSITIVE_INFINITY*VALUE));
198 errn += verify("test_mulc: ", 2, a0[2], (Float.NEGATIVE_INFINITY*VALUE));
199 errn += verify("test_mulc: ", 3, a0[3], (Float.MAX_VALUE*VALUE));
200 errn += verify("test_mulc: ", 4, a0[4], (Float.MIN_VALUE*VALUE));
201 errn += verify("test_mulc: ", 5, a0[5], (Float.MIN_NORMAL*VALUE));
202 for (int i=6; i<ARRLEN; i++) {
203 errn += verify("test_mulc: ", i, a0[i], ((ADD_INIT+i)*VALUE));
204 }
205 test_mulv(a0, a1, VALUE);
206 errn += verify("test_mulv: ", 0, a0[0], (Float.NaN*VALUE));
207 errn += verify("test_mulv: ", 1, a0[1], (Float.POSITIVE_INFINITY*VALUE));
208 errn += verify("test_mulv: ", 2, a0[2], (Float.NEGATIVE_INFINITY*VALUE));
209 errn += verify("test_mulv: ", 3, a0[3], (Float.MAX_VALUE*VALUE));
210 errn += verify("test_mulv: ", 4, a0[4], (Float.MIN_VALUE*VALUE));
211 errn += verify("test_mulv: ", 5, a0[5], (Float.MIN_NORMAL*VALUE));
212 for (int i=6; i<ARRLEN; i++) {
213 errn += verify("test_mulv: ", i, a0[i], ((ADD_INIT+i)*VALUE));
214 }
215 test_mula(a0, a1, a2);
216 errn += verify("test_mula: ", 0, a0[0], (Float.NaN*VALUE));
217 errn += verify("test_mula: ", 1, a0[1], (Float.POSITIVE_INFINITY*VALUE));
218 errn += verify("test_mula: ", 2, a0[2], (Float.NEGATIVE_INFINITY*VALUE));
219 errn += verify("test_mula: ", 3, a0[3], (Float.MAX_VALUE*VALUE));
220 errn += verify("test_mula: ", 4, a0[4], (Float.MIN_VALUE*VALUE));
221 errn += verify("test_mula: ", 5, a0[5], (Float.MIN_NORMAL*VALUE));
222 errn += verify("test_mula: ", 6, a0[6], ((ADD_INIT+6)*Float.NaN));
223 errn += verify("test_mula: ", 7, a0[7], ((ADD_INIT+7)*Float.POSITIVE_INFINITY));
224 errn += verify("test_mula: ", 8, a0[8], ((ADD_INIT+8)*Float.NEGATIVE_INFINITY));
225 errn += verify("test_mula: ", 9, a0[9], ((ADD_INIT+9)*Float.MAX_VALUE));
226 errn += verify("test_mula: ", 10, a0[10], ((ADD_INIT+10)*Float.MIN_VALUE));
227 errn += verify("test_mula: ", 11, a0[11], ((ADD_INIT+11)*Float.MIN_NORMAL));
228 for (int i=12; i<ARRLEN; i++) {
229 errn += verify("test_mula: ", i, a0[i], ((ADD_INIT+i)*VALUE));
230 }
231
232 test_divc(a0, a1);
233 errn += verify("test_divc: ", 0, a0[0], (Float.NaN/VALUE));
234 errn += verify("test_divc: ", 1, a0[1], (Float.POSITIVE_INFINITY/VALUE));
235 errn += verify("test_divc: ", 2, a0[2], (Float.NEGATIVE_INFINITY/VALUE));
236 errn += verify("test_divc: ", 3, a0[3], (Float.MAX_VALUE/VALUE));
237 errn += verify("test_divc: ", 4, a0[4], (Float.MIN_VALUE/VALUE));
238 errn += verify("test_divc: ", 5, a0[5], (Float.MIN_NORMAL/VALUE));
239 for (int i=6; i<ARRLEN; i++) {
240 errn += verify("test_divc: ", i, a0[i], ((ADD_INIT+i)/VALUE));
241 }
242 test_divv(a0, a1, VALUE);
243 errn += verify("test_divv: ", 0, a0[0], (Float.NaN/VALUE));
244 errn += verify("test_divv: ", 1, a0[1], (Float.POSITIVE_INFINITY/VALUE));
245 errn += verify("test_divv: ", 2, a0[2], (Float.NEGATIVE_INFINITY/VALUE));
246 errn += verify("test_divv: ", 3, a0[3], (Float.MAX_VALUE/VALUE));
247 errn += verify("test_divv: ", 4, a0[4], (Float.MIN_VALUE/VALUE));
248 errn += verify("test_divv: ", 5, a0[5], (Float.MIN_NORMAL/VALUE));
249 for (int i=6; i<ARRLEN; i++) {
250 errn += verify("test_divv: ", i, a0[i], ((ADD_INIT+i)/VALUE));
251 }
252 test_diva(a0, a1, a2);
253 errn += verify("test_diva: ", 0, a0[0], (Float.NaN/VALUE));
254 errn += verify("test_diva: ", 1, a0[1], (Float.POSITIVE_INFINITY/VALUE));
255 errn += verify("test_diva: ", 2, a0[2], (Float.NEGATIVE_INFINITY/VALUE));
256 errn += verify("test_diva: ", 3, a0[3], (Float.MAX_VALUE/VALUE));
257 errn += verify("test_diva: ", 4, a0[4], (Float.MIN_VALUE/VALUE));
258 errn += verify("test_diva: ", 5, a0[5], (Float.MIN_NORMAL/VALUE));
259 errn += verify("test_diva: ", 6, a0[6], ((ADD_INIT+6)/Float.NaN));
260 errn += verify("test_diva: ", 7, a0[7], ((ADD_INIT+7)/Float.POSITIVE_INFINITY));
261 errn += verify("test_diva: ", 8, a0[8], ((ADD_INIT+8)/Float.NEGATIVE_INFINITY));
262 errn += verify("test_diva: ", 9, a0[9], ((ADD_INIT+9)/Float.MAX_VALUE));
263 errn += verify("test_diva: ", 10, a0[10], ((ADD_INIT+10)/Float.MIN_VALUE));
264 errn += verify("test_diva: ", 11, a0[11], ((ADD_INIT+11)/Float.MIN_NORMAL));
265 for (int i=12; i<ARRLEN; i++) {
266 errn += verify("test_diva: ", i, a0[i], ((ADD_INIT+i)/VALUE));
267 }
268
269 test_mulc_n(a0, a1);
270 errn += verify("test_mulc_n: ", 0, a0[0], (Float.NaN*(-VALUE)));
271 errn += verify("test_mulc_n: ", 1, a0[1], (Float.POSITIVE_INFINITY*(-VALUE)));
272 errn += verify("test_mulc_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY*(-VALUE)));
273 errn += verify("test_mulc_n: ", 3, a0[3], (Float.MAX_VALUE*(-VALUE)));
274 errn += verify("test_mulc_n: ", 4, a0[4], (Float.MIN_VALUE*(-VALUE)));
275 errn += verify("test_mulc_n: ", 5, a0[5], (Float.MIN_NORMAL*(-VALUE)));
276 for (int i=6; i<ARRLEN; i++) {
277 errn += verify("test_mulc_n: ", i, a0[i], ((ADD_INIT+i)*(-VALUE)));
278 }
279 test_mulv(a0, a1, -VALUE);
280 errn += verify("test_mulv_n: ", 0, a0[0], (Float.NaN*(-VALUE)));
281 errn += verify("test_mulv_n: ", 1, a0[1], (Float.POSITIVE_INFINITY*(-VALUE)));
282 errn += verify("test_mulv_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY*(-VALUE)));
283 errn += verify("test_mulv_n: ", 3, a0[3], (Float.MAX_VALUE*(-VALUE)));
284 errn += verify("test_mulv_n: ", 4, a0[4], (Float.MIN_VALUE*(-VALUE)));
285 errn += verify("test_mulv_n: ", 5, a0[5], (Float.MIN_NORMAL*(-VALUE)));
286 for (int i=6; i<ARRLEN; i++) {
287 errn += verify("test_mulv_n: ", i, a0[i], ((ADD_INIT+i)*(-VALUE)));
288 }
289 test_mula(a0, a1, a3);
290 errn += verify("test_mula_n: ", 0, a0[0], (Float.NaN*(-VALUE)));
291 errn += verify("test_mula_n: ", 1, a0[1], (Float.POSITIVE_INFINITY*(-VALUE)));
292 errn += verify("test_mula_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY*(-VALUE)));
293 errn += verify("test_mula_n: ", 3, a0[3], (Float.MAX_VALUE*(-VALUE)));
294 errn += verify("test_mula_n: ", 4, a0[4], (Float.MIN_VALUE*(-VALUE)));
295 errn += verify("test_mula_n: ", 5, a0[5], (Float.MIN_NORMAL*(-VALUE)));
296 errn += verify("test_mula_n: ", 6, a0[6], ((ADD_INIT+6)*(-Float.NaN)));
297 errn += verify("test_mula_n: ", 7, a0[7], ((ADD_INIT+7)*(-Float.POSITIVE_INFINITY)));
298 errn += verify("test_mula_n: ", 8, a0[8], ((ADD_INIT+8)*(-Float.NEGATIVE_INFINITY)));
299 errn += verify("test_mula_n: ", 9, a0[9], ((ADD_INIT+9)*(-Float.MAX_VALUE)));
300 errn += verify("test_mula_n: ", 10, a0[10], ((ADD_INIT+10)*(-Float.MIN_VALUE)));
301 errn += verify("test_mula_n: ", 11, a0[11], ((ADD_INIT+11)*(-Float.MIN_NORMAL)));
302 for (int i=12; i<ARRLEN; i++) {
303 errn += verify("test_mula_n: ", i, a0[i], ((ADD_INIT+i)*(-VALUE)));
304 }
305
306 test_divc_n(a0, a1);
307 errn += verify("test_divc_n: ", 0, a0[0], (Float.NaN/(-VALUE)));
308 errn += verify("test_divc_n: ", 1, a0[1], (Float.POSITIVE_INFINITY/(-VALUE)));
309 errn += verify("test_divc_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY/(-VALUE)));
310 errn += verify("test_divc_n: ", 3, a0[3], (Float.MAX_VALUE/(-VALUE)));
311 errn += verify("test_divc_n: ", 4, a0[4], (Float.MIN_VALUE/(-VALUE)));
312 errn += verify("test_divc_n: ", 5, a0[5], (Float.MIN_NORMAL/(-VALUE)));
313 for (int i=6; i<ARRLEN; i++) {
314 errn += verify("test_divc_n: ", i, a0[i], ((ADD_INIT+i)/(-VALUE)));
315 }
316 test_divv(a0, a1, -VALUE);
317 errn += verify("test_divv_n: ", 0, a0[0], (Float.NaN/(-VALUE)));
318 errn += verify("test_divv_n: ", 1, a0[1], (Float.POSITIVE_INFINITY/(-VALUE)));
319 errn += verify("test_divv_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY/(-VALUE)));
320 errn += verify("test_divv_n: ", 3, a0[3], (Float.MAX_VALUE/(-VALUE)));
321 errn += verify("test_divv_n: ", 4, a0[4], (Float.MIN_VALUE/(-VALUE)));
322 errn += verify("test_divv_n: ", 5, a0[5], (Float.MIN_NORMAL/(-VALUE)));
323 for (int i=6; i<ARRLEN; i++) {
324 errn += verify("test_divv_n: ", i, a0[i], ((ADD_INIT+i)/(-VALUE)));
325 }
326 test_diva(a0, a1, a3);
327 errn += verify("test_diva_n: ", 0, a0[0], (Float.NaN/(-VALUE)));
328 errn += verify("test_diva_n: ", 1, a0[1], (Float.POSITIVE_INFINITY/(-VALUE)));
329 errn += verify("test_diva_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY/(-VALUE)));
330 errn += verify("test_diva_n: ", 3, a0[3], (Float.MAX_VALUE/(-VALUE)));
331 errn += verify("test_diva_n: ", 4, a0[4], (Float.MIN_VALUE/(-VALUE)));
332 errn += verify("test_diva_n: ", 5, a0[5], (Float.MIN_NORMAL/(-VALUE)));
333 errn += verify("test_diva_n: ", 6, a0[6], ((ADD_INIT+6)/(-Float.NaN)));
334 errn += verify("test_diva_n: ", 7, a0[7], ((ADD_INIT+7)/(-Float.POSITIVE_INFINITY)));
335 errn += verify("test_diva_n: ", 8, a0[8], ((ADD_INIT+8)/(-Float.NEGATIVE_INFINITY)));
336 errn += verify("test_diva_n: ", 9, a0[9], ((ADD_INIT+9)/(-Float.MAX_VALUE)));
337 errn += verify("test_diva_n: ", 10, a0[10], ((ADD_INIT+10)/(-Float.MIN_VALUE)));
338 errn += verify("test_diva_n: ", 11, a0[11], ((ADD_INIT+11)/(-Float.MIN_NORMAL)));
339 for (int i=12; i<ARRLEN; i++) {
340 errn += verify("test_diva_n: ", i, a0[i], ((ADD_INIT+i)/(-VALUE)));
341 }
342
343 }
344
345 if (errn > 0)
346 return errn;
347
348 System.out.println("Time");
349 long start, end;
350
351 start = System.currentTimeMillis();
352 for (int i=0; i<ITERS; i++) {
353 test_sum(a1);
354 }
355 end = System.currentTimeMillis();
356 System.out.println("test_sum: " + (end - start));
357
358 start = System.currentTimeMillis();
359 for (int i=0; i<ITERS; i++) {
360 test_addc(a0, a1);
361 }
362 end = System.currentTimeMillis();
363 System.out.println("test_addc: " + (end - start));
364 start = System.currentTimeMillis();
365 for (int i=0; i<ITERS; i++) {
366 test_addv(a0, a1, VALUE);
367 }
368 end = System.currentTimeMillis();
369 System.out.println("test_addv: " + (end - start));
370 start = System.currentTimeMillis();
371 for (int i=0; i<ITERS; i++) {
372 test_adda(a0, a1, a2);
373 }
374 end = System.currentTimeMillis();
375 System.out.println("test_adda: " + (end - start));
376
377 start = System.currentTimeMillis();
378 for (int i=0; i<ITERS; i++) {
379 test_subc(a0, a1);
380 }
381 end = System.currentTimeMillis();
382 System.out.println("test_subc: " + (end - start));
383 start = System.currentTimeMillis();
384 for (int i=0; i<ITERS; i++) {
385 test_subv(a0, a1, VALUE);
386 }
387 end = System.currentTimeMillis();
388 System.out.println("test_subv: " + (end - start));
389 start = System.currentTimeMillis();
390 for (int i=0; i<ITERS; i++) {
391 test_suba(a0, a1, a2);
392 }
393 end = System.currentTimeMillis();
394 System.out.println("test_suba: " + (end - start));
395
396 start = System.currentTimeMillis();
397 for (int i=0; i<ITERS; i++) {
398 test_mulc(a0, a1);
399 }
400 end = System.currentTimeMillis();
401 System.out.println("test_mulc: " + (end - start));
402 start = System.currentTimeMillis();
403 for (int i=0; i<ITERS; i++) {
404 test_mulv(a0, a1, VALUE);
405 }
406 end = System.currentTimeMillis();
407 System.out.println("test_mulv: " + (end - start));
408 start = System.currentTimeMillis();
409 for (int i=0; i<ITERS; i++) {
410 test_mula(a0, a1, a2);
411 }
412 end = System.currentTimeMillis();
413 System.out.println("test_mula: " + (end - start));
414
415 start = System.currentTimeMillis();
416 for (int i=0; i<ITERS; i++) {
417 test_divc(a0, a1);
418 }
419 end = System.currentTimeMillis();
420 System.out.println("test_divc: " + (end - start));
421 start = System.currentTimeMillis();
422 for (int i=0; i<ITERS; i++) {
423 test_divv(a0, a1, VALUE);
424 }
425 end = System.currentTimeMillis();
426 System.out.println("test_divv: " + (end - start));
427 start = System.currentTimeMillis();
428 for (int i=0; i<ITERS; i++) {
429 test_diva(a0, a1, a2);
430 }
431 end = System.currentTimeMillis();
432 System.out.println("test_diva: " + (end - start));
433
434 start = System.currentTimeMillis();
435 for (int i=0; i<ITERS; i++) {
436 test_mulc_n(a0, a1);
437 }
438 end = System.currentTimeMillis();
439 System.out.println("test_mulc_n: " + (end - start));
440 start = System.currentTimeMillis();
441 for (int i=0; i<ITERS; i++) {
442 test_mulv(a0, a1, -VALUE);
443 }
444 end = System.currentTimeMillis();
445 System.out.println("test_mulv_n: " + (end - start));
446 start = System.currentTimeMillis();
447 for (int i=0; i<ITERS; i++) {
448 test_mula(a0, a1, a3);
449 }
450 end = System.currentTimeMillis();
451 System.out.println("test_mula_n: " + (end - start));
452
453 start = System.currentTimeMillis();
454 for (int i=0; i<ITERS; i++) {
455 test_divc_n(a0, a1);
456 }
457 end = System.currentTimeMillis();
458 System.out.println("test_divc_n: " + (end - start));
459 start = System.currentTimeMillis();
460 for (int i=0; i<ITERS; i++) {
461 test_divv(a0, a1, -VALUE);
462 }
463 end = System.currentTimeMillis();
464 System.out.println("test_divv_n: " + (end - start));
465 start = System.currentTimeMillis();
466 for (int i=0; i<ITERS; i++) {
467 test_diva(a0, a1, a3);
468 }
469 end = System.currentTimeMillis();
470 System.out.println("test_diva_n: " + (end - start));
471
472 return errn;
473 }
474
475 static float test_sum(float[] a1) {
476 float sum = 0;
477 for (int i = 0; i < a1.length; i+=1) {
478 sum += a1[i];
479 }
480 return sum;
481 }
482
483 static void test_addc(float[] a0, float[] a1) {
484 for (int i = 0; i < a0.length; i+=1) {
485 a0[i] = (a1[i]+VALUE);
486 }
487 }
488 static void test_addv(float[] a0, float[] a1, float b) {
489 for (int i = 0; i < a0.length; i+=1) {
490 a0[i] = (a1[i]+b);
491 }
492 }
493 static void test_adda(float[] a0, float[] a1, float[] a2) {
494 for (int i = 0; i < a0.length; i+=1) {
495 a0[i] = (a1[i]+a2[i]);
496 }
497 }
498
499 static void test_subc(float[] a0, float[] a1) {
500 for (int i = 0; i < a0.length; i+=1) {
501 a0[i] = (a1[i]-VALUE);
502 }
503 }
504 static void test_subv(float[] a0, float[] a1, float b) {
505 for (int i = 0; i < a0.length; i+=1) {
506 a0[i] = (a1[i]-b);
507 }
508 }
509 static void test_suba(float[] a0, float[] a1, float[] a2) {
510 for (int i = 0; i < a0.length; i+=1) {
511 a0[i] = (a1[i]-a2[i]);
512 }
513 }
514
515 static void test_mulc(float[] a0, float[] a1) {
516 for (int i = 0; i < a0.length; i+=1) {
517 a0[i] = (a1[i]*VALUE);
518 }
519 }
520 static void test_mulc_n(float[] a0, float[] a1) {
521 for (int i = 0; i < a0.length; i+=1) {
522 a0[i] = (a1[i]*(-VALUE));
523 }
524 }
525 static void test_mulv(float[] a0, float[] a1, float b) {
526 for (int i = 0; i < a0.length; i+=1) {
527 a0[i] = (a1[i]*b);
528 }
529 }
530 static void test_mula(float[] a0, float[] a1, float[] a2) {
531 for (int i = 0; i < a0.length; i+=1) {
532 a0[i] = (a1[i]*a2[i]);
533 }
534 }
535
536 static void test_divc(float[] a0, float[] a1) {
537 for (int i = 0; i < a0.length; i+=1) {
538 a0[i] = (a1[i]/VALUE);
539 }
540 }
541 static void test_divc_n(float[] a0, float[] a1) {
542 for (int i = 0; i < a0.length; i+=1) {
543 a0[i] = (a1[i]/(-VALUE));
544 }
545 }
546 static void test_divv(float[] a0, float[] a1, float b) {
547 for (int i = 0; i < a0.length; i+=1) {
548 a0[i] = (a1[i]/b);
549 }
550 }
551 static void test_diva(float[] a0, float[] a1, float[] a2) {
552 for (int i = 0; i < a0.length; i+=1) {
553 a0[i] = (a1[i]/a2[i]);
554 }
555 }
556
557 static int verify(String text, int i, float elem, float val) {
558 if (elem != val && !(Float.isNaN(elem) && Float.isNaN(val))) {
559 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
560 return 1;
561 }
562 return 0;
563 }
564 }