Benchmarking

[Alexey911]

Write benchmarks

[Alexey911]

    @Fork(4)
    @State(Scope.Benchmark)
    @BenchmarkMode(Mode.AverageTime)
    @Warmup(iterations = 30, time = 1, timeUnit = TimeUnit.SECONDS)
    @Measurement(iterations = 4, time = 1, timeUnit = TimeUnit.SECONDS)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public static abstract class BaseLineReadingBenchmark {

        @Param({})
        String path;

        Path nioPath;

        @Setup(Level.Trial)
        public void setUp() {
            nioPath = Paths.get(path);
        }
    }

    public static class LineReaderBenchmark extends BaseLineReadingBenchmark {

        @Benchmark
        public void read(Blackhole bh) {
            new LineReader(nioPath).subscribe(new LineSubscriber(bh));
        }

        @Benchmark
        public void lineCount(Blackhole bh) {
            new LineReader(nioPath).subscribe(new LineCountSubscriber(bh));
        }

        private static class LineSubscriber implements Subscriber<ByteBuffer> {

            private Blackhole blackhole;

            LineSubscriber(Blackhole blackhole) {
                this.blackhole = blackhole;
            }

            @Override
            public void onSubscribe(Subscription s) {
                s.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(ByteBuffer line) {
                blackhole.consume(new String(line.array(), line.position(), line.remaining(), UTF_8));
            }

            @Override
            public void onError(Throwable e) {
                throw new RuntimeException(e);
            }

            @Override
            public void onComplete() {
            }
        }

        private static class LineCountSubscriber implements Subscriber<ByteBuffer> {

            private int count = 0;
            private Blackhole blackhole;

            LineCountSubscriber(Blackhole blackhole) {
                this.blackhole = blackhole;
            }

            @Override
            public void onSubscribe(Subscription s) {
                s.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(ByteBuffer line) {
                ++count;
            }

            @Override
            public void onError(Throwable e) {
                throw new RuntimeException(e);
            }

            @Override
            public void onComplete() {
                blackhole.consume(count);
            }
        }
    }

    public static class DefaultReadBenchmark extends BaseLineReadingBenchmark {

        @Benchmark
        public void read(Blackhole bh) throws IOException {
            try (Stream<String> lines = Files.lines(nioPath, UTF_8)) {
                lines.forEach(bh::consume);
            }
        }

        @Benchmark
        public void parallelRead(Blackhole bh) throws IOException {
            try (Stream<String> lines = Files.lines(nioPath, UTF_8).parallel()) {
                lines.forEach(bh::consume);
            }
        }

        @Benchmark
        public void lineCount(Blackhole bh) throws IOException {
            try (Stream<String> lines = Files.lines(nioPath, UTF_8)) {
                bh.consume(lines.count());
            }
        }

        @Benchmark
        public void parallelLineCount(Blackhole bh) throws IOException {
            try (Stream<String> lines = Files.lines(nioPath, UTF_8).parallel()) {
                bh.consume(lines.count());
            }
        }
    }

[Alexey911]

jmh_output.txt
2MB.txt
8MB.txt

[Alexey911]

LineReaderBenchmark.read 8MB.txt avgt 16 50.193 ± 6.121 ms/op
LineReaderBenchmark.lineCount 8MB.txt avgt 16 12.625 ± 0.351 ms/op
DefaultReadBenchmark.read 8MB.txt avgt 16 49.078 ± 1.741 ms/op
DefaultReadBenchmark.parallelRead 8MB.txt avgt 16 23.462 ± 2.501 ms/op
DefaultReadBenchmark.lineCount 8MB.txt avgt 16 48.354 ± 1.890 ms/op
DefaultReadBenchmark.parallelLineCount 8MB.txt avgt 16 24.316 ± 0.696 ms/op