This is the margin of error for the score. In most cases, that is a half of confidence interval. Think about it as if there is a “±” sign between “Score” and “Score error”. In fact, the human-readable log will show that: Result: 1.986 ±(99.9%) 0.009 ops/ns [Average] Statistics: (min, avg, max) = (1.984, 1.986, … Read more
As noted in your question and in my comment, ZoneRulesProvider.getAvailableZoneIds() creates a new set of all the available time zones’ string representation (the keys of the static final ConcurrentMap<String, ZoneRulesProvider> ZONES) each time a time zone needs to be parsed.1 Fortunately, a ZoneRulesProvider is an abstract class which is designed to be subclassed. The method … Read more
You are measuring empty benchmarks, not empty methods. In other words, measuring the minimal infrastructure code that handles the benchmark itself. This is easy to dissect, because you’d expect only a few instructions on the hot path. JMH’s -prof perfasm or -prof xperfasm would give you those hottest instructions in seconds. I think the effect … Read more
JMH supports the following Benchmark modes: Throughput: operations per unit of time AverageTime: average time per operation SampleTime: samples the time for each operation SingleShotTime: measures the time for a single operation Now you can analyse if higher score is better or not. The default benchmark mode is (Throughput) 1 and in this case higher … Read more
JMH offers the fork functionality for a few reasons. One is compilation profile separation as discussed by Rafael above. But this behaviour is not controlled by the @Forks annotation (unless you choose 0 forks, which means no subprocesses are forked to run benchmarks at all). You can choose to run all the benchmarks as part … Read more
First of all, the problem has nothing to do with the module system (directly). I noticed that even with JDK 9 the first warmup iteration of newInstance was as fast as with JDK 8. # Fork: 1 of 1 # Warmup Iteration 1: 10,578 ns/op <– Fast! # Warmup Iteration 2: 246,426 ns/op # Warmup … Read more
None of the other answers mention the primary reason for the difference in speed, which is that the zipped version avoids 10,000 tuple allocations. As a couple of the other answers do note, the zip version involves an intermediate array, while the zipped version doesn’t, but allocating an array for 10,000 elements isn’t what makes … Read more
I’ve been running JMH inside my existing Maven project using JUnit with no apparent ill effects. I cannot answer why the authors recommend doing things differently. I have not observed a difference in results. JMH launches a separate JVM to run benchmarks to isolate them. Here is what I do: Add the JMH dependencies to … Read more
The JIT will first compile the hot loop that is iterating over and operating (map/reduce) on the array elements. This happens quite early on since the array contains 220 elements. Later on the JIT compiles the pipeline, most likely inlined within the compiled benchmark method, and due to inlining limits fails to compile it all … Read more
String concatenation a + b + c is a very frequent pattern in Java programs, so HotSpot JVM has a special optimization for it: -XX:+OptimizeStringConcat which is ON by default. HotSpot JVM recognizes new StringBuilder().append()…append().toString() pattern in the bytecode and translates it to the optimized machine code without calling actual Java methods and without allocating … Read more