Code execution time questions
 

I have a bit of a problem with some code, it seems that everything i know is wrong. i am trying to clock some code exicution time and the results are puzzling me. i am clocking the difrences in calling a method vs having that method in the code it self, so it does not have make the method call. and i would think the addition of the method call would slow it down, but my results show that it speeds it up, i think adding complexity would add time, but my results say difrent, can any oen look at this code and tell me why i am getting these results?



Here is the code for the main()


int i =0;
while (i++<50000)
System.out.println(i);


long m=0;
testInt1=101;
double result2=0;
start7= System.currentTimeMillis();
while(m++<5000000000l)
result2=convertFahrToCels(testInt1);
stop7 = System.currentTimeMillis();
m=0;
start8= System.currentTimeMillis();
while(m++<5000000000l)
result2=(5 * (testInt1 - 32) / 9);
stop8 = System.currentTimeMillis();



here is the method i am comparing it to:

private static double convertFahrToCels(double fahr)
{
return (5 * (fahr - 32) / 9);
}



When I calculate the run times for the code, the method call is always about 3 times less than having the code in the loop it self. btw I know that java takes a bit to 'get warmed up' so I have a loop at the beginning of my program to warm up the JVM.

~dil

Well, there is always the chance that Java is inlining your method for you. e.g., it notices that your method is only a line long and therefore just places it inside your main loop instead of making the call.

In fact you might want to place each of the loops into it's own program since there is a chance if Java is using the Hot Spot compiler it will have optimized the 2nd loop because of the 1st loop...

Also, which Java version and operating system are you using? Some of the earlier Java versions don't handle timing very well. I think they fixed the timing issues with Java 1.5.

Sorry if this is rambling a bit much but it is late and I'm might not be thinking completely straight.

Also, try wrapping your test while() loop in a loop that will run twice, use the output of the second iteration. Another thing... System.out.println is EXPENSIVE!

i know System.out.println is expensive, that is the warmup loop

i did find an answer, the first 4 numeric variables declared in a method are accessed with a shorter byte code. so the method call had a quicker access to the variables then the other way who's variables are declared far after the first 4

I haven't been coding in a while, but are you using an interpreter? JIT compilers should make both versions use register vars and the code would split hairs.

"First four" should still be implementation dependent (based on jvm and processor), though it may have become a compatibility rule by now.

System.currentTimeMillis() is bugged on Windows systems. At any point it can be inaccurate by 0-20 milliseconds- more if under heavy load or while running on an Athlon 64(this is a seperate bug though) The bug has been documented but not fixed completely. Part of Sun's solution was to include a higher resolution timer in the release of Java 1.5: System.nanoTime()

This is actually a repackage of a debug timer used internally by a few Sun packages, but it works great nonetheless.

If you're still getting erratic results try executing the code using the server VM.

I tried the nano seconds method, and still, I have the same result.

How do I execute using the server VM ?

When launching the VM from command line use "java -server [args...]" instead of "java [args...]".