# HG changeset patch
# User shade
# Date 1481889571 -3600
# Node ID adaa1d0e7226d5cbf445f34b3428dfdfaa18d789
# Parent  fca0611bff5230b5997995bf9b4ef71b3ae4bacd
Cut down threads/heap size steps.

diff -r fca0611bff52 -r adaa1d0e7226 src/main/java/org/openjdk/gcbench/GCBench.java
--- a/src/main/java/org/openjdk/gcbench/GCBench.java	Thu Dec 15 23:19:23 2016 +0100
+++ b/src/main/java/org/openjdk/gcbench/GCBench.java	Fri Dec 16 12:59:31 2016 +0100
@@ -73,7 +73,7 @@
                 .withRequiredArg().ofType(Integer.class).describedAs("MB");
 
         OptionSpec<Integer> optMinHeap = parser.accepts("minHeap", "Min heap to be used for tests.")
-                .withRequiredArg().ofType(Integer.class).describedAs("MB").defaultsTo(8192);
+                .withRequiredArg().ofType(Integer.class).describedAs("MB");
 
         OptionSpec<Integer> optMinThreads = parser.accepts("minThreads", "Min threads to be used for tests.")
                 .withRequiredArg().ofType(Integer.class).describedAs("#").defaultsTo(1);
@@ -89,14 +89,6 @@
             return;
         }
 
-        if (set.has(optMaxHeap)) {
-            HeapSizeManager.override(set.valueOf(optMinHeap), set.valueOf(optMaxHeap));
-        } else {
-            pw.println("===== Calibrating max heap size");
-            pw.println();
-            HeapSizeManager.init(set.valueOf(optMinHeap), pw);
-        }
-
         final int MIN_THREADS = set.valueOf(optMinThreads);
         final int MAX_THREADS;
         if (set.has(optMaxThreads)) {
@@ -105,6 +97,28 @@
             MAX_THREADS = Runtime.getRuntime().availableProcessors()*2;
         }
 
+        List<Integer> threads = new ArrayList<>();
+        threads.add(1);
+        threads.add(Runtime.getRuntime().availableProcessors()/2);
+        threads.add(Runtime.getRuntime().availableProcessors());
+        threads.add(Runtime.getRuntime().availableProcessors()*2);
+        threads.removeIf(i -> i < MIN_THREADS || i > MAX_THREADS);
+
+        int minHeap;
+        if (set.has(optMinHeap)) {
+            minHeap = set.valueOf(optMinHeap);
+        } else {
+            minHeap = Runtime.getRuntime().availableProcessors() * 1024; // 1 GB per thread
+        }
+
+        if (set.has(optMaxHeap)) {
+            HeapSizeManager.override(minHeap, set.valueOf(optMaxHeap));
+        } else {
+            pw.println("===== Calibrating max heap size");
+            pw.println();
+            HeapSizeManager.init(minHeap, pw);
+        }
+
         Options opts = new OptionsBuilder()
                 .detectJvmArgs()
                 .threads(Threads.MAX)
@@ -171,20 +185,20 @@
 
             tests.add(new DimensionalTest(baseOpts, org.openjdk.gcbench.alloc.plain.Objects.class,
                     "alloc.peak.object", groupDescr + "Allocates plain Java Objects.",
-                    Dimensions.threads(Sequence.powersOfTwo(MIN_THREADS, MAX_THREADS)),
+                    Dimensions.threads(Sequence.predefined(threads)),
                     Dimensions.heapSize(Sequence.powersOfTwo_WithMax(HeapSizeManager.MIN_HEAP, HeapSizeManager.MAX_HEAP))
             ));
 
             tests.add(new DimensionalTest(baseOpts, org.openjdk.gcbench.alloc.plain.PrimArray.class,
                     "alloc.peak.intarray", groupDescr + "Allocates int[] arrays of different sizes.",
-                    Dimensions.threads(Sequence.powersOfTwo(MIN_THREADS, MAX_THREADS)),
+                    Dimensions.threads(Sequence.predefined(threads)),
                     Dimensions.heapSize(Sequence.powersOfTwo_WithMax(HeapSizeManager.MIN_HEAP, HeapSizeManager.MAX_HEAP)),
                     Dimensions.size(Sequence.powersOfTen(1, 10_000_000))
             ));
 
             tests.add(new DimensionalTest(baseOpts, org.openjdk.gcbench.alloc.plain.RefArray.class,
                     "alloc.peak.refarray", groupDescr + "Allocates Object[] arrays of different sizes.",
-                    Dimensions.threads(Sequence.powersOfTwo(MIN_THREADS, MAX_THREADS)),
+                    Dimensions.threads(Sequence.predefined(threads)),
                     Dimensions.heapSize(Sequence.powersOfTwo_WithMax(HeapSizeManager.MIN_HEAP, HeapSizeManager.MAX_HEAP)),
                     Dimensions.size(Sequence.powersOfTen(1, 10_000_000))
             ));
@@ -197,7 +211,7 @@
 
             tests.add(new DimensionalTest(baseOpts, org.openjdk.gcbench.alloc.uninit.IntArray.class,
                     "alloc.uninit.intarray", groupDescr + "Allocates uninitialized int[] arrays of different sizes.",
-                    Dimensions.threads(Sequence.powersOfTwo(MIN_THREADS, MAX_THREADS)),
+                    Dimensions.threads(Sequence.predefined(threads)),
                     Dimensions.heapSize(Sequence.powersOfTwo_WithMax(HeapSizeManager.MIN_HEAP, HeapSizeManager.MAX_HEAP)),
                     Dimensions.size(Sequence.powersOfTen(1, 10_000))
             ));
diff -r fca0611bff52 -r adaa1d0e7226 src/main/java/org/openjdk/gcbench/tests/Sequence.java
--- a/src/main/java/org/openjdk/gcbench/tests/Sequence.java	Thu Dec 15 23:19:23 2016 +0100
+++ b/src/main/java/org/openjdk/gcbench/tests/Sequence.java	Fri Dec 16 12:59:31 2016 +0100
@@ -4,6 +4,7 @@
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class Sequence implements Iterable<Object> {
 
@@ -57,6 +58,14 @@
         return new Sequence("[" + min + ", " + max + "], step size = " + stepSize, vs);
     }
 
+    public static Sequence predefined(int... values) {
+        return new Sequence(Arrays.toString(values), Arrays.stream(values).boxed().collect(Collectors.toList()));
+    }
+
+    public static Sequence predefined(List<Integer> values) {
+        return new Sequence(values.toString(), new ArrayList<>(values));
+    }
+
     private Sequence(String descr, List<Object> vals) {
         this.descr = descr;
         this.vals = vals;