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
24 /*
25 * @test
26 * @summary micro-benchmark correctness mode
27 * @run main IteratorMicroBenchmark iterations=1 size=8 warmup=0
28 */
29
30 import static java.util.stream.Collectors.summingInt;
31 import static java.util.stream.Collectors.toCollection;
32
33 import java.lang.ref.WeakReference;
34 import java.util.ArrayDeque;
35 import java.util.ArrayList;
36 import java.util.Collection;
37 import java.util.Collections;
38 import java.util.Deque;
39 import java.util.Iterator;
40 import java.util.LinkedList;
41 import java.util.List;
42 import java.util.ListIterator;
43 import java.util.PriorityQueue;
44 import java.util.Spliterator;
45 import java.util.Vector;
46 import java.util.concurrent.ArrayBlockingQueue;
47 import java.util.concurrent.ConcurrentLinkedDeque;
48 import java.util.concurrent.ConcurrentLinkedQueue;
49 import java.util.concurrent.CopyOnWriteArrayList;
50 import java.util.concurrent.LinkedBlockingDeque;
51 import java.util.concurrent.LinkedBlockingQueue;
52 import java.util.concurrent.LinkedTransferQueue;
53 import java.util.concurrent.PriorityBlockingQueue;
54 import java.util.concurrent.CountDownLatch;
55 import java.util.concurrent.ThreadLocalRandom;
56 import java.util.concurrent.TimeUnit;
57 import java.util.concurrent.atomic.LongAdder;
58 import java.util.regex.Pattern;
59 import java.util.stream.Stream;
60
61 /**
62 * Usage: [iterations=N] [size=N] [filter=REGEXP] [warmup=SECONDS]
63 *
64 * To run this in micro-benchmark mode, simply run as a normal java program.
65 * Be patient; this program runs for a very long time.
66 * For faster runs, restrict execution using command line args.
67 *
68 * This is an interface based version of ArrayList/IteratorMicroBenchmark
69 *
70 * @author Martin Buchholz
71 */
72 public class IteratorMicroBenchmark {
73 abstract static class Job {
74 private final String name;
75 public Job(String name) { this.name = name; }
76 public String name() { return name; }
77 public abstract void work() throws Throwable;
78 }
79
80 final int iterations;
81 final int size; // number of elements in collections
82 final double warmupSeconds;
83 final long warmupNanos;
84 final Pattern nameFilter; // select subset of Jobs to run
85 final boolean reverse; // reverse order of Jobs
86 final boolean shuffle; // randomize order of Jobs
87
88 IteratorMicroBenchmark(String[] args) {
89 iterations = intArg(args, "iterations", 10_000);
90 size = intArg(args, "size", 1000);
91 warmupSeconds = doubleArg(args, "warmup", 7.0);
92 nameFilter = patternArg(args, "filter");
93 reverse = booleanArg(args, "reverse");
94 shuffle = booleanArg(args, "shuffle");
95
96 warmupNanos = (long) (warmupSeconds * (1000L * 1000L * 1000L));
97 }
98
99 // --------------- GC finalization infrastructure ---------------
100
101 /** No guarantees, but effective in practice. */
102 static void forceFullGc() {
103 CountDownLatch finalizeDone = new CountDownLatch(1);
104 WeakReference<?> ref = new WeakReference<Object>(new Object() {
105 protected void finalize() { finalizeDone.countDown(); }});
106 try {
107 for (int i = 0; i < 10; i++) {
108 System.gc();
109 if (finalizeDone.await(1L, TimeUnit.SECONDS) && ref.get() == null) {
110 System.runFinalization(); // try to pick up stragglers
111 return;
112 }
113 }
114 } catch (InterruptedException unexpected) {
115 throw new AssertionError("unexpected InterruptedException");
116 }
117 throw new AssertionError("failed to do a \"full\" gc");
118 }
119
120 /**
121 * Runs each job for long enough that all the runtime compilers
122 * have had plenty of time to warm up, i.e. get around to
123 * compiling everything worth compiling.
124 * Returns array of average times per job per run.
125 */
126 long[] time0(List<Job> jobs) throws Throwable {
127 final int size = jobs.size();
128 long[] nanoss = new long[size];
129 for (int i = 0; i < size; i++) {
130 if (warmupNanos > 0) forceFullGc();
131 Job job = jobs.get(i);
132 long totalTime;
133 int runs = 0;
134 long startTime = System.nanoTime();
135 do { job.work(); runs++; }
136 while ((totalTime = System.nanoTime() - startTime) < warmupNanos);
137 nanoss[i] = totalTime/runs;
138 }
139 return nanoss;
140 }
141
142 void time(List<Job> jobs) throws Throwable {
143 if (warmupNanos > 0) time0(jobs); // Warm up run
144 final int size = jobs.size();
145 final long[] nanoss = time0(jobs); // Real timing run
146 final long[] milliss = new long[size];
147 final double[] ratios = new double[size];
148
149 final String nameHeader = "Method";
150 final String millisHeader = "Millis";
151 final String ratioHeader = "Ratio";
152
153 int nameWidth = nameHeader.length();
154 int millisWidth = millisHeader.length();
155 int ratioWidth = ratioHeader.length();
194 return (val == null) ? defaultValue : Double.parseDouble(val);
195 }
196
197 private static Pattern patternArg(String[] args, String keyword) {
198 String val = keywordValue(args, keyword);
199 return (val == null) ? null : Pattern.compile(val);
200 }
201
202 private static boolean booleanArg(String[] args, String keyword) {
203 String val = keywordValue(args, keyword);
204 if (val == null || val.equals("false")) return false;
205 if (val.equals("true")) return true;
206 throw new IllegalArgumentException(val);
207 }
208
209 private static void deoptimize(int sum) {
210 if (sum == 42)
211 System.out.println("the answer");
212 }
213
214 private static <T> List<T> asSubList(List<T> list) {
215 return list.subList(0, list.size());
216 }
217
218 private static <T> Iterable<T> backwards(final List<T> list) {
219 return new Iterable<T>() {
220 public Iterator<T> iterator() {
221 return new Iterator<T>() {
222 final ListIterator<T> it = list.listIterator(list.size());
223 public boolean hasNext() { return it.hasPrevious(); }
224 public T next() { return it.previous(); }
225 public void remove() { it.remove(); }};}};
226 }
227
228 // Checks for correctness *and* prevents loop optimizations
229 static class Check {
230 private int sum;
231 public void sum(int sum) {
232 if (this.sum == 0)
233 this.sum = sum;
234 if (this.sum != sum)
235 throw new AssertionError("Sum mismatch");
236 }
237 }
238 volatile Check check = new Check();
239
240 public static void main(String[] args) throws Throwable {
241 new IteratorMicroBenchmark(args).run();
242 }
243
244 void run() throws Throwable {
245 // System.out.printf(
246 // "iterations=%d size=%d, warmup=%1g, filter=\"%s\"%n",
247 // iterations, size, warmupSeconds, nameFilter);
248
249 final ArrayList<Integer> al = new ArrayList<>(size);
250
251 // Populate collections with random data
252 final ThreadLocalRandom rnd = ThreadLocalRandom.current();
253 for (int i = 0; i < size; i++)
254 al.add(rnd.nextInt(size));
255
256 final ArrayDeque<Integer> ad = new ArrayDeque<>(al);
257 final ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<>(al.size());
258 abq.addAll(al);
259
260 // shuffle circular array elements so they wrap
261 for (int i = 0, n = rnd.nextInt(size); i < n; i++) {
262 ad.addLast(ad.removeFirst());
263 abq.add(abq.remove());
264 }
265
266 ArrayList<Job> jobs = Stream.<Collection<Integer>>of(
267 al, ad, abq,
268 new LinkedList<>(al),
269 new PriorityQueue<>(al),
270 new Vector<>(al),
271 new CopyOnWriteArrayList<>(al),
272 new ConcurrentLinkedQueue<>(al),
273 new ConcurrentLinkedDeque<>(al),
274 new LinkedBlockingQueue<>(al),
275 new LinkedBlockingDeque<>(al),
276 new LinkedTransferQueue<>(al),
277 new PriorityBlockingQueue<>(al))
278 .flatMap(x -> jobs(x))
279 .filter(job ->
280 nameFilter == null || nameFilter.matcher(job.name()).find())
281 .collect(toCollection(ArrayList::new));
282
283 if (reverse) Collections.reverse(jobs);
284 if (shuffle) Collections.shuffle(jobs);
285
286 time(jobs);
287 }
288
289 @SafeVarargs @SuppressWarnings("varargs")
290 private <T> Stream<T> concatStreams(Stream<T> ... streams) {
291 return Stream.of(streams).flatMap(s -> s);
292 }
293
294 Stream<Job> jobs(Collection<Integer> x) {
295 return concatStreams(
296 collectionJobs(x),
297 (x instanceof Deque)
298 ? dequeJobs((Deque<Integer>)x)
299 : Stream.empty(),
300 (x instanceof List)
301 ? listJobs((List<Integer>)x)
302 : Stream.empty());
303 }
304
305 Stream<Job> collectionJobs(Collection<Integer> x) {
306 String klazz = x.getClass().getSimpleName();
307 return Stream.of(
308 new Job(klazz + " iterate for loop") {
309 public void work() throws Throwable {
310 for (int i = 0; i < iterations; i++) {
311 int sum = 0;
312 for (Integer n : x)
313 sum += n;
314 check.sum(sum);}}},
315 new Job(klazz + " iterator().forEachRemaining()") {
316 public void work() throws Throwable {
317 int[] sum = new int[1];
318 for (int i = 0; i < iterations; i++) {
319 sum[0] = 0;
320 x.iterator().forEachRemaining(n -> sum[0] += n);
321 check.sum(sum[0]);}}},
322 new Job(klazz + " spliterator().tryAdvance()") {
323 public void work() throws Throwable {
324 int[] sum = new int[1];
325 for (int i = 0; i < iterations; i++) {
326 sum[0] = 0;
328 do {} while (spliterator.tryAdvance(n -> sum[0] += n));
329 check.sum(sum[0]);}}},
330 new Job(klazz + " spliterator().forEachRemaining()") {
331 public void work() throws Throwable {
332 int[] sum = new int[1];
333 for (int i = 0; i < iterations; i++) {
334 sum[0] = 0;
335 x.spliterator().forEachRemaining(n -> sum[0] += n);
336 check.sum(sum[0]);}}},
337 new Job(klazz + " removeIf") {
338 public void work() throws Throwable {
339 int[] sum = new int[1];
340 for (int i = 0; i < iterations; i++) {
341 sum[0] = 0;
342 if (x.removeIf(n -> { sum[0] += n; return false; }))
343 throw new AssertionError();
344 check.sum(sum[0]);}}},
345 new Job(klazz + " contains") {
346 public void work() throws Throwable {
347 int[] sum = new int[1];
348 Object y = new Object() {
349 public boolean equals(Object z) {
350 sum[0] += (int) z; return false; }};
351 for (int i = 0; i < iterations; i++) {
352 sum[0] = 0;
353 if (x.contains(y)) throw new AssertionError();
354 check.sum(sum[0]);}}},
355 new Job(klazz + " remove(Object)") {
356 public void work() throws Throwable {
357 int[] sum = new int[1];
358 Object y = new Object() {
359 public boolean equals(Object z) {
360 sum[0] += (int) z; return false; }};
361 for (int i = 0; i < iterations; i++) {
362 sum[0] = 0;
363 if (x.remove(y)) throw new AssertionError();
364 check.sum(sum[0]);}}},
365 new Job(klazz + " forEach") {
366 public void work() throws Throwable {
367 int[] sum = new int[1];
368 for (int i = 0; i < iterations; i++) {
369 sum[0] = 0;
370 x.forEach(n -> sum[0] += n);
371 check.sum(sum[0]);}}},
372 new Job(klazz + " toArray()") {
373 public void work() throws Throwable {
374 int[] sum = new int[1];
375 for (int i = 0; i < iterations; i++) {
376 sum[0] = 0;
377 for (Object o : x.toArray())
378 sum[0] += (Integer) o;
379 check.sum(sum[0]);}}},
380 new Job(klazz + " toArray(a)") {
381 public void work() throws Throwable {
382 Integer[] a = new Integer[x.size()];
383 int[] sum = new int[1];
429 new Job(klazz + " parallelStream().mapToInt") {
430 public void work() throws Throwable {
431 for (int i = 0; i < iterations; i++) {
432 check.sum(x.parallelStream().mapToInt(e -> e).sum());}}},
433 new Job(klazz + " parallelStream().collect") {
434 public void work() throws Throwable {
435 for (int i = 0; i < iterations; i++) {
436 check.sum(x.parallelStream()
437 .collect(summingInt(e -> e)));}}},
438 new Job(klazz + " parallelStream()::iterator") {
439 public void work() throws Throwable {
440 int[] sum = new int[1];
441 for (int i = 0; i < iterations; i++) {
442 sum[0] = 0;
443 for (Integer o : (Iterable<Integer>) x.parallelStream()::iterator)
444 sum[0] += o;
445 check.sum(sum[0]);}}});
446 }
447
448 Stream<Job> dequeJobs(Deque<Integer> x) {
449 String klazz = x.getClass().getSimpleName();
450 return Stream.of(
451 new Job(klazz + " descendingIterator() loop") {
452 public void work() throws Throwable {
453 for (int i = 0; i < iterations; i++) {
454 int sum = 0;
455 Iterator<Integer> it = x.descendingIterator();
456 while (it.hasNext())
457 sum += it.next();
458 check.sum(sum);}}},
459 new Job(klazz + " descendingIterator().forEachRemaining()") {
460 public void work() throws Throwable {
461 int[] sum = new int[1];
462 for (int i = 0; i < iterations; i++) {
463 sum[0] = 0;
464 x.descendingIterator().forEachRemaining(n -> sum[0] += n);
465 check.sum(sum[0]);}}});
466 }
467
468 Stream<Job> listJobs(List<Integer> x) {
469 String klazz = x.getClass().getSimpleName();
470 return Stream.of(
471 new Job(klazz + " subList toArray()") {
472 public void work() throws Throwable {
473 int size = x.size();
474 for (int i = 0; i < iterations; i++) {
475 int total = Stream.of(x.subList(0, size / 2),
476 x.subList(size / 2, size))
477 .mapToInt(subList -> {
478 int sum = 0;
479 for (Object o : subList.toArray())
480 sum += (Integer) o;
481 return sum; })
482 .sum();
483 check.sum(total);}}},
484 new Job(klazz + " subList toArray(a)") {
485 public void work() throws Throwable {
486 int size = x.size();
487 for (int i = 0; i < iterations; i++) {
488 int total = Stream.of(x.subList(0, size / 2),
489 x.subList(size / 2, size))
490 .mapToInt(subList -> {
491 int sum = 0;
492 Integer[] a = new Integer[subList.size()];
493 for (Object o : subList.toArray(a))
494 sum += (Integer) o;
495 return sum; })
496 .sum();
497 check.sum(total);}}},
498 new Job(klazz + " subList toArray(empty)") {
499 public void work() throws Throwable {
500 int size = x.size();
501 Integer[] empty = new Integer[0];
502 for (int i = 0; i < iterations; i++) {
503 int total = Stream.of(x.subList(0, size / 2),
504 x.subList(size / 2, size))
505 .mapToInt(subList -> {
506 int sum = 0;
507 for (Object o : subList.toArray(empty))
508 sum += (Integer) o;
509 return sum; })
510 .sum();
511 check.sum(total);}}});
512 }
513 }
|
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
24 /*
25 * @test
26 * @summary micro-benchmark correctness mode
27 * @run main IteratorMicroBenchmark iterations=1 size=8 warmup=0
28 */
29
30 import static java.util.stream.Collectors.summingInt;
31 import static java.util.stream.Collectors.toCollection;
32
33 import java.lang.ref.WeakReference;
34 import java.util.ArrayDeque;
35 import java.util.ArrayList;
36 import java.util.Collection;
37 import java.util.Collections;
38 import java.util.Deque;
39 import java.util.HashMap;
40 import java.util.Iterator;
41 import java.util.LinkedList;
42 import java.util.List;
43 import java.util.ListIterator;
44 import java.util.PriorityQueue;
45 import java.util.Spliterator;
46 import java.util.Vector;
47 import java.util.concurrent.ArrayBlockingQueue;
48 import java.util.concurrent.ConcurrentLinkedDeque;
49 import java.util.concurrent.ConcurrentLinkedQueue;
50 import java.util.concurrent.CopyOnWriteArrayList;
51 import java.util.concurrent.LinkedBlockingDeque;
52 import java.util.concurrent.LinkedBlockingQueue;
53 import java.util.concurrent.LinkedTransferQueue;
54 import java.util.concurrent.PriorityBlockingQueue;
55 import java.util.concurrent.CountDownLatch;
56 import java.util.concurrent.ThreadLocalRandom;
57 import java.util.concurrent.TimeUnit;
58 import java.util.concurrent.atomic.LongAdder;
59 import java.util.function.UnaryOperator;
60 import java.util.regex.Pattern;
61 import java.util.stream.Stream;
62
63 /**
64 * Usage: [iterations=N] [size=N] [filter=REGEXP] [warmup=SECONDS]
65 *
66 * To run this in micro-benchmark mode, simply run as a normal java program.
67 * Be patient; this program runs for a very long time.
68 * For faster runs, restrict execution using command line args.
69 *
70 * This is an interface based version of ArrayList/IteratorMicroBenchmark
71 *
72 * @author Martin Buchholz
73 */
74 public class IteratorMicroBenchmark {
75 abstract static class Job {
76 private final String name;
77 public Job(String name) { this.name = name; }
78 public String name() { return name; }
79 public abstract void work() throws Throwable;
80 public void run() {
81 try { work(); }
82 catch (Throwable ex) {
83 // current job cannot always be deduced from stacktrace.
84 throw new RuntimeException("Job failed: " + name(), ex);
85 }
86 }
87 }
88
89 final int iterations;
90 final int size; // number of elements in collections
91 final double warmupSeconds;
92 final long warmupNanos;
93 final Pattern nameFilter; // select subset of Jobs to run
94 final boolean reverse; // reverse order of Jobs
95 final boolean shuffle; // randomize order of Jobs
96
97 IteratorMicroBenchmark(String[] args) {
98 iterations = intArg(args, "iterations", 10_000);
99 size = intArg(args, "size", 1000);
100 warmupSeconds = doubleArg(args, "warmup", 7.0);
101 nameFilter = patternArg(args, "filter");
102 reverse = booleanArg(args, "reverse");
103 shuffle = booleanArg(args, "shuffle");
104
105 warmupNanos = (long) (warmupSeconds * (1000L * 1000L * 1000L));
106 }
107
108 // --------------- GC finalization infrastructure ---------------
109
110 /** No guarantees, but effective in practice. */
111 static void forceFullGc() {
112 CountDownLatch finalizeDone = new CountDownLatch(1);
113 WeakReference<?> ref = new WeakReference<Object>(new Object() {
114 @SuppressWarnings("deprecation")
115 protected void finalize() { finalizeDone.countDown(); }});
116 try {
117 for (int i = 0; i < 10; i++) {
118 System.gc();
119 if (finalizeDone.await(1L, TimeUnit.SECONDS) && ref.get() == null) {
120 System.runFinalization(); // try to pick up stragglers
121 return;
122 }
123 }
124 } catch (InterruptedException unexpected) {
125 throw new AssertionError("unexpected InterruptedException");
126 }
127 throw new AssertionError("failed to do a \"full\" gc");
128 }
129
130 /**
131 * Runs each job for long enough that all the runtime compilers
132 * have had plenty of time to warm up, i.e. get around to
133 * compiling everything worth compiling.
134 * Returns array of average times per job per run.
135 */
136 long[] time0(List<Job> jobs) {
137 final int size = jobs.size();
138 long[] nanoss = new long[size];
139 for (int i = 0; i < size; i++) {
140 if (warmupNanos > 0) forceFullGc();
141 Job job = jobs.get(i);
142 long totalTime;
143 int runs = 0;
144 long startTime = System.nanoTime();
145 do { job.run(); runs++; }
146 while ((totalTime = System.nanoTime() - startTime) < warmupNanos);
147 nanoss[i] = totalTime/runs;
148 }
149 return nanoss;
150 }
151
152 void time(List<Job> jobs) throws Throwable {
153 if (warmupNanos > 0) time0(jobs); // Warm up run
154 final int size = jobs.size();
155 final long[] nanoss = time0(jobs); // Real timing run
156 final long[] milliss = new long[size];
157 final double[] ratios = new double[size];
158
159 final String nameHeader = "Method";
160 final String millisHeader = "Millis";
161 final String ratioHeader = "Ratio";
162
163 int nameWidth = nameHeader.length();
164 int millisWidth = millisHeader.length();
165 int ratioWidth = ratioHeader.length();
204 return (val == null) ? defaultValue : Double.parseDouble(val);
205 }
206
207 private static Pattern patternArg(String[] args, String keyword) {
208 String val = keywordValue(args, keyword);
209 return (val == null) ? null : Pattern.compile(val);
210 }
211
212 private static boolean booleanArg(String[] args, String keyword) {
213 String val = keywordValue(args, keyword);
214 if (val == null || val.equals("false")) return false;
215 if (val.equals("true")) return true;
216 throw new IllegalArgumentException(val);
217 }
218
219 private static void deoptimize(int sum) {
220 if (sum == 42)
221 System.out.println("the answer");
222 }
223
224 private static <T> Iterable<T> backwards(final List<T> list) {
225 return new Iterable<T>() {
226 public Iterator<T> iterator() {
227 return new Iterator<T>() {
228 final ListIterator<T> it = list.listIterator(list.size());
229 public boolean hasNext() { return it.hasPrevious(); }
230 public T next() { return it.previous(); }
231 public void remove() { it.remove(); }};}};
232 }
233
234 // Checks for correctness *and* prevents loop optimizations
235 static class Check {
236 private int sum;
237 public void sum(int sum) {
238 if (this.sum == 0)
239 this.sum = sum;
240 if (this.sum != sum)
241 throw new AssertionError("Sum mismatch");
242 }
243 }
244 volatile Check check = new Check();
245
246 public static void main(String[] args) throws Throwable {
247 new IteratorMicroBenchmark(args).run();
248 }
249
250 HashMap<Class<?>, String> goodClassName = new HashMap<>();
251
252 String goodClassName(Class<?> klazz) {
253 return goodClassName.computeIfAbsent(
254 klazz,
255 k -> {
256 String simple = k.getSimpleName();
257 return (simple.equals("SubList")) // too simple!
258 ? k.getName().replaceFirst(".*\\.", "")
259 : simple;
260 });
261 }
262
263 static List<Integer> makeSubList(List<Integer> list) {
264 final ThreadLocalRandom rnd = ThreadLocalRandom.current();
265 int size = list.size();
266 if (size <= 2) return list.subList(0, size);
267 List<Integer> subList = list.subList(rnd.nextInt(0, 2),
268 size - rnd.nextInt(0, 2));
269 List<Integer> copy = new ArrayList<>(list);
270 subList.clear();
271 subList.addAll(copy);
272 return subList;
273 }
274
275 void run() throws Throwable {
276 final ArrayList<Integer> al = new ArrayList<>(size);
277
278 // Populate collections with random data
279 final ThreadLocalRandom rnd = ThreadLocalRandom.current();
280 for (int i = 0; i < size; i++)
281 al.add(rnd.nextInt(size));
282
283 final ArrayDeque<Integer> ad = new ArrayDeque<>(al);
284 final ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<>(al.size());
285 abq.addAll(al);
286
287 // shuffle circular array elements so they wrap
288 for (int i = 0, n = rnd.nextInt(size); i < n; i++) {
289 ad.addLast(ad.removeFirst());
290 abq.add(abq.remove());
291 }
292
293 ArrayList<Job> jobs = Stream.<Collection<Integer>>of(
294 al, ad, abq,
295 makeSubList(new ArrayList<>(al)),
296 new LinkedList<>(al),
297 makeSubList(new LinkedList<>(al)),
298 new PriorityQueue<>(al),
299 new Vector<>(al),
300 makeSubList(new Vector<>(al)),
301 new CopyOnWriteArrayList<>(al),
302 makeSubList(new CopyOnWriteArrayList<>(al)),
303 new ConcurrentLinkedQueue<>(al),
304 new ConcurrentLinkedDeque<>(al),
305 new LinkedBlockingQueue<>(al),
306 new LinkedBlockingDeque<>(al),
307 new LinkedTransferQueue<>(al),
308 new PriorityBlockingQueue<>(al))
309 .flatMap(x -> jobs(x))
310 .filter(job ->
311 nameFilter == null || nameFilter.matcher(job.name()).find())
312 .collect(toCollection(ArrayList::new));
313
314 if (reverse) Collections.reverse(jobs);
315 if (shuffle) Collections.shuffle(jobs);
316
317 time(jobs);
318 }
319
320 @SafeVarargs @SuppressWarnings("varargs")
321 private <T> Stream<T> concatStreams(Stream<T> ... streams) {
322 return Stream.of(streams).flatMap(s -> s);
323 }
324
325 Stream<Job> jobs(Collection<Integer> x) {
326 return concatStreams(
327 collectionJobs(x),
328
329 (x instanceof Deque)
330 ? dequeJobs((Deque<Integer>)x)
331 : Stream.empty(),
332
333 (x instanceof List)
334 ? listJobs((List<Integer>)x)
335 : Stream.empty());
336 }
337
338 Object sneakyAdder(int[] sneakySum) {
339 return new Object() {
340 public int hashCode() { throw new AssertionError(); }
341 public boolean equals(Object z) {
342 sneakySum[0] += (int) z; return false; }};
343 }
344
345 Stream<Job> collectionJobs(Collection<Integer> x) {
346 final String klazz = goodClassName(x.getClass());
347 return Stream.of(
348 new Job(klazz + " iterate for loop") {
349 public void work() throws Throwable {
350 for (int i = 0; i < iterations; i++) {
351 int sum = 0;
352 for (Integer n : x)
353 sum += n;
354 check.sum(sum);}}},
355 new Job(klazz + " iterator().forEachRemaining()") {
356 public void work() throws Throwable {
357 int[] sum = new int[1];
358 for (int i = 0; i < iterations; i++) {
359 sum[0] = 0;
360 x.iterator().forEachRemaining(n -> sum[0] += n);
361 check.sum(sum[0]);}}},
362 new Job(klazz + " spliterator().tryAdvance()") {
363 public void work() throws Throwable {
364 int[] sum = new int[1];
365 for (int i = 0; i < iterations; i++) {
366 sum[0] = 0;
368 do {} while (spliterator.tryAdvance(n -> sum[0] += n));
369 check.sum(sum[0]);}}},
370 new Job(klazz + " spliterator().forEachRemaining()") {
371 public void work() throws Throwable {
372 int[] sum = new int[1];
373 for (int i = 0; i < iterations; i++) {
374 sum[0] = 0;
375 x.spliterator().forEachRemaining(n -> sum[0] += n);
376 check.sum(sum[0]);}}},
377 new Job(klazz + " removeIf") {
378 public void work() throws Throwable {
379 int[] sum = new int[1];
380 for (int i = 0; i < iterations; i++) {
381 sum[0] = 0;
382 if (x.removeIf(n -> { sum[0] += n; return false; }))
383 throw new AssertionError();
384 check.sum(sum[0]);}}},
385 new Job(klazz + " contains") {
386 public void work() throws Throwable {
387 int[] sum = new int[1];
388 Object sneakyAdder = sneakyAdder(sum);
389 for (int i = 0; i < iterations; i++) {
390 sum[0] = 0;
391 if (x.contains(sneakyAdder)) throw new AssertionError();
392 check.sum(sum[0]);}}},
393 new Job(klazz + " containsAll") {
394 public void work() throws Throwable {
395 int[] sum = new int[1];
396 Collection<Object> sneakyAdderCollection =
397 Collections.singleton(sneakyAdder(sum));
398 for (int i = 0; i < iterations; i++) {
399 sum[0] = 0;
400 if (x.containsAll(sneakyAdderCollection))
401 throw new AssertionError();
402 check.sum(sum[0]);}}},
403 new Job(klazz + " remove(Object)") {
404 public void work() throws Throwable {
405 int[] sum = new int[1];
406 Object sneakyAdder = sneakyAdder(sum);
407 for (int i = 0; i < iterations; i++) {
408 sum[0] = 0;
409 if (x.remove(sneakyAdder)) throw new AssertionError();
410 check.sum(sum[0]);}}},
411 new Job(klazz + " forEach") {
412 public void work() throws Throwable {
413 int[] sum = new int[1];
414 for (int i = 0; i < iterations; i++) {
415 sum[0] = 0;
416 x.forEach(n -> sum[0] += n);
417 check.sum(sum[0]);}}},
418 new Job(klazz + " toArray()") {
419 public void work() throws Throwable {
420 int[] sum = new int[1];
421 for (int i = 0; i < iterations; i++) {
422 sum[0] = 0;
423 for (Object o : x.toArray())
424 sum[0] += (Integer) o;
425 check.sum(sum[0]);}}},
426 new Job(klazz + " toArray(a)") {
427 public void work() throws Throwable {
428 Integer[] a = new Integer[x.size()];
429 int[] sum = new int[1];
475 new Job(klazz + " parallelStream().mapToInt") {
476 public void work() throws Throwable {
477 for (int i = 0; i < iterations; i++) {
478 check.sum(x.parallelStream().mapToInt(e -> e).sum());}}},
479 new Job(klazz + " parallelStream().collect") {
480 public void work() throws Throwable {
481 for (int i = 0; i < iterations; i++) {
482 check.sum(x.parallelStream()
483 .collect(summingInt(e -> e)));}}},
484 new Job(klazz + " parallelStream()::iterator") {
485 public void work() throws Throwable {
486 int[] sum = new int[1];
487 for (int i = 0; i < iterations; i++) {
488 sum[0] = 0;
489 for (Integer o : (Iterable<Integer>) x.parallelStream()::iterator)
490 sum[0] += o;
491 check.sum(sum[0]);}}});
492 }
493
494 Stream<Job> dequeJobs(Deque<Integer> x) {
495 String klazz = goodClassName(x.getClass());
496 return Stream.of(
497 new Job(klazz + " descendingIterator() loop") {
498 public void work() throws Throwable {
499 for (int i = 0; i < iterations; i++) {
500 int sum = 0;
501 Iterator<Integer> it = x.descendingIterator();
502 while (it.hasNext())
503 sum += it.next();
504 check.sum(sum);}}},
505 new Job(klazz + " descendingIterator().forEachRemaining()") {
506 public void work() throws Throwable {
507 int[] sum = new int[1];
508 for (int i = 0; i < iterations; i++) {
509 sum[0] = 0;
510 x.descendingIterator().forEachRemaining(n -> sum[0] += n);
511 check.sum(sum[0]);}}});
512 }
513
514 Stream<Job> listJobs(List<Integer> x) {
515 final String klazz = goodClassName(x.getClass());
516 return Stream.of(
517 new Job(klazz + " listIterator forward loop") {
518 public void work() throws Throwable {
519 for (int i = 0; i < iterations; i++) {
520 int sum = 0;
521 ListIterator<Integer> it = x.listIterator();
522 while (it.hasNext())
523 sum += it.next();
524 check.sum(sum);}}},
525 new Job(klazz + " listIterator backward loop") {
526 public void work() throws Throwable {
527 for (int i = 0; i < iterations; i++) {
528 int sum = 0;
529 ListIterator<Integer> it = x.listIterator(x.size());
530 while (it.hasPrevious())
531 sum += it.previous();
532 check.sum(sum);}}},
533 new Job(klazz + " indexOf") {
534 public void work() throws Throwable {
535 int[] sum = new int[1];
536 Object sneakyAdder = sneakyAdder(sum);
537 for (int i = 0; i < iterations; i++) {
538 sum[0] = 0;
539 if (x.indexOf(sneakyAdder) != -1)
540 throw new AssertionError();
541 check.sum(sum[0]);}}},
542 new Job(klazz + " lastIndexOf") {
543 public void work() throws Throwable {
544 int[] sum = new int[1];
545 Object sneakyAdder = sneakyAdder(sum);
546 for (int i = 0; i < iterations; i++) {
547 sum[0] = 0;
548 if (x.lastIndexOf(sneakyAdder) != -1)
549 throw new AssertionError();
550 check.sum(sum[0]);}}},
551 new Job(klazz + " replaceAll") {
552 public void work() throws Throwable {
553 int[] sum = new int[1];
554 UnaryOperator<Integer> sneakyAdder =
555 x -> { sum[0] += x; return x; };
556 for (int i = 0; i < iterations; i++) {
557 sum[0] = 0;
558 x.replaceAll(sneakyAdder);
559 check.sum(sum[0]);}}});
560 }
561 }
|