Does unused variable will impact JIT optimization really? - jvm

Question

Here is an example from [Java performance]:
public static void main(String[] args){
double d;
long start=System.currentTimeMillis();
for (int i=0;i<10;i++){
d=fblImpl1(50);
}
long end=System.currentTimeMillis();
System.out.println("elapsed time :"+(end-start));
}
private static double fblImpl1(int n){
if(n<0) throw new IllegalArgumentException("Must be >0");
if (n==0) return 0d;
if (n==1) return 1d;
double d =fblImpl1(n-2) +fblImpl1(n-1);
if (Double.isInfinite(d)) throw new ArithmeticException("overflow");
return d;
}
The author said the modern JIT will optimize the code like this:
long start=System.currentTimeMillis();
long end=System.currentTimeMillis();
System.out.println("elapsed time :"+(end-start));
Because the program doesn't use the variable "d" in the following.
But in my test, oracle hostspot jdk1.7 doesn't do this optimization, the program need to run a long time to complete.
#Holger, thanks for your reply at first. As according my understand for your words, i modified the code as below :
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
doTest();
}
}
private static void doTest() {
double d;
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
d = fblImpl1(50);
}
long end = System.currentTimeMillis();
System.out.println("elapsed time :" + (end - start));
}
private static double fblImpl1(int n) {
//if (n < 0) throw new IllegalArgumentException("Must be >0");
if (n == 0) return 0d;
if (n == 1) return 1d;
double d = fblImpl1(n - 2) + fblImpl1(n - 1);
//if (Double.isInfinite(d)) throw new ArithmeticException("overflow");
return d;
}
}
But it seems JIT still doesn't apply any optimization as my expected. Is there something wrong?

Answer 1

You don't need to execute main method multiple times since JIT can compile loops that are executed often, so there is no need for 'doTest' method. It seems the problem is in the recursion. The desired effect is easy to get if you replace fblImpl1 with something trivial like sum.
public static void main(String[] args) {
double d;
List<Long> list = new ArrayList<>();
for (int i = 0; i < 50000; i++) {
long start = System.nanoTime();
fblImpl1(20000);
long end = System.nanoTime();
list.add(end - start);
}
for(long z : list) {
System.out.println(z);
}
}
public static double fblImpl1(int n) {
int sum = 0;
for(int i = 0; i < n; i++) {
sum += i;
}
return sum;
}
The following code produces results as follows: first the code is really executed and then you get zeros.
5812
5811
5812
5812
5812
5812
6088
6089
5812
6089
5812
5812
5811
5812
6089
6088
5812
....
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
277
0
0
0
0
0
0
0
0
I executed the code with the following flags:
-XX:+PrintCompilation -XX:-TieredCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining
Tip: don't use SystemCurrentTimeMillis as it's has very bad precision(especially on Windows)