OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

38
regardless of the technique selected, virtual method dispatch still requires additional
work compared to non-virtual method dispatch. Furthermore, because the exact
method being invoked is not known until runtime, virtual method dispatch makes
other optimizations such as method inlining much more challenging.
Method devirtualization can be used to help overcome the cost of virtual methods.
Numerous devirtualization techniques have been developed for languages other than
Java. However, many of them are not applicable because they rely on whole program
analysis at compile time. Because Java permits class files to be loaded dynamically,
it is possible that some class files will not be made available until runtime, making
such techniques inappropriate.
Several new techniques have been developed to permit method devirtualization in
Java. One option is to assume that the entire set of classes that will be utilized by
the application is available at compile time. Another option is to perform a test each
time the call site is reached in order to determine if inlined code can be executed or
virtual method dispatch must be performed [30]. Techniques have also been proposed
which perform devirtualization and method inlining under the assumption that no
additional classes will be loaded. However, if a class is loaded that invalidates that
assumption, code patching is used in order to introduce the necessary virtual method
dispatch [66]. A similar technique is also employed by the Java HotSpot compiler [4].
Other techniques that can be used include on-stack replacement [58] and pre-existence
[39].
3.2.4 Minimizing Synchronization Operations
The Java programming language provides the ability to start multiple threads of
execution within an application. Synchronization operations are necessary in order
to ensure that accesses to data structures which are shared across these threads of
execution are performed safely. Consequently, the Java library makes extensive use
of synchronization operations.
Unfortunately synchronization operations are costly. One optimization strategy
has been to reduce the cost of synchronization operations directly by performing each
locking or unlocking operation as efficiently as possible [17]. Other researchers have
developed techniques to remove synchronization operations that are proved to be
unnecessary [34, 97, 101]. It has been shown that reducing the number of synchronization
operations performed by the application can improve application runtime by
as much as 36 percent [23].