OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

39
3.2.5 Bytecode Optimization
Tools have been developed which improve the performance of Java applications by
performing ahead of time optimization on the Java bytecode stream. Soot is a tool
that performs traditional optimizations such as constant folding, copy propagation
and dead code elimination [115, 114] on Java class files. It works by translating the
bytecode stream from Java bytecodes into three different intermediate representations.
Most of the optimizations are conducted on a representation known as Jimple
which is a form of three address code. Using this strategy allows traditional optimization
algorithms to be employed. Unfortunately the conversion process from
Jimple back to Java bytecodes is imperfect, reducing the impact of the optimizations
performed.
Cream is another Java class file optimizer that performs traditional optimizations
such as dead code elimination and loop invariant code removal [36]. In addition,
Cream uses side-effect analysis in order to optimize field accesses and method invocations.
Performance improvements of as much as 25 percent are reported. However,
other applications incurred a performance loss due to the “optimizations” performed.
Unlike the other tools presented in this section, JAX is primarily concerned with
manipulating Java class files in order to reduce their size rather than improving their
runtime performance [110]. The transformations performed include renaming classes,
methods and fields, removing redundant methods and fields, transforming the class
hierarchy and devirtualizing and inlining method calls. Reductions in class file size
of between 14 percent and 90 percent were observed. The average performance gain
achieved was 4.7 percent.
3.2.6 Native Methods
The Java Native Interface (JNI) provides a mechanism for calling code developed in
programming languages other than Java from within a Java application [72]. Performing
this task can serve several purposes including accessing features of the underlying
platform that are not readily accessible through the virtual machine, developing portions
of the application in a language that is more appropriate for the problem being
solved and optimizing performance critical methods by developing them in a language
that offers better performance. Unfortunately these benefits come at the expense of
portability. At a minimum, any code that is called by the Java Native Interface
normally has to be recompiled on any new target architecture.