1 /*
2 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package org.openjdk.bench.java.util.stream.ops.value;
24
25 import org.openjdk.bench.java.util.stream.ops.LongAccumulator;
26 import org.openjdk.jmh.annotations.Benchmark;
27 import org.openjdk.jmh.annotations.BenchmarkMode;
28 import org.openjdk.jmh.annotations.Mode;
29 import org.openjdk.jmh.annotations.OutputTimeUnit;
30 import org.openjdk.jmh.annotations.Param;
31 import org.openjdk.jmh.annotations.Scope;
32 import org.openjdk.jmh.annotations.State;
33
34 import java.util.concurrent.TimeUnit;
35 import java.util.stream.LongStream;
36
37 /**
38 * Benchmark for limit() operation.
39 */
40 @BenchmarkMode(Mode.Throughput)
41 @OutputTimeUnit(TimeUnit.SECONDS)
42 @State(Scope.Thread)
43 public class Limit {
44
45 /**
46 * Implementation notes:
47 * - parallel version requires thread-safe sink, we use the same for sequential version for better comparison
48 * - operations are explicit inner classes to untangle unwanted lambda effects
49 * - the tests include:
50 * - return nothing
51 * - return just a single element
52 * - return half
53 * - return all but last element
54 * - return all
55 */
56
57 @Param("100000")
58 private int size;
59
60 @Benchmark
61 public long seq_baseline() {
62 return LongStream.range(0, size)
63 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
64 }
65
66 @Benchmark
67 public long seq_limit0() {
68 return LongStream.range(0, size)
69 .limit(0)
70 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
71 }
72
73 @Benchmark
74 public long seq_limit1() {
75 return LongStream.range(0, size)
76 .limit(1)
77 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
78 }
79
80 @Benchmark
81 public long seq_limitHalf() {
82 return LongStream.range(0, size)
83 .limit(size / 2)
84 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
85 }
86
87 @Benchmark
88 public long seq_limitFull() {
89 return LongStream.range(0, size)
90 .limit(size - 1)
91 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
92 }
93
94 @Benchmark
95 public long seq_limitFullest() {
96 return LongStream.range(0, size)
97 .limit(size)
98 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
99 }
100
101 @Benchmark
102 public long par_baseline() {
103 return LongStream.range(0, size).parallel()
104 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
105 }
106
107 @Benchmark
108 public long par_limit0() {
109 return LongStream.range(0, size).parallel()
110 .limit(0)
111 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
112 }
113
114 @Benchmark
115 public long par_limit1() {
116 return LongStream.range(0, size).parallel()
117 .limit(1)
118 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
119 }
120
121 @Benchmark
122 public long par_limitHalf() {
123 return LongStream.range(0, size).parallel()
124 .limit(size / 2)
125 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
126 }
127
128 @Benchmark
129 public long par_limitFull() {
130 return LongStream.range(0, size).parallel()
131 .limit(size - 1)
132 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
133 }
134
135 @Benchmark
136 public long par_limitFullest() {
137 return LongStream.range(0, size).parallel()
138 .limit(size)
139 .collect(LongAccumulator::new, LongAccumulator::add, LongAccumulator::merge).get();
140 }
141
142 }