1. P ARALLEL P ROCESSING I NSTITUTE · F UDAN U NIVERSITY 1

2. Outline Motivation Design & Implementation Evaluation Future work 2

3. The popularity of Java The popularity of Java 3 20.299%

4. Java! Java! Architecture neutral Simplified memory management Security and Productivity …… 4 Write Once Run Anywhere How to further improve Java runtime performance?

5. Our Research Leverage the synergy between static and dynamic optimizations Dynamic environment while leveraging static benefits Finding performance opportunities before runtime Static annotation to help runtime optimization 5

6. Opencj Opencj It is our first milestone in the whole project Develop based on Open64 Takes Java source files or Class files as input Outputs executable code for Linux/IA32&x86-64 Compilation process is similar to compiling C/C++ applications 6

7. Outline Outline Motivation Design & Implementation Evaluation Future work 7

8. Design Overview of Opencj Design Overview of Opencj Migrate frontend of gcj into Open64 8

9. Java exception handling Java exception handling Similar to C++ exception, but has some differences, such as  runtime exceptions: a/0, NullPointerException  No “catch-all” handler used in C++  “finally” mechanism, makes Java exception more complex than C++ The key point of Java exception handling is to record the relationship among try/catch/finally blocks. 9

10. Devirtualization Easy to reuse code for programmers but hard to analyze for compiler Resolve java virtual function call to promote indirect call into direct call Class hierarchy analysis and Rapid type analysis Devirtualization is implemented at IPA phase Many optimizations can benefit from this transformation In SciMark 2.0 Java benchmark test, it can resolve all 21 user defined virtual function calls. 10

11. Synchronization elimination Based on Escape Analysis  Flow-insensitive & interprocedural analysis  Connection Graph: captures the connectivity relationship among objects and object references.  Easily determine whether an object is local to a thread.  If a synchronized object is local to a thread, the synchronized operation can be removed 11

12. Building connect graph Only five kinds of statements 1. p = new P() 2. p = return_new_P() 3. p = q 4. p = q.f 5. p.f = q 12

13. Analysis process Analysis process Intra-procedural analysis  Check every call graph node to find out whether there is a synchronized call in a PU  Set initial escape state of each reference node Inter-procedural analysis  Start from main function and traverse the call graph in depth-first order  Pass escape states between caller and callee 13

14. Example 1 Example 1 14 GlobalEscape OutEscape GlobalEscape NoEscape OutEscape

15. Example 1 Example 1 15 GlobalEscape NoEscape GlobalEscape NoEscape

16. Example2 16 GlobalEscape ArgEscape NoEscape GlobalEscape

17. Example2 17 NoEscape GlobalEscape NoEscape

18. Array bounds check elimination Array bounds check elimination Array bounds check to guarantee Java type- safe execution Prevent many useful code optimizations since array bounds check may raise exceptions Fully elimination: if the check never fails Partial elimination: whenever possible, moves bounds check out of loops 18

19. Example of ABCE 19

20. Fully redundant check elimination Example 20 0<=i1<100 jc1

21. Fully redundant check elimination Example 21

22. Partial elimination Partial elimination Adopting loop versioning technique to guarantee the exception semantic for Java Set trigger conditions before and after the optimized loop 22

23. Example Partial redundant check elimination 23

24. Checks elimination of ABCE 24 Total: the total number checks in the test case PRCE: the number of Partial Redundant Check Elimination FRCE: the number of Fully Redundant Check Elimination ABCE: FPCE+PRCE 28.4% speedup in Scimark2 test, lower than we expected

25. Outline Motivation Design & Implementation Evaluation Future work 25

26. Performance gap between Java & C 26 opencj -O3 -IPA -fno-bounds-check opencc -O3 -IPA gcj -O3 -fno-bounds-check -funroll-loops gcc -O3 -funroll-loops higher is better

27. Static compilation vs JIT 27 higher is better Comparing two Java running modes.  Running in JVM  Running executable file directly

28. Static compilation vs JIT 28 lower is better JDK 1.6 is best except mpegaudio More analysis work need to do.

29. Outline Motivation Design & Implementation Evaluation Future work 29

30. Future Trends – for Java Future Trends – for Java Where is Java headed with its dynamic optimization framework:  Exploring opportunities to achieve performance parity with native code  Online profiling mechanisms and feedback- directed optimizations becoming mainstream  … 30

31. Java advantages Several studies show that Java could potentially be faster than C/C++ for some reasons:  C/C++ Pointers make optimization difficult  It is easier to do memory management in Java than C/C++ as Java only allocates memory through object instantiation. So Java garbage collectors can achieve better cache coherence  Dynamic compilation of Java can use additional information available at run-time to optimize code more effectively. 31

32. Future of Opencj Opencj will achieve better runtime performance by using JVM as the execution environment  Static annotation with annotation-aware JIT - Runtime IPA  Using just-in-time compiler - Apply more effective optimizations by profiling run- time information  Using garbage collection - Better performance due to cache coherence There are three steps in our schedule 32

33. Framework---step1 33

34. Framework—step2 34

35. Framework---final 35

36. Discussion Shin is the leader of this project Q&A 36

37. P ARALLEL P ROCESSING I NSTITUTE · F UDAN U NIVERSITY 37