Updates while validating no major performance and memory regressions

benjchristensen · benjchristensen · commit 4571e92ed5ec · 2014-01-20T21:49:10.000-08:00
diff --git a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java b/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
@@ -49,11 +49,11 @@ public void call() {
      * 
      * --- always with CompositeSubscription():
      * 
-     * Run: 10 - 13,716,405 ops/sec
-     * Run: 11 - 13,920,015 ops/sec
-     * Run: 12 - 14,122,977 ops/sec
-     * Run: 13 - 14,048,534 ops/sec
-     * Run: 14 - 13,824,451 ops/sec
+     * Run: 10 - 15,846,002 ops/sec
+     * Run: 11 - 15,671,181 ops/sec
+     * Run: 12 - 15,401,580 ops/sec
+     * Run: 13 - 15,841,283 ops/sec
+     * Run: 14 - 15,317,970 ops/sec
      */
     public long timeCreateAndSubscribe() {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
@@ -19,9 +19,9 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.timeRepetitionsEmission();
-                    //                    spt.timeTenLongs();
-                    //                    spt.time1000Longs();
+                    //                    spt.timeRepetitionsEmission();
+                    spt.timeTenLongs();
+                    //                                        spt.time1000Longs();
                 }
             });
         } catch (Exception e) {
@@ -114,11 +114,11 @@ public void remove() {
      * 
      * --- New synchronous implementation with OperatorSubscription and unsubscribe support
      * 
-     * Run: 10 - 7,957,006 ops/sec
-     * Run: 11 - 8,017,973 ops/sec
-     * Run: 12 - 8,020,519 ops/sec
-     * Run: 13 - 8,220,250 ops/sec
-     * Run: 14 - 7,770,853 ops/sec
+     * Run: 10 - 8,096,667 ops/sec
+     * Run: 11 - 8,382,131 ops/sec
+     * Run: 12 - 8,256,288 ops/sec
+     * Run: 13 - 8,139,703 ops/sec
+     * Run: 14 - 8,011,023 ops/sec
      */
     public long timeTenLongs() {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
@@ -28,11 +28,11 @@ public void call() {
     /**
      * Observable.from(1L).map((l) -> { l+1})
      * 
-     * Run: 10 - 10,699,215 ops/sec
-     * Run: 11 - 10,554,267 ops/sec
-     * Run: 12 - 10,663,481 ops/sec
-     * Run: 13 - 10,500,032 ops/sec
-     * Run: 14 - 10,556,629 ops/sec
+     * Run: 10 - 11,375,632 ops/sec
+     * Run: 11 - 11,390,325 ops/sec
+     * Run: 12 - 11,655,527 ops/sec
+     * Run: 13 - 11,528,440 ops/sec
+     * Run: 14 - 11,321,181 ops/sec
      */
     public long timeMapPlusOne() {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
@@ -4,6 +4,7 @@
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
 import rx.perf.LongSumObserver;
+import rx.schedulers.Schedulers;
 import rx.util.functions.Action0;
 
 public class OperatorMergePerformance extends AbstractPerformanceTester {
@@ -16,7 +17,7 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.timeRepetitionsEmission();
+                    spt.timeRepetitionsEmissionSynchronous();
                     //                    spt.timeMergeAandBwithSingleItems();
                     //                    spt.timeMergeAandBwith100Items();
                 }
@@ -28,13 +29,13 @@ public void call() {
     }
 
     /**
-     * Run: 10 - 44,561,691 ops/sec
-     * Run: 11 - 44,038,119 ops/sec
-     * Run: 12 - 44,032,689 ops/sec
-     * Run: 13 - 43,390,724 ops/sec
-     * Run: 14 - 44,088,600 ops/sec
+     * Run: 10 - 32,609,617 ops/sec
+     * Run: 11 - 33,511,839 ops/sec
+     * Run: 12 - 34,768,096 ops/sec
+     * Run: 13 - 32,376,499 ops/sec
+     * Run: 14 - 33,166,835 ops/sec
      */
-    public long timeRepetitionsEmission() {
+    public long timeRepetitionsEmissionSynchronous() {
 
         Observable<Long> sA = Observable.from(ITERABLE_OF_REPETITIONS);
         Observable<Long> sB = Observable.from(ITERABLE_OF_REPETITIONS);
@@ -45,6 +46,24 @@ public long timeRepetitionsEmission() {
         return o.sum;
     }
 
+    /**
+     * Run: 10 - 7,911,392,405 ops/sec
+     * Run: 11 - 8,620,689,655 ops/sec
+     * Run: 12 - 8,333,333,333 ops/sec
+     * Run: 13 - 6,775,067,750 ops/sec
+     * Run: 14 - 9,074,410,163 ops/sec
+     */
+    public long timeRepetitionsEmissionConcurrent() {
+
+        Observable<Long> sA = Observable.from(ITERABLE_OF_REPETITIONS).subscribeOn(Schedulers.newThread());
+        Observable<Long> sB = Observable.from(ITERABLE_OF_REPETITIONS).subscribeOn(Schedulers.newThread());
+        Observable<Long> s = Observable.merge(sA, sB);
+
+        LongSumObserver o = new LongSumObserver();
+        s.subscribe(o);
+        return o.sum;
+    }
+
     /**
      * Observable.merge(from(1), from(1))
      * 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
@@ -27,11 +27,11 @@ public void call() {
     /**
      * Observable.range(0, 10).take(5);
      * 
-     * Run: 10 - 8,780,556 ops/sec
-     * Run: 11 - 8,822,590 ops/sec
-     * Run: 12 - 8,842,733 ops/sec
-     * Run: 13 - 8,825,486 ops/sec
-     * Run: 14 - 8,771,545 ops/sec
+     * Run: 10 - 7,936,306 ops/sec
+     * Run: 11 - 8,220,209 ops/sec
+     * Run: 12 - 7,783,276 ops/sec
+     * Run: 13 - 8,435,373 ops/sec
+     * Run: 14 - 7,894,454 ops/sec
      */
     public long timeTake5() {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
@@ -16,8 +16,8 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    //                    spt.timeZipAandBwithSingleItems();
-                    spt.timeZipAandBwith100Items();
+                    spt.timeZipAandBwithSingleItems();
+                    //                    spt.timeZipAandBwith100Items();
                 }
             });
         } catch (Exception e) {
diff --git a/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java
@@ -38,8 +38,8 @@ public static void main(String args[]) {
         usingFunc2(Schedulers.currentThread());
         usingAction0(Schedulers.currentThread());
 
-        usingFunc2(Schedulers.threadPoolForComputation());
-        usingAction0(Schedulers.threadPoolForComputation());
+        usingFunc2(Schedulers.computation());
+        usingAction0(Schedulers.computation());
     }
 
     protected static void usingFunc2(final Scheduler scheduler) {

Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,8 @@ public static void main(String args[]) {`
`38`	`38`	`usingFunc2(Schedulers.currentThread());`
`39`	`39`	`usingAction0(Schedulers.currentThread());`
`40`	`40`
`41`		`- usingFunc2(Schedulers.threadPoolForComputation());`
`42`		`- usingAction0(Schedulers.threadPoolForComputation());`
	`41`	`+ usingFunc2(Schedulers.computation());`
	`42`	`+ usingAction0(Schedulers.computation());`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`protected static void usingFunc2(final Scheduler scheduler) {`