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