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