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