Small change to convert from Caliper to JMH.

abersnaze · abersnaze · commit d012a528ed2c · 2014-02-07T00:46:00.000-08:00
diff --git a/build.gradle b/build.gradle
@@ -54,8 +54,7 @@ subprojects {
     }
 
     dependencies {
-        perfCompile 'com.google.caliper:caliper:1.0-beta-1'
-        perfRuntime 'com.sun.jersey:jersey-core:1.11'
+        perfCompile 'org.openjdk.jmh:jmh-core:0.2'
     }
 
     tasks.build { 
diff --git a/rxjava-core/build.gradle b/rxjava-core/build.gradle
@@ -33,13 +33,8 @@ jar {
 }
 
 task time(type:JavaExec) {
-    //sourceSets.metaClass.methods.each { println it }
     classpath = sourceSets.perf.runtimeClasspath
     group 'Application'
     description 'Execute the calipser benchmark timing of Rx'
     main 'rx.operators.ObservableBenchmark'
-    // args '--print-config' // dump the caliper configuration before starting
-    // args '--verbose' // uncomment to have caliper log what it's doing
-    args '--trials=1' // only run the experiments once
-    //args '--time-limit=0' // experiments never timeout
 }
diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
@@ -3,51 +3,59 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.util.functions.Func1;
 
-import com.google.caliper.Benchmark;
-import com.google.caliper.runner.CaliperMain;
+public class ObservableBenchmark {
 
-public class ObservableBenchmark extends Benchmark {
-    public void timeBaseline(int reps) {
-        for (int i = 0; i < reps; i++) {
-            observableOfInts.subscribe(newObserver());
-        }
+    @GenerateMicroBenchmark
+    public void timeBaseline() {
+        observableOfInts.subscribe(newObserver());
         awaitAllObservers();
     }
 
-    public int timeMapIterate(long reps) {
+    @GenerateMicroBenchmark
+    public int timeMapIterate() {
         int x = 0;
-        for (int i = 0; i < reps; i++) {
-            for (int j = 0; j < intValues.length; j++) {
-                // use hash code to make sure the JIT doesn't optimize too much and remove all of
-                // our code.
-                x |= ident.call(intValues[j]).hashCode();
-            }
+        for (int j = 0; j < intValues.length; j++) {
+            // use hash code to make sure the JIT doesn't optimize too much and remove all of
+            // our code.
+            x |= ident.call(intValues[j]).hashCode();
         }
         return x;
     }
 
-    public void timeMap(long reps) {
-        timeOperator(reps, new OperatorMap<Integer, Object>(ident));
+    @GenerateMicroBenchmark
+    public void timeMap() {
+        timeOperator(new OperatorMap<Integer, Object>(ident));
     }
 
     /**************************************************************************
      * Below is internal stuff to avoid object allocation and time overhead of anything that isn't
      * being tested.
+     * 
+     * @throws RunnerException
      **************************************************************************/
 
-    public static void main(String[] args) {
-        CaliperMain.main(ObservableBenchmark.class, args);
+    public static void main(String[] args) throws RunnerException {
+        Options opt = new OptionsBuilder()
+                .include(ObservableBenchmark.class.getName()+".*")
+                .forks(1)
+                .build();
+
+        new Runner(opt).run();
     }
 
-    private void timeOperator(long reps, Operator<Object, Integer> op) {
-        for (int i = 0; i < reps; i++) {
-            observableOfInts.lift(op).subscribe(newObserver());
-        }
+    private void timeOperator(Operator<Object, Integer> op) {
+        observableOfInts.lift(op).subscribe(newObserver());
         awaitAllObservers();
     }
 

Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,7 @@ subprojects {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`dependencies {`
`57`		`- perfCompile 'com.google.caliper:caliper:1.0-beta-1'`
`58`		`- perfRuntime 'com.sun.jersey:jersey-core:1.11'`
	`57`	`+ perfCompile 'org.openjdk.jmh:jmh-core:0.2'`
`59`	`58`	`}`
`60`	`59`
`61`	`60`	`tasks.build {`
Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,8 @@ jar {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`task time(type:JavaExec) {`
`36`		`- //sourceSets.metaClass.methods.each { println it }`
`37`	`36`	`classpath = sourceSets.perf.runtimeClasspath`
`38`	`37`	`group 'Application'`
`39`	`38`	`description 'Execute the calipser benchmark timing of Rx'`
`40`	`39`	`main 'rx.operators.ObservableBenchmark'`
`41`		`- // args '--print-config' // dump the caliper configuration before starting`
`42`		`- // args '--verbose' // uncomment to have caliper log what it's doing`
`43`		`- args '--trials=1' // only run the experiments once`
`44`		`- //args '--time-limit=0' // experiments never timeout`
`45`	`40`	`}`