Load Time Structural Reflection in Java

1
Load Time Structural Reflection in Java

• Shigeru Chiba
• Institute of Information Science and Electronics
• University of Tsukuba

2
Introduction

• Reflection in java
• Behavioral reflection
• Structural reflection
• Javassist, a class library enabling structural
  reflection in java

3
Properties of Javassist

• Portable
• Provides source level abstraction
• Does byte code transformation at compile time

4
BCA

• class Calendar implements Writable
• public void write(PrintStream s) ...
• class Calendar implements Printable
• public void write(PrintStream s) ...
• public void print() write(System.out)
• Implementation of BCA with behavioral reflection
  is
• not straightforward

5
Javassist

• Translates alterations by structural reflection
  into equivalent bytecode
• It is used with a user class loader
• class MyLoader extends ClassLoader
• public Class loadClass(String name)
• byte bytecode readClassFile(name)
• return resolveClass(defineClass(bytecode))
• private byte readClassFile(String name)
• // read a class file from a resource.

6
Javassist API

• A CtClass object has to be created
• CtClass c new CtClass(stream or string)
• To obtain bytecode of altered class
• byte bytecode c.toBytecode()
• Javassist allows to dynamically define a new
  class
• CtClass c2 new CtNewClass()

7
Introspection

• This part of Javassist is compatible with Java
  reflection API with the difference that Javassist
  does not provide methods for creating an instance
  or invoking a method because these are
  meaningless at load time

8
Methods in CtClass for introspecting classes
9
Alteration by Javassist

• Principles governing alteration in Javassist
• Source level abstraction for programmers
• Execution of structural reflection efficiently
• Type safety while performing Structural reflection

10
Adding a new member

• void addMethod(CtMethod m, String name, ClassMap
  map)
• void addWrapper(int modifiers, CtClass
  returnType, String name,CtClass parameters,
  CtClass exceptions,CtMethod body,
  ConstParameter constParam)

11
Replacing a Class name in the method body

• public class XVector extends java.util.Vector
• public void add(X e)
• super.addElement(e)
• CtMethod m / method add() in XVector /
• CtClass c / class StringVector /
• ClassMap map new ClassMap()
• map.put("X", "java.lang.String")
• c.addMethod(m, "addString", map)
• public void addString(java.lang.String e)
• super.addElement(e)

12
Altering a Method body

• void setBody(CtMethod m, ClassMap map)
• void setWrapper(CtMethod m, ConstParameter param)

13
Reflective class loader

• Javassist provides a reflective class loader
  which can be used to self-reflectively modify the
  bytecode

14
Using Javassist with a Web server

• for ()
• receive an http request from a web browser.
• CtClass c new CtClass(the requested class)
• do structural reflection on c if needed.
• byte bytecode c.toBytecode()
• send the bytecode to the web browser.

15
Using Javassist Off line

• CtClass c newCtClass("Rectangle")
• do structural reflection on c if needed.
• c.compile()
• writes bytecode on the original class file.
• Now the over written class file can be loaded in
  the JVM without user class loader

16
Use of Javassist

• Binary Code Adaption
• Remote Method Invocation

17
Comparison of OpenJava and Javassist

• Openjava needs source file of every processed
  class whereas Javassist needs just the class
  files of the classes
• Javassist is much faster as it can move
  compilation penalties to an earlier stage

18
Conclusion

• Javassist is portable
• Provides source level abstraction in a safe
  manner
• Does not need source code
• Can be extended to other object oriented
  languages with individually designed API for each
  language

19
The Jalapeno Dynamic Optimizing Compiler for java

• Thomas J.Watson Research Center
• IBM

20
Project overview

• Jalapeno is a JVM built by IBM Research
• (initiated in December 1997)
• It takes a compile-only approach to program
  execution
• Three different compilers to provide
  translations
• A baseline compiler that makes it easier
  to mix execution of un-optimized and optimized
  methods in the JVM
• A quick compiler for a low level of code
  optimization
  An optimizing
  compiler for computationally intensive code

21
Motivation of the Project

• To deliver high performance and scalability
  ofJava applications on SMP server machines
• To support all Java features and semantics with
  respect to exceptions, garbage collection and
  threads

22
Jalapeno JVM

• Jalapeno JVM includes the following
• subsystems
• - Dynamic Class Loader
• - Dynamic Linker
• - Object Allocator
• - Garbage Collector
• - Thread Scheduler
• - Profiler
• - Three dynamic compilers

23
Jalapeno JVM

• All subsystems implemented in Java
• Self-bootstrapping
• Can dynamically self-optimize the JVM itself

24
Structure of Jalapeno Optimization system

• Unlike traditional JVMs, Jalapeno is adaptive
• and dynamic
• Automatically select a set of methods to
  optimize
• Generate the best possible code for
  selected methods for a given compile-time budget
• Reduce synchronization and other thread
  primitive

25
Structure of Jalapeno adaptive Optimization
system

• Jalapeno Adaptive Optimization System includes
• On-Line Measurement (OLM) subsystem
• Controller subsystem
• Optimizing Compiler subsystem

26
Online Measurment

• OLM
• Collect application and hardware
  performance information
• Maintain Calling Context Graph (CCG) to
  keep track of context-sensitive information
• Continuously monitor the methods, including
  those previously optimized

27
Controller

• Controller
• Detect if certain performance threshold
  is reached
• Use information collected from OLM to build
  an optimization plan (e.g. which methods need to
  be compiled and the optimization levels)

28
Optimizing Compiler

• The Optimizing Compiler can be used either as a
  static or dynamic compiler.
• When used as a static compiler or a bytecode
  -to-bytecode optimizer, it generates file for
  later execution ,used to bootstrap Jalapeno JVM

29
Optimizing Compiler

• When used as a dynamic compiler, it
• generates the best possible code given compile
  -time budget
• The Jalapeno Optimizing Compiler consists of an
  optimizer front-end and an optimizer backend

30
Intermediate Representation(IR)

• The Optimizing Compiler uses register-based
  intermediate representations
• IR consists of an operator and some number of
  operands
• Jalapeno uses 3 different types of IRs
• HIR (High-Level IR)
• LIR (Low-Level IR)
• MIR (Machine-Specific IR)

31
IR

• Operators such as NULL_CHECK and BOUNDS_CHECK
  operators are used to facilitate optimization
• Control Flow Graph (CFG) and Basic Blocks (BB)
  are constructed as a by-product of BC2IR(Byte
  Code to Intermediate Representation)

32
Front end of Optimizing compiler

• The Front-End contains two parts
• BC2IR algorithm to translate byte code to
  HIR and perform on the fly optimizations
• Additional optimization performed on the
  generated HIR

33
Back end of Optimizer Compiler

• The Back-End of the compiler translates
• HIR to LIR
• LIR to MIR
• MIR to the final binary code
• Different optimizations are performed during each
  phase

34
HIR to LIR

• HIR is lowered to low-level IR (LIR)
• LIR expands instructions into operations that are
  specific to the Jalapeno JVM (such as object
  layouts or parameter-passing mechanism)
• The expanded LIR may expose more
• opportunities for low-level optimizations

35
Final Assembly

• Emit the binary executable code into an
• instruction array
• Convert offsets in the IR to offsets in the
• machine code
• Store the instruction array (a Java array
• reference) into a field of the object instance
  for that method

36
Inlining Method Calls

• During BC2IR phase
• Static and final methods can be safely
  inlined.
• Inlining plan is based on static code
  size and depth heuristics

37
Implementation Status

• OLM is in prototype stage, and the controller is
  in design phase
• The Optimizing compiler can only be invoked as a
  static compiler or dynamically by the Jalapeno
  class loader to optimize all methods

38
Performance Benchmark Enviroments

• Four Java Environments
  
• IBM JDK 1.1.6 w/o JIT
• IBM JDK 1.1.6 w IBM JIT v3.0
• Jalapeno Baseline Use Jalapeno Baseline
  Compiler as a JIT for all classes dynamically
  loaded
• Jalapeno Optimizer Use Jalapeno
  Optimizing as JIT for all classes dynamically
  loaded

39
Benchmark Programs

• Benchmark Programs
• 9 Micro-benchmark Programs from Symantec
• 4 Macro-benchmark programs from
  SPECjvm98suite

40
Performance Results

• Micro-Benchmark
• 3 of the 9 tests run faster with the
  Jalapeno Optimizing Compiler
• Remaining cases are within 1.6 times slower
  of the standard IBM JIT compiler

41
Performance Results

• Macro-Benchmark
• 1.3 to 3.3 times slower than the best
  current commercial JVM"
• With further improvements, Jalapeno (a pure
  Java JVM) may achieve performance competitive to
  a state-of-the-art JVM implemented in C

42
Conclusion

• First dynamic optimizing compiler for Java
• that is being used in JVM with a compile
  only approach to program execution
• Validated the compile-only approach to
  program execution
• Demonstrated that a JVM implemented in Java
  can deliver performance comparable to a standard
  JIT compiler