Debian Codegraph @

src/jmh/java/io/reactivex/rxjava3/core/XMapYPerf.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 = 1, timeUnit = TimeUnit.SECONDS)
28 @OutputTimeUnit(TimeUnit.SECONDS)
29 @Fork(value = 1)
30 @State(Scope.Thread)
31 public class XMapYPerf {
32 @Param({ "1", "10", "100", "1000", "10000", "100000", "1000000" })
33 public int times;
34
35 Flowable<Integer> flowFlatMapIterable1;
36
37 Flowable<Integer> flowFlatMapIterable0;
38
39 Flowable<Integer> flowFlatMapFlowable0;
40
41 Flowable<Integer> flowFlatMapFlowable1;
42
43 Flowable<Integer> flowFlatMapSingle1;
44
45 Flowable<Integer> flowFlatMapMaybe1;
46
47 Flowable<Integer> flowFlatMapMaybe0;
48
49 Completable flowFlatMapCompletable0;
50
51 // oooooooooooooooooooooooooooooooooooooooooo
52
53 Flowable<Integer> flowFlatMapSingleAsFlow1;
54
55 Flowable<Integer> flowFlatMapMaybeAsFlow1;
56
57 Flowable<Integer> flowFlatMapMaybeAsFlow0;
58
59 Flowable<Integer> flowFlatMapCompletableAsFlow0;
60
61 Flowable<Integer> flowFlatMapIterableAsFlow1;
62
63 Flowable<Integer> flowFlatMapIterableAsFlow0;
64
65 // -----------------------------------------------------------------
66
67 Observable<Integer> obsFlatMapIterable0;
68
69 Observable<Integer> obsFlatMapIterable1;
70
71 Observable<Integer> obsFlatMapObservable0;
72
73 Observable<Integer> obsFlatMapObservable1;
74
75 Observable<Integer> obsFlatMapSingle1;
76
77 Observable<Integer> obsFlatMapMaybe1;
78
79 Observable<Integer> obsFlatMapMaybe0;
80
81 Completable obsFlatMapCompletable0;
82
83 // oooooooooooooooooooooooooooooooooooooooooo
84
85 Observable<Integer> obsFlatMapSingleAsObs1;
86
87 Observable<Integer> obsFlatMapMaybeAsObs1;
88
89 Observable<Integer> obsFlatMapMaybeAsObs0;
90
91 Observable<Integer> obsFlatMapCompletableAsObs0;
92
93 Observable<Integer> obsFlatMapIterableAsObs1;
94
95 Observable<Integer> obsFlatMapIterableAsObs0;
96
97 @Setup
98 public void setup() {
99 Integer[] values = new Integer[times];
100 Arrays.fill(values, 777);
101
102 Flowable<Integer> fsource = Flowable.fromArray(values);
103
104 flowFlatMapFlowable1 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
105 @Override
106 public Publisher<Integer> apply(Integer v) {
107 return Flowable.just(v);
108 }
109 });
110
111 flowFlatMapFlowable0 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
112 @Override
113 public Publisher<Integer> apply(Integer v) {
114 return Flowable.empty();
115 }
116 });
117
118 flowFlatMapSingle1 = fsource.flatMapSingle(new Function<Integer, SingleSource<Integer>>() {
119 @Override
120 public SingleSource<Integer> apply(Integer v) {
121 return Single.just(v);
122 }
123 });
124
125 flowFlatMapMaybe1 = fsource.flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
126 @Override
127 public MaybeSource<Integer> apply(Integer v) {
128 return Maybe.just(v);
129 }
130 });
131
132 flowFlatMapMaybe0 = fsource.flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
133 @Override
134 public MaybeSource<Integer> apply(Integer v) {
135 return Maybe.empty();
136 }
137 });
138
139 flowFlatMapCompletable0 = fsource.flatMapCompletable(new Function<Integer, CompletableSource>() {
140 @Override
141 public CompletableSource apply(Integer v) {
142 return Completable.complete();
143 }
144 });
145
146 flowFlatMapIterable1 = fsource.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
147 @Override
148 public Iterable<Integer> apply(Integer v) {
149 return Collections.singletonList(v);
150 }
151 });
152
153 flowFlatMapIterable0 = fsource.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
154 @Override
155 public Iterable<Integer> apply(Integer v) {
156 return Collections.emptyList();
157 }
158 });
159
160 flowFlatMapSingle1 = fsource.flatMapSingle(new Function<Integer, SingleSource<Integer>>() {
161 @Override
162 public SingleSource<Integer> apply(Integer v) {
163 return Single.just(v);
164 }
165 });
166
167 flowFlatMapMaybe1 = fsource.flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
168 @Override
169 public MaybeSource<Integer> apply(Integer v) {
170 return Maybe.just(v);
171 }
172 });
173
174 flowFlatMapMaybe0 = fsource.flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
175 @Override
176 public MaybeSource<Integer> apply(Integer v) {
177 return Maybe.empty();
178 }
179 });
180
181 flowFlatMapCompletable0 = fsource.flatMapCompletable(new Function<Integer, CompletableSource>() {
182 @Override
183 public CompletableSource apply(Integer v) {
184 return Completable.complete();
185 }
186 });
187
188 // ooooooooooooooooooooooooo
189
190 flowFlatMapSingleAsFlow1 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
191 @Override
192 public Publisher<Integer> apply(Integer v) {
193 return Single.just(v).toFlowable();
194 }
195 });
196
197 flowFlatMapMaybeAsFlow1 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
198 @Override
199 public Publisher<Integer> apply(Integer v) {
200 return Maybe.just(v).toFlowable();
201 }
202 });
203
204 flowFlatMapMaybeAsFlow0 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
205 @Override
206 public Publisher<Integer> apply(Integer v) {
207 return Maybe.<Integer>empty().toFlowable();
208 }
209 });
210
211 flowFlatMapCompletableAsFlow0 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
212 @Override
213 public Publisher<Integer> apply(Integer v) {
214 return Completable.complete().toFlowable();
215 }
216 });
217
218 flowFlatMapIterableAsFlow1 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
219 @Override
220 public Publisher<Integer> apply(Integer v) {
221 return Flowable.fromIterable(Collections.singletonList(v));
222 }
223 });
224
225 flowFlatMapIterableAsFlow0 = fsource.flatMap(new Function<Integer, Publisher<Integer>>() {
226 @Override
227 public Publisher<Integer> apply(Integer v) {
228 return Flowable.fromIterable(Collections.emptyList());
229 }
230 });
231
232 // -------------------------------------------------------------------
233
234 Observable<Integer> osource = Observable.fromArray(values);
235
236 obsFlatMapObservable1 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
237 @Override
238 public Observable<Integer> apply(Integer v) {
239 return Observable.just(v);
240 }
241 });
242
243 obsFlatMapObservable0 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
244 @Override
245 public Observable<Integer> apply(Integer v) {
246 return Observable.empty();
247 }
248 });
249
250 obsFlatMapSingle1 = osource.flatMapSingle(new Function<Integer, SingleSource<Integer>>() {
251 @Override
252 public SingleSource<Integer> apply(Integer v) {
253 return Single.just(v);
254 }
255 });
256
257 obsFlatMapMaybe1 = osource.flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
258 @Override
259 public MaybeSource<Integer> apply(Integer v) {
260 return Maybe.just(v);
261 }
262 });
263
264 obsFlatMapMaybe0 = osource.flatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
265 @Override
266 public MaybeSource<Integer> apply(Integer v) {
267 return Maybe.empty();
268 }
269 });
270
271 obsFlatMapCompletable0 = osource.flatMapCompletable(new Function<Integer, CompletableSource>() {
272 @Override
273 public CompletableSource apply(Integer v) {
274 return Completable.complete();
275 }
276 });
277
278 obsFlatMapIterable1 = osource.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
279 @Override
280 public Iterable<Integer> apply(Integer v) {
281 return Collections.singletonList(v);
282 }
283 });
284
285 obsFlatMapIterable0 = osource.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
286 @Override
287 public Iterable<Integer> apply(Integer v) {
288 return Collections.emptyList();
289 }
290 });
291
292 // ooooooooooooooooooooooooo
293
294 obsFlatMapSingleAsObs1 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
295 @Override
296 public Observable<Integer> apply(Integer v) {
297 return Single.just(v).toObservable();
298 }
299 });
300
301 obsFlatMapMaybeAsObs1 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
302 @Override
303 public Observable<Integer> apply(Integer v) {
304 return Maybe.just(v).toObservable();
305 }
306 });
307
308 obsFlatMapMaybeAsObs0 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
309 @Override
310 public Observable<Integer> apply(Integer v) {
311 return Maybe.<Integer>empty().toObservable();
312 }
313 });
314
315 obsFlatMapCompletableAsObs0 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
316 @Override
317 public Observable<Integer> apply(Integer v) {
318 return Completable.complete().toObservable();
319 }
320 });
321
322 obsFlatMapIterableAsObs1 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
323 @Override
324 public Observable<Integer> apply(Integer v) {
325 return Observable.fromIterable(Collections.singletonList(v));
326 }
327 });
328
329 obsFlatMapIterableAsObs0 = osource.flatMap(new Function<Integer, Observable<Integer>>() {
330 @Override
331 public Observable<Integer> apply(Integer v) {
332 return Observable.fromIterable(Collections.emptyList());
333 }
334 });
335 }
336
337 @Benchmark
338 public void flowFlatMapIterable1(Blackhole bh) {
339 flowFlatMapIterable1.subscribe(new PerfConsumer(bh));
340 }
341
342 @Benchmark
343 public void flowFlatMapIterable0(Blackhole bh) {
344 flowFlatMapIterable0.subscribe(new PerfConsumer(bh));
345 }
346
347 @Benchmark
348 public void flowFlatMapFlowable0(Blackhole bh) {
349 flowFlatMapFlowable0.subscribe(new PerfConsumer(bh));
350 }
351
352 @Benchmark
353 public void flowFlatMapFlowable1(Blackhole bh) {
354 flowFlatMapFlowable1.subscribe(new PerfConsumer(bh));
355 }
356
357 @Benchmark
358 public void flowFlatMapSingle1(Blackhole bh) {
359 flowFlatMapSingle1.subscribe(new PerfConsumer(bh));
360 }
361
362 @Benchmark
363 public void flowFlatMapMaybe1(Blackhole bh) {
364 flowFlatMapMaybe1.subscribe(new PerfConsumer(bh));
365 }
366
367 @Benchmark
368 public void flowFlatMapMaybe0(Blackhole bh) {
369 flowFlatMapMaybe0.subscribe(new PerfConsumer(bh));
370 }
371
372 @Benchmark
373 public void flowFlatMapCompletable0(Blackhole bh) {
374 flowFlatMapCompletable0.subscribe(new PerfConsumer(bh));
375 }
376
377 // oooooooooooooooooooooooooooooooo
378
379 @Benchmark
380 public void flowFlatMapIterableAsFlow1(Blackhole bh) {
381 flowFlatMapIterableAsFlow1.subscribe(new PerfConsumer(bh));
382 }
383
384 @Benchmark
385 public void flowFlatMapIterableAsFlow0(Blackhole bh) {
386 flowFlatMapIterableAsFlow0.subscribe(new PerfConsumer(bh));
387 }
388
389 @Benchmark
390 public void flowFlatMapSingleAsFlow1(Blackhole bh) {
391 flowFlatMapSingleAsFlow1.subscribe(new PerfConsumer(bh));
392 }
393
394 @Benchmark
395 public void flowFlatMapMaybeAsFlow1(Blackhole bh) {
396 flowFlatMapMaybeAsFlow1.subscribe(new PerfConsumer(bh));
397 }
398
399 @Benchmark
400 public void flowFlatMapMaybeAsFlow0(Blackhole bh) {
401 flowFlatMapMaybeAsFlow0.subscribe(new PerfConsumer(bh));
402 }
403
404 @Benchmark
405 public void flowFlatMapCompletableAsFlow0(Blackhole bh) {
406 flowFlatMapCompletableAsFlow0.subscribe(new PerfConsumer(bh));
407 }
408
409 // --------------------------------------------------------------------------------
410
411 @Benchmark
412 public void obsFlatMapIterable0(Blackhole bh) {
413 obsFlatMapIterable0.subscribe(new PerfConsumer(bh));
414 }
415
416 @Benchmark
417 public void obsFlatMapIterable1(Blackhole bh) {
418 obsFlatMapIterable1.subscribe(new PerfConsumer(bh));
419 }
420
421 @Benchmark
422 public void obsFlatMapObservable0(Blackhole bh) {
423 obsFlatMapObservable0.subscribe(new PerfConsumer(bh));
424 }
425
426 @Benchmark
427 public void obsFlatMapObservable1(Blackhole bh) {
428 obsFlatMapObservable1.subscribe(new PerfConsumer(bh));
429 }
430
431 @Benchmark
432 public void obsFlatMapSingle1(Blackhole bh) {
433 obsFlatMapSingle1.subscribe(new PerfConsumer(bh));
434 }
435
436 @Benchmark
437 public void obsFlatMapMaybe1(Blackhole bh) {
438 obsFlatMapMaybe1.subscribe(new PerfConsumer(bh));
439 }
440
441 @Benchmark
442 public void obsFlatMapMaybe0(Blackhole bh) {
443 obsFlatMapMaybe0.subscribe(new PerfConsumer(bh));
444 }
445
446 @Benchmark
447 public void obsFlatMapCompletable0(Blackhole bh) {
448 obsFlatMapCompletable0.subscribe(new PerfConsumer(bh));
449 }
450
451 // oooooooooooooooooooooooooooooooo
452
453 @Benchmark
454 public void obsFlatMapIterableAsObs1(Blackhole bh) {
455 obsFlatMapIterableAsObs1.subscribe(new PerfConsumer(bh));
456 }
457
458 @Benchmark
459 public void obsFlatMapIterableAsObs0(Blackhole bh) {
460 obsFlatMapIterableAsObs0.subscribe(new PerfConsumer(bh));
461 }
462
463 @Benchmark
464 public void obsFlatMapSingleAsObs1(Blackhole bh) {
465 obsFlatMapSingleAsObs1.subscribe(new PerfConsumer(bh));
466 }
467
468 @Benchmark
469 public void obsFlatMapMaybeAsObs1(Blackhole bh) {
470 obsFlatMapMaybeAsObs1.subscribe(new PerfConsumer(bh));
471 }
472
473 @Benchmark
474 public void obsFlatMapMaybeAsObs0(Blackhole bh) {
475 obsFlatMapMaybeAsObs0.subscribe(new PerfConsumer(bh));
476 }
477
478 @Benchmark
479 public void obsFlatMapCompletableAsObs0(Blackhole bh) {
480 obsFlatMapCompletableAsObs0.subscribe(new PerfConsumer(bh));
481 }
482 }