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