Mercurial > hg > truffle
comparison test/compiler/6340864/TestLongVect.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 | b2c669fd8114 |
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 TestLongVect | |
31 */ | |
32 | |
33 public class TestLongVect { | |
34 private static final int ARRLEN = 997; | |
35 private static final int ITERS = 11000; | |
36 private static final long ADD_INIT = Long.MAX_VALUE-500; | |
37 private static final long BIT_MASK = 0xEC80F731EC80F731L; | |
38 private static final int VALUE = 31; | |
39 private static final int SHIFT = 64; | |
40 | |
41 public static void main(String args[]) { | |
42 System.out.println("Testing Long vectors"); | |
43 int errn = test(); | |
44 if (errn > 0) { | |
45 System.err.println("FAILED: " + errn + " errors"); | |
46 System.exit(97); | |
47 } | |
48 System.out.println("PASSED"); | |
49 } | |
50 | |
51 static int test() { | |
52 long[] a0 = new long[ARRLEN]; | |
53 long[] a1 = new long[ARRLEN]; | |
54 long[] a2 = new long[ARRLEN]; | |
55 long[] a3 = new long[ARRLEN]; | |
56 long[] a4 = new long[ARRLEN]; | |
57 // Initialize | |
58 long gold_sum = 0; | |
59 for (int i=0; i<ARRLEN; i++) { | |
60 long val = (long)(ADD_INIT+i); | |
61 gold_sum += val; | |
62 a1[i] = val; | |
63 a2[i] = (long)VALUE; | |
64 a3[i] = (long)-VALUE; | |
65 a4[i] = (long)BIT_MASK; | |
66 } | |
67 System.out.println("Warmup"); | |
68 for (int i=0; i<ITERS; i++) { | |
69 test_sum(a1); | |
70 test_addc(a0, a1); | |
71 test_addv(a0, a1, (long)VALUE); | |
72 test_adda(a0, a1, a2); | |
73 test_subc(a0, a1); | |
74 test_subv(a0, a1, (long)VALUE); | |
75 test_suba(a0, a1, a2); | |
76 test_mulc(a0, a1); | |
77 test_mulv(a0, a1, (long)VALUE); | |
78 test_mula(a0, a1, a2); | |
79 test_divc(a0, a1); | |
80 test_divv(a0, a1, (long)VALUE); | |
81 test_diva(a0, a1, a2); | |
82 test_mulc_n(a0, a1); | |
83 test_mulv(a0, a1, (long)-VALUE); | |
84 test_mula(a0, a1, a3); | |
85 test_divc_n(a0, a1); | |
86 test_divv(a0, a1, (long)-VALUE); | |
87 test_diva(a0, a1, a3); | |
88 test_andc(a0, a1); | |
89 test_andv(a0, a1, (long)BIT_MASK); | |
90 test_anda(a0, a1, a4); | |
91 test_orc(a0, a1); | |
92 test_orv(a0, a1, (long)BIT_MASK); | |
93 test_ora(a0, a1, a4); | |
94 test_xorc(a0, a1); | |
95 test_xorv(a0, a1, (long)BIT_MASK); | |
96 test_xora(a0, a1, a4); | |
97 test_sllc(a0, a1); | |
98 test_sllv(a0, a1, VALUE); | |
99 test_srlc(a0, a1); | |
100 test_srlv(a0, a1, VALUE); | |
101 test_srac(a0, a1); | |
102 test_srav(a0, a1, VALUE); | |
103 test_sllc_n(a0, a1); | |
104 test_sllv(a0, a1, -VALUE); | |
105 test_srlc_n(a0, a1); | |
106 test_srlv(a0, a1, -VALUE); | |
107 test_srac_n(a0, a1); | |
108 test_srav(a0, a1, -VALUE); | |
109 test_sllc_o(a0, a1); | |
110 test_sllv(a0, a1, SHIFT); | |
111 test_srlc_o(a0, a1); | |
112 test_srlv(a0, a1, SHIFT); | |
113 test_srac_o(a0, a1); | |
114 test_srav(a0, a1, SHIFT); | |
115 test_sllc_on(a0, a1); | |
116 test_sllv(a0, a1, -SHIFT); | |
117 test_srlc_on(a0, a1); | |
118 test_srlv(a0, a1, -SHIFT); | |
119 test_srac_on(a0, a1); | |
120 test_srav(a0, a1, -SHIFT); | |
121 } | |
122 // Test and verify results | |
123 System.out.println("Verification"); | |
124 int errn = 0; | |
125 { | |
126 long sum = test_sum(a1); | |
127 if (sum != gold_sum) { | |
128 System.err.println("test_sum: " + sum + " != " + gold_sum); | |
129 errn++; | |
130 } | |
131 | |
132 test_addc(a0, a1); | |
133 for (int i=0; i<ARRLEN; i++) { | |
134 errn += verify("test_addc: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE)); | |
135 } | |
136 test_addv(a0, a1, (long)VALUE); | |
137 for (int i=0; i<ARRLEN; i++) { | |
138 errn += verify("test_addv: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE)); | |
139 } | |
140 test_adda(a0, a1, a2); | |
141 for (int i=0; i<ARRLEN; i++) { | |
142 errn += verify("test_adda: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE)); | |
143 } | |
144 | |
145 test_subc(a0, a1); | |
146 for (int i=0; i<ARRLEN; i++) { | |
147 errn += verify("test_subc: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE)); | |
148 } | |
149 test_subv(a0, a1, (long)VALUE); | |
150 for (int i=0; i<ARRLEN; i++) { | |
151 errn += verify("test_subv: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE)); | |
152 } | |
153 test_suba(a0, a1, a2); | |
154 for (int i=0; i<ARRLEN; i++) { | |
155 errn += verify("test_suba: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE)); | |
156 } | |
157 | |
158 test_mulc(a0, a1); | |
159 for (int i=0; i<ARRLEN; i++) { | |
160 errn += verify("test_mulc: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE)); | |
161 } | |
162 test_mulv(a0, a1, (long)VALUE); | |
163 for (int i=0; i<ARRLEN; i++) { | |
164 errn += verify("test_mulv: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE)); | |
165 } | |
166 test_mula(a0, a1, a2); | |
167 for (int i=0; i<ARRLEN; i++) { | |
168 errn += verify("test_mula: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE)); | |
169 } | |
170 | |
171 test_divc(a0, a1); | |
172 for (int i=0; i<ARRLEN; i++) { | |
173 errn += verify("test_divc: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE)); | |
174 } | |
175 test_divv(a0, a1, (long)VALUE); | |
176 for (int i=0; i<ARRLEN; i++) { | |
177 errn += verify("test_divv: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE)); | |
178 } | |
179 test_diva(a0, a1, a2); | |
180 for (int i=0; i<ARRLEN; i++) { | |
181 errn += verify("test_diva: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE)); | |
182 } | |
183 | |
184 test_mulc_n(a0, a1); | |
185 for (int i=0; i<ARRLEN; i++) { | |
186 errn += verify("test_mulc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE))); | |
187 } | |
188 test_mulv(a0, a1, (long)-VALUE); | |
189 for (int i=0; i<ARRLEN; i++) { | |
190 errn += verify("test_mulv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE))); | |
191 } | |
192 test_mula(a0, a1, a3); | |
193 for (int i=0; i<ARRLEN; i++) { | |
194 errn += verify("test_mula_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE))); | |
195 } | |
196 | |
197 test_divc_n(a0, a1); | |
198 for (int i=0; i<ARRLEN; i++) { | |
199 errn += verify("test_divc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE))); | |
200 } | |
201 test_divv(a0, a1, (long)-VALUE); | |
202 for (int i=0; i<ARRLEN; i++) { | |
203 errn += verify("test_divv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE))); | |
204 } | |
205 test_diva(a0, a1, a3); | |
206 for (int i=0; i<ARRLEN; i++) { | |
207 errn += verify("test_diva_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE))); | |
208 } | |
209 | |
210 test_andc(a0, a1); | |
211 for (int i=0; i<ARRLEN; i++) { | |
212 errn += verify("test_andc: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK)); | |
213 } | |
214 test_andv(a0, a1, (long)BIT_MASK); | |
215 for (int i=0; i<ARRLEN; i++) { | |
216 errn += verify("test_andv: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK)); | |
217 } | |
218 test_anda(a0, a1, a4); | |
219 for (int i=0; i<ARRLEN; i++) { | |
220 errn += verify("test_anda: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK)); | |
221 } | |
222 | |
223 test_orc(a0, a1); | |
224 for (int i=0; i<ARRLEN; i++) { | |
225 errn += verify("test_orc: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK)); | |
226 } | |
227 test_orv(a0, a1, (long)BIT_MASK); | |
228 for (int i=0; i<ARRLEN; i++) { | |
229 errn += verify("test_orv: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK)); | |
230 } | |
231 test_ora(a0, a1, a4); | |
232 for (int i=0; i<ARRLEN; i++) { | |
233 errn += verify("test_ora: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK)); | |
234 } | |
235 | |
236 test_xorc(a0, a1); | |
237 for (int i=0; i<ARRLEN; i++) { | |
238 errn += verify("test_xorc: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK)); | |
239 } | |
240 test_xorv(a0, a1, (long)BIT_MASK); | |
241 for (int i=0; i<ARRLEN; i++) { | |
242 errn += verify("test_xorv: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK)); | |
243 } | |
244 test_xora(a0, a1, a4); | |
245 for (int i=0; i<ARRLEN; i++) { | |
246 errn += verify("test_xora: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK)); | |
247 } | |
248 | |
249 test_sllc(a0, a1); | |
250 for (int i=0; i<ARRLEN; i++) { | |
251 errn += verify("test_sllc: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE)); | |
252 } | |
253 test_sllv(a0, a1, VALUE); | |
254 for (int i=0; i<ARRLEN; i++) { | |
255 errn += verify("test_sllv: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE)); | |
256 } | |
257 | |
258 test_srlc(a0, a1); | |
259 for (int i=0; i<ARRLEN; i++) { | |
260 errn += verify("test_srlc: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE)); | |
261 } | |
262 test_srlv(a0, a1, VALUE); | |
263 for (int i=0; i<ARRLEN; i++) { | |
264 errn += verify("test_srlv: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE)); | |
265 } | |
266 | |
267 test_srac(a0, a1); | |
268 for (int i=0; i<ARRLEN; i++) { | |
269 errn += verify("test_srac: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE)); | |
270 } | |
271 test_srav(a0, a1, VALUE); | |
272 for (int i=0; i<ARRLEN; i++) { | |
273 errn += verify("test_srav: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE)); | |
274 } | |
275 | |
276 test_sllc_n(a0, a1); | |
277 for (int i=0; i<ARRLEN; i++) { | |
278 errn += verify("test_sllc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE))); | |
279 } | |
280 test_sllv(a0, a1, -VALUE); | |
281 for (int i=0; i<ARRLEN; i++) { | |
282 errn += verify("test_sllv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE))); | |
283 } | |
284 | |
285 test_srlc_n(a0, a1); | |
286 for (int i=0; i<ARRLEN; i++) { | |
287 errn += verify("test_srlc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE))); | |
288 } | |
289 test_srlv(a0, a1, -VALUE); | |
290 for (int i=0; i<ARRLEN; i++) { | |
291 errn += verify("test_srlv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE))); | |
292 } | |
293 | |
294 test_srac_n(a0, a1); | |
295 for (int i=0; i<ARRLEN; i++) { | |
296 errn += verify("test_srac_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE))); | |
297 } | |
298 test_srav(a0, a1, -VALUE); | |
299 for (int i=0; i<ARRLEN; i++) { | |
300 errn += verify("test_srav_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE))); | |
301 } | |
302 | |
303 test_sllc_o(a0, a1); | |
304 for (int i=0; i<ARRLEN; i++) { | |
305 errn += verify("test_sllc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT)); | |
306 } | |
307 test_sllv(a0, a1, SHIFT); | |
308 for (int i=0; i<ARRLEN; i++) { | |
309 errn += verify("test_sllv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT)); | |
310 } | |
311 | |
312 test_srlc_o(a0, a1); | |
313 for (int i=0; i<ARRLEN; i++) { | |
314 errn += verify("test_srlc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT)); | |
315 } | |
316 test_srlv(a0, a1, SHIFT); | |
317 for (int i=0; i<ARRLEN; i++) { | |
318 errn += verify("test_srlv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT)); | |
319 } | |
320 | |
321 test_srac_o(a0, a1); | |
322 for (int i=0; i<ARRLEN; i++) { | |
323 errn += verify("test_srac_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT)); | |
324 } | |
325 test_srav(a0, a1, SHIFT); | |
326 for (int i=0; i<ARRLEN; i++) { | |
327 errn += verify("test_srav_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT)); | |
328 } | |
329 | |
330 test_sllc_on(a0, a1); | |
331 for (int i=0; i<ARRLEN; i++) { | |
332 errn += verify("test_sllc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT))); | |
333 } | |
334 test_sllv(a0, a1, -SHIFT); | |
335 for (int i=0; i<ARRLEN; i++) { | |
336 errn += verify("test_sllv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT))); | |
337 } | |
338 | |
339 test_srlc_on(a0, a1); | |
340 for (int i=0; i<ARRLEN; i++) { | |
341 errn += verify("test_srlc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT))); | |
342 } | |
343 test_srlv(a0, a1, -SHIFT); | |
344 for (int i=0; i<ARRLEN; i++) { | |
345 errn += verify("test_srlv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT))); | |
346 } | |
347 | |
348 test_srac_on(a0, a1); | |
349 for (int i=0; i<ARRLEN; i++) { | |
350 errn += verify("test_srac_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT))); | |
351 } | |
352 test_srav(a0, a1, -SHIFT); | |
353 for (int i=0; i<ARRLEN; i++) { | |
354 errn += verify("test_srav_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT))); | |
355 } | |
356 | |
357 } | |
358 | |
359 if (errn > 0) | |
360 return errn; | |
361 | |
362 System.out.println("Time"); | |
363 long start, end; | |
364 | |
365 start = System.currentTimeMillis(); | |
366 for (int i=0; i<ITERS; i++) { | |
367 test_sum(a1); | |
368 } | |
369 end = System.currentTimeMillis(); | |
370 System.out.println("test_sum: " + (end - start)); | |
371 | |
372 start = System.currentTimeMillis(); | |
373 for (int i=0; i<ITERS; i++) { | |
374 test_addc(a0, a1); | |
375 } | |
376 end = System.currentTimeMillis(); | |
377 System.out.println("test_addc: " + (end - start)); | |
378 start = System.currentTimeMillis(); | |
379 for (int i=0; i<ITERS; i++) { | |
380 test_addv(a0, a1, (long)VALUE); | |
381 } | |
382 end = System.currentTimeMillis(); | |
383 System.out.println("test_addv: " + (end - start)); | |
384 start = System.currentTimeMillis(); | |
385 for (int i=0; i<ITERS; i++) { | |
386 test_adda(a0, a1, a2); | |
387 } | |
388 end = System.currentTimeMillis(); | |
389 System.out.println("test_adda: " + (end - start)); | |
390 | |
391 start = System.currentTimeMillis(); | |
392 for (int i=0; i<ITERS; i++) { | |
393 test_subc(a0, a1); | |
394 } | |
395 end = System.currentTimeMillis(); | |
396 System.out.println("test_subc: " + (end - start)); | |
397 start = System.currentTimeMillis(); | |
398 for (int i=0; i<ITERS; i++) { | |
399 test_subv(a0, a1, (long)VALUE); | |
400 } | |
401 end = System.currentTimeMillis(); | |
402 System.out.println("test_subv: " + (end - start)); | |
403 start = System.currentTimeMillis(); | |
404 for (int i=0; i<ITERS; i++) { | |
405 test_suba(a0, a1, a2); | |
406 } | |
407 end = System.currentTimeMillis(); | |
408 System.out.println("test_suba: " + (end - start)); | |
409 | |
410 start = System.currentTimeMillis(); | |
411 for (int i=0; i<ITERS; i++) { | |
412 test_mulc(a0, a1); | |
413 } | |
414 end = System.currentTimeMillis(); | |
415 System.out.println("test_mulc: " + (end - start)); | |
416 start = System.currentTimeMillis(); | |
417 for (int i=0; i<ITERS; i++) { | |
418 test_mulv(a0, a1, (long)VALUE); | |
419 } | |
420 end = System.currentTimeMillis(); | |
421 System.out.println("test_mulv: " + (end - start)); | |
422 start = System.currentTimeMillis(); | |
423 for (int i=0; i<ITERS; i++) { | |
424 test_mula(a0, a1, a2); | |
425 } | |
426 end = System.currentTimeMillis(); | |
427 System.out.println("test_mula: " + (end - start)); | |
428 | |
429 start = System.currentTimeMillis(); | |
430 for (int i=0; i<ITERS; i++) { | |
431 test_divc(a0, a1); | |
432 } | |
433 end = System.currentTimeMillis(); | |
434 System.out.println("test_divc: " + (end - start)); | |
435 start = System.currentTimeMillis(); | |
436 for (int i=0; i<ITERS; i++) { | |
437 test_divv(a0, a1, (long)VALUE); | |
438 } | |
439 end = System.currentTimeMillis(); | |
440 System.out.println("test_divv: " + (end - start)); | |
441 start = System.currentTimeMillis(); | |
442 for (int i=0; i<ITERS; i++) { | |
443 test_diva(a0, a1, a2); | |
444 } | |
445 end = System.currentTimeMillis(); | |
446 System.out.println("test_diva: " + (end - start)); | |
447 | |
448 start = System.currentTimeMillis(); | |
449 for (int i=0; i<ITERS; i++) { | |
450 test_mulc_n(a0, a1); | |
451 } | |
452 end = System.currentTimeMillis(); | |
453 System.out.println("test_mulc_n: " + (end - start)); | |
454 start = System.currentTimeMillis(); | |
455 for (int i=0; i<ITERS; i++) { | |
456 test_mulv(a0, a1, (long)-VALUE); | |
457 } | |
458 end = System.currentTimeMillis(); | |
459 System.out.println("test_mulv_n: " + (end - start)); | |
460 start = System.currentTimeMillis(); | |
461 for (int i=0; i<ITERS; i++) { | |
462 test_mula(a0, a1, a3); | |
463 } | |
464 end = System.currentTimeMillis(); | |
465 System.out.println("test_mula_n: " + (end - start)); | |
466 | |
467 start = System.currentTimeMillis(); | |
468 for (int i=0; i<ITERS; i++) { | |
469 test_divc_n(a0, a1); | |
470 } | |
471 end = System.currentTimeMillis(); | |
472 System.out.println("test_divc_n: " + (end - start)); | |
473 start = System.currentTimeMillis(); | |
474 for (int i=0; i<ITERS; i++) { | |
475 test_divv(a0, a1, (long)-VALUE); | |
476 } | |
477 end = System.currentTimeMillis(); | |
478 System.out.println("test_divv_n: " + (end - start)); | |
479 start = System.currentTimeMillis(); | |
480 for (int i=0; i<ITERS; i++) { | |
481 test_diva(a0, a1, a3); | |
482 } | |
483 end = System.currentTimeMillis(); | |
484 System.out.println("test_diva_n: " + (end - start)); | |
485 | |
486 start = System.currentTimeMillis(); | |
487 for (int i=0; i<ITERS; i++) { | |
488 test_andc(a0, a1); | |
489 } | |
490 end = System.currentTimeMillis(); | |
491 System.out.println("test_andc: " + (end - start)); | |
492 start = System.currentTimeMillis(); | |
493 for (int i=0; i<ITERS; i++) { | |
494 test_andv(a0, a1, (long)BIT_MASK); | |
495 } | |
496 end = System.currentTimeMillis(); | |
497 System.out.println("test_andv: " + (end - start)); | |
498 start = System.currentTimeMillis(); | |
499 for (int i=0; i<ITERS; i++) { | |
500 test_anda(a0, a1, a4); | |
501 } | |
502 end = System.currentTimeMillis(); | |
503 System.out.println("test_anda: " + (end - start)); | |
504 | |
505 start = System.currentTimeMillis(); | |
506 for (int i=0; i<ITERS; i++) { | |
507 test_orc(a0, a1); | |
508 } | |
509 end = System.currentTimeMillis(); | |
510 System.out.println("test_orc: " + (end - start)); | |
511 start = System.currentTimeMillis(); | |
512 for (int i=0; i<ITERS; i++) { | |
513 test_orv(a0, a1, (long)BIT_MASK); | |
514 } | |
515 end = System.currentTimeMillis(); | |
516 System.out.println("test_orv: " + (end - start)); | |
517 start = System.currentTimeMillis(); | |
518 for (int i=0; i<ITERS; i++) { | |
519 test_ora(a0, a1, a4); | |
520 } | |
521 end = System.currentTimeMillis(); | |
522 System.out.println("test_ora: " + (end - start)); | |
523 | |
524 start = System.currentTimeMillis(); | |
525 for (int i=0; i<ITERS; i++) { | |
526 test_xorc(a0, a1); | |
527 } | |
528 end = System.currentTimeMillis(); | |
529 System.out.println("test_xorc: " + (end - start)); | |
530 start = System.currentTimeMillis(); | |
531 for (int i=0; i<ITERS; i++) { | |
532 test_xorv(a0, a1, (long)BIT_MASK); | |
533 } | |
534 end = System.currentTimeMillis(); | |
535 System.out.println("test_xorv: " + (end - start)); | |
536 start = System.currentTimeMillis(); | |
537 for (int i=0; i<ITERS; i++) { | |
538 test_xora(a0, a1, a4); | |
539 } | |
540 end = System.currentTimeMillis(); | |
541 System.out.println("test_xora: " + (end - start)); | |
542 | |
543 start = System.currentTimeMillis(); | |
544 for (int i=0; i<ITERS; i++) { | |
545 test_sllc(a0, a1); | |
546 } | |
547 end = System.currentTimeMillis(); | |
548 System.out.println("test_sllc: " + (end - start)); | |
549 start = System.currentTimeMillis(); | |
550 for (int i=0; i<ITERS; i++) { | |
551 test_sllv(a0, a1, VALUE); | |
552 } | |
553 end = System.currentTimeMillis(); | |
554 System.out.println("test_sllv: " + (end - start)); | |
555 | |
556 start = System.currentTimeMillis(); | |
557 for (int i=0; i<ITERS; i++) { | |
558 test_srlc(a0, a1); | |
559 } | |
560 end = System.currentTimeMillis(); | |
561 System.out.println("test_srlc: " + (end - start)); | |
562 start = System.currentTimeMillis(); | |
563 for (int i=0; i<ITERS; i++) { | |
564 test_srlv(a0, a1, VALUE); | |
565 } | |
566 end = System.currentTimeMillis(); | |
567 System.out.println("test_srlv: " + (end - start)); | |
568 | |
569 start = System.currentTimeMillis(); | |
570 for (int i=0; i<ITERS; i++) { | |
571 test_srac(a0, a1); | |
572 } | |
573 end = System.currentTimeMillis(); | |
574 System.out.println("test_srac: " + (end - start)); | |
575 start = System.currentTimeMillis(); | |
576 for (int i=0; i<ITERS; i++) { | |
577 test_srav(a0, a1, VALUE); | |
578 } | |
579 end = System.currentTimeMillis(); | |
580 System.out.println("test_srav: " + (end - start)); | |
581 | |
582 start = System.currentTimeMillis(); | |
583 for (int i=0; i<ITERS; i++) { | |
584 test_sllc_n(a0, a1); | |
585 } | |
586 end = System.currentTimeMillis(); | |
587 System.out.println("test_sllc_n: " + (end - start)); | |
588 start = System.currentTimeMillis(); | |
589 for (int i=0; i<ITERS; i++) { | |
590 test_sllv(a0, a1, -VALUE); | |
591 } | |
592 end = System.currentTimeMillis(); | |
593 System.out.println("test_sllv_n: " + (end - start)); | |
594 | |
595 start = System.currentTimeMillis(); | |
596 for (int i=0; i<ITERS; i++) { | |
597 test_srlc_n(a0, a1); | |
598 } | |
599 end = System.currentTimeMillis(); | |
600 System.out.println("test_srlc_n: " + (end - start)); | |
601 start = System.currentTimeMillis(); | |
602 for (int i=0; i<ITERS; i++) { | |
603 test_srlv(a0, a1, -VALUE); | |
604 } | |
605 end = System.currentTimeMillis(); | |
606 System.out.println("test_srlv_n: " + (end - start)); | |
607 | |
608 start = System.currentTimeMillis(); | |
609 for (int i=0; i<ITERS; i++) { | |
610 test_srac_n(a0, a1); | |
611 } | |
612 end = System.currentTimeMillis(); | |
613 System.out.println("test_srac_n: " + (end - start)); | |
614 start = System.currentTimeMillis(); | |
615 for (int i=0; i<ITERS; i++) { | |
616 test_srav(a0, a1, -VALUE); | |
617 } | |
618 end = System.currentTimeMillis(); | |
619 System.out.println("test_srav_n: " + (end - start)); | |
620 | |
621 start = System.currentTimeMillis(); | |
622 for (int i=0; i<ITERS; i++) { | |
623 test_sllc_o(a0, a1); | |
624 } | |
625 end = System.currentTimeMillis(); | |
626 System.out.println("test_sllc_o: " + (end - start)); | |
627 start = System.currentTimeMillis(); | |
628 for (int i=0; i<ITERS; i++) { | |
629 test_sllv(a0, a1, SHIFT); | |
630 } | |
631 end = System.currentTimeMillis(); | |
632 System.out.println("test_sllv_o: " + (end - start)); | |
633 | |
634 start = System.currentTimeMillis(); | |
635 for (int i=0; i<ITERS; i++) { | |
636 test_srlc_o(a0, a1); | |
637 } | |
638 end = System.currentTimeMillis(); | |
639 System.out.println("test_srlc_o: " + (end - start)); | |
640 start = System.currentTimeMillis(); | |
641 for (int i=0; i<ITERS; i++) { | |
642 test_srlv(a0, a1, SHIFT); | |
643 } | |
644 end = System.currentTimeMillis(); | |
645 System.out.println("test_srlv_o: " + (end - start)); | |
646 | |
647 start = System.currentTimeMillis(); | |
648 for (int i=0; i<ITERS; i++) { | |
649 test_srac_o(a0, a1); | |
650 } | |
651 end = System.currentTimeMillis(); | |
652 System.out.println("test_srac_o: " + (end - start)); | |
653 start = System.currentTimeMillis(); | |
654 for (int i=0; i<ITERS; i++) { | |
655 test_srav(a0, a1, SHIFT); | |
656 } | |
657 end = System.currentTimeMillis(); | |
658 System.out.println("test_srav_o: " + (end - start)); | |
659 | |
660 start = System.currentTimeMillis(); | |
661 for (int i=0; i<ITERS; i++) { | |
662 test_sllc_on(a0, a1); | |
663 } | |
664 end = System.currentTimeMillis(); | |
665 System.out.println("test_sllc_on: " + (end - start)); | |
666 start = System.currentTimeMillis(); | |
667 for (int i=0; i<ITERS; i++) { | |
668 test_sllv(a0, a1, -SHIFT); | |
669 } | |
670 end = System.currentTimeMillis(); | |
671 System.out.println("test_sllv_on: " + (end - start)); | |
672 | |
673 start = System.currentTimeMillis(); | |
674 for (int i=0; i<ITERS; i++) { | |
675 test_srlc_on(a0, a1); | |
676 } | |
677 end = System.currentTimeMillis(); | |
678 System.out.println("test_srlc_on: " + (end - start)); | |
679 start = System.currentTimeMillis(); | |
680 for (int i=0; i<ITERS; i++) { | |
681 test_srlv(a0, a1, -SHIFT); | |
682 } | |
683 end = System.currentTimeMillis(); | |
684 System.out.println("test_srlv_on: " + (end - start)); | |
685 | |
686 start = System.currentTimeMillis(); | |
687 for (int i=0; i<ITERS; i++) { | |
688 test_srac_on(a0, a1); | |
689 } | |
690 end = System.currentTimeMillis(); | |
691 System.out.println("test_srac_on: " + (end - start)); | |
692 start = System.currentTimeMillis(); | |
693 for (int i=0; i<ITERS; i++) { | |
694 test_srav(a0, a1, -SHIFT); | |
695 } | |
696 end = System.currentTimeMillis(); | |
697 System.out.println("test_srav_on: " + (end - start)); | |
698 | |
699 return errn; | |
700 } | |
701 | |
702 static long test_sum(long[] a1) { | |
703 long sum = 0; | |
704 for (int i = 0; i < a1.length; i+=1) { | |
705 sum += a1[i]; | |
706 } | |
707 return sum; | |
708 } | |
709 | |
710 static void test_addc(long[] a0, long[] a1) { | |
711 for (int i = 0; i < a0.length; i+=1) { | |
712 a0[i] = (long)(a1[i]+VALUE); | |
713 } | |
714 } | |
715 static void test_addv(long[] a0, long[] a1, long b) { | |
716 for (int i = 0; i < a0.length; i+=1) { | |
717 a0[i] = (long)(a1[i]+b); | |
718 } | |
719 } | |
720 static void test_adda(long[] a0, long[] a1, long[] a2) { | |
721 for (int i = 0; i < a0.length; i+=1) { | |
722 a0[i] = (long)(a1[i]+a2[i]); | |
723 } | |
724 } | |
725 | |
726 static void test_subc(long[] a0, long[] a1) { | |
727 for (int i = 0; i < a0.length; i+=1) { | |
728 a0[i] = (long)(a1[i]-VALUE); | |
729 } | |
730 } | |
731 static void test_subv(long[] a0, long[] a1, long b) { | |
732 for (int i = 0; i < a0.length; i+=1) { | |
733 a0[i] = (long)(a1[i]-b); | |
734 } | |
735 } | |
736 static void test_suba(long[] a0, long[] a1, long[] a2) { | |
737 for (int i = 0; i < a0.length; i+=1) { | |
738 a0[i] = (long)(a1[i]-a2[i]); | |
739 } | |
740 } | |
741 | |
742 static void test_mulc(long[] a0, long[] a1) { | |
743 for (int i = 0; i < a0.length; i+=1) { | |
744 a0[i] = (long)(a1[i]*VALUE); | |
745 } | |
746 } | |
747 static void test_mulc_n(long[] a0, long[] a1) { | |
748 for (int i = 0; i < a0.length; i+=1) { | |
749 a0[i] = (long)(a1[i]*(-VALUE)); | |
750 } | |
751 } | |
752 static void test_mulv(long[] a0, long[] a1, long b) { | |
753 for (int i = 0; i < a0.length; i+=1) { | |
754 a0[i] = (long)(a1[i]*b); | |
755 } | |
756 } | |
757 static void test_mula(long[] a0, long[] a1, long[] a2) { | |
758 for (int i = 0; i < a0.length; i+=1) { | |
759 a0[i] = (long)(a1[i]*a2[i]); | |
760 } | |
761 } | |
762 | |
763 static void test_divc(long[] a0, long[] a1) { | |
764 for (int i = 0; i < a0.length; i+=1) { | |
765 a0[i] = (long)(a1[i]/VALUE); | |
766 } | |
767 } | |
768 static void test_divc_n(long[] a0, long[] a1) { | |
769 for (int i = 0; i < a0.length; i+=1) { | |
770 a0[i] = (long)(a1[i]/(-VALUE)); | |
771 } | |
772 } | |
773 static void test_divv(long[] a0, long[] a1, long b) { | |
774 for (int i = 0; i < a0.length; i+=1) { | |
775 a0[i] = (long)(a1[i]/b); | |
776 } | |
777 } | |
778 static void test_diva(long[] a0, long[] a1, long[] a2) { | |
779 for (int i = 0; i < a0.length; i+=1) { | |
780 a0[i] = (long)(a1[i]/a2[i]); | |
781 } | |
782 } | |
783 | |
784 static void test_andc(long[] a0, long[] a1) { | |
785 for (int i = 0; i < a0.length; i+=1) { | |
786 a0[i] = (long)(a1[i]&BIT_MASK); | |
787 } | |
788 } | |
789 static void test_andv(long[] a0, long[] a1, long b) { | |
790 for (int i = 0; i < a0.length; i+=1) { | |
791 a0[i] = (long)(a1[i]&b); | |
792 } | |
793 } | |
794 static void test_anda(long[] a0, long[] a1, long[] a2) { | |
795 for (int i = 0; i < a0.length; i+=1) { | |
796 a0[i] = (long)(a1[i]&a2[i]); | |
797 } | |
798 } | |
799 | |
800 static void test_orc(long[] a0, long[] a1) { | |
801 for (int i = 0; i < a0.length; i+=1) { | |
802 a0[i] = (long)(a1[i]|BIT_MASK); | |
803 } | |
804 } | |
805 static void test_orv(long[] a0, long[] a1, long b) { | |
806 for (int i = 0; i < a0.length; i+=1) { | |
807 a0[i] = (long)(a1[i]|b); | |
808 } | |
809 } | |
810 static void test_ora(long[] a0, long[] a1, long[] a2) { | |
811 for (int i = 0; i < a0.length; i+=1) { | |
812 a0[i] = (long)(a1[i]|a2[i]); | |
813 } | |
814 } | |
815 | |
816 static void test_xorc(long[] a0, long[] a1) { | |
817 for (int i = 0; i < a0.length; i+=1) { | |
818 a0[i] = (long)(a1[i]^BIT_MASK); | |
819 } | |
820 } | |
821 static void test_xorv(long[] a0, long[] a1, long b) { | |
822 for (int i = 0; i < a0.length; i+=1) { | |
823 a0[i] = (long)(a1[i]^b); | |
824 } | |
825 } | |
826 static void test_xora(long[] a0, long[] a1, long[] a2) { | |
827 for (int i = 0; i < a0.length; i+=1) { | |
828 a0[i] = (long)(a1[i]^a2[i]); | |
829 } | |
830 } | |
831 | |
832 static void test_sllc(long[] a0, long[] a1) { | |
833 for (int i = 0; i < a0.length; i+=1) { | |
834 a0[i] = (long)(a1[i]<<VALUE); | |
835 } | |
836 } | |
837 static void test_sllc_n(long[] a0, long[] a1) { | |
838 for (int i = 0; i < a0.length; i+=1) { | |
839 a0[i] = (long)(a1[i]<<(-VALUE)); | |
840 } | |
841 } | |
842 static void test_sllc_o(long[] a0, long[] a1) { | |
843 for (int i = 0; i < a0.length; i+=1) { | |
844 a0[i] = (long)(a1[i]<<SHIFT); | |
845 } | |
846 } | |
847 static void test_sllc_on(long[] a0, long[] a1) { | |
848 for (int i = 0; i < a0.length; i+=1) { | |
849 a0[i] = (long)(a1[i]<<(-SHIFT)); | |
850 } | |
851 } | |
852 static void test_sllv(long[] a0, long[] a1, int b) { | |
853 for (int i = 0; i < a0.length; i+=1) { | |
854 a0[i] = (long)(a1[i]<<b); | |
855 } | |
856 } | |
857 | |
858 static void test_srlc(long[] a0, long[] a1) { | |
859 for (int i = 0; i < a0.length; i+=1) { | |
860 a0[i] = (long)(a1[i]>>>VALUE); | |
861 } | |
862 } | |
863 static void test_srlc_n(long[] a0, long[] a1) { | |
864 for (int i = 0; i < a0.length; i+=1) { | |
865 a0[i] = (long)(a1[i]>>>(-VALUE)); | |
866 } | |
867 } | |
868 static void test_srlc_o(long[] a0, long[] a1) { | |
869 for (int i = 0; i < a0.length; i+=1) { | |
870 a0[i] = (long)(a1[i]>>>SHIFT); | |
871 } | |
872 } | |
873 static void test_srlc_on(long[] a0, long[] a1) { | |
874 for (int i = 0; i < a0.length; i+=1) { | |
875 a0[i] = (long)(a1[i]>>>(-SHIFT)); | |
876 } | |
877 } | |
878 static void test_srlv(long[] a0, long[] a1, int b) { | |
879 for (int i = 0; i < a0.length; i+=1) { | |
880 a0[i] = (long)(a1[i]>>>b); | |
881 } | |
882 } | |
883 | |
884 static void test_srac(long[] a0, long[] a1) { | |
885 for (int i = 0; i < a0.length; i+=1) { | |
886 a0[i] = (long)(a1[i]>>VALUE); | |
887 } | |
888 } | |
889 static void test_srac_n(long[] a0, long[] a1) { | |
890 for (int i = 0; i < a0.length; i+=1) { | |
891 a0[i] = (long)(a1[i]>>(-VALUE)); | |
892 } | |
893 } | |
894 static void test_srac_o(long[] a0, long[] a1) { | |
895 for (int i = 0; i < a0.length; i+=1) { | |
896 a0[i] = (long)(a1[i]>>SHIFT); | |
897 } | |
898 } | |
899 static void test_srac_on(long[] a0, long[] a1) { | |
900 for (int i = 0; i < a0.length; i+=1) { | |
901 a0[i] = (long)(a1[i]>>(-SHIFT)); | |
902 } | |
903 } | |
904 static void test_srav(long[] a0, long[] a1, int b) { | |
905 for (int i = 0; i < a0.length; i+=1) { | |
906 a0[i] = (long)(a1[i]>>b); | |
907 } | |
908 } | |
909 | |
910 static int verify(String text, int i, long elem, long val) { | |
911 if (elem != val) { | |
912 System.err.println(text + "[" + i + "] = " + elem + " != " + val); | |
913 return 1; | |
914 } | |
915 return 0; | |
916 } | |
917 } |