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