1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 import java.util.ArrayList; 18 19 /** 20 * The matrix of tests includes the A-E axis for loop body contents and 21 * the 0-5 axis for iterator style. 22 * 23 * <ul> 24 * <li>A: empty body</li> 25 * <li>B: array element access and update</li> 26 * <li>C: instance field access and update</li> 27 * <li>D: method call to empty method</li> 28 * <li>E: synch and then method call to empty method</li> 29 * <li>F: 5 method calls to empty method</li> 30 * <li>G: one small object allocation (empty constructor)</li> 31 * <li>H: copy 8k of bytes from one array to another</li> 32 * </ul> 33 * 34 * <ul> 35 * <li>0: for() loop backward to 0</li> 36 * <li>1: for() loop forward to local variable</li> 37 * <li>2: for() loop forward to array length</li> 38 * <li>3: for(:) loop over array</li> 39 * <li>4: for() loop forward to instance variable</li> 40 * <li>5: for() loop forward to trivial method call</li> 41 * <li>6: for(:) loop over ArrayList</li> 42 * </ul> 43 */ 44 public class Main { 45 static public final int BODIES = 8; 46 static public final int LOOPS = 7; 47 48 static public void main(String[] args) throws Exception { 49 boolean timing = (args.length >= 1) && args[0].equals("--timing"); 50 51 int iters = 100; 52 double probeSec; 53 54 for (;;) { 55 long t0 = System.nanoTime(); 56 runAllTests(iters, false); 57 long t1 = System.nanoTime(); 58 59 probeSec = (t1 - t0) / 1000000000.0; 60 if (probeSec > 0.25) { 61 break; 62 } 63 64 iters *= 2; 65 } 66 67 // Attempt to arrange for the real test to take 20 seconds. 68 iters = (int) ((iters / probeSec) * 20); 69 70 if (timing) { 71 System.out.println("iters = " + iters); 72 } 73 74 run(timing, iters); 75 } 76 77 static private enum Normalization { 78 NONE, PER_COLUMN, TOP_LEFT; 79 } 80 81 static public void printTimings(double[][] timings, Normalization norm) { 82 System.out.println(); 83 System.out.printf("%-7s A B C D E" + 84 " F G H\n", 85 (norm == Normalization.NONE) ? "(usec)" : "(ratio)"); 86 System.out.println(" -------- -------- -------- -------- " + 87 "-------- -------- -------- --------"); 88 89 double bases[] = new double[BODIES]; 90 for (int i = 0; i < BODIES; i++) { 91 double n; 92 switch (norm) { 93 case PER_COLUMN: n = timings[i][0]; break; 94 case TOP_LEFT: n = timings[0][0]; break; 95 default /*NONE*/: n = 1.0; break; 96 } 97 bases[i] = n; 98 } 99 100 for (int i = 0; i < LOOPS; i++) { 101 System.out.printf("%4d: %8.3g %8.3g %8.3g %8.3g %8.3g %8.3g " + 102 "%8.3g %8.3g\n", 103 i, 104 timings[0][i] / bases[0], 105 timings[1][i] / bases[1], 106 timings[2][i] / bases[2], 107 timings[3][i] / bases[3], 108 timings[4][i] / bases[4], 109 timings[5][i] / bases[5], 110 timings[6][i] / bases[6], 111 timings[7][i] / bases[7]); 112 } 113 } 114 115 static public void run(boolean timing, int iters) { 116 double[][] timings = null; // assign to avoid apparent javac bug 117 118 // Try up to 5 times to get good times. 119 for (int i = 0; i < 5; i++) { 120 double[][] newTimings = runAllTests(iters, timing || (i == 0)); 121 122 if (timings == null) { 123 timings = newTimings; 124 } else { 125 combineTimings(timings, newTimings, i); 126 } 127 128 if (checkTimes(timings, timing)) { 129 break; 130 } 131 } 132 133 System.out.println("Done with runs."); 134 135 boolean goodTimes = checkTimes(timings, true); 136 137 if (! goodTimes) { 138 timing = true; 139 } 140 141 if (timing) { 142 printTimings(timings, Normalization.NONE); 143 printTimings(timings, Normalization.TOP_LEFT); 144 printTimings(timings, Normalization.PER_COLUMN); 145 } else { 146 System.out.println("\nAll times are within the expected ranges."); 147 } 148 } 149 150 static public void combineTimings(double[][] target, double[][] newTimes, 151 int oldWeight) { 152 for (int i = 0; i < target.length; i++) { 153 for (int j = 0; j < target[i].length; j++) { 154 target[i][j] = 155 ((target[i][j] * oldWeight) + newTimes[i][j]) 156 / (oldWeight + 1); 157 } 158 } 159 } 160 161 static public boolean checkTimes(double[][] timings, boolean print) { 162 // expected increase over A1 163 double[][] expected = { 164 { 1.0, 2.3, 2.4, 3.3, 6.5, 12.0, 57.0, 94.0 }, 165 { 1.2, 2.4, 2.5, 3.4, 6.6, 12.2, 60.0, 95.0 }, 166 { 1.5, 2.6, 2.9, 3.5, 6.7, 12.4, 63.0, 96.0 }, 167 { 1.6, 2.8, 2.9, 3.6, 6.8, 12.6, 63.5, 97.0 }, 168 { 1.7, 3.0, 2.9, 3.7, 6.9, 12.8, 64.0, 98.0 }, 169 { 6.0, 6.0, 6.0, 7.0, 10.0, 15.0, 64.5, 105.0 }, 170 { 31.0, 31.2, 31.5, 34.0, 41.0, 43.0, 91.0, 135.0 }, 171 }; 172 173 boolean good = true; 174 175 for (int x = 0; x < BODIES; x++) { 176 for (int y = 0; y < LOOPS; y++) { 177 double ratio = timings[x][y] / timings[0][0]; 178 if (ratio > expected[y][x]) { 179 if (print) { 180 System.out.printf("%c%d is too slow: %.3g vs. %.3g\n", 181 (char) (x + 'A'), y, ratio, expected[y][x]); 182 } 183 good = false; 184 } 185 } 186 } 187 188 return good; 189 } 190 191 static public double[][] runAllTests(int iters, boolean print) { 192 // diters is used to get usec, not nanosec; hence the extra 1000. 193 double diters = (double) iters * INNER_COUNT * 1000; 194 195 double[][] timings = new double[BODIES][LOOPS]; 196 long t0, t1, t2, t3, t4, t5, t6, t7; 197 198 // Column A 199 200 if (print) { 201 System.out.println("Running A..."); 202 } 203 204 t0 = System.nanoTime(); 205 testA0(iters); 206 t1 = System.nanoTime(); 207 testA1(iters); 208 t2 = System.nanoTime(); 209 testA2(iters); 210 t3 = System.nanoTime(); 211 testA3(iters); 212 t4 = System.nanoTime(); 213 testA4(iters); 214 t5 = System.nanoTime(); 215 testA5(iters); 216 t6 = System.nanoTime(); 217 testA6(iters); 218 t7 = System.nanoTime(); 219 220 timings[0][0] = (t1 - t0) / diters; 221 timings[0][1] = (t2 - t1) / diters; 222 timings[0][2] = (t3 - t2) / diters; 223 timings[0][3] = (t4 - t3) / diters; 224 timings[0][4] = (t5 - t4) / diters; 225 timings[0][5] = (t6 - t5) / diters; 226 timings[0][6] = (t7 - t6) / diters; 227 228 // Column B 229 230 if (print) { 231 System.out.println("Running B..."); 232 } 233 234 t0 = System.nanoTime(); 235 testB0(iters); 236 t1 = System.nanoTime(); 237 testB1(iters); 238 t2 = System.nanoTime(); 239 testB2(iters); 240 t3 = System.nanoTime(); 241 testB3(iters); 242 t4 = System.nanoTime(); 243 testB4(iters); 244 t5 = System.nanoTime(); 245 testB5(iters); 246 t6 = System.nanoTime(); 247 testB6(iters); 248 t7 = System.nanoTime(); 249 250 timings[1][0] = (t1 - t0) / diters; 251 timings[1][1] = (t2 - t1) / diters; 252 timings[1][2] = (t3 - t2) / diters; 253 timings[1][3] = (t4 - t3) / diters; 254 timings[1][4] = (t5 - t4) / diters; 255 timings[1][5] = (t6 - t5) / diters; 256 timings[1][6] = (t7 - t6) / diters; 257 258 // Column C 259 260 if (print) { 261 System.out.println("Running C..."); 262 } 263 264 t0 = System.nanoTime(); 265 testC0(iters); 266 t1 = System.nanoTime(); 267 testC1(iters); 268 t2 = System.nanoTime(); 269 testC2(iters); 270 t3 = System.nanoTime(); 271 testC3(iters); 272 t4 = System.nanoTime(); 273 testC4(iters); 274 t5 = System.nanoTime(); 275 testC5(iters); 276 t6 = System.nanoTime(); 277 testC6(iters); 278 t7 = System.nanoTime(); 279 280 timings[2][0] = (t1 - t0) / diters; 281 timings[2][1] = (t2 - t1) / diters; 282 timings[2][2] = (t3 - t2) / diters; 283 timings[2][3] = (t4 - t3) / diters; 284 timings[2][4] = (t5 - t4) / diters; 285 timings[2][5] = (t6 - t5) / diters; 286 timings[2][6] = (t7 - t6) / diters; 287 288 // Column D 289 290 if (print) { 291 System.out.println("Running D..."); 292 } 293 294 t0 = System.nanoTime(); 295 testD0(iters); 296 t1 = System.nanoTime(); 297 testD1(iters); 298 t2 = System.nanoTime(); 299 testD2(iters); 300 t3 = System.nanoTime(); 301 testD3(iters); 302 t4 = System.nanoTime(); 303 testD4(iters); 304 t5 = System.nanoTime(); 305 testD5(iters); 306 t6 = System.nanoTime(); 307 testD6(iters); 308 t7 = System.nanoTime(); 309 310 timings[3][0] = (t1 - t0) / diters; 311 timings[3][1] = (t2 - t1) / diters; 312 timings[3][2] = (t3 - t2) / diters; 313 timings[3][3] = (t4 - t3) / diters; 314 timings[3][4] = (t5 - t4) / diters; 315 timings[3][5] = (t6 - t5) / diters; 316 timings[3][6] = (t7 - t6) / diters; 317 318 // Column E 319 320 if (print) { 321 System.out.println("Running E..."); 322 } 323 324 t0 = System.nanoTime(); 325 testE0(iters); 326 t1 = System.nanoTime(); 327 testE1(iters); 328 t2 = System.nanoTime(); 329 testE2(iters); 330 t3 = System.nanoTime(); 331 testE3(iters); 332 t4 = System.nanoTime(); 333 testE4(iters); 334 t5 = System.nanoTime(); 335 testE5(iters); 336 t6 = System.nanoTime(); 337 testE6(iters); 338 t7 = System.nanoTime(); 339 340 timings[4][0] = (t1 - t0) / diters; 341 timings[4][1] = (t2 - t1) / diters; 342 timings[4][2] = (t3 - t2) / diters; 343 timings[4][3] = (t4 - t3) / diters; 344 timings[4][4] = (t5 - t4) / diters; 345 timings[4][5] = (t6 - t5) / diters; 346 timings[4][6] = (t7 - t6) / diters; 347 348 // Column F 349 350 if (print) { 351 System.out.println("Running F..."); 352 } 353 354 t0 = System.nanoTime(); 355 testF0(iters); 356 t1 = System.nanoTime(); 357 testF1(iters); 358 t2 = System.nanoTime(); 359 testF2(iters); 360 t3 = System.nanoTime(); 361 testF3(iters); 362 t4 = System.nanoTime(); 363 testF4(iters); 364 t5 = System.nanoTime(); 365 testF5(iters); 366 t6 = System.nanoTime(); 367 testF6(iters); 368 t7 = System.nanoTime(); 369 370 timings[5][0] = (t1 - t0) / diters; 371 timings[5][1] = (t2 - t1) / diters; 372 timings[5][2] = (t3 - t2) / diters; 373 timings[5][3] = (t4 - t3) / diters; 374 timings[5][4] = (t5 - t4) / diters; 375 timings[5][5] = (t6 - t5) / diters; 376 timings[5][6] = (t7 - t6) / diters; 377 378 // Reduce the iters for the last two, since they're much slower. 379 380 iters /= 5; 381 diters /= 5; 382 383 // Column G 384 385 if (print) { 386 System.out.println("Running G..."); 387 } 388 389 t0 = System.nanoTime(); 390 testG0(iters); 391 t1 = System.nanoTime(); 392 testG1(iters); 393 t2 = System.nanoTime(); 394 testG2(iters); 395 t3 = System.nanoTime(); 396 testG3(iters); 397 t4 = System.nanoTime(); 398 testG4(iters); 399 t5 = System.nanoTime(); 400 testG5(iters); 401 t6 = System.nanoTime(); 402 testG6(iters); 403 t7 = System.nanoTime(); 404 405 timings[6][0] = (t1 - t0) / diters; 406 timings[6][1] = (t2 - t1) / diters; 407 timings[6][2] = (t3 - t2) / diters; 408 timings[6][3] = (t4 - t3) / diters; 409 timings[6][4] = (t5 - t4) / diters; 410 timings[6][5] = (t6 - t5) / diters; 411 timings[6][6] = (t7 - t6) / diters; 412 413 // Column H 414 415 if (print) { 416 System.out.println("Running H..."); 417 } 418 419 t0 = System.nanoTime(); 420 testH0(iters); 421 t1 = System.nanoTime(); 422 testH1(iters); 423 t2 = System.nanoTime(); 424 testH2(iters); 425 t3 = System.nanoTime(); 426 testH3(iters); 427 t4 = System.nanoTime(); 428 testH4(iters); 429 t5 = System.nanoTime(); 430 testH5(iters); 431 t6 = System.nanoTime(); 432 testH6(iters); 433 t7 = System.nanoTime(); 434 435 timings[7][0] = (t1 - t0) / diters; 436 timings[7][1] = (t2 - t1) / diters; 437 timings[7][2] = (t3 - t2) / diters; 438 timings[7][3] = (t4 - t3) / diters; 439 timings[7][4] = (t5 - t4) / diters; 440 timings[7][5] = (t6 - t5) / diters; 441 timings[7][6] = (t7 - t6) / diters; 442 443 return timings; 444 } 445 446 // Helper bits and pieces 447 448 static private final int INNER_COUNT = 100; 449 static private final int[] INNER_ARRAY = new int[INNER_COUNT]; 450 static private final ArrayList<Object> INNER_LIST = 451 new ArrayList<Object>(INNER_COUNT); 452 static private final Target TARGET = new Target(); 453 static private final int ARRAY_BYTES = 8192; 454 static private final byte[] BYTES_1 = new byte[ARRAY_BYTES]; 455 static private final byte[] BYTES_2 = new byte[ARRAY_BYTES]; 456 457 static { 458 for (int i = 0; i < INNER_COUNT; i++) { 459 INNER_LIST.add(null); 460 } 461 } 462 463 public static class Target { 464 public int value; 465 public int size = INNER_COUNT; 466 467 public void simple() { 468 // empty 469 } 470 471 public int size() { 472 return size; 473 } 474 } 475 476 // The tests themselves 477 478 static public void testA0(int iters) { 479 for (int outer = iters; outer > 0; outer--) { 480 for (int i = INNER_COUNT; i > 0; i--) { 481 // empty 482 } 483 } 484 } 485 486 static public void testA1(int iters) { 487 int count = INNER_COUNT; 488 489 for (int outer = iters; outer > 0; outer--) { 490 for (int i = 0; i < count; i++) { 491 // empty 492 } 493 } 494 } 495 496 static public void testA2(int iters) { 497 int[] array = INNER_ARRAY; 498 499 for (int outer = iters; outer > 0; outer--) { 500 for (int i = 0; i < array.length; i++) { 501 // empty 502 } 503 } 504 } 505 506 static public void testA3(int iters) { 507 int[] array = INNER_ARRAY; 508 509 for (int outer = iters; outer > 0; outer--) { 510 for (int i : array) { 511 // empty 512 } 513 } 514 } 515 516 static public void testA4(int iters) { 517 Target target = TARGET; 518 519 for (int outer = iters; outer > 0; outer--) { 520 for (int i = 0; i < target.size; i++) { 521 // empty 522 } 523 } 524 } 525 526 static public void testA5(int iters) { 527 Target target = TARGET; 528 529 for (int outer = iters; outer > 0; outer--) { 530 for (int i = 0; i < target.size(); i++) { 531 // empty 532 } 533 } 534 } 535 536 static public void testA6(int iters) { 537 ArrayList<Object> list = INNER_LIST; 538 539 for (int outer = iters; outer > 0; outer--) { 540 for (Object o : list) { 541 // empty 542 } 543 } 544 } 545 546 static public void testB0(int iters) { 547 Target target = TARGET; 548 549 for (int outer = iters; outer > 0; outer--) { 550 for (int i = INNER_COUNT; i > 0; i--) { 551 target.value++; 552 } 553 } 554 } 555 556 static public void testB1(int iters) { 557 Target target = TARGET; 558 int count = INNER_COUNT; 559 560 for (int outer = iters; outer > 0; outer--) { 561 for (int i = 0; i < count; i++) { 562 target.value++; 563 } 564 } 565 } 566 567 static public void testB2(int iters) { 568 Target target = TARGET; 569 int[] array = INNER_ARRAY; 570 571 for (int outer = iters; outer > 0; outer--) { 572 for (int i = 0; i < array.length; i++) { 573 target.value++; 574 } 575 } 576 } 577 578 static public void testB3(int iters) { 579 Target target = TARGET; 580 int[] array = INNER_ARRAY; 581 582 for (int outer = iters; outer > 0; outer--) { 583 for (int i : array) { 584 target.value++; 585 } 586 } 587 } 588 589 static public void testB4(int iters) { 590 Target target = TARGET; 591 592 for (int outer = iters; outer > 0; outer--) { 593 for (int i = 0; i < target.size; i++) { 594 target.value++; 595 } 596 } 597 } 598 599 static public void testB5(int iters) { 600 Target target = TARGET; 601 602 for (int outer = iters; outer > 0; outer--) { 603 for (int i = 0; i < target.size(); i++) { 604 target.value++; 605 } 606 } 607 } 608 609 static public void testB6(int iters) { 610 Target target = TARGET; 611 ArrayList<Object> list = INNER_LIST; 612 613 for (int outer = iters; outer > 0; outer--) { 614 for (Object o : list) { 615 target.value++; 616 } 617 } 618 } 619 620 static public void testC0(int iters) { 621 int[] array = INNER_ARRAY; 622 623 for (int outer = iters; outer > 0; outer--) { 624 for (int i = INNER_COUNT - 1; i >= 0; i--) { 625 array[i]++; 626 } 627 } 628 } 629 630 static public void testC1(int iters) { 631 int[] array = INNER_ARRAY; 632 int count = INNER_COUNT; 633 634 for (int outer = iters; outer > 0; outer--) { 635 for (int i = 0; i < count; i++) { 636 array[i]++; 637 } 638 } 639 } 640 641 static public void testC2(int iters) { 642 int[] array = INNER_ARRAY; 643 644 for (int outer = iters; outer > 0; outer--) { 645 for (int i = 0; i < array.length; i++) { 646 array[i]++; 647 } 648 } 649 } 650 651 static public void testC3(int iters) { 652 int[] array = INNER_ARRAY; 653 654 for (int outer = iters; outer > 0; outer--) { 655 for (int i : array) { 656 array[0] = i + 1; 657 } 658 } 659 } 660 661 static public void testC4(int iters) { 662 Target target = TARGET; 663 int[] array = INNER_ARRAY; 664 665 for (int outer = iters; outer > 0; outer--) { 666 for (int i = 0; i < target.size; i++) { 667 array[i]++; 668 } 669 } 670 } 671 672 static public void testC5(int iters) { 673 int[] array = INNER_ARRAY; 674 Target target = TARGET; 675 676 for (int outer = iters; outer > 0; outer--) { 677 for (int i = 0; i < target.size(); i++) { 678 array[i]++; 679 } 680 } 681 } 682 683 static public void testC6(int iters) { 684 int[] array = INNER_ARRAY; 685 ArrayList<Object> list = INNER_LIST; 686 687 for (int outer = iters; outer > 0; outer--) { 688 for (Object o : list) { 689 array[0]++; 690 } 691 } 692 } 693 694 static public void testD0(int iters) { 695 Target target = TARGET; 696 697 for (int outer = iters; outer > 0; outer--) { 698 for (int i = INNER_COUNT; i > 0; i--) { 699 target.simple(); 700 } 701 } 702 } 703 704 static public void testD1(int iters) { 705 Target target = TARGET; 706 int count = INNER_COUNT; 707 708 for (int outer = iters; outer > 0; outer--) { 709 for (int i = 0; i < count; i++) { 710 target.simple(); 711 } 712 } 713 } 714 715 static public void testD2(int iters) { 716 Target target = TARGET; 717 int[] array = INNER_ARRAY; 718 719 for (int outer = iters; outer > 0; outer--) { 720 for (int i = 0; i < array.length; i++) { 721 target.simple(); 722 } 723 } 724 } 725 726 static public void testD3(int iters) { 727 Target target = TARGET; 728 int[] array = INNER_ARRAY; 729 730 for (int outer = iters; outer > 0; outer--) { 731 for (int i : array) { 732 target.simple(); 733 } 734 } 735 } 736 737 static public void testD4(int iters) { 738 Target target = TARGET; 739 740 for (int outer = iters; outer > 0; outer--) { 741 for (int i = 0; i < target.size; i++) { 742 target.simple(); 743 } 744 } 745 } 746 747 static public void testD5(int iters) { 748 Target target = TARGET; 749 750 for (int outer = iters; outer > 0; outer--) { 751 for (int i = 0; i < target.size(); i++) { 752 target.simple(); 753 } 754 } 755 } 756 757 static public void testD6(int iters) { 758 Target target = TARGET; 759 ArrayList<Object> list = INNER_LIST; 760 761 for (int outer = iters; outer > 0; outer--) { 762 for (Object o : list) { 763 target.simple(); 764 } 765 } 766 } 767 768 static public void testE0(int iters) { 769 Target target = TARGET; 770 771 for (int outer = iters; outer > 0; outer--) { 772 for (int i = INNER_COUNT; i > 0; i--) { 773 synchronized (target) { 774 target.simple(); 775 } 776 } 777 } 778 } 779 780 static public void testE1(int iters) { 781 Target target = TARGET; 782 int count = INNER_COUNT; 783 784 for (int outer = iters; outer > 0; outer--) { 785 for (int i = 0; i < count; i++) { 786 synchronized (target) { 787 target.simple(); 788 } 789 } 790 } 791 } 792 793 static public void testE2(int iters) { 794 Target target = TARGET; 795 int[] array = INNER_ARRAY; 796 797 for (int outer = iters; outer > 0; outer--) { 798 for (int i = 0; i < array.length; i++) { 799 synchronized (target) { 800 target.simple(); 801 } 802 } 803 } 804 } 805 806 static public void testE3(int iters) { 807 Target target = TARGET; 808 int[] array = INNER_ARRAY; 809 810 for (int outer = iters; outer > 0; outer--) { 811 for (int i : array) { 812 synchronized (target) { 813 target.simple(); 814 } 815 } 816 } 817 } 818 819 static public void testE4(int iters) { 820 Target target = TARGET; 821 822 for (int outer = iters; outer > 0; outer--) { 823 for (int i = 0; i < target.size; i++) { 824 synchronized (target) { 825 target.simple(); 826 } 827 } 828 } 829 } 830 831 static public void testE5(int iters) { 832 Target target = TARGET; 833 834 for (int outer = iters; outer > 0; outer--) { 835 for (int i = 0; i < target.size(); i++) { 836 synchronized (target) { 837 target.simple(); 838 } 839 } 840 } 841 } 842 843 static public void testE6(int iters) { 844 Target target = TARGET; 845 ArrayList<Object> list = INNER_LIST; 846 847 for (int outer = iters; outer > 0; outer--) { 848 for (Object o : list) { 849 synchronized (target) { 850 target.simple(); 851 } 852 } 853 } 854 } 855 856 static public void testF0(int iters) { 857 Target target = TARGET; 858 859 for (int outer = iters; outer > 0; outer--) { 860 for (int i = INNER_COUNT; i > 0; i--) { 861 target.simple(); 862 target.simple(); 863 target.simple(); 864 target.simple(); 865 target.simple(); 866 } 867 } 868 } 869 870 static public void testF1(int iters) { 871 Target target = TARGET; 872 int count = INNER_COUNT; 873 874 for (int outer = iters; outer > 0; outer--) { 875 for (int i = 0; i < count; i++) { 876 target.simple(); 877 target.simple(); 878 target.simple(); 879 target.simple(); 880 target.simple(); 881 } 882 } 883 } 884 885 static public void testF2(int iters) { 886 Target target = TARGET; 887 int[] array = INNER_ARRAY; 888 889 for (int outer = iters; outer > 0; outer--) { 890 for (int i = 0; i < array.length; i++) { 891 target.simple(); 892 target.simple(); 893 target.simple(); 894 target.simple(); 895 target.simple(); 896 } 897 } 898 } 899 900 static public void testF3(int iters) { 901 Target target = TARGET; 902 int[] array = INNER_ARRAY; 903 904 for (int outer = iters; outer > 0; outer--) { 905 for (int i : array) { 906 target.simple(); 907 target.simple(); 908 target.simple(); 909 target.simple(); 910 target.simple(); 911 } 912 } 913 } 914 915 static public void testF4(int iters) { 916 Target target = TARGET; 917 918 for (int outer = iters; outer > 0; outer--) { 919 for (int i = 0; i < target.size; i++) { 920 target.simple(); 921 target.simple(); 922 target.simple(); 923 target.simple(); 924 target.simple(); 925 } 926 } 927 } 928 929 static public void testF5(int iters) { 930 Target target = TARGET; 931 932 for (int outer = iters; outer > 0; outer--) { 933 for (int i = 0; i < target.size(); i++) { 934 target.simple(); 935 target.simple(); 936 target.simple(); 937 target.simple(); 938 target.simple(); 939 } 940 } 941 } 942 943 static public void testF6(int iters) { 944 Target target = TARGET; 945 ArrayList<Object> list = INNER_LIST; 946 947 for (int outer = iters; outer > 0; outer--) { 948 for (Object o : list) { 949 target.simple(); 950 target.simple(); 951 target.simple(); 952 target.simple(); 953 target.simple(); 954 } 955 } 956 } 957 958 static public void testG0(int iters) { 959 for (int outer = iters; outer > 0; outer--) { 960 for (int i = INNER_COUNT; i > 0; i--) { 961 new Target(); 962 } 963 } 964 } 965 966 static public void testG1(int iters) { 967 int count = INNER_COUNT; 968 969 for (int outer = iters; outer > 0; outer--) { 970 for (int i = 0; i < count; i++) { 971 new Target(); 972 } 973 } 974 } 975 976 static public void testG2(int iters) { 977 int[] array = INNER_ARRAY; 978 979 for (int outer = iters; outer > 0; outer--) { 980 for (int i = 0; i < array.length; i++) { 981 new Target(); 982 } 983 } 984 } 985 986 static public void testG3(int iters) { 987 int[] array = INNER_ARRAY; 988 989 for (int outer = iters; outer > 0; outer--) { 990 for (int i : array) { 991 new Target(); 992 } 993 } 994 } 995 996 static public void testG4(int iters) { 997 Target target = TARGET; 998 999 for (int outer = iters; outer > 0; outer--) { 1000 for (int i = 0; i < target.size; i++) { 1001 new Target(); 1002 } 1003 } 1004 } 1005 1006 static public void testG5(int iters) { 1007 Target target = TARGET; 1008 1009 for (int outer = iters; outer > 0; outer--) { 1010 for (int i = 0; i < target.size(); i++) { 1011 new Target(); 1012 } 1013 } 1014 } 1015 1016 static public void testG6(int iters) { 1017 ArrayList<Object> list = INNER_LIST; 1018 1019 for (int outer = iters; outer > 0; outer--) { 1020 for (Object o : list) { 1021 new Target(); 1022 } 1023 } 1024 } 1025 1026 static public void testH0(int iters) { 1027 byte[] b1 = BYTES_1; 1028 byte[] b2 = BYTES_2; 1029 1030 for (int outer = iters; outer > 0; outer--) { 1031 for (int i = INNER_COUNT; i > 0; i--) { 1032 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1033 } 1034 } 1035 } 1036 1037 static public void testH1(int iters) { 1038 byte[] b1 = BYTES_1; 1039 byte[] b2 = BYTES_2; 1040 int count = INNER_COUNT; 1041 1042 for (int outer = iters; outer > 0; outer--) { 1043 for (int i = 0; i < count; i++) { 1044 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1045 } 1046 } 1047 } 1048 1049 static public void testH2(int iters) { 1050 byte[] b1 = BYTES_1; 1051 byte[] b2 = BYTES_2; 1052 int[] array = INNER_ARRAY; 1053 1054 for (int outer = iters; outer > 0; outer--) { 1055 for (int i = 0; i < array.length; i++) { 1056 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1057 } 1058 } 1059 } 1060 1061 static public void testH3(int iters) { 1062 byte[] b1 = BYTES_1; 1063 byte[] b2 = BYTES_2; 1064 int[] array = INNER_ARRAY; 1065 1066 for (int outer = iters; outer > 0; outer--) { 1067 for (int i : array) { 1068 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1069 } 1070 } 1071 } 1072 1073 static public void testH4(int iters) { 1074 Target target = TARGET; 1075 byte[] b1 = BYTES_1; 1076 byte[] b2 = BYTES_2; 1077 1078 for (int outer = iters; outer > 0; outer--) { 1079 for (int i = 0; i < target.size; i++) { 1080 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1081 } 1082 } 1083 } 1084 1085 static public void testH5(int iters) { 1086 Target target = TARGET; 1087 byte[] b1 = BYTES_1; 1088 byte[] b2 = BYTES_2; 1089 1090 for (int outer = iters; outer > 0; outer--) { 1091 for (int i = 0; i < target.size(); i++) { 1092 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1093 } 1094 } 1095 } 1096 1097 static public void testH6(int iters) { 1098 byte[] b1 = BYTES_1; 1099 byte[] b2 = BYTES_2; 1100 ArrayList<Object> list = INNER_LIST; 1101 1102 for (int outer = iters; outer > 0; outer--) { 1103 for (Object o : list) { 1104 System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); 1105 } 1106 } 1107 } 1108 } 1109
