OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

21
piled into machine language instructions that are executed directly by the central
processing unit. In an interpreter, the loop structure, fetch and decode operations
are all implemented in software, each represented by a sequence of machine language
instructions that must also be executed using the central processing unit. Only the
single line shown in italics in figure 2.4 represents work performed directly toward
progressing the user’s application. Consequently, interpreted implementations generally
show far poorer performance than code executed using a traditional model of
compilation and execution. Some studies have shown this performance gap to be as
large as an order of magnitude [62].
The following sections describe techniques that can be used to construct a Java
interpreter. Each section includes a figure that shows the implementation of a portion
of the interpreter’s main execution loop in C-like pseudo code. The code shown uses
stack to refer to the array of slots which represents the operand stack. The symbol
sp is the index of the top element on the stack. The array of slots used to store
the local variables for the method is denoted by local vars. The bytecodes that
implement the method are stored in the array named code with pc indicating the
index of the next instruction to execute.
2.4.1 Implementing an Interpreter with a Switch Statement
Many implementation options are possible for a Java interpreter. In the simplest
case, a while loop is used with a standard switch/case statement. This structure is
shown in Figure 2.5. It offers poor performance for a number of reasons. First, the
use of a while loop requires that a condition be tested for every iteration of the loop.
Fortunately, if the condition is structured using only constant values, most optimizing
compilers will recognize the fact that the condition is always true, avoiding the need
to test the condition each time through the loop.
The use of a standard switch/case statement also results in poor performance. In
Figure 2.5, arrows are used to show the branches performed when the aload 0 case
is executed. Notice that there is a branch from the break statement at the end of the
codelet for aload 0, which transfers control to the bottom of the loop. However, no
work is performed between the switch/case statement and the bottom of the loop. As
a result, a second unconditional branch is immediately performed to return control
to the top of the loop.