Debian Codegraph @

src/jmh/java/io/reactivex/rxjava3/core/JustAsyncPerf.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.core;
15
16 import java.util.concurrent.TimeUnit;
17
18 import org.openjdk.jmh.annotations.*;
19 import org.openjdk.jmh.infra.Blackhole;
20
21 import io.reactivex.rxjava3.internal.schedulers.SingleScheduler;
22 import io.reactivex.rxjava3.schedulers.Schedulers;
23
24 @BenchmarkMode(Mode.Throughput)
25 @Warmup(iterations = 5)
26 @Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS)
27 @OutputTimeUnit(TimeUnit.SECONDS)
28 @Fork(value = 1)
29 @State(Scope.Thread)
30 public class JustAsyncPerf {
31
32 Flowable<Integer> subscribeOnFlowable;
33
34 Flowable<Integer> observeOnFlowable;
35
36 Flowable<Integer> pipelineFlowable;
37
38 Observable<Integer> subscribeOnObservable;
39
40 Observable<Integer> observeOnObservable;
41
42 Observable<Integer> pipelineObservable;
43
44 Single<Integer> observeOnSingle;
45
46 Single<Integer> subscribeOnSingle;
47
48 Single<Integer> pipelineSingle;
49
50 Completable observeOnCompletable;
51
52 Completable subscribeOnCompletable;
53
54 Completable pipelineCompletable;
55
56 Maybe<Integer> observeOnMaybe;
57
58 Maybe<Integer> subscribeOnMaybe;
59
60 Maybe<Integer> pipelineMaybe;
61
62 @Setup
63 public void setup() {
64
65 Scheduler s = Schedulers.single();
66
67 Scheduler s2 = new SingleScheduler();
68
69 subscribeOnFlowable = Flowable.just(1).subscribeOn(s);
70
71 observeOnFlowable = Flowable.just(1).observeOn(s);
72
73 pipelineFlowable = Flowable.just(1).subscribeOn(s).observeOn(s2);
74
75 // ----
76
77 subscribeOnObservable = Observable.just(1).subscribeOn(s);
78
79 observeOnObservable = Observable.just(1).observeOn(s);
80
81 pipelineObservable = Observable.just(1).subscribeOn(s).observeOn(s2);
82
83 // ----
84
85 observeOnSingle = Single.just(1).observeOn(s);
86
87 subscribeOnSingle = Single.just(1).subscribeOn(s);
88
89 pipelineSingle = Single.just(1).subscribeOn(s).observeOn(s2);
90
91 // ----
92
93 observeOnCompletable = Completable.complete().observeOn(s);
94
95 subscribeOnCompletable = Completable.complete().subscribeOn(s);
96
97 pipelineCompletable = Completable.complete().subscribeOn(s).observeOn(s2);
98
99 // ----
100
101 observeOnMaybe = Maybe.just(1).observeOn(s);
102
103 subscribeOnMaybe = Maybe.just(1).subscribeOn(s);
104
105 pipelineMaybe = Maybe.just(1).subscribeOn(s).observeOn(s2);
106 }
107
108 @Benchmark
109 public void subscribeOnFlowable(Blackhole bh) {
110 subscribeOnFlowable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
111 }
112
113 @Benchmark
114 public void observeOnFlowable(Blackhole bh) {
115 observeOnFlowable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
116 }
117
118 @Benchmark
119 public void pipelineFlowable(Blackhole bh) {
120 pipelineFlowable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
121 }
122
123 @Benchmark
124 public void subscribeOnObservable(Blackhole bh) {
125 subscribeOnObservable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
126 }
127
128 @Benchmark
129 public void observeOnObservable(Blackhole bh) {
130 observeOnObservable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
131 }
132
133 @Benchmark
134 public void pipelineObservable(Blackhole bh) {
135 pipelineObservable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
136 }
137
138 @Benchmark
139 public void observeOnSingle(Blackhole bh) {
140 observeOnSingle.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
141 }
142
143 @Benchmark
144 public void subscribeOnSingle(Blackhole bh) {
145 subscribeOnSingle.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
146 }
147
148 @Benchmark
149 public void pipelineSingle(Blackhole bh) {
150 pipelineSingle.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
151 }
152
153 @Benchmark
154 public void observeOnCompletable(Blackhole bh) {
155 observeOnCompletable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
156 }
157
158 @Benchmark
159 public void subscribeOnCompletable(Blackhole bh) {
160 subscribeOnCompletable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
161 }
162
163 @Benchmark
164 public void pipelineCompletable(Blackhole bh) {
165 pipelineCompletable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
166 }
167
168 @Benchmark
169 public void observeOnMaybe(Blackhole bh) {
170 observeOnMaybe.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
171 }
172
173 @Benchmark
174 public void subscribeOnMaybe(Blackhole bh) {
175 subscribeOnMaybe.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
176 }
177
178 @Benchmark
179 public void pipelineMaybe(Blackhole bh) {
180 pipelineMaybe.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
181 }
182
183 }