OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

103
were performed was less than 0.1 percent. When 48 despecializations were performed,
the overall average change in performance increased to 0.6 percent. Performing all
62 despecializations considered during this study resulted in a performance change
of just over 2 percent. Consequently, it is concluded that while performing despecialization
can impact the performance of any one benchmark executed on a specific
virtual machine and computer architecture, the overall impact of despecialization is
small. Consequently, the author questions the value of utilizing 62 bytecodes for this
purpose.
5.3 Despecialization and Class File Size
The initial despecialization study discussed in Chapter 4 included a discussion of the
implications despecialization has on class file size. This study extends the previous
examination of the impact despecialization has on class file size by considering both
the additional class files and virtual machines used in this study and by showing
a detailed breakdown of the progressive impact as the number of despecializations
performed increases.
The class files tested during the size analysis include the standard libraries from
each of the virtual machines tested as well as the application classes for each of the
benchmarks. The lone exception was the file install.class included as part of the
SPEC JVM98 benchmark suite. As noted previously, this class file’s large size is
primarily the result of a non-standard attribute can be used to install the benchmark
suite. Had this class file been included during this portion of the study its overall
impact on the results would have been minor because a considerably larger number
of class files were evaluated compared to the size analysis conducted in Section 4.3.
The impact performing despecializations had on class file size is shown graphically
in Figure 5.12. The figure shows that the first despecializations performed have
almost no impact on class file size. This was not a surprising result because those
bytecodes are executed so infrequently. However, it was observed that while some
of those bytecodes were never executed, they do occur statically within some Java
class files. This was determined by looking at the table of data from which the graph
was generated. It revealed that the overall change in the total size of all class files
was 901 bytes when four despecializations were performed. This indicated that there
were approximately 901 static occurrences of these bytecodes present across all of the
benchmarks and libraries considered. This count is not precise because performing