OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

144
• The second application converts the execution trace (a stream of bytecodes and
method invocations) into a collection of multicode blocks.
• The third application was responsible for processing the list of multicode blocks
in order to generate a list of bytecode sequences to be represented by multicodes.
This was accomplished by first counting the number of times each sequence of
bytecodes occurred within the block list. The score for each sequence was then
computed and the best sequence was identified.
The entire identification process is shown graphically in Figure 7.3. Unfortunately
this identification algorithm presents some practical difficulties. Even when executed
at their smallest input sizes, some benchmarks generated execution traces that were
gigabytes in size. While modern disks can easily accommodate these files, the amount
of time required to both generate and process them was cumbersome. This was also
true of the files used to hold the block lists. While they were approximately 30 percent
of the size of the execution traces, they still represented a large amount of data that
had to be processed for each multicode that was identified. As a result, the multicode
identification process was revised to reduce both the amount of space required to
record the profile data and shorten the time required for multicode identification.
These revisions are discussed in the next section.
7.3.4 Reducing the Cost of Dynamic Profiling
The original multicode identification algorithm, presented in the previous section,
required excessive disk space because even simple applications can execute millions
of bytecodes. To address this problem, additional modifications were made to the
Kaffe virtual machine. Some of this additional work reflects tasks that were previously
performed in later stages of the analysis while other additions were made based
on insights gained during the implementation of the iterative algorithm described
previously.
The first addition involved adding a data structure to the Kaffe virtual machine
that maintained the branch and exception structure of each method encountered. By
storing this information in memory, a second, more significant addition was made
possible. In particular, the Kaffe virtual machine became capable of identifying multicode
blocks itself, without having to write millions of bytecodes to disk so that they
could be broken into multicode blocks by another application.
The process of identifying multicode blocks is relatively straightforward. As the
virtual machine executes each new bytecode, it checks to see whether the bytecode