Java - Repeated function call reduces execution time

Question

I have this following code

public class BenchMark {
    public static void main(String args[]) {
        doLinear();

        doLinear();

        doLinear(         


        

Answer 1

true execution time

There's no thing like "true execution time". If you need to solve this task only once, the true execution time would be the time of the first test (along with time to startup the JVM itself). In general the time spent for execution of given piece of code depends on many things:

• Whether this piece of code is interpreted, JIT-compiled by C1 or C2 compiler. Note that there are not just three options. If you call one method from another, one of them might be interpreted and another might be C2-compiled.

• For C2 compiler: how this code was executed previously, so what's in branch and type profile. The polluted type profile can drastically reduce the performance.

• Garbage collector state: whether it interrupts the execution or not

• Compilation queue: whether JIT-compiler compiles other code simultaneously (which may slow down the execution of current code)

• The memory layout: how objects located in the memory, how many cache lines should be loaded to access all the necessary data.

• CPU branch predictor state which depends on the previous code execution and may increase or decrease number of branch mispredictions.

And so on and so forth. So even if you measure something in the isolated benchmark, this does not mean that the speed of the same code in the production will be the same. It may differ in the order of magnitude. So before measuring something you should ask yourself why you want to measure this thing. Usually you don't care how long some part of your program is executed. What you usually care is the latency and the throughput of the whole program. So profile the whole program and optimize the slowest parts. Probably the thing you are measuring is not the slowest.