OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

118
bytecodes. The number of specialized bytecodes increases to 8 when the top 40 store
bytecodes are considered. If the selection of store bytecodes was performed perfectly,
the 20 most frequently executed store bytecodes would be specialized bytecodes.
It was further observed that of the 8 specialized store bytecodes that do reside in
the 40 most frequently executed store instructions, only two access either slot 0 or slot
1 (the slots that are used to hold method parameters with greatest frequency). This
behavior is due to the parameter structure of the virtual machine and the semantics
associated with method parameters in Java. As has been mentioned previously, the
virtual machine arguments are stored in the first local variable slots which generally
reduces the number of accesses to those slots. This is particularly true for stores to
those slots because Java only supports pass by value semantics for primitive types,
including object references. As a consequence, any value that is stored into a slot
holding a method parameter will only be retained within the scope of the current
method. The updated value will not appear in the calling scope. This design decision
severely restricts the number of stores performed on slots containing method
parameters. Note that this design choice does not prevent fields in objects passed as
parameters to methods from changing since it is the object reference that is passed
by value, not all of the data members that make up the object. As a consequence,
changing the value of a field in an object is changing the value in a memory location
stored on the heap, not in the local variable array.
Comparing the frequency of execution of the most executed load bytecodes with
that of the most frequently utilized store bytecodes reveals that loads are executed
much more often than stores. This is typical of a stack based architecture as most
operations load two or more values onto the stack in order to generate a single result
value that must be stored back into a local variable. While it is difficult to compare
the graphs directly due to their differing y-axis scales, examining the data reveals
that only 7 of the most frequently executed store bytecodes execute with more frequency
than aload 0x0f, the 40 th most frequently executed load bytecode. This
indicates another area where future virtual machine designers should consider eliminating
symmetry from their instruction set design. Since loads are performed with
much greater frequency than stores on a stack based architecture, more instructions
should be devoted to specialized load bytecodes than to specialized store bytecodes.
Figure 6.4 shows the 40 least frequently executed store bytecodes. Examining
the graph reveals that there are 5 specialized bytecodes present, 4 of which do not
contribute sufficiently for their bars to be visible. Further examination of the data
reveals these 4 specialized bytecodes (fstore 0, fstore 1, fstore 2 and dstore 0)