TestLongVect.java revision 11707:ad7af1afda7a 
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
33package compiler.c2.cr6340864;
34
35public 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}
1132