OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

169
a larger portion of the instruction cache is required to hold the entire loop. Consequently,
there is a greater possibility that portions of the main loop will be removed
from the cache, resulting in more cache misses. In the worst case, the size of the interpreter
loop will grow beyond the size of the instruction cache, causing instruction
cache misses to occur with great frequency unless the application being executed uses
only a small number of distinct bytecodes. These cache misses are expensive because
the interpreter’s execution cannot proceed until the needed instructions are loaded
from main memory.
There is also a software engineering cost associated with introducing new multicodes.
Because multicodes increase the number of cases within the interpreter’s main
loop, they increase the amount of code that must be maintained and debugged. However,
since the codelet that implements each multicode is generated automatically,
and the total amount of new code that is added is small in comparison to the size
of the virtual machine, the increased amount of code is not a large concern from a
software engineering perspective.
7.7 Multicode Optimization
When the codelet that implements a multicode is formed, new optimization opportunities
become available. The opportunities could not be utilized before the substitution
was performed because of the intervening transfers of control present between
each bytecode.
A large number of optimizations can be performed. These optimizations can be
divided into two categories:
• Traditional optimizations such as constant folding, dead code elimination and
common subexpression elimination.
• Specialized optimization that exploit the stack semantics used by the virtual
machine’s operand stack.
Many of the traditional optimizations are performed automatically by the compiler
when the virtual machine is compiled. However, the compiler is unable to perform
the specialized optimizations that exploit the stack semantics used by the operand
stack because it does not know that the array used to implement the operand stack
behaves like a stack.
An example will be used in order to demonstrate some of the optimizations that
can be performed. Consider the bytecode sequence: