\begin{center}
{\bf Annotating the Java Bytecodes in Support of Optimization} \\
\vspace{7pt}
{\em J. Hummel, A. Azevedo, D. Kolson, and A. Nicolau}
\end{center}
The efficient execution of Java programs presents a challenge to 
hardware and software designers alike.  The difficulty however lies
with the Java bytecodes.  Their model of a simplistic, platform-independent
stack machine is well-suited for portability, though at the expense of 
execution speed.  Various approaches are being proposed to increase the 
speed of Java bytecode programs, including:
\mbox{(1) on-the-fly} compilation to native code (also known as JIT or 
``just-in-time'' compilation); \mbox{(2) traditional} (``ahead-of-time'')
compilation of bytecodes to some higher-level intermediate form and 
then to native code; and \mbox{(3) translation}
of bytecodes to a higher-level language and then use of an existing 
compiler to produce native code.  Speedups on the order of 50 over
standard bytecode interpretation have been claimed.

All of these approaches rely upon bytecode analysis (of varying 
sophistication) to extract information about the program, which is 
then used to optimize the native code during the translation process.  
However, extracting information from a lower-level representation such as
the Java bytecodes can be very expensive. And given the fact that most
approaches for executing Java bytecodes cannot spend a great deal of time 
recovering high-level information, the solutions adopted during the
translation process must use faster and less accurate analysis techniques,
thus penalizing the quality of the native code.

In this paper we propose an optimization approach based on bytecode
annotations.  The bytecodes are annotated during the original source
code to bytecode translation, allowing both traditional interpretation 
by a JVM and aggressive optimization by an annotation-aware 
bytecode compiler.  Annotations do not hinder portability nor 
compatibility, while preserving optimization information that is
expensive to recompute. Preliminary results yield bytecode with C-like
performance using JIT technology.
\vspace{8pt}
\noindent{\bf Short Code:\ \ }[Hummel:97a]
\vspace{5pt}
\noindent{\bf Reference:\ \ \ \ }Vol. 9, No. 11, pp. 1003--1016
\vspace{0.25in}

\begin{center}
{\bf CACAO---A 64 Bit JavaVM Just-in-time Compiler} \\
\vspace{7pt}
{\em A. Krall, and R. Grafl}
\end{center}
This article describes the design and implementation of CACAO, a just in
time compiler for Java. The CACAO system translates Java byte code on
demand into native code for the ALPHA processor. During this translation
process the stack oriented Java byte code is transformed into a register
oriented intermediate code. Local variables and stack locations are
replaced by pseudo registers eliminating the 32 bit restriction on address
types. A fast register allocation algorithm is applied to map the pseudo
registers to machine registers. During code generation, field offsets are
computed for proper alignment on 64 bit architectures. Even though the
CACAO system has to incur loading and compilation time, it executes Java
programs up to 85 times faster than the JDK interpreter, up to 7 times
faster than the kaffe JIT compiler. It is slightly slower than equivalent C
programs compiled at the highest optimization level.
\vspace{8pt}
\noindent{\bf Short Code:\ \ }[Krall:97a]
\vspace{5pt}
\noindent{\bf Reference:\ \ \ \ }Vol. 9, No. 11, pp. 1017--1030
\vspace{0.25in}

{\bf A Java Bytecode Optimizer Using Side-effect Analysis} \\
\vspace{7pt}
{\em L. R. Clausen}
\end{center}
This paper describes Cream, an optimizer for Java bytecode using
side-effect analysis to improve the optimizations.  Dead code
elimination and loop invariant removal is implemented and tested, as
well as several variations of the side-effect analysis.  The optimizer
is tested on real-world applications such as itself and JavaSoft's Java
compiler.  Results show that the optimizations benefit a lot from the
side-effect analysis.  The best side-effect analysis gives five to ten
times as many optimizations as without an analysis, and, in one case,
makes a sped increase of 25 \% possible.}
\vspace{8pt}
\noindent{\bf Short Code:\ \ }[Clausen:97a]
\vspace{5pt}
\noindent{\bf Reference:\ \ \ \ }Vol. 9, No. 11, pp. 1031--1045
\vspace{0.25in}

{\bf A Prototype of FORTRAN-to-Java Converter} \\
\vspace{7pt}
{\em G. C. Fox, and X. Li}
\end{center}
This is a report on a prototype of a FORTRAN 77 to Java converter, {\em
f2j}.  Translation issues are identified, approaches are presented, a
URL is provided for interested readers to download the package, and
some unsolved problems are brought up. {\em F2j} allows value added to
some of the investment on FORTRAN code, in particular, those well
established FORTRAN libraries for scientific and engineering
computation.
\vspace{8pt}
\noindent{\bf Short Code:\ \ }[Fox:97j]
\vspace{5pt}
\noindent{\bf Reference:\ \ \ \ }Vol. 9, No. 11, pp. 1047--1061
\vspace{0.25in}

{\bf Just-in-time Optimizations for High-performance Java Programs} \\
\vspace{7pt}
{\em M. Cierniak, and W. Li}
\end{center}
Our previous experience with an off-line Java optimizer has shown that
some traditional algorithms used in compilers are too slow for a JIT
compiler.  In this paper we propose and implement faster ways of
performing analyses needed for our optimizations.  For instance we have
replaced {\em reaching definitions\/} with {\em constant values\/} and
{\em loop induction variables\/} with {\em loop-defined variables}.  As
the result our JIT compiler, Briki, is very fast, so that its running
time is negligible even when the data sets used with our benchmarks
result in execution times of only a few seconds.  The impact for the
same benchmarks running on more realistic problem sizes would be even
smaller.

Currently the speedups resulting from applying our optimizations are
between 10\% and 20\%, but when the JIT compiler will perform standard
optimizations which are absent in the current version of the JIT
compiler used by us, the speedups should be similar to the ones
observed for Fortran programs---up to 50\%.
\vspace{8pt}
\noindent{\bf Short Code:\ \ }[Cierniak:97b]
\vspace{5pt}
\noindent{\bf Reference:\ \ \ \ }Vol. 9, No. 11, pp. 1063--1073
\vspace{0.25in}