Mercurial > hg > truffle
comparison test/compiler/6340864/TestFloatVect.java @ 6614:006050192a5a
6340864: Implement vectorization optimizations in hotspot-server
Summary: Added asm encoding and mach nodes for vector arithmetic instructions on x86.
Reviewed-by: roland
author | kvn |
---|---|
date | Mon, 20 Aug 2012 09:07:21 -0700 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
6594:d5ec46c7da5c | 6614:006050192a5a |
---|---|
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 } |