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 TestIntUnsafeVolatile 32 * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:+OptimizeFill TestIntUnsafeVolatile 33 */ 34 35 import jdk.internal.misc.Unsafe; 36 import java.lang.reflect.*; 37 38 public class TestIntUnsafeVolatile { 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 = TestIntUnsafeVolatile.class.getClassLoader().loadClass("jdk.internal.misc.Unsafe"); 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 volatile 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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i), -123); 790 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i), c); 796 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i), -123); 817 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i), c); 823 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(limit-i), -123); 848 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i), c); 855 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i+OFFSET), -123); 876 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i+OFFSET), c); 882 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i+k), -123); 903 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i+k), c); 909 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i*SCALE), -123); 930 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i*SCALE), c); 936 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i+ALIGN_OFF), -123); 952 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i), c); 958 unsafe.putIntVolatile(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.putIntVolatile(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.putIntVolatile(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.putIntVolatile(a, byte_offset(i+UNALIGN_OFF), -123); 974 unsafe.putIntVolatile(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.putIntVolatile(a, byte_offset(i), c); 980 unsafe.putIntVolatile(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 }