Debian Codegraph @

src/jmh/java/io/reactivex/rxjava3/core/MemoryPerf.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.lang.management.ManagementFactory;
17 import java.util.concurrent.Callable;
18
19 import org.reactivestreams.Subscription;
20
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import io.reactivex.rxjava3.functions.*;
23
24 /**
25 * Measure various prepared flows about their memory usage and print the result
26 * in a JMH compatible format; run {@link #main(String[])}.
27 */
28 public final class MemoryPerf {
29
30 private MemoryPerf() { }
31
32 static long memoryUse() {
33 return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
34 }
35
36 static final class MyRx2Subscriber implements FlowableSubscriber<Object> {
37
38 org.reactivestreams.Subscription upstream;
39
40 @Override
41 public void onSubscribe(Subscription s) {
42 this.upstream = s;
43 }
44
45 @Override
46 public void onComplete() {
47
48 }
49
50 @Override
51 public void onError(Throwable e) {
52
53 }
54
55 @Override
56 public void onNext(Object t) {
57
58 }
59 }
60
61 static final class MyRx2Observer implements io.reactivex.rxjava3.core.Observer<Object>, io.reactivex.rxjava3.core.SingleObserver<Object>,
62 io.reactivex.rxjava3.core.MaybeObserver<Object>, io.reactivex.rxjava3.core.CompletableObserver {
63
64 Disposable upstream;
65
66 @Override
67 public void onSubscribe(Disposable d) {
68 this.upstream = d;
69 }
70
71 @Override
72 public void onComplete() {
73
74 }
75
76 @Override
77 public void onError(Throwable e) {
78
79 }
80
81 @Override
82 public void onNext(Object t) {
83
84 }
85
86 @Override
87 public void onSuccess(Object value) {
88
89 }
90 }
91 static <U> void checkMemory(Callable<U> item, String name, String typeLib) throws Exception {
92 checkMemory(item, name, typeLib, 1000000);
93 }
94
95 static <U> void checkMemory(Callable<U> item, String name, String typeLib, int n) throws Exception {
96 // make sure classes are initialized
97 item.call();
98
99 Object[] array = new Object[n];
100
101 Thread.sleep(100);
102 System.gc();
103 Thread.sleep(100);
104
105 long before = memoryUse();
106
107 for (int i = 0; i < n; i++) {
108 array[i] = item.call();
109 }
110
111 Thread.sleep(100);
112 System.gc();
113 Thread.sleep(100);
114
115 long after = memoryUse();
116
117 double use = Math.max(0.0, (after - before) / 1024.0 / 1024.0);
118
119 System.out.print(name);
120 System.out.print(" ");
121 System.out.print(typeLib);
122 System.out.print(" thrpt ");
123 System.out.print(n);
124 System.out.printf(" %.3f 0.000 MB%n", use);
125
126 if (array.hashCode() == 1) {
127 System.out.print("");
128 }
129
130 array = null;
131 item = null;
132
133 Thread.sleep(100);
134 System.gc();
135 Thread.sleep(100);
136 }
137
138 public static void main(String[] args) throws Exception {
139
140 System.out.println("Benchmark (lib-type) Mode Cnt Score Error Units");
141
142 // ---------------------------------------------------------------------------------------------------------------------
143
144 checkMemory(new Callable<Object>() {
145 @Override
146 public Object call() {
147 return io.reactivex.rxjava3.core.Observable.just(1);
148 }
149 }, "just", "Rx2Observable");
150
151 checkMemory(new Callable<Object>() {
152 @Override
153 public Object call() {
154 return io.reactivex.rxjava3.core.Observable.range(1, 10);
155 }
156 }, "range", "Rx2Observable");
157
158 checkMemory(new Callable<Object>() {
159 @Override
160 public Object call() {
161 return io.reactivex.rxjava3.core.Observable.empty();
162 }
163 }, "empty", "Rx2Observable");
164
165 checkMemory(new Callable<Object>() {
166 @Override
167 public Object call() {
168 return io.reactivex.rxjava3.core.Observable.fromCallable(new Callable<Object>() {
169 @Override
170 public Object call() {
171 return 1;
172 }
173 });
174 }
175 }, "fromCallable", "Rx2Observable");
176
177 checkMemory(new Callable<Object>() {
178 @Override
179 public Object call() {
180 return new MyRx2Observer();
181 }
182 }, "consumer", "Rx2Observable");
183
184 checkMemory(new Callable<Object>() {
185 @Override
186 public Object call() {
187 return new io.reactivex.rxjava3.observers.TestObserver<>();
188 }
189 }, "test-consumer", "Rx2Observable");
190
191 checkMemory(new Callable<Object>() {
192 @Override
193 public Object call() {
194 return io.reactivex.rxjava3.core.Observable.just(1).subscribeWith(new MyRx2Observer());
195 }
196 }, "just+consumer", "Rx2Observable");
197
198 checkMemory(new Callable<Object>() {
199 @Override
200 public Object call() {
201 return io.reactivex.rxjava3.core.Observable.range(1, 10).subscribeWith(new MyRx2Observer());
202 }
203 }, "range+consumer", "Rx2Observable");
204
205 checkMemory(new Callable<Object>() {
206 @Override
207 public Object call() {
208 return io.reactivex.rxjava3.core.Observable.range(1, 10).map(new Function<Integer, Object>() {
209 @Override
210 public Object apply(Integer v) {
211 return v;
212 }
213 }).subscribeWith(new MyRx2Observer());
214 }
215 }, "range+map+consumer", "Rx2Observable");
216
217 checkMemory(new Callable<Object>() {
218 @Override
219 public Object call() {
220 return io.reactivex.rxjava3.core.Observable.range(1, 10).map(new Function<Integer, Object>() {
221 @Override
222 public Object apply(Integer v) {
223 return v;
224 }
225 }).filter(new Predicate<Object>() {
226 @Override
227 public boolean test(Object v) {
228 return true;
229 }
230 }).subscribeWith(new MyRx2Observer());
231 }
232 }, "range+map+filter+consumer", "Rx2Observable");
233
234 checkMemory(new Callable<Object>() {
235 @Override
236 public Object call() {
237 return io.reactivex.rxjava3.core.Observable.range(1, 10).subscribeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).subscribeWith(new MyRx2Observer());
238 }
239 }, "range+subscribeOn+consumer", "Rx2Observable");
240
241 checkMemory(new Callable<Object>() {
242 @Override
243 public Object call() {
244 return io.reactivex.rxjava3.core.Observable.range(1, 10).observeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).subscribeWith(new MyRx2Observer());
245 }
246 }, "range+observeOn+consumer", "Rx2Observable");
247
248 checkMemory(new Callable<Object>() {
249 @Override
250 public Object call() {
251 return io.reactivex.rxjava3.core.Observable.range(1, 10).subscribeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).observeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).subscribeWith(new MyRx2Observer());
252 }
253 }, "range+subscribeOn+observeOn+consumer", "Rx2Observable");
254
255 checkMemory(new Callable<Object>() {
256 @Override
257 public Object call() {
258 return io.reactivex.rxjava3.subjects.AsyncSubject.create();
259 }
260 }, "Async", "Rx2Observable");
261
262 checkMemory(new Callable<Object>() {
263 @Override
264 public Object call() {
265 return io.reactivex.rxjava3.subjects.PublishSubject.create();
266 }
267 }, "Publish", "Rx2Observable");
268
269 checkMemory(new Callable<Object>() {
270 @Override
271 public Object call() {
272 return io.reactivex.rxjava3.subjects.ReplaySubject.create();
273 }
274 }, "Replay", "Rx2Observable");
275
276 checkMemory(new Callable<Object>() {
277 @Override
278 public Object call() {
279 return io.reactivex.rxjava3.subjects.BehaviorSubject.create();
280 }
281 }, "Behavior", "Rx2Observable");
282
283 checkMemory(new Callable<Object>() {
284 @Override
285 public Object call() {
286 return io.reactivex.rxjava3.subjects.UnicastSubject.create();
287 }
288 }, "Unicast", "Rx2Observable");
289
290 checkMemory(new Callable<Object>() {
291 @Override
292 public Object call() {
293 return io.reactivex.rxjava3.subjects.AsyncSubject.create().subscribeWith(new MyRx2Observer());
294 }
295 }, "Async+consumer", "Rx2Observable");
296
297 checkMemory(new Callable<Object>() {
298 @Override
299 public Object call() {
300 return io.reactivex.rxjava3.subjects.PublishSubject.create().subscribeWith(new MyRx2Observer());
301 }
302 }, "Publish+consumer", "Rx2Observable");
303
304 checkMemory(new Callable<Object>() {
305 @Override
306 public Object call() {
307 return io.reactivex.rxjava3.subjects.ReplaySubject.create().subscribeWith(new MyRx2Observer());
308 }
309 }, "Replay+consumer", "Rx2Observable");
310
311 checkMemory(new Callable<Object>() {
312 @Override
313 public Object call() {
314 return io.reactivex.rxjava3.subjects.BehaviorSubject.create().subscribeWith(new MyRx2Observer());
315 }
316 }, "Behavior+consumer", "Rx2Observable");
317
318 checkMemory(new Callable<Object>() {
319 @Override
320 public Object call() {
321 return io.reactivex.rxjava3.subjects.UnicastSubject.create().subscribeWith(new MyRx2Observer());
322 }
323 }, "Unicast+consumer", "Rx2Observable");
324
325 // ---------------------------------------------------------------------------------------------------------------------
326
327 checkMemory(new Callable<Object>() {
328 @Override
329 public Object call() {
330 return io.reactivex.rxjava3.core.Flowable.just(1);
331 }
332 }, "just", "Rx2Flowable");
333
334 checkMemory(new Callable<Object>() {
335 @Override
336 public Object call() {
337 return io.reactivex.rxjava3.core.Flowable.range(1, 10);
338 }
339 }, "range", "Rx2Flowable");
340
341 checkMemory(new Callable<Object>() {
342 @Override
343 public Object call() {
344 return io.reactivex.rxjava3.core.Flowable.empty();
345 }
346 }, "empty", "Rx2Flowable");
347
348 checkMemory(new Callable<Object>() {
349 @Override
350 public Object call() {
351 return io.reactivex.rxjava3.core.Flowable.empty();
352 }
353 }, "empty", "Rx2Flowable", 10000000);
354
355 checkMemory(new Callable<Object>() {
356 @Override
357 public Object call() {
358 return io.reactivex.rxjava3.core.Flowable.fromCallable(new Callable<Object>() {
359 @Override
360 public Object call() {
361 return 1;
362 }
363 });
364 }
365 }, "fromCallable", "Rx2Flowable");
366
367 checkMemory(new Callable<Object>() {
368 @Override
369 public Object call() {
370 return new MyRx2Subscriber();
371 }
372 }, "consumer", "Rx2Flowable");
373
374 checkMemory(new Callable<Object>() {
375 @Override
376 public Object call() {
377 return new io.reactivex.rxjava3.observers.TestObserver<>();
378 }
379 }, "test-consumer", "Rx2Flowable");
380
381 checkMemory(new Callable<Object>() {
382 @Override
383 public Object call() {
384 return io.reactivex.rxjava3.core.Flowable.just(1).subscribeWith(new MyRx2Subscriber());
385 }
386 }, "just+consumer", "Rx2Flowable");
387
388 checkMemory(new Callable<Object>() {
389 @Override
390 public Object call() {
391 return io.reactivex.rxjava3.core.Flowable.range(1, 10).subscribeWith(new MyRx2Subscriber());
392 }
393 }, "range+consumer", "Rx2Flowable");
394
395 checkMemory(new Callable<Object>() {
396 @Override
397 public Object call() {
398 return io.reactivex.rxjava3.core.Flowable.range(1, 10).map(new Function<Integer, Object>() {
399 @Override
400 public Object apply(Integer v) {
401 return v;
402 }
403 }).subscribeWith(new MyRx2Subscriber());
404 }
405 }, "range+map+consumer", "Rx2Flowable");
406
407 checkMemory(new Callable<Object>() {
408 @Override
409 public Object call() {
410 return io.reactivex.rxjava3.core.Flowable.range(1, 10).map(new Function<Integer, Object>() {
411 @Override
412 public Object apply(Integer v) {
413 return v;
414 }
415 }).filter(new Predicate<Object>() {
416 @Override
417 public boolean test(Object v) {
418 return true;
419 }
420 }).subscribeWith(new MyRx2Subscriber());
421 }
422 }, "range+map+filter+consumer", "Rx2Flowable");
423
424 checkMemory(new Callable<Object>() {
425 @Override
426 public Object call() {
427 return io.reactivex.rxjava3.core.Flowable.range(1, 10).subscribeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).subscribeWith(new MyRx2Subscriber());
428 }
429 }, "range+subscribeOn+consumer", "Rx2Flowable");
430
431 checkMemory(new Callable<Object>() {
432 @Override
433 public Object call() {
434 return io.reactivex.rxjava3.core.Flowable.range(1, 10).observeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).subscribeWith(new MyRx2Subscriber());
435 }
436 }, "range+observeOn+consumer", "Rx2Flowable");
437
438 checkMemory(new Callable<Object>() {
439 @Override
440 public Object call() {
441 return io.reactivex.rxjava3.core.Flowable.range(1, 10).subscribeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).observeOn(io.reactivex.rxjava3.schedulers.Schedulers.computation()).subscribeWith(new MyRx2Subscriber());
442 }
443 }, "range+subscribeOn+observeOn+consumer", "Rx2Flowable");
444
445 checkMemory(new Callable<Object>() {
446 @Override
447 public Object call() {
448 return io.reactivex.rxjava3.processors.AsyncProcessor.create();
449 }
450 }, "Async", "Rx2Flowable");
451
452 checkMemory(new Callable<Object>() {
453 @Override
454 public Object call() {
455 return io.reactivex.rxjava3.processors.PublishProcessor.create();
456 }
457 }, "Publish", "Rx2Flowable");
458
459 checkMemory(new Callable<Object>() {
460 @Override
461 public Object call() {
462 return io.reactivex.rxjava3.processors.ReplayProcessor.create();
463 }
464 }, "Replay", "Rx2Flowable");
465
466 checkMemory(new Callable<Object>() {
467 @Override
468 public Object call() {
469 return io.reactivex.rxjava3.processors.BehaviorProcessor.create();
470 }
471 }, "Behavior", "Rx2Flowable");
472
473 checkMemory(new Callable<Object>() {
474 @Override
475 public Object call() {
476 return io.reactivex.rxjava3.processors.UnicastProcessor.create();
477 }
478 }, "Unicast", "Rx2Flowable");
479
480 checkMemory(new Callable<Object>() {
481 @Override
482 public Object call() {
483 return io.reactivex.rxjava3.processors.AsyncProcessor.create().subscribeWith(new MyRx2Subscriber());
484 }
485 }, "Async+consumer", "Rx2Flowable");
486
487 checkMemory(new Callable<Object>() {
488 @Override
489 public Object call() {
490 return io.reactivex.rxjava3.processors.PublishProcessor.create().subscribeWith(new MyRx2Subscriber());
491 }
492 }, "Publish+consumer", "Rx2Flowable");
493
494 checkMemory(new Callable<Object>() {
495 @Override
496 public Object call() {
497 return io.reactivex.rxjava3.processors.ReplayProcessor.create().subscribeWith(new MyRx2Subscriber());
498 }
499 }, "Replay+consumer", "Rx2Flowable");
500
501 checkMemory(new Callable<Object>() {
502 @Override
503 public Object call() {
504 return io.reactivex.rxjava3.processors.BehaviorProcessor.create().subscribeWith(new MyRx2Subscriber());
505 }
506 }, "Behavior+consumer", "Rx2Flowable");
507
508 checkMemory(new Callable<Object>() {
509 @Override
510 public Object call() {
511 return io.reactivex.rxjava3.processors.UnicastProcessor.create().subscribeWith(new MyRx2Subscriber());
512 }
513 }, "Unicast+consumer", "Rx2Flowable");
514
515 // ---------------------------------------------------------------------------------------------------------------------
516 }
517 }