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
39 package compiler.c2.cr8004867;
40
41 import jdk.internal.misc.Unsafe;
42
43 import java.lang.reflect.Field;
44
45 public 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 }