A study of devirtualization techniques for a Java Just-In-Time compiler

Abstract

Many devirtualization techniques have been proposed to reduce the runtime overhead of dynamic method calls for various objectoriented languages, however, most of them are less effective or cannot be applied for Java in a straightforward manner. This is partly because Java is a statically-typed language and thus transforming a dynamic call to a static one does not make a tangible performance gain (owing to the low overhead of accessing the method table) unless it is inlined, and partly because the dynamic class loading feature of Java prohibits the whole program analysis and optimizations from being applied.We propose a new technique called direct devirtualization with the code patching mechanism. For a given dynamic call site, our compiler first determines whether the call can be devirtualized, by analyzing the current class hierarchy. When the call is devirtualizable and the target method is suitably sized, the compiler generates the inlined code of the method, together with the backup code of making the dynamic call. Only the inlined code is actually executed until our assumption about the devirtualization becomes invalidated, at which time the compiler performs code patching to make the backup code executed subsequently. Since the new technique prevents some code motions across the merge point between the inlined code and the backup code, we have furthermore implemented recently-known analysis techniques, such as type analysis and preexistence analysis, which allow the backup code to be completely eliminated. We made various experiments using 16 real programs to understand the effectiveness and characteristics of the devirtualization techniques in our Java Just-InTime (JIT) compiler. In summary, we reduced the number of dynamic calls by ranging from 8.9% to 97.3% (the average of 40.2%), and we improved the execution performance by ranging from -1% to 133% (with the geometric mean of 16%).

A method‐level comparison of the Java Grande and SPEC JVM98 benchmark suites

“…However, it is possible to program in a "pseudo" object oriented style, where methods are defined as virtual, but are not actually overridden in the program code. Such method call sites are prime targets for optimisation, since the target of most, if not all their calls can be calculated statically [29,17].…”

“…Their JIT inlines static calls to small methods, and uses class hierarchy analysis [17] to devirtualise dynamic calls. The test suite they use includes the SPEC benchmarks as well as some more GUI-based programs, and Ishizaki et al report good scope for devirtualisation across the suite, in particular for mtrt which makes extensive use of small methods.…”

A Study of Type Analysis for Speculative Method Inlining in a JIT Environment

“…The section discusses additional related work on the topic. Ishizaki et al [12] conducted an extensive study of dynamic devirtualization techniques for Java programs. In their experiments, size limits were put on inlined targets, and techniques using dynamic CHA were shown to inline about 46% of virtual calls (execution counts).…”

“…Ishizaki et al [12] presented a code patching technique to remove the direct overhead of all method and class tests for monomorphic call sites in the presence of dynamic class loading. Code patching uses CHA to identify monomorphic calls at compile time.…”

Method Inlining, Dynamic Class Loading, and Type Soundness.

“…Previous work has explored inlining for whole programs (see, e.g., [4]) and for programs that use dynamic class loading (see, e.g., [9,3,1,5,12]). That work has devised analysis and transformations for devirtualisation and method inlining, shown the effectiveness of these optimisations, and argued informally for their correctness.…”