OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

151
Both the Total Bytecodes Score and the Transfer Reduction Score fail to consider
the optimization potential of the sequence or the impact its replacement has on cache
performance. Another scoring technique which attempts to capture of complete impact
of the multicode’s impact including transfers removed, optimization potential
and caching is discussed in Section 7.8.
7.4 Multicode Substitution
Once a multicode is identified, the Java class files must be modified to make use
of it. This process is referred to as multicode substitution. It involves examining
the code stream within each class file in order to locate occurrences of the bytecode
sequence to replace with the multicode. However, performing multicode substitution
is not as simple as replacing all occurrences of the bytecode sequence with the new
multicode. Branching, exceptions, and the difference in size between the multicode
and the sequence of bytecodes that it represents all must be taken into consideration.
Checks were performed during profiling in order to ensure that only those sequences
that can be replaced contribute to the score of each multicode. However, those checks
do not guarantee the absence of other occurrences of the sequence that are ineligible
for substitution within the class files. As a result, care must be taken during the
substitution process.
Branching presents difficulties because it is not possible to branch to the middle
of a multicode – either the entire multicode executes or the entire multicode does
not execute. Consequently, it is not possible to perform a multicode substitution
on any sequence of bytecodes, x 1 →x 2 →x 3 →... →x n →, where a bytecode in the
sequence, other than x 1 , is a target of a branch, conditional or unconditional. The
lookupswitch and tableswitch bytecodes are treated as a special type of conditional
branch that has multiple branch targets. If such a substitution was performed, there
would be no way to express the target of the branch bytecode. Branching to the start
of the multicode would result in bytecodes being executed that were not executed
before the substitution was performed, potentially placing values with inconsistent
types on the operand stack or otherwise resulting in incorrect results being generated.
The same situation can occur if the branch target was set to the bytecode immediately
following the multicode.
Exception handlers are represented within the Java Virtual Machine by specifying
the program counter value for the first bytecode within the exception handler and
the first bytecode that is not covered by the exception handler. As a result, a similar