From 86c36061c98ec35d012f35c8a1612b61d96c1fd7 Mon Sep 17 00:00:00 2001 From: Daniel Strmecki Date: Sun, 9 May 2021 11:41:35 +0200 Subject: [PATCH] BAEL-4876: Add more benchmarks --- core-java-modules/core-java-streams-3/pom.xml | 22 +++++++- .../streams/parallel/BenchmarkRunner.java | 9 ++++ .../parallel/DifferentSourceSplitting.java | 20 +++---- .../streams/parallel/MemoryLocalityCosts.java | 52 +++++++++++++++++++ .../streams/parallel/MergingCosts.java | 52 +++++++++++++++++++ .../streams/parallel/SplittingCosts.java | 21 ++++---- 6 files changed, 155 insertions(+), 21 deletions(-) create mode 100644 core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/BenchmarkRunner.java create mode 100644 core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MemoryLocalityCosts.java create mode 100644 core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MergingCosts.java diff --git a/core-java-modules/core-java-streams-3/pom.xml b/core-java-modules/core-java-streams-3/pom.xml index fb525decc3..068d6df74f 100644 --- a/core-java-modules/core-java-streams-3/pom.xml +++ b/core-java-modules/core-java-streams-3/pom.xml @@ -30,12 +30,12 @@ org.openjdk.jmh jmh-core - ${jmh-core.version} + ${jmh.version} org.openjdk.jmh jmh-generator-annprocess - ${jmh-generator.version} + ${jmh.version} test @@ -55,12 +55,30 @@ true + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.8 + 1.8 + + + org.openjdk.jmh + jmh-generator-annprocess + ${jmh.version} + + + + + 1.18.20 3.6.1 + 1.29 diff --git a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/BenchmarkRunner.java b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/BenchmarkRunner.java new file mode 100644 index 0000000000..461d728ad0 --- /dev/null +++ b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/BenchmarkRunner.java @@ -0,0 +1,9 @@ +package com.baeldung.streams.parallel; + +public class BenchmarkRunner { + + public static void main(String[] args) throws Exception { + org.openjdk.jmh.Main.main(args); + } + +} diff --git a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/DifferentSourceSplitting.java b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/DifferentSourceSplitting.java index 37d7d25bf6..3e133c21b1 100644 --- a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/DifferentSourceSplitting.java +++ b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/DifferentSourceSplitting.java @@ -3,10 +3,12 @@ package com.baeldung.streams.parallel; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; +import java.util.concurrent.TimeUnit; import java.util.stream.IntStream; public class DifferentSourceSplitting { @@ -15,37 +17,37 @@ public class DifferentSourceSplitting { private static final List linkedListOfNumbers = new LinkedList<>(); static { - IntStream.rangeClosed(1, 100_000_000).forEach(i -> { + IntStream.rangeClosed(1, 100_000).forEach(i -> { arrayListOfNumbers.add(i); linkedListOfNumbers.add(i); }); } - public static void main(String[] args) throws Exception { - org.openjdk.jmh.Main.main(args); - } - @Benchmark @BenchmarkMode(Mode.AverageTime) - public static void arrayListSequential() { + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void differentSourceArrayListSequential() { arrayListOfNumbers.stream().reduce(0, Integer::sum); } @Benchmark @BenchmarkMode(Mode.AverageTime) - public static void arrayListParallel() { + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void differentSourceArrayListParallel() { arrayListOfNumbers.parallelStream().reduce(0, Integer::sum); } @Benchmark @BenchmarkMode(Mode.AverageTime) - public static void linkedListSequential() { + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void differentSourceLinkedListSequential() { linkedListOfNumbers.stream().reduce(0, Integer::sum); } @Benchmark @BenchmarkMode(Mode.AverageTime) - public static void linkedListParallel() { + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void differentSourceLinkedListParallel() { linkedListOfNumbers.parallelStream().reduce(0, Integer::sum); } diff --git a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MemoryLocalityCosts.java b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MemoryLocalityCosts.java new file mode 100644 index 0000000000..9bb6fcaa81 --- /dev/null +++ b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MemoryLocalityCosts.java @@ -0,0 +1,52 @@ +package com.baeldung.streams.parallel; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; + +import java.util.Arrays; +import java.util.concurrent.TimeUnit; +import java.util.stream.IntStream; + +public class MemoryLocalityCosts { + + private static final int[] intArray = new int[100_000]; + private static final Integer[] integerArray = new Integer[100_000]; + + static { + IntStream.rangeClosed(1, 100_000).forEach(i -> { + intArray[i-1] = i; + integerArray[i-1] = i; + }); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void localityIntArraySequential() { + Arrays.stream(intArray).reduce(0, Integer::sum); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void localityIntArrayParallel() { + Arrays.stream(intArray).parallel().reduce(0, Integer::sum); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void localityIntegerArraySequential() { + Arrays.stream(integerArray).reduce(0, Integer::sum); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void localityIntegerArrayParallel() { + Arrays.stream(integerArray).parallel().reduce(0, Integer::sum); + } + +} diff --git a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MergingCosts.java b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MergingCosts.java new file mode 100644 index 0000000000..7266f6954f --- /dev/null +++ b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/MergingCosts.java @@ -0,0 +1,52 @@ +package com.baeldung.streams.parallel; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +public class MergingCosts { + + private static final List arrayListOfNumbers = new ArrayList<>(); + + static { + IntStream.rangeClosed(1, 100_000).forEach(i -> { + arrayListOfNumbers.add(i); + }); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void mergingCostsSumSequential() { + arrayListOfNumbers.stream().reduce(0, Integer::sum); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void mergingCostsSumParallel() { + arrayListOfNumbers.stream().parallel().reduce(0, Integer::sum); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void mergingCostsGroupingSequential() { + arrayListOfNumbers.stream().collect(Collectors.groupingBy(i -> i % 2 == 0)); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void mergingCostsGroupingParallel() { + arrayListOfNumbers.stream().parallel().collect(Collectors.groupingBy(i -> i % 2 == 0)); + } + +} diff --git a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/SplittingCosts.java b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/SplittingCosts.java index 1f9f7f062b..d1e878df1f 100644 --- a/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/SplittingCosts.java +++ b/core-java-modules/core-java-streams-3/src/main/java/com/baeldung/streams/parallel/SplittingCosts.java @@ -3,24 +3,25 @@ package com.baeldung.streams.parallel; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; + +import java.util.concurrent.TimeUnit; import java.util.stream.IntStream; public class SplittingCosts { - public static void main(String[] args) throws Exception { - org.openjdk.jmh.Main.main(args); + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void sourceSplittingIntStreamSequential() { + IntStream.rangeClosed(1, 100).reduce(0, Integer::sum); } @Benchmark @BenchmarkMode(Mode.AverageTime) - public static void arrayListSequential() { - IntStream.rangeClosed(1, 1_000).reduce(0, Integer::sum); - } - - @Benchmark - @BenchmarkMode(Mode.AverageTime) - public static void arrayListParallel() { - IntStream.rangeClosed(1, 1_000).parallel().reduce(0, Integer::sum); + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public static void sourceSplittingIntStreamParallel() { + IntStream.rangeClosed(1, 100).parallel().reduce(0, Integer::sum); } }