A query on a small benchmark test.

Question

I ran a small code snippet from a book I am reading and was surprised by the results. The code calls an empty method and also a method with a variables assignment as the body. I figured the empty method call should have been quicker but it is consistently the other way round. Here is the code I ran:
class MethodBenchmark extends Benchmark {
    void benchmark() {
         int x = 2+2+2+2+2+2+2;
    //899543099 as above
    //923825235 empty body
    //925611216 empty body
    //884589242 as above
    public static void main(String[] args) {
        int count = 100000000;
        long time = new MethodBenchmark().repeat(count);
        System.out.println(count + " methods in " +
                           time + " nanoseconds");
abstract class Benchmark {
    abstract void benchmark();
    public final long repeat(int count) {
        long start = System.nanoTime();
        for (int i = 0; i < count; i++)
            benchmark();
        return (System.nanoTime() - start);
}What is the reason for this?
By the way this is not a "Java is broke thread" I am sure there is a logical answer to this.

Answer 1

I just came across this on Google.
http://java.sun.com/docs/hotspot/HotSpotFAQ.html#benchmarking_method
Here is an extract
Code is generated into memory and executed from there. The way the code is laid out in memory makes a big difference in the way it executes. In this example on my machine, the loop that claims to call the method is better aligned and so runs faster than the loop that's trying to figure out how long it takes to run an empty loop, so I get negative numbers for methodTime-loopTime.
Which would mean I was running the same code each time, the compiler would have ignored the body because it was dead and I was essential running an empty method body both times, but why the change?
But it also says this
The HotSpot compiler is smart enough not to generate code for dead variables.
In the method above, the local variable is never used, so there's no reason to compute its value. So then the method body is empty again and when the code gets compiled (and inlined, because we removed enough code to make it small enough for inlining) it turns into an empty method again.
I guess an inlined empty method in memory must be quicker than an empty method from the beginning.
Message was edited by:
helloWorld