Debian Codegraph @

src/jmh/java/io/reactivex/rxjava3/core/BinaryFlatMapPerf.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.*;
17 import java.util.concurrent.TimeUnit;
18
19 import org.openjdk.jmh.annotations.*;
20 import org.openjdk.jmh.infra.Blackhole;
21 import org.reactivestreams.Publisher;
22
23 import io.reactivex.rxjava3.functions.Function;
24
25 @BenchmarkMode(Mode.Throughput)
26 @Warmup(iterations = 5)
27 @Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS)
28 @OutputTimeUnit(TimeUnit.SECONDS)
29 @Fork(value = 1)
30 @State(Scope.Thread)
31 public class BinaryFlatMapPerf {
32 @Param({ "1", "1000", "1000000" })
33 public int times;
34
35 Flowable<Integer> singleFlatMapPublisher;
36
37 Flowable<Integer> singleFlatMapHidePublisher;
38
39 Flowable<Integer> singleFlattenAsPublisher;
40
41 Flowable<Integer> maybeFlatMapPublisher;
42
43 Flowable<Integer> maybeFlatMapHidePublisher;
44
45 Flowable<Integer> maybeFlattenAsPublisher;
46
47 Flowable<Integer> completableFlatMapPublisher;
48
49 Flowable<Integer> completableFlattenAsPublisher;
50
51 Observable<Integer> singleFlatMapObservable;
52
53 Observable<Integer> singleFlatMapHideObservable;
54
55 Observable<Integer> singleFlattenAsObservable;
56
57 Observable<Integer> maybeFlatMapObservable;
58
59 Observable<Integer> maybeFlatMapHideObservable;
60
61 Observable<Integer> maybeFlattenAsObservable;
62
63 Observable<Integer> completableFlatMapObservable;
64
65 Observable<Integer> completableFlattenAsObservable;
66
67 @Setup
68 public void setup() {
69
70 // --------------------------------------------------------------------------
71
72 final Integer[] array = new Integer[times];
73 Arrays.fill(array, 777);
74
75 final List<Integer> list = Arrays.asList(array);
76
77 final Flowable<Integer> arrayFlowable = Flowable.fromArray(array);
78 final Flowable<Integer> arrayFlowableHide = Flowable.fromArray(array).hide();
79 final Flowable<Integer> listFlowable = Flowable.fromIterable(list);
80
81 final Observable<Integer> arrayObservable = Observable.fromArray(array);
82 final Observable<Integer> arrayObservableHide = Observable.fromArray(array).hide();
83 final Observable<Integer> listObservable = Observable.fromIterable(list);
84
85 // --------------------------------------------------------------------------
86
87 singleFlatMapPublisher = Single.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
88 @Override
89 public Publisher<? extends Integer> apply(Integer v) {
90 return arrayFlowable;
91 }
92 });
93
94 singleFlatMapHidePublisher = Single.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
95 @Override
96 public Publisher<? extends Integer> apply(Integer v) {
97 return arrayFlowableHide;
98 }
99 });
100
101 singleFlattenAsPublisher = Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<? extends Integer>>() {
102 @Override
103 public Iterable<? extends Integer> apply(Integer v) {
104 return list;
105 }
106 });
107
108 maybeFlatMapPublisher = Maybe.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
109 @Override
110 public Publisher<? extends Integer> apply(Integer v) {
111 return arrayFlowable;
112 }
113 });
114
115 maybeFlatMapHidePublisher = Maybe.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
116 @Override
117 public Publisher<? extends Integer> apply(Integer v) {
118 return arrayFlowableHide;
119 }
120 });
121
122 maybeFlattenAsPublisher = Maybe.just(1).flattenAsFlowable(new Function<Integer, Iterable<? extends Integer>>() {
123 @Override
124 public Iterable<? extends Integer> apply(Integer v) {
125 return list;
126 }
127 });
128
129 completableFlatMapPublisher = Completable.complete().andThen(listFlowable);
130
131 completableFlattenAsPublisher = Completable.complete().andThen(arrayFlowable);
132
133 // --------------------------------------------------------------------------
134
135 singleFlatMapObservable = Single.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
136 @Override
137 public Observable<? extends Integer> apply(Integer v) {
138 return arrayObservable;
139 }
140 });
141
142 singleFlatMapHideObservable = Single.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
143 @Override
144 public Observable<? extends Integer> apply(Integer v) {
145 return arrayObservableHide;
146 }
147 });
148
149 singleFlattenAsObservable = Single.just(1).flattenAsObservable(new Function<Integer, Iterable<? extends Integer>>() {
150 @Override
151 public Iterable<? extends Integer> apply(Integer v) {
152 return list;
153 }
154 });
155
156 maybeFlatMapObservable = Maybe.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
157 @Override
158 public Observable<? extends Integer> apply(Integer v) {
159 return arrayObservable;
160 }
161 });
162
163 maybeFlatMapHideObservable = Maybe.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
164 @Override
165 public Observable<? extends Integer> apply(Integer v) {
166 return arrayObservableHide;
167 }
168 });
169
170 maybeFlattenAsObservable = Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<? extends Integer>>() {
171 @Override
172 public Iterable<? extends Integer> apply(Integer v) {
173 return list;
174 }
175 });
176
177 completableFlatMapObservable = Completable.complete().andThen(listObservable);
178
179 completableFlattenAsObservable = Completable.complete().andThen(arrayObservable);
180
181 }
182
183 @Benchmark
184 public void singleFlatMapPublisher(Blackhole bh) {
185 singleFlatMapPublisher.subscribe(new PerfConsumer(bh));
186 }
187
188 @Benchmark
189 public void singleFlatMapHidePublisher(Blackhole bh) {
190 singleFlatMapHidePublisher.subscribe(new PerfConsumer(bh));
191 }
192
193 @Benchmark
194 public void singleFlattenAsPublisher(Blackhole bh) {
195 singleFlattenAsPublisher.subscribe(new PerfConsumer(bh));
196 }
197
198 @Benchmark
199 public void maybeFlatMapPublisher(Blackhole bh) {
200 maybeFlatMapPublisher.subscribe(new PerfConsumer(bh));
201 }
202
203 @Benchmark
204 public void maybeFlatMapHidePublisher(Blackhole bh) {
205 maybeFlatMapHidePublisher.subscribe(new PerfConsumer(bh));
206 }
207
208 @Benchmark
209 public void maybeFlattenAsPublisher(Blackhole bh) {
210 maybeFlattenAsPublisher.subscribe(new PerfConsumer(bh));
211 }
212
213 @Benchmark
214 public void completableFlatMapPublisher(Blackhole bh) {
215 completableFlatMapPublisher.subscribe(new PerfConsumer(bh));
216 }
217
218 @Benchmark
219 public void completableFlattenAsPublisher(Blackhole bh) {
220 completableFlattenAsPublisher.subscribe(new PerfConsumer(bh));
221 }
222
223 @Benchmark
224 public void singleFlatMapObservable(Blackhole bh) {
225 singleFlatMapObservable.subscribe(new PerfConsumer(bh));
226 }
227
228 @Benchmark
229 public void singleFlatMapHideObservable(Blackhole bh) {
230 singleFlatMapHideObservable.subscribe(new PerfConsumer(bh));
231 }
232
233 @Benchmark
234 public void singleFlattenAsObservable(Blackhole bh) {
235 singleFlattenAsObservable.subscribe(new PerfConsumer(bh));
236 }
237
238 @Benchmark
239 public void maybeFlatMapObservable(Blackhole bh) {
240 maybeFlatMapObservable.subscribe(new PerfConsumer(bh));
241 }
242
243 @Benchmark
244 public void maybeFlatMapHideObservable(Blackhole bh) {
245 maybeFlatMapHideObservable.subscribe(new PerfConsumer(bh));
246 }
247
248 @Benchmark
249 public void maybeFlattenAsObservable(Blackhole bh) {
250 maybeFlattenAsObservable.subscribe(new PerfConsumer(bh));
251 }
252
253 @Benchmark
254 public void completableFlatMapObservable(Blackhole bh) {
255 completableFlatMapObservable.subscribe(new PerfConsumer(bh));
256 }
257
258 @Benchmark
259 public void completableFlattenAsObservable(Blackhole bh) {
260 completableFlattenAsObservable.subscribe(new PerfConsumer(bh));
261 }
262 }