TestIntUnsafeOrdered.java revision 11707:ad7af1afda7a 
1/*
2 * Copyright (c) 2013, 2015, 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 8004867
28 * @summary VM crashing with assert "share/vm/opto/node.hpp:357 - assert(i < _max) failed: oob"
29 * @modules java.base/jdk.internal.misc
30 *
31 * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation
32 *    -XX:-OptimizeFill
33 *    compiler.c2.cr8004867.TestIntUnsafeOrdered
34 * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation
35 *    -XX:+OptimizeFill
36 *    compiler.c2.cr8004867.TestIntUnsafeOrdered
37 */
38
39package compiler.c2.cr8004867;
40
41import jdk.internal.misc.Unsafe;
42
43import java.lang.reflect.Field;
44
45public class TestIntUnsafeOrdered {
46  private static final int ARRLEN = 97;
47  private static final int ITERS  = 11000;
48  private static final int OFFSET = 3;
49  private static final int SCALE = 2;
50  private static final int ALIGN_OFF = 8;
51  private static final int UNALIGN_OFF = 5;
52
53  private static final Unsafe unsafe;
54  private static final int BASE;
55  static {
56    try {
57      Class<?> c = Unsafe.class;
58      Field f = c.getDeclaredField("theUnsafe");
59      f.setAccessible(true);
60      unsafe = (Unsafe) f.get(c);
61      BASE = unsafe.arrayBaseOffset(int[].class);
62    } catch (Exception e) {
63      InternalError err = new InternalError();
64      err.initCause(e);
65      throw err;
66    }
67  }
68
69  public static void main(String args[]) {
70    System.out.println("Testing Integer array unsafe ordered operations");
71    int errn = test(false);
72    if (errn > 0) {
73      System.err.println("FAILED: " + errn + " errors");
74      System.exit(97);
75    }
76    System.out.println("PASSED");
77  }
78
79  static int test(boolean test_only) {
80    int[] a1 = new int[ARRLEN];
81    int[] a2 = new int[ARRLEN];
82    // Initialize
83    for (int i=0; i<ARRLEN; i++) {
84      a1[i] = -1;
85      a2[i] = -1;
86    }
87    System.out.println("Warmup");
88    for (int i=0; i<ITERS; i++) {
89      test_ci(a1);
90      test_vi(a2, 123, -1);
91      test_cp(a1, a2);
92      test_2ci(a1, a2);
93      test_2vi(a1, a2, 123, 103);
94      test_ci_neg(a1, 123);
95      test_vi_neg(a2, 123, 103);
96      test_cp_neg(a1, a2);
97      test_2ci_neg(a1, a2);
98      test_2vi_neg(a1, a2, 123, 103);
99      test_ci_oppos(a1, 123);
100      test_vi_oppos(a2, 123, 103);
101      test_cp_oppos(a1, a2);
102      test_2ci_oppos(a1, a2);
103      test_2vi_oppos(a1, a2, 123, 103);
104      test_ci_off(a1, 123);
105      test_vi_off(a2, 123, 103);
106      test_cp_off(a1, a2);
107      test_2ci_off(a1, a2);
108      test_2vi_off(a1, a2, 123, 103);
109      test_ci_inv(a1, OFFSET, 123);
110      test_vi_inv(a2, 123, OFFSET, 103);
111      test_cp_inv(a1, a2, OFFSET);
112      test_2ci_inv(a1, a2, OFFSET);
113      test_2vi_inv(a1, a2, 123, 103, OFFSET);
114      test_ci_scl(a1, 123);
115      test_vi_scl(a2, 123, 103);
116      test_cp_scl(a1, a2);
117      test_2ci_scl(a1, a2);
118      test_2vi_scl(a1, a2, 123, 103);
119      test_cp_alndst(a1, a2);
120      test_cp_alnsrc(a1, a2);
121      test_2ci_aln(a1, a2);
122      test_2vi_aln(a1, a2, 123, 103);
123      test_cp_unalndst(a1, a2);
124      test_cp_unalnsrc(a1, a2);
125      test_2ci_unaln(a1, a2);
126      test_2vi_unaln(a1, a2, 123, 103);
127    }
128    // Initialize
129    for (int i=0; i<ARRLEN; i++) {
130      a1[i] = -1;
131      a2[i] = -1;
132    }
133    // Test and verify results
134    System.out.println("Verification");
135    int errn = 0;
136    {
137      test_ci(a1);
138      for (int i=0; i<ARRLEN; i++) {
139        errn += verify("test_ci: a1", i, a1[i], -123);
140      }
141      test_vi(a2, 123, -1);
142      for (int i=0; i<ARRLEN; i++) {
143        errn += verify("test_vi: a2", i, a2[i], 123);
144      }
145      test_cp(a1, a2);
146      for (int i=0; i<ARRLEN; i++) {
147        errn += verify("test_cp: a1", i, a1[i], 123);
148      }
149      test_2ci(a1, a2);
150      for (int i=0; i<ARRLEN; i++) {
151        errn += verify("test_2ci: a1", i, a1[i], -123);
152        errn += verify("test_2ci: a2", i, a2[i], -103);
153      }
154      test_2vi(a1, a2, 123, 103);
155      for (int i=0; i<ARRLEN; i++) {
156        errn += verify("test_2vi: a1", i, a1[i], 123);
157        errn += verify("test_2vi: a2", i, a2[i], 103);
158      }
159      // Reset for negative stride
160      for (int i=0; i<ARRLEN; i++) {
161        a1[i] = -1;
162        a2[i] = -1;
163      }
164      test_ci_neg(a1, -1);
165      for (int i=0; i<ARRLEN; i++) {
166        errn += verify("test_ci_neg: a1", i, a1[i], -123);
167      }
168      test_vi_neg(a2, 123, -1);
169      for (int i=0; i<ARRLEN; i++) {
170        errn += verify("test_vi_neg: a2", i, a2[i], 123);
171      }
172      test_cp_neg(a1, a2);
173      for (int i=0; i<ARRLEN; i++) {
174        errn += verify("test_cp_neg: a1", i, a1[i], 123);
175      }
176      test_2ci_neg(a1, a2);
177      for (int i=0; i<ARRLEN; i++) {
178        errn += verify("test_2ci_neg: a1", i, a1[i], -123);
179        errn += verify("test_2ci_neg: a2", i, a2[i], -103);
180      }
181      test_2vi_neg(a1, a2, 123, 103);
182      for (int i=0; i<ARRLEN; i++) {
183        errn += verify("test_2vi_neg: a1", i, a1[i], 123);
184        errn += verify("test_2vi_neg: a2", i, a2[i], 103);
185      }
186      // Reset for opposite stride
187      for (int i=0; i<ARRLEN; i++) {
188        a1[i] = -1;
189        a2[i] = -1;
190      }
191      test_ci_oppos(a1, -1);
192      for (int i=0; i<ARRLEN; i++) {
193        errn += verify("test_ci_oppos: a1", i, a1[i], -123);
194      }
195      test_vi_oppos(a2, 123, -1);
196      for (int i=0; i<ARRLEN; i++) {
197        errn += verify("test_vi_oppos: a2", i, a2[i], 123);
198      }
199      test_cp_oppos(a1, a2);
200      for (int i=0; i<ARRLEN; i++) {
201        errn += verify("test_cp_oppos: a1", i, a1[i], 123);
202      }
203      test_2ci_oppos(a1, a2);
204      for (int i=0; i<ARRLEN; i++) {
205        errn += verify("test_2ci_oppos: a1", i, a1[i], -123);
206        errn += verify("test_2ci_oppos: a2", i, a2[i], -103);
207      }
208      test_2vi_oppos(a1, a2, 123, 103);
209      for (int i=0; i<ARRLEN; i++) {
210        errn += verify("test_2vi_oppos: a1", i, a1[i], 123);
211        errn += verify("test_2vi_oppos: a2", i, a2[i], 103);
212      }
213      // Reset for indexing with offset
214      for (int i=0; i<ARRLEN; i++) {
215        a1[i] = -1;
216        a2[i] = -1;
217      }
218      test_ci_off(a1, -1);
219      for (int i=OFFSET; i<ARRLEN; i++) {
220        errn += verify("test_ci_off: a1", i, a1[i], -123);
221      }
222      test_vi_off(a2, 123, -1);
223      for (int i=OFFSET; i<ARRLEN; i++) {
224        errn += verify("test_vi_off: a2", i, a2[i], 123);
225      }
226      test_cp_off(a1, a2);
227      for (int i=OFFSET; i<ARRLEN; i++) {
228        errn += verify("test_cp_off: a1", i, a1[i], 123);
229      }
230      test_2ci_off(a1, a2);
231      for (int i=OFFSET; i<ARRLEN; i++) {
232        errn += verify("test_2ci_off: a1", i, a1[i], -123);
233        errn += verify("test_2ci_off: a2", i, a2[i], -103);
234      }
235      test_2vi_off(a1, a2, 123, 103);
236      for (int i=OFFSET; i<ARRLEN; i++) {
237        errn += verify("test_2vi_off: a1", i, a1[i], 123);
238        errn += verify("test_2vi_off: a2", i, a2[i], 103);
239      }
240      for (int i=0; i<OFFSET; i++) {
241        errn += verify("test_2vi_off: a1", i, a1[i], -1);
242        errn += verify("test_2vi_off: a2", i, a2[i], -1);
243      }
244      // Reset for indexing with invariant offset
245      for (int i=0; i<ARRLEN; i++) {
246        a1[i] = -1;
247        a2[i] = -1;
248      }
249      test_ci_inv(a1, OFFSET, -1);
250      for (int i=OFFSET; i<ARRLEN; i++) {
251        errn += verify("test_ci_inv: a1", i, a1[i], -123);
252      }
253      test_vi_inv(a2, 123, OFFSET, -1);
254      for (int i=OFFSET; i<ARRLEN; i++) {
255        errn += verify("test_vi_inv: a2", i, a2[i], 123);
256      }
257      test_cp_inv(a1, a2, OFFSET);
258      for (int i=OFFSET; i<ARRLEN; i++) {
259        errn += verify("test_cp_inv: a1", i, a1[i], 123);
260      }
261      test_2ci_inv(a1, a2, OFFSET);
262      for (int i=OFFSET; i<ARRLEN; i++) {
263        errn += verify("test_2ci_inv: a1", i, a1[i], -123);
264        errn += verify("test_2ci_inv: a2", i, a2[i], -103);
265      }
266      test_2vi_inv(a1, a2, 123, 103, OFFSET);
267      for (int i=OFFSET; i<ARRLEN; i++) {
268        errn += verify("test_2vi_inv: a1", i, a1[i], 123);
269        errn += verify("test_2vi_inv: a2", i, a2[i], 103);
270      }
271      for (int i=0; i<OFFSET; i++) {
272        errn += verify("test_2vi_inv: a1", i, a1[i], -1);
273        errn += verify("test_2vi_inv: a2", i, a2[i], -1);
274      }
275      // Reset for indexing with scale
276      for (int i=0; i<ARRLEN; i++) {
277        a1[i] = -1;
278        a2[i] = -1;
279      }
280      test_ci_scl(a1, -1);
281      for (int i=0; i<ARRLEN; i++) {
282        int val = (i%SCALE != 0) ? -1 : -123;
283        errn += verify("test_ci_scl: a1", i, a1[i], val);
284      }
285      test_vi_scl(a2, 123, -1);
286      for (int i=0; i<ARRLEN; i++) {
287        int val = (i%SCALE != 0) ? -1 : 123;
288        errn += verify("test_vi_scl: a2", i, a2[i], val);
289      }
290      test_cp_scl(a1, a2);
291      for (int i=0; i<ARRLEN; i++) {
292        int val = (i%SCALE != 0) ? -1 : 123;
293        errn += verify("test_cp_scl: a1", i, a1[i], val);
294      }
295      test_2ci_scl(a1, a2);
296      for (int i=0; i<ARRLEN; i++) {
297        if (i%SCALE != 0) {
298          errn += verify("test_2ci_scl: a1", i, a1[i], -1);
299        } else if (i*SCALE < ARRLEN) {
300          errn += verify("test_2ci_scl: a1", i*SCALE, a1[i*SCALE], -123);
301        }
302        if (i%SCALE != 0) {
303          errn += verify("test_2ci_scl: a2", i, a2[i], -1);
304        } else if (i*SCALE < ARRLEN) {
305          errn += verify("test_2ci_scl: a2", i*SCALE, a2[i*SCALE], -103);
306        }
307      }
308      test_2vi_scl(a1, a2, 123, 103);
309      for (int i=0; i<ARRLEN; i++) {
310        if (i%SCALE != 0) {
311          errn += verify("test_2vi_scl: a1", i, a1[i], -1);
312        } else if (i*SCALE < ARRLEN) {
313          errn += verify("test_2vi_scl: a1", i*SCALE, a1[i*SCALE], 123);
314        }
315        if (i%SCALE != 0) {
316          errn += verify("test_2vi_scl: a2", i, a2[i], -1);
317        } else if (i*SCALE < ARRLEN) {
318          errn += verify("test_2vi_scl: a2", i*SCALE, a2[i*SCALE], 103);
319        }
320      }
321      // Reset for 2 arrays with relative aligned offset
322      for (int i=0; i<ARRLEN; i++) {
323        a1[i] = -1;
324        a2[i] = -1;
325      }
326      test_vi(a2, 123, -1);
327      test_cp_alndst(a1, a2);
328      for (int i=0; i<ALIGN_OFF; i++) {
329        errn += verify("test_cp_alndst: a1", i, a1[i], -1);
330      }
331      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
332        errn += verify("test_cp_alndst: a1", i, a1[i], 123);
333      }
334      for (int i=0; i<ALIGN_OFF; i++) {
335        a1[i] = 123;
336      }
337      test_vi(a2, -123, 123);
338      test_cp_alnsrc(a1, a2);
339      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
340        errn += verify("test_cp_alnsrc: a1", i, a1[i], -123);
341      }
342      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
343        errn += verify("test_cp_alnsrc: a1", i, a1[i], 123);
344      }
345      for (int i=0; i<ARRLEN; i++) {
346        a1[i] = -1;
347        a2[i] = -1;
348      }
349      test_2ci_aln(a1, a2);
350      for (int i=0; i<ALIGN_OFF; i++) {
351        errn += verify("test_2ci_aln: a1", i, a1[i], -1);
352      }
353      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
354        errn += verify("test_2ci_aln: a1", i, a1[i], -123);
355      }
356      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
357        errn += verify("test_2ci_aln: a2", i, a2[i], -103);
358      }
359      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
360        errn += verify("test_2ci_aln: a2", i, a2[i], -1);
361      }
362      for (int i=0; i<ARRLEN; i++) {
363        a1[i] = -1;
364        a2[i] = -1;
365      }
366      test_2vi_aln(a1, a2, 123, 103);
367      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
368        errn += verify("test_2vi_aln: a1", i, a1[i], 123);
369      }
370      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
371        errn += verify("test_2vi_aln: a1", i, a1[i], -1);
372      }
373      for (int i=0; i<ALIGN_OFF; i++) {
374        errn += verify("test_2vi_aln: a2", i, a2[i], -1);
375      }
376      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
377        errn += verify("test_2vi_aln: a2", i, a2[i], 103);
378      }
379
380      // Reset for 2 arrays with relative unaligned offset
381      for (int i=0; i<ARRLEN; i++) {
382        a1[i] = -1;
383        a2[i] = -1;
384      }
385      test_vi(a2, 123, -1);
386      test_cp_unalndst(a1, a2);
387      for (int i=0; i<UNALIGN_OFF; i++) {
388        errn += verify("test_cp_unalndst: a1", i, a1[i], -1);
389      }
390      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
391        errn += verify("test_cp_unalndst: a1", i, a1[i], 123);
392      }
393      test_vi(a2, -123, 123);
394      test_cp_unalnsrc(a1, a2);
395      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
396        errn += verify("test_cp_unalnsrc: a1", i, a1[i], -123);
397      }
398      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
399        errn += verify("test_cp_unalnsrc: a1", i, a1[i], 123);
400      }
401      for (int i=0; i<ARRLEN; i++) {
402        a1[i] = -1;
403        a2[i] = -1;
404      }
405      test_2ci_unaln(a1, a2);
406      for (int i=0; i<UNALIGN_OFF; i++) {
407        errn += verify("test_2ci_unaln: a1", i, a1[i], -1);
408      }
409      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
410        errn += verify("test_2ci_unaln: a1", i, a1[i], -123);
411      }
412      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
413        errn += verify("test_2ci_unaln: a2", i, a2[i], -103);
414      }
415      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
416        errn += verify("test_2ci_unaln: a2", i, a2[i], -1);
417      }
418      for (int i=0; i<ARRLEN; i++) {
419        a1[i] = -1;
420        a2[i] = -1;
421      }
422      test_2vi_unaln(a1, a2, 123, 103);
423      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
424        errn += verify("test_2vi_unaln: a1", i, a1[i], 123);
425      }
426      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
427        errn += verify("test_2vi_unaln: a1", i, a1[i], -1);
428      }
429      for (int i=0; i<UNALIGN_OFF; i++) {
430        errn += verify("test_2vi_unaln: a2", i, a2[i], -1);
431      }
432      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
433        errn += verify("test_2vi_unaln: a2", i, a2[i], 103);
434      }
435
436      // Reset for aligned overlap initialization
437      for (int i=0; i<ALIGN_OFF; i++) {
438        a1[i] = i;
439      }
440      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
441        a1[i] = -1;
442      }
443      test_cp_alndst(a1, a1);
444      for (int i=0; i<ARRLEN; i++) {
445        int v = i%ALIGN_OFF;
446        errn += verify("test_cp_alndst_overlap: a1", i, a1[i], v);
447      }
448      for (int i=0; i<ALIGN_OFF; i++) {
449        a1[i+ALIGN_OFF] = -1;
450      }
451      test_cp_alnsrc(a1, a1);
452      for (int i=0; i<ALIGN_OFF; i++) {
453        errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], -1);
454      }
455      for (int i=ALIGN_OFF; i<ARRLEN; i++) {
456        int v = i%ALIGN_OFF;
457        errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], v);
458      }
459      for (int i=0; i<ARRLEN; i++) {
460        a1[i] = -1;
461      }
462      test_2ci_aln(a1, a1);
463      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
464        errn += verify("test_2ci_aln_overlap: a1", i, a1[i], -103);
465      }
466      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
467        errn += verify("test_2ci_aln_overlap: a1", i, a1[i], -123);
468      }
469      for (int i=0; i<ARRLEN; i++) {
470        a1[i] = -1;
471      }
472      test_2vi_aln(a1, a1, 123, 103);
473      for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
474        errn += verify("test_2vi_aln_overlap: a1", i, a1[i], 123);
475      }
476      for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
477        errn += verify("test_2vi_aln_overlap: a1", i, a1[i], 103);
478      }
479
480      // Reset for unaligned overlap initialization
481      for (int i=0; i<UNALIGN_OFF; i++) {
482        a1[i] = i;
483      }
484      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
485        a1[i] = -1;
486      }
487      test_cp_unalndst(a1, a1);
488      for (int i=0; i<ARRLEN; i++) {
489        int v = i%UNALIGN_OFF;
490        errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], v);
491      }
492      for (int i=0; i<UNALIGN_OFF; i++) {
493        a1[i+UNALIGN_OFF] = -1;
494      }
495      test_cp_unalnsrc(a1, a1);
496      for (int i=0; i<UNALIGN_OFF; i++) {
497        errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], -1);
498      }
499      for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
500        int v = i%UNALIGN_OFF;
501        errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], v);
502      }
503      for (int i=0; i<ARRLEN; i++) {
504        a1[i] = -1;
505      }
506      test_2ci_unaln(a1, a1);
507      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
508        errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], -103);
509      }
510      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
511        errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], -123);
512      }
513      for (int i=0; i<ARRLEN; i++) {
514        a1[i] = -1;
515      }
516      test_2vi_unaln(a1, a1, 123, 103);
517      for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
518        errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], 123);
519      }
520      for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
521        errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], 103);
522      }
523
524    }
525
526    if (errn > 0 || test_only)
527      return errn;
528
529    // Initialize
530    for (int i=0; i<ARRLEN; i++) {
531      a1[i] = -1;
532      a2[i] = -1;
533    }
534    System.out.println("Time");
535    long start, end;
536    start = System.currentTimeMillis();
537    for (int i=0; i<ITERS; i++) {
538      test_ci(a1);
539    }
540    end = System.currentTimeMillis();
541    System.out.println("test_ci: " + (end - start));
542    start = System.currentTimeMillis();
543    for (int i=0; i<ITERS; i++) {
544      test_vi(a2, 123, -1);
545    }
546    end = System.currentTimeMillis();
547    System.out.println("test_vi: " + (end - start));
548    start = System.currentTimeMillis();
549    for (int i=0; i<ITERS; i++) {
550      test_cp(a1, a2);
551    }
552    end = System.currentTimeMillis();
553    System.out.println("test_cp: " + (end - start));
554    start = System.currentTimeMillis();
555    for (int i=0; i<ITERS; i++) {
556      test_2ci(a1, a2);
557    }
558    end = System.currentTimeMillis();
559    System.out.println("test_2ci: " + (end - start));
560    start = System.currentTimeMillis();
561    for (int i=0; i<ITERS; i++) {
562      test_2vi(a1, a2, 123, 103);
563    }
564    end = System.currentTimeMillis();
565    System.out.println("test_2vi: " + (end - start));
566
567    start = System.currentTimeMillis();
568    for (int i=0; i<ITERS; i++) {
569      test_ci_neg(a1, 123);
570    }
571    end = System.currentTimeMillis();
572    System.out.println("test_ci_neg: " + (end - start));
573    start = System.currentTimeMillis();
574    for (int i=0; i<ITERS; i++) {
575      test_vi_neg(a2, 123, 103);
576    }
577    end = System.currentTimeMillis();
578    System.out.println("test_vi_neg: " + (end - start));
579    start = System.currentTimeMillis();
580    for (int i=0; i<ITERS; i++) {
581      test_cp_neg(a1, a2);
582    }
583    end = System.currentTimeMillis();
584    System.out.println("test_cp_neg: " + (end - start));
585    start = System.currentTimeMillis();
586    for (int i=0; i<ITERS; i++) {
587      test_2ci_neg(a1, a2);
588    }
589    end = System.currentTimeMillis();
590    System.out.println("test_2ci_neg: " + (end - start));
591    start = System.currentTimeMillis();
592    for (int i=0; i<ITERS; i++) {
593      test_2vi_neg(a1, a2, 123, 103);
594    }
595    end = System.currentTimeMillis();
596    System.out.println("test_2vi_neg: " + (end - start));
597
598    start = System.currentTimeMillis();
599    for (int i=0; i<ITERS; i++) {
600      test_ci_oppos(a1, 123);
601    }
602    end = System.currentTimeMillis();
603    System.out.println("test_ci_oppos: " + (end - start));
604    start = System.currentTimeMillis();
605    for (int i=0; i<ITERS; i++) {
606      test_vi_oppos(a2, 123, 103);
607    }
608    end = System.currentTimeMillis();
609    System.out.println("test_vi_oppos: " + (end - start));
610    start = System.currentTimeMillis();
611    for (int i=0; i<ITERS; i++) {
612      test_cp_oppos(a1, a2);
613    }
614    end = System.currentTimeMillis();
615    System.out.println("test_cp_oppos: " + (end - start));
616    start = System.currentTimeMillis();
617    for (int i=0; i<ITERS; i++) {
618      test_2ci_oppos(a1, a2);
619    }
620    end = System.currentTimeMillis();
621    System.out.println("test_2ci_oppos: " + (end - start));
622    start = System.currentTimeMillis();
623    for (int i=0; i<ITERS; i++) {
624      test_2vi_oppos(a1, a2, 123, 103);
625    }
626    end = System.currentTimeMillis();
627    System.out.println("test_2vi_oppos: " + (end - start));
628
629    start = System.currentTimeMillis();
630    for (int i=0; i<ITERS; i++) {
631      test_ci_off(a1, 123);
632    }
633    end = System.currentTimeMillis();
634    System.out.println("test_ci_off: " + (end - start));
635    start = System.currentTimeMillis();
636    for (int i=0; i<ITERS; i++) {
637      test_vi_off(a2, 123, 103);
638    }
639    end = System.currentTimeMillis();
640    System.out.println("test_vi_off: " + (end - start));
641    start = System.currentTimeMillis();
642    for (int i=0; i<ITERS; i++) {
643      test_cp_off(a1, a2);
644    }
645    end = System.currentTimeMillis();
646    System.out.println("test_cp_off: " + (end - start));
647    start = System.currentTimeMillis();
648    for (int i=0; i<ITERS; i++) {
649      test_2ci_off(a1, a2);
650    }
651    end = System.currentTimeMillis();
652    System.out.println("test_2ci_off: " + (end - start));
653    start = System.currentTimeMillis();
654    for (int i=0; i<ITERS; i++) {
655      test_2vi_off(a1, a2, 123, 103);
656    }
657    end = System.currentTimeMillis();
658    System.out.println("test_2vi_off: " + (end - start));
659
660    start = System.currentTimeMillis();
661    for (int i=0; i<ITERS; i++) {
662      test_ci_inv(a1, OFFSET, 123);
663    }
664    end = System.currentTimeMillis();
665    System.out.println("test_ci_inv: " + (end - start));
666    start = System.currentTimeMillis();
667    for (int i=0; i<ITERS; i++) {
668      test_vi_inv(a2, 123, OFFSET, 103);
669    }
670    end = System.currentTimeMillis();
671    System.out.println("test_vi_inv: " + (end - start));
672    start = System.currentTimeMillis();
673    for (int i=0; i<ITERS; i++) {
674      test_cp_inv(a1, a2, OFFSET);
675    }
676    end = System.currentTimeMillis();
677    System.out.println("test_cp_inv: " + (end - start));
678    start = System.currentTimeMillis();
679    for (int i=0; i<ITERS; i++) {
680      test_2ci_inv(a1, a2, OFFSET);
681    }
682    end = System.currentTimeMillis();
683    System.out.println("test_2ci_inv: " + (end - start));
684    start = System.currentTimeMillis();
685    for (int i=0; i<ITERS; i++) {
686      test_2vi_inv(a1, a2, 123, 103, OFFSET);
687    }
688    end = System.currentTimeMillis();
689    System.out.println("test_2vi_inv: " + (end - start));
690
691    start = System.currentTimeMillis();
692    for (int i=0; i<ITERS; i++) {
693      test_ci_scl(a1, 123);
694    }
695    end = System.currentTimeMillis();
696    System.out.println("test_ci_scl: " + (end - start));
697    start = System.currentTimeMillis();
698    for (int i=0; i<ITERS; i++) {
699      test_vi_scl(a2, 123, 103);
700    }
701    end = System.currentTimeMillis();
702    System.out.println("test_vi_scl: " + (end - start));
703    start = System.currentTimeMillis();
704    for (int i=0; i<ITERS; i++) {
705      test_cp_scl(a1, a2);
706    }
707    end = System.currentTimeMillis();
708    System.out.println("test_cp_scl: " + (end - start));
709    start = System.currentTimeMillis();
710    for (int i=0; i<ITERS; i++) {
711      test_2ci_scl(a1, a2);
712    }
713    end = System.currentTimeMillis();
714    System.out.println("test_2ci_scl: " + (end - start));
715    start = System.currentTimeMillis();
716    for (int i=0; i<ITERS; i++) {
717      test_2vi_scl(a1, a2, 123, 103);
718    }
719    end = System.currentTimeMillis();
720    System.out.println("test_2vi_scl: " + (end - start));
721
722    start = System.currentTimeMillis();
723    for (int i=0; i<ITERS; i++) {
724      test_cp_alndst(a1, a2);
725    }
726    end = System.currentTimeMillis();
727    System.out.println("test_cp_alndst: " + (end - start));
728    start = System.currentTimeMillis();
729    for (int i=0; i<ITERS; i++) {
730      test_cp_alnsrc(a1, a2);
731    }
732    end = System.currentTimeMillis();
733    System.out.println("test_cp_alnsrc: " + (end - start));
734    start = System.currentTimeMillis();
735    for (int i=0; i<ITERS; i++) {
736      test_2ci_aln(a1, a2);
737    }
738    end = System.currentTimeMillis();
739    System.out.println("test_2ci_aln: " + (end - start));
740    start = System.currentTimeMillis();
741    for (int i=0; i<ITERS; i++) {
742      test_2vi_aln(a1, a2, 123, 103);
743    }
744    end = System.currentTimeMillis();
745    System.out.println("test_2vi_aln: " + (end - start));
746
747    start = System.currentTimeMillis();
748    for (int i=0; i<ITERS; i++) {
749      test_cp_unalndst(a1, a2);
750    }
751    end = System.currentTimeMillis();
752    System.out.println("test_cp_unalndst: " + (end - start));
753    start = System.currentTimeMillis();
754    for (int i=0; i<ITERS; i++) {
755      test_cp_unalnsrc(a1, a2);
756    }
757    end = System.currentTimeMillis();
758    System.out.println("test_cp_unalnsrc: " + (end - start));
759    start = System.currentTimeMillis();
760    for (int i=0; i<ITERS; i++) {
761      test_2ci_unaln(a1, a2);
762    }
763    end = System.currentTimeMillis();
764    System.out.println("test_2ci_unaln: " + (end - start));
765    start = System.currentTimeMillis();
766    for (int i=0; i<ITERS; i++) {
767      test_2vi_unaln(a1, a2, 123, 103);
768    }
769    end = System.currentTimeMillis();
770    System.out.println("test_2vi_unaln: " + (end - start));
771
772    return errn;
773  }
774
775  private final static long byte_offset(int i) {
776    return ((long)i << 2) + BASE;
777  }
778
779  static void test_ci(int[] a) {
780    for (int i = 0; i < ARRLEN; i+=1) {
781      unsafe.putIntRelease(a, byte_offset(i), -123);
782    }
783  }
784  static void test_vi(int[] a, int b, int old) {
785    for (int i = 0; i < ARRLEN; i+=1) {
786      unsafe.putIntRelease(a, byte_offset(i), b);
787    }
788  }
789  static void test_cp(int[] a, int[] b) {
790    for (int i = 0; i < ARRLEN; i+=1) {
791      unsafe.putIntRelease(a, byte_offset(i), b[i]);
792    }
793  }
794  static void test_2ci(int[] a, int[] b) {
795    for (int i = 0; i < ARRLEN; i+=1) {
796      unsafe.putIntRelease(a, byte_offset(i), -123);
797      unsafe.putIntRelease(b, byte_offset(i), -103);
798    }
799  }
800  static void test_2vi(int[] a, int[] b, int c, int d) {
801    for (int i = 0; i < ARRLEN; i+=1) {
802      unsafe.putIntRelease(a, byte_offset(i), c);
803      unsafe.putIntRelease(b, byte_offset(i), d);
804    }
805  }
806  static void test_ci_neg(int[] a, int old) {
807    for (int i = ARRLEN-1; i >= 0; i-=1) {
808      unsafe.putIntRelease(a, byte_offset(i), -123);
809    }
810  }
811  static void test_vi_neg(int[] a, int b, int old) {
812    for (int i = ARRLEN-1; i >= 0; i-=1) {
813      unsafe.putIntRelease(a, byte_offset(i), b);
814    }
815  }
816  static void test_cp_neg(int[] a, int[] b) {
817    for (int i = ARRLEN-1; i >= 0; i-=1) {
818      unsafe.putIntRelease(a, byte_offset(i), b[i]);
819    }
820  }
821  static void test_2ci_neg(int[] a, int[] b) {
822    for (int i = ARRLEN-1; i >= 0; i-=1) {
823      unsafe.putIntRelease(a, byte_offset(i), -123);
824      unsafe.putIntRelease(b, byte_offset(i), -103);
825    }
826  }
827  static void test_2vi_neg(int[] a, int[] b, int c, int d) {
828    for (int i = ARRLEN-1; i >= 0; i-=1) {
829      unsafe.putIntRelease(a, byte_offset(i), c);
830      unsafe.putIntRelease(b, byte_offset(i), d);
831    }
832  }
833  static void test_ci_oppos(int[] a, int old) {
834    int limit = ARRLEN-1;
835    for (int i = 0; i < ARRLEN; i+=1) {
836      unsafe.putIntRelease(a, byte_offset(limit-i), -123);
837    }
838  }
839  static void test_vi_oppos(int[] a, int b, int old) {
840    int limit = ARRLEN-1;
841    for (int i = limit; i >= 0; i-=1) {
842      unsafe.putIntRelease(a, byte_offset(limit-i), b);
843    }
844  }
845  static void test_cp_oppos(int[] a, int[] b) {
846    int limit = ARRLEN-1;
847    for (int i = 0; i < ARRLEN; i+=1) {
848      unsafe.putIntRelease(a, byte_offset(i), b[limit-i]);
849    }
850  }
851  static void test_2ci_oppos(int[] a, int[] b) {
852    int limit = ARRLEN-1;
853    for (int i = 0; i < ARRLEN; i+=1) {
854      unsafe.putIntRelease(a, byte_offset(limit-i), -123);
855      unsafe.putIntRelease(b, byte_offset(i), -103);
856    }
857  }
858  static void test_2vi_oppos(int[] a, int[] b, int c, int d) {
859    int limit = ARRLEN-1;
860    for (int i = limit; i >= 0; i-=1) {
861      unsafe.putIntRelease(a, byte_offset(i), c);
862      unsafe.putIntRelease(b, byte_offset(limit-i), d);
863    }
864  }
865  static void test_ci_off(int[] a, int old) {
866    for (int i = 0; i < ARRLEN-OFFSET; i+=1) {
867      unsafe.putIntRelease(a, byte_offset(i+OFFSET), -123);
868    }
869  }
870  static void test_vi_off(int[] a, int b, int old) {
871    for (int i = 0; i < ARRLEN-OFFSET; i+=1) {
872      unsafe.putIntRelease(a, byte_offset(i+OFFSET), b);
873    }
874  }
875  static void test_cp_off(int[] a, int[] b) {
876    for (int i = 0; i < ARRLEN-OFFSET; i+=1) {
877      unsafe.putIntRelease(a, byte_offset(i+OFFSET), b[i+OFFSET]);
878    }
879  }
880  static void test_2ci_off(int[] a, int[] b) {
881    for (int i = 0; i < ARRLEN-OFFSET; i+=1) {
882      unsafe.putIntRelease(a, byte_offset(i+OFFSET), -123);
883      unsafe.putIntRelease(b, byte_offset(i+OFFSET), -103);
884    }
885  }
886  static void test_2vi_off(int[] a, int[] b, int c, int d) {
887    for (int i = 0; i < ARRLEN-OFFSET; i+=1) {
888      unsafe.putIntRelease(a, byte_offset(i+OFFSET), c);
889      unsafe.putIntRelease(b, byte_offset(i+OFFSET), d);
890    }
891  }
892  static void test_ci_inv(int[] a, int k, int old) {
893    for (int i = 0; i < ARRLEN-k; i+=1) {
894      unsafe.putIntRelease(a, byte_offset(i+k), -123);
895    }
896  }
897  static void test_vi_inv(int[] a, int b, int k, int old) {
898    for (int i = 0; i < ARRLEN-k; i+=1) {
899      unsafe.putIntRelease(a, byte_offset(i+k), b);
900    }
901  }
902  static void test_cp_inv(int[] a, int[] b, int k) {
903    for (int i = 0; i < ARRLEN-k; i+=1) {
904      unsafe.putIntRelease(a, byte_offset(i+k), b[i+k]);
905    }
906  }
907  static void test_2ci_inv(int[] a, int[] b, int k) {
908    for (int i = 0; i < ARRLEN-k; i+=1) {
909      unsafe.putIntRelease(a, byte_offset(i+k), -123);
910      unsafe.putIntRelease(b, byte_offset(i+k), -103);
911    }
912  }
913  static void test_2vi_inv(int[] a, int[] b, int c, int d, int k) {
914    for (int i = 0; i < ARRLEN-k; i+=1) {
915      unsafe.putIntRelease(a, byte_offset(i+k), c);
916      unsafe.putIntRelease(b, byte_offset(i+k), d);
917    }
918  }
919  static void test_ci_scl(int[] a, int old) {
920    for (int i = 0; i*SCALE < ARRLEN; i+=1) {
921      unsafe.putIntRelease(a, byte_offset(i*SCALE), -123);
922    }
923  }
924  static void test_vi_scl(int[] a, int b, int old) {
925    for (int i = 0; i*SCALE < ARRLEN; i+=1) {
926      unsafe.putIntRelease(a, byte_offset(i*SCALE), b);
927    }
928  }
929  static void test_cp_scl(int[] a, int[] b) {
930    for (int i = 0; i*SCALE < ARRLEN; i+=1) {
931      unsafe.putIntRelease(a, byte_offset(i*SCALE), b[i*SCALE]);
932    }
933  }
934  static void test_2ci_scl(int[] a, int[] b) {
935    for (int i = 0; i*SCALE < ARRLEN; i+=1) {
936      unsafe.putIntRelease(a, byte_offset(i*SCALE), -123);
937      unsafe.putIntRelease(b, byte_offset(i*SCALE), -103);
938    }
939  }
940  static void test_2vi_scl(int[] a, int[] b, int c, int d) {
941    for (int i = 0; i*SCALE < ARRLEN; i+=1) {
942      unsafe.putIntRelease(a, byte_offset(i*SCALE), c);
943      unsafe.putIntRelease(b, byte_offset(i*SCALE), d);
944    }
945  }
946  static void test_cp_alndst(int[] a, int[] b) {
947    for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {
948      unsafe.putIntRelease(a, byte_offset(i+ALIGN_OFF), b[i]);
949    }
950  }
951  static void test_cp_alnsrc(int[] a, int[] b) {
952    for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {
953      unsafe.putIntRelease(a, byte_offset(i), b[i+ALIGN_OFF]);
954    }
955  }
956  static void test_2ci_aln(int[] a, int[] b) {
957    for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {
958      unsafe.putIntRelease(a, byte_offset(i+ALIGN_OFF), -123);
959      unsafe.putIntRelease(b, byte_offset(i), -103);
960    }
961  }
962  static void test_2vi_aln(int[] a, int[] b, int c, int d) {
963    for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {
964      unsafe.putIntRelease(a, byte_offset(i), c);
965      unsafe.putIntRelease(b, byte_offset(i+ALIGN_OFF), d);
966    }
967  }
968  static void test_cp_unalndst(int[] a, int[] b) {
969    for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {
970      unsafe.putIntRelease(a, byte_offset(i+UNALIGN_OFF), b[i]);
971    }
972  }
973  static void test_cp_unalnsrc(int[] a, int[] b) {
974    for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {
975      unsafe.putIntRelease(a, byte_offset(i), b[i+UNALIGN_OFF]);
976    }
977  }
978  static void test_2ci_unaln(int[] a, int[] b) {
979    for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {
980      unsafe.putIntRelease(a, byte_offset(i+UNALIGN_OFF), -123);
981      unsafe.putIntRelease(b, byte_offset(i), -103);
982    }
983  }
984  static void test_2vi_unaln(int[] a, int[] b, int c, int d) {
985    for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {
986      unsafe.putIntRelease(a, byte_offset(i), c);
987      unsafe.putIntRelease(b, byte_offset(i+UNALIGN_OFF), d);
988    }
989  }
990
991  static int verify(String text, int i, int elem, int val) {
992    if (elem != val) {
993      System.err.println(text + "[" + i + "] = " + elem + " != " + val);
994      return 1;
995    }
996    return 0;
997  }
998}
999