Effective Enhancement of Loop Versioning in Java

Mikheev, V. P.; Fedoseev, Stanislav A.; Sukharev, Vladimir V.

doi:10.1007/3-540-45937-5_21

Cited by 3 publications

(3 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For example, loop versioning [Suganuma et al 2000;Mikheev et al 2002] is an optimization technique for hoisting the array bound exception checking code for an individual array access outside a loop by providing two copies of the loop: the unoptimized loop, where exception checking code is retained as in the original loop, and the optimized loop, where all array exception checking code is eliminated. Guard code is provided to examine the whole range of the index against the bound of the arrays accessed within the loop.…”

Section: Discussionmentioning

confidence: 99%

A region-based compilation technique for dynamic compilers

Suganuma

Yasue

Nakatani

2006

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

Method inlining and data flow analysis are two major optimization components for effective program transformations, but they often suffer from the existence of rarely or never executed code contained in the target method. One major problem lies in the assumption that the compilation unit is partitioned at method boundaries. This article describes the design and implementation of a region-based compilation technique in our dynamic optimization framework, in which the compiled regions are selected as code portions without rarely executed code. The key parts of this technique are the region selection, partial inlining, and region exit handling. For region selection, we employ both static heuristics and dynamic profiles to identify and eliminate rare sections of code. The region selection process and method inlining decisions are interwoven, so that method inlining exposes other targets for region selection, while the region selection in the inline target conserves the inlining budget, allowing more method inlining to be performed. The inlining process can be performed for parts of a method, not just for the entire body of the method. When the program attempts to exit from a region boundary, we trigger recompilation and then use on-stack replacement to continue the execution from the corresponding entry point in the recompiled code. We have implemented these techniques in our Java JIT compiler, and conducted a comprehensive evaluation. The experimental results show that our region-based compilation approach achieves approximately 4% performance improvement on average, while reducing the compilation overhead by 10% to 30%, in comparison to the traditional method-based compilation techniques.

show abstract

Section: Discussionmentioning

confidence: 99%

A region-based compilation technique for dynamic compilers

Suganuma

Yasue

Nakatani

2006

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

show abstract

“…A common solution to this problem uses loop versioning (see for example [11]). An optimized version of the loop without bounds checks is executed when it is known that the checks are unnecessary, and the unmodified loop with bounds checks is executed otherwise.…”

Section: Loop-invariant Checksmentioning

confidence: 99%

Array bounds check elimination for the Java HotSpot#8482; client compiler

Würthinger

Wimmer

Mössenböck

2007

Proceedings of the 5th International Symposium on Principles and Practice of Programming in Java - PPPJ '07

View full text Add to dashboard Cite

Whenever an array element is accessed, Java virtual machines execute a compare instruction to ensure that the index value is within the valid bounds. This reduces the execution speed of Java programs. Array bounds check elimination identifies situations in which such checks are redundant and can be removed. We present an array bounds check elimination algorithm for the Java HotSpot TM VM based on static analysis in the just-in-time compiler.The algorithm works on an intermediate representation in static single assignment form and maintains conditions for index expressions. It fully removes bounds checks if it can be proven that they never fail. Whenever possible, it moves bounds checks out of loops. The static number of checks remains the same, but a check inside a loop is likely to be executed more often. If such a check fails, the executing program falls back to interpreted mode, avoiding the problem that an exception is thrown at the wrong place.The evaluation shows a speedup near to the theoretical maximum for the scientific SciMark benchmark suite (40% on average). The algorithm also improves the execution speed for the SPECjvm98 benchmark suite (2% on average, 12% maximum).

show abstract

“…We perform two kinds of loop optimizations: loop versioning and loop simplification. Loop versioning [1,17] is a technique to eliminate the exception-checking code within a loop by creating two versions of the loop: an optimized loop and an unoptimized loop. Guard code is provided at the loop entry for checking the possibility of raising an exception within the loop, and-depending on the result of the entry check-either the optimized loop or the unoptimized loop is selected at runtime.…”

Section: Loop Optimizationsmentioning

confidence: 99%

Evolution of a Java just-in-time compiler for IA-32 platforms

et al. 2004

View full text Add to dashboard Cite

Java has gained widespread popularity in the industry, and an efficient Java virtual machine (JVM) and just-in-time (JIT) compiler are crucial in providing high performance for Java applications. This paper describes the design and implementation of our JIT compiler for IA-32 platforms by focusing on the recent advances achieved in the past several years. We first present the dynamic optimization framework, which focuses the expensive optimization efforts only on performance-critical methods, thus helping to manage the total compilation overhead. We then describe the platformindependent features, which include the conversion from the stack-semantic Java bytecode into our register-based intermediate representation (IR) and a variety of aggressive optimizations applied to the IR. We also present some techniques specific to the IA-32 used to improve code quality, especially for the efficient use of the small number of registers on that platform. Using several industry-standard benchmark programs, the experimental results show that our approach offers high performance with low compilation overhead. Most of the techniques presented here are included in the IBM JIT compiler product, integrated into the IBM Development Kit for Microsoft Windows, Java Technology Edition Version 1.4.0.

show abstract

Effective Enhancement of Loop Versioning in Java

Cited by 3 publications

References 14 publications

A region-based compilation technique for dynamic compilers

A region-based compilation technique for dynamic compilers

Array bounds check elimination for the Java HotSpot#8482; client compiler

Evolution of a Java just-in-time compiler for IA-32 platforms

Contact Info

Product

Resources

About