| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| import java.util.ArrayList; |
| |
| /** |
| * The matrix of tests includes the A-E axis for loop body contents and |
| * the 0-5 axis for iterator style. |
| * |
| * <ul> |
| * <li>A: empty body</li> |
| * <li>B: array element access and update</li> |
| * <li>C: instance field access and update</li> |
| * <li>D: method call to empty method</li> |
| * <li>E: synch and then method call to empty method</li> |
| * <li>F: 5 method calls to empty method</li> |
| * <li>G: one small object allocation (empty constructor)</li> |
| * <li>H: copy 8k of bytes from one array to another</li> |
| * </ul> |
| * |
| * <ul> |
| * <li>0: for() loop backward to 0</li> |
| * <li>1: for() loop forward to local variable</li> |
| * <li>2: for() loop forward to array length</li> |
| * <li>3: for(:) loop over array</li> |
| * <li>4: for() loop forward to instance variable</li> |
| * <li>5: for() loop forward to trivial method call</li> |
| * <li>6: for(:) loop over ArrayList</li> |
| * </ul> |
| */ |
| public class Main { |
| static public final int BODIES = 8; |
| static public final int LOOPS = 7; |
| |
| static public void main(String[] args) throws Exception { |
| boolean timing = (args.length >= 1) && args[0].equals("--timing"); |
| |
| int iters = 100; |
| double probeSec; |
| |
| for (;;) { |
| long t0 = System.nanoTime(); |
| runAllTests(iters, false); |
| long t1 = System.nanoTime(); |
| |
| probeSec = (t1 - t0) / 1000000000.0; |
| if (probeSec > 0.25) { |
| break; |
| } |
| |
| iters *= 2; |
| } |
| |
| // Attempt to arrange for the real test to take 20 seconds. |
| iters = (int) ((iters / probeSec) * 20); |
| |
| if (timing) { |
| System.out.println("iters = " + iters); |
| } |
| |
| run(timing, iters); |
| } |
| |
| static private enum Normalization { |
| NONE, PER_COLUMN, TOP_LEFT; |
| } |
| |
| static public void printTimings(double[][] timings, Normalization norm) { |
| System.out.println(); |
| System.out.printf("%-7s A B C D E" + |
| " F G H\n", |
| (norm == Normalization.NONE) ? "(usec)" : "(ratio)"); |
| System.out.println(" -------- -------- -------- -------- " + |
| "-------- -------- -------- --------"); |
| |
| double bases[] = new double[BODIES]; |
| for (int i = 0; i < BODIES; i++) { |
| double n; |
| switch (norm) { |
| case PER_COLUMN: n = timings[i][0]; break; |
| case TOP_LEFT: n = timings[0][0]; break; |
| default /*NONE*/: n = 1.0; break; |
| } |
| bases[i] = n; |
| } |
| |
| for (int i = 0; i < LOOPS; i++) { |
| System.out.printf("%4d: %8.3g %8.3g %8.3g %8.3g %8.3g %8.3g " + |
| "%8.3g %8.3g\n", |
| i, |
| timings[0][i] / bases[0], |
| timings[1][i] / bases[1], |
| timings[2][i] / bases[2], |
| timings[3][i] / bases[3], |
| timings[4][i] / bases[4], |
| timings[5][i] / bases[5], |
| timings[6][i] / bases[6], |
| timings[7][i] / bases[7]); |
| } |
| } |
| |
| static public void run(boolean timing, int iters) { |
| double[][] timings = null; // assign to avoid apparent javac bug |
| |
| // Try up to 5 times to get good times. |
| for (int i = 0; i < 5; i++) { |
| double[][] newTimings = runAllTests(iters, timing || (i == 0)); |
| |
| if (timings == null) { |
| timings = newTimings; |
| } else { |
| combineTimings(timings, newTimings, i); |
| } |
| |
| if (checkTimes(timings, timing)) { |
| break; |
| } |
| } |
| |
| System.out.println("Done with runs."); |
| |
| boolean goodTimes = checkTimes(timings, true); |
| |
| if (! goodTimes) { |
| timing = true; |
| } |
| |
| if (timing) { |
| printTimings(timings, Normalization.NONE); |
| printTimings(timings, Normalization.TOP_LEFT); |
| printTimings(timings, Normalization.PER_COLUMN); |
| } else { |
| System.out.println("\nAll times are within the expected ranges."); |
| } |
| } |
| |
| static public void combineTimings(double[][] target, double[][] newTimes, |
| int oldWeight) { |
| for (int i = 0; i < target.length; i++) { |
| for (int j = 0; j < target[i].length; j++) { |
| target[i][j] = |
| ((target[i][j] * oldWeight) + newTimes[i][j]) |
| / (oldWeight + 1); |
| } |
| } |
| } |
| |
| static public boolean checkTimes(double[][] timings, boolean print) { |
| // expected increase over A1 |
| double[][] expected = { |
| { 1.0, 2.3, 2.4, 3.3, 6.5, 12.0, 57.0, 94.0 }, |
| { 1.2, 2.4, 2.5, 3.4, 6.6, 12.2, 60.0, 95.0 }, |
| { 1.5, 2.6, 2.9, 3.5, 6.7, 12.4, 63.0, 96.0 }, |
| { 1.6, 2.8, 2.9, 3.6, 6.8, 12.6, 63.5, 97.0 }, |
| { 1.7, 3.0, 2.9, 3.7, 6.9, 12.8, 64.0, 98.0 }, |
| { 6.0, 6.0, 6.0, 7.0, 10.0, 15.0, 64.5, 105.0 }, |
| { 31.0, 31.2, 31.5, 34.0, 41.0, 43.0, 91.0, 135.0 }, |
| }; |
| |
| boolean good = true; |
| |
| for (int x = 0; x < BODIES; x++) { |
| for (int y = 0; y < LOOPS; y++) { |
| double ratio = timings[x][y] / timings[0][0]; |
| if (ratio > expected[y][x]) { |
| if (print) { |
| System.out.printf("%c%d is too slow: %.3g vs. %.3g\n", |
| (char) (x + 'A'), y, ratio, expected[y][x]); |
| } |
| good = false; |
| } |
| } |
| } |
| |
| return good; |
| } |
| |
| static public double[][] runAllTests(int iters, boolean print) { |
| // diters is used to get usec, not nanosec; hence the extra 1000. |
| double diters = (double) iters * INNER_COUNT * 1000; |
| |
| double[][] timings = new double[BODIES][LOOPS]; |
| long t0, t1, t2, t3, t4, t5, t6, t7; |
| |
| // Column A |
| |
| if (print) { |
| System.out.println("Running A..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testA0(iters); |
| t1 = System.nanoTime(); |
| testA1(iters); |
| t2 = System.nanoTime(); |
| testA2(iters); |
| t3 = System.nanoTime(); |
| testA3(iters); |
| t4 = System.nanoTime(); |
| testA4(iters); |
| t5 = System.nanoTime(); |
| testA5(iters); |
| t6 = System.nanoTime(); |
| testA6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[0][0] = (t1 - t0) / diters; |
| timings[0][1] = (t2 - t1) / diters; |
| timings[0][2] = (t3 - t2) / diters; |
| timings[0][3] = (t4 - t3) / diters; |
| timings[0][4] = (t5 - t4) / diters; |
| timings[0][5] = (t6 - t5) / diters; |
| timings[0][6] = (t7 - t6) / diters; |
| |
| // Column B |
| |
| if (print) { |
| System.out.println("Running B..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testB0(iters); |
| t1 = System.nanoTime(); |
| testB1(iters); |
| t2 = System.nanoTime(); |
| testB2(iters); |
| t3 = System.nanoTime(); |
| testB3(iters); |
| t4 = System.nanoTime(); |
| testB4(iters); |
| t5 = System.nanoTime(); |
| testB5(iters); |
| t6 = System.nanoTime(); |
| testB6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[1][0] = (t1 - t0) / diters; |
| timings[1][1] = (t2 - t1) / diters; |
| timings[1][2] = (t3 - t2) / diters; |
| timings[1][3] = (t4 - t3) / diters; |
| timings[1][4] = (t5 - t4) / diters; |
| timings[1][5] = (t6 - t5) / diters; |
| timings[1][6] = (t7 - t6) / diters; |
| |
| // Column C |
| |
| if (print) { |
| System.out.println("Running C..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testC0(iters); |
| t1 = System.nanoTime(); |
| testC1(iters); |
| t2 = System.nanoTime(); |
| testC2(iters); |
| t3 = System.nanoTime(); |
| testC3(iters); |
| t4 = System.nanoTime(); |
| testC4(iters); |
| t5 = System.nanoTime(); |
| testC5(iters); |
| t6 = System.nanoTime(); |
| testC6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[2][0] = (t1 - t0) / diters; |
| timings[2][1] = (t2 - t1) / diters; |
| timings[2][2] = (t3 - t2) / diters; |
| timings[2][3] = (t4 - t3) / diters; |
| timings[2][4] = (t5 - t4) / diters; |
| timings[2][5] = (t6 - t5) / diters; |
| timings[2][6] = (t7 - t6) / diters; |
| |
| // Column D |
| |
| if (print) { |
| System.out.println("Running D..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testD0(iters); |
| t1 = System.nanoTime(); |
| testD1(iters); |
| t2 = System.nanoTime(); |
| testD2(iters); |
| t3 = System.nanoTime(); |
| testD3(iters); |
| t4 = System.nanoTime(); |
| testD4(iters); |
| t5 = System.nanoTime(); |
| testD5(iters); |
| t6 = System.nanoTime(); |
| testD6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[3][0] = (t1 - t0) / diters; |
| timings[3][1] = (t2 - t1) / diters; |
| timings[3][2] = (t3 - t2) / diters; |
| timings[3][3] = (t4 - t3) / diters; |
| timings[3][4] = (t5 - t4) / diters; |
| timings[3][5] = (t6 - t5) / diters; |
| timings[3][6] = (t7 - t6) / diters; |
| |
| // Column E |
| |
| if (print) { |
| System.out.println("Running E..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testE0(iters); |
| t1 = System.nanoTime(); |
| testE1(iters); |
| t2 = System.nanoTime(); |
| testE2(iters); |
| t3 = System.nanoTime(); |
| testE3(iters); |
| t4 = System.nanoTime(); |
| testE4(iters); |
| t5 = System.nanoTime(); |
| testE5(iters); |
| t6 = System.nanoTime(); |
| testE6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[4][0] = (t1 - t0) / diters; |
| timings[4][1] = (t2 - t1) / diters; |
| timings[4][2] = (t3 - t2) / diters; |
| timings[4][3] = (t4 - t3) / diters; |
| timings[4][4] = (t5 - t4) / diters; |
| timings[4][5] = (t6 - t5) / diters; |
| timings[4][6] = (t7 - t6) / diters; |
| |
| // Column F |
| |
| if (print) { |
| System.out.println("Running F..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testF0(iters); |
| t1 = System.nanoTime(); |
| testF1(iters); |
| t2 = System.nanoTime(); |
| testF2(iters); |
| t3 = System.nanoTime(); |
| testF3(iters); |
| t4 = System.nanoTime(); |
| testF4(iters); |
| t5 = System.nanoTime(); |
| testF5(iters); |
| t6 = System.nanoTime(); |
| testF6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[5][0] = (t1 - t0) / diters; |
| timings[5][1] = (t2 - t1) / diters; |
| timings[5][2] = (t3 - t2) / diters; |
| timings[5][3] = (t4 - t3) / diters; |
| timings[5][4] = (t5 - t4) / diters; |
| timings[5][5] = (t6 - t5) / diters; |
| timings[5][6] = (t7 - t6) / diters; |
| |
| // Reduce the iters for the last two, since they're much slower. |
| |
| iters /= 5; |
| diters /= 5; |
| |
| // Column G |
| |
| if (print) { |
| System.out.println("Running G..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testG0(iters); |
| t1 = System.nanoTime(); |
| testG1(iters); |
| t2 = System.nanoTime(); |
| testG2(iters); |
| t3 = System.nanoTime(); |
| testG3(iters); |
| t4 = System.nanoTime(); |
| testG4(iters); |
| t5 = System.nanoTime(); |
| testG5(iters); |
| t6 = System.nanoTime(); |
| testG6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[6][0] = (t1 - t0) / diters; |
| timings[6][1] = (t2 - t1) / diters; |
| timings[6][2] = (t3 - t2) / diters; |
| timings[6][3] = (t4 - t3) / diters; |
| timings[6][4] = (t5 - t4) / diters; |
| timings[6][5] = (t6 - t5) / diters; |
| timings[6][6] = (t7 - t6) / diters; |
| |
| // Column H |
| |
| if (print) { |
| System.out.println("Running H..."); |
| } |
| |
| t0 = System.nanoTime(); |
| testH0(iters); |
| t1 = System.nanoTime(); |
| testH1(iters); |
| t2 = System.nanoTime(); |
| testH2(iters); |
| t3 = System.nanoTime(); |
| testH3(iters); |
| t4 = System.nanoTime(); |
| testH4(iters); |
| t5 = System.nanoTime(); |
| testH5(iters); |
| t6 = System.nanoTime(); |
| testH6(iters); |
| t7 = System.nanoTime(); |
| |
| timings[7][0] = (t1 - t0) / diters; |
| timings[7][1] = (t2 - t1) / diters; |
| timings[7][2] = (t3 - t2) / diters; |
| timings[7][3] = (t4 - t3) / diters; |
| timings[7][4] = (t5 - t4) / diters; |
| timings[7][5] = (t6 - t5) / diters; |
| timings[7][6] = (t7 - t6) / diters; |
| |
| return timings; |
| } |
| |
| // Helper bits and pieces |
| |
| static private final int INNER_COUNT = 100; |
| static private final int[] INNER_ARRAY = new int[INNER_COUNT]; |
| static private final ArrayList<Object> INNER_LIST = |
| new ArrayList<Object>(INNER_COUNT); |
| static private final Target TARGET = new Target(); |
| static private final int ARRAY_BYTES = 8192; |
| static private final byte[] BYTES_1 = new byte[ARRAY_BYTES]; |
| static private final byte[] BYTES_2 = new byte[ARRAY_BYTES]; |
| |
| static { |
| for (int i = 0; i < INNER_COUNT; i++) { |
| INNER_LIST.add(null); |
| } |
| } |
| |
| public static class Target { |
| public int value; |
| public int size = INNER_COUNT; |
| |
| public void simple() { |
| // empty |
| } |
| |
| public int size() { |
| return size; |
| } |
| } |
| |
| // The tests themselves |
| |
| static public void testA0(int iters) { |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testA1(int iters) { |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testA2(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testA3(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testA4(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testA5(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testA6(int iters) { |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| // empty |
| } |
| } |
| } |
| |
| static public void testB0(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testB1(int iters) { |
| Target target = TARGET; |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testB2(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testB3(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testB4(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testB5(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testB6(int iters) { |
| Target target = TARGET; |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| target.value++; |
| } |
| } |
| } |
| |
| static public void testC0(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT - 1; i >= 0; i--) { |
| array[i]++; |
| } |
| } |
| } |
| |
| static public void testC1(int iters) { |
| int[] array = INNER_ARRAY; |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| array[i]++; |
| } |
| } |
| } |
| |
| static public void testC2(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| array[i]++; |
| } |
| } |
| } |
| |
| static public void testC3(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| array[0] = i + 1; |
| } |
| } |
| } |
| |
| static public void testC4(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| array[i]++; |
| } |
| } |
| } |
| |
| static public void testC5(int iters) { |
| int[] array = INNER_ARRAY; |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| array[i]++; |
| } |
| } |
| } |
| |
| static public void testC6(int iters) { |
| int[] array = INNER_ARRAY; |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| array[0]++; |
| } |
| } |
| } |
| |
| static public void testD0(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testD1(int iters) { |
| Target target = TARGET; |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testD2(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testD3(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testD4(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testD5(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testD6(int iters) { |
| Target target = TARGET; |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testE0(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testE1(int iters) { |
| Target target = TARGET; |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testE2(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testE3(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testE4(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testE5(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testE6(int iters) { |
| Target target = TARGET; |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| synchronized (target) { |
| target.simple(); |
| } |
| } |
| } |
| } |
| |
| static public void testF0(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testF1(int iters) { |
| Target target = TARGET; |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testF2(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testF3(int iters) { |
| Target target = TARGET; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testF4(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testF5(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testF6(int iters) { |
| Target target = TARGET; |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| target.simple(); |
| } |
| } |
| } |
| |
| static public void testG0(int iters) { |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testG1(int iters) { |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testG2(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testG3(int iters) { |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testG4(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testG5(int iters) { |
| Target target = TARGET; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testG6(int iters) { |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| new Target(); |
| } |
| } |
| } |
| |
| static public void testH0(int iters) { |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = INNER_COUNT; i > 0; i--) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| |
| static public void testH1(int iters) { |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| int count = INNER_COUNT; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < count; i++) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| |
| static public void testH2(int iters) { |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < array.length; i++) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| |
| static public void testH3(int iters) { |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| int[] array = INNER_ARRAY; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i : array) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| |
| static public void testH4(int iters) { |
| Target target = TARGET; |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size; i++) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| |
| static public void testH5(int iters) { |
| Target target = TARGET; |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (int i = 0; i < target.size(); i++) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| |
| static public void testH6(int iters) { |
| byte[] b1 = BYTES_1; |
| byte[] b2 = BYTES_2; |
| ArrayList<Object> list = INNER_LIST; |
| |
| for (int outer = iters; outer > 0; outer--) { |
| for (Object o : list) { |
| System.arraycopy(b1, 0, b2, 0, ARRAY_BYTES); |
| } |
| } |
| } |
| } |
