Monday Jul 13, 2015

A fast overview of Just-In-Time(JIT) Compiler

JIT comes in these flavors:
 C1 (Client compiler) -client option
 C2 (Server compiler)-server option
 -XX:+TieredCompilation - Better decision of compilers.

Common Optimizations done by Just-In-Time (JIT) Compiler do:

 1. Eliminate dead codes and Expression optimization.

 int someCalculation(int x1, int x2, int x3) {
         int res1 = x1+x2;
         int res2 = x1-x2;
         int res3 = x1+x3;
         return (res1+res2)/2; 
 }

will be converted to

int someCalculation(int x1, int x2, int x3) {
	return x1; 
} 

 2. Inline Method

- Substitute body of the method (<35 bytes of JVM bytecode) - This provides the best optimization by JIT - A better inline that C++ 

For Example: 

int compute(int var) { int result; if(var > 5) { result = computeFurther(var); } else { result = 100; } return result; } 

If you call myVal = compute(3); it will get converted into myVal = 100;

 

3. Caching Technique:

Point findMid(Point p1, Point p2) { Point p; p.x = (p1.x + p2.x)/2; p.y = (p1.y + p2.y)/2; return p;

p1.x, p2.x -> It can convert into temp1, temp2 and can be cached.

 

4. Monomorphic dispatch:

public class Birds { private String color; public String getColor() { return color; } } myColor = birds.getColor(); 

If there is no other override of this method, it will convert into

public class Birds { String color; }

mycolor = birds.color; 

 

5. Null Checks Removal:

x = point.x; y = point.y; At JVM it is equivalents to: if(point==null) throw new NullPointerException(); else { x = point.x; y = point.y; }  

But if the code will not throw NullPointer for more than threshold reference, it will remove the if check.

 

6. Threading Optimizations:

- Eliminate locks if monitor is not reachable from other threads - Join adjacent synchronized blocks on the same object

7. Loop Optimizations: 

- Combining loops – Two loops can be combined if taking equivalent time. - Inversion loops – Change while into do-while. (why, just give a javap -c) - Tiling loops – Re-organize loop so that it will fix in cache. 

 

VM Args:

Xint – Interpreter mode Xcomp – Compiled mode Xmixed – Interpreter + Compiler -server → C2 compiler -client → C1 compiler -XX:+TieredCompilation → C1 + C2 (used by 32/64 bit mode) 

 

Logging Options:

-XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation -XX:LogFile=<path to file> -XX:MaxInlineSize=<size> -XX:FreqInlineSize=<size> 

(For more see my last blog)

 

 

Tuesday Jun 03, 2008

Compilation on Fly !

Weeks back, I had a discussion with one of my colleagues on classLoader. Actually his classLoader is not able to perform certain job but then suddenly he asked me about any option in Java from which I can generate class file at runtime. Yes, why not. This is how JSP Compiler,Jasper works. There are some of the older way to do this in previous Java. But from J2SE 6 and onwards, one can do it neatly. 

J2SE 6 has added a package called javax.tools which has some awesome work to do. And the above task is one of it. We are going to use a class call ToolProvider which provides method to locate tools like Compiler :-).

Here I have written a simple code which go ahead and compile all the java files in a given directory at runtime and show the result.

import java.io.\*;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;

public class RuntimeCompilation {

    public static void main(String args[]) throws IOException {
        String dirName = "E:\\\\Program Files\\\\Java\\\\jdk1.6.0\\\\bin\\\\compiler";
        File f = new File(dirName);
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        if (f.isDirectory() == false) {
            System.out.println("Directory is not correct");
        } else {
            String lists[] = f.list();
            for (int i = 0; i < lists.length; i++) {
                if (lists[i].endsWith("java")) {
                    int results = compiler.run(null, null, null, lists[i]);
                    System.out.println("Compiling ..." + lists[i] + "      " + (results == 0));
                }
            }
        }
    }
}
 

I have 4-5 Java files at this location: E:\\Program Files\\Java\\jdk1.6.0\\bin\\compiler. So, simply checked the directory and then list the file and pass it into the compilation process, thats it.Code is not written cleanly but do the basic job :). javax.tools package is quite amazing, have a look !

Wednesday Apr 30, 2008

Compiler Optimization Can cause problem

Last week, I was created a presentation on Multi-threading in Java.
Though this fact, I have covered in presentation but still wanted to
blog on same. In multi-threading world, compiler optimization can cause
serious problems. Just check my small code:

public class NonVolatileProblem extends Thread{

ChangeFlag cf;

public static void main(String[] args) {
ChangeFlag cf = new ChangeFlag();
NonVolatileProblem th1 = new NonVolatileProblem(cf);
NonVolatileProblem th2 = new NonVolatileProblem(cf);

th1.start();
th2.start();

}
public void run() {
cf.method1();
cf.method2();
}

public NonVolatileProblem(ChangeFlag cf) {
this.cf = cf;
}
}

class ChangeFlag {

boolean flag = false;

public void method1() {
flag = false;
try {
Thread.sleep(1000);
} catch(Exception e) { System.out.println("Don't want to be here"); }
if(flag) {
System.out.println("This can be reached ");
}
System.out.println("Value of flag" + flag);
}

public void method2() {
flag = true;
}
}

Check
out the reason in bold. Now if compiler optimize the code and remove
the part of if(flag), thinking of that flag value will always be false.
Then we have a situation here(FBI style of speaking :-D), because other
thread can change its value and can make the flag value true. Just run
this code 5-6 may be 10 times, you will be able to see the SOP
statement "This can be reached". Just for the shake of getting that I
have added sleep statement. Here what I got on my 3rd run of the code :)

Value of flag:false
This can be reached
Value of flag:true

Handling
such type of situation is not difficult, specification says to add a
word volatile before the variable flag which will tell the compiler not
to optimize its code just by seeing some initial value or declaration.

About

Vaibhav Hi, I am Vaibhav Choudhary working in Oracle with JDK team. This blog is all about simple concept of Java, JVM and JavaFX.

Search

Archives
« August 2015
SunMonTueWedThuFriSat
      
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
     
Today