Effectiveness of cross-platform optimizations for a java just-in-time compiler

Ishizaki, Kazuaki; Yasue, Toshiaki; Ogasawara, T.; Onodera, Tamiya; Komatsu, Hideaki; Nakatani, Toshio; Takeuchi, Mikio; Kawachiya, Kiyokuni; Suganuma, Toshio; Gohda, Osamu; Inagaki, Tatsushi; Koseki, Akira; Ogata, Kazunori; Kawahito, Motohiro

doi:10.1145/949319.949322

Cited by 4 publications

(4 citation statements)

References 0 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Since compilation time is an integral part of the total execution time in a dynamic compiler, it is of utmost importance to make a good trade-off between compilation time and code quality when proposing optimization levels in a optimizing dynamic compiler. Ishizaki et al [17] describe how optimization levels can be determined manually. The COLE framework on the other hand, enables making such a multi-objective trade-off in an automated manner, which is likely going to result in even better optimization levels.…”

Section: Dynamic Optimizationmentioning

confidence: 99%

“…These heuristics typically look like: optimizations that do not increase compilation time and are likely to produce good code, should be activated at -O1; optimizations that tend to increase code size but will likely result in better code quality, should be activated at -O2 and disabled at -Os; and optimizations that typically require a lot of compilation time, and might lead to even better code, should be activated at -O3. Ishizaki et al [17] describe such a manual optimization level selection process for a dynamic Just-In-Time compiler.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Cole

Hoste

Eeckhout

2008

Proceedings of the 6th Annual IEEE/ACM International Symposium on Code Generation and Optimization

110

View full text Add to dashboard Cite

Modern compilers implement a large number of optimizations which all interact in complex ways, and which all have a different impact on code quality, compilation time, code size, energy consumption, etc. For this reason, compilers typically provide a limited number of standard optimization levels, such as -O1, -O2, -O3 and -Os, that combine various optimizations providing a number of trade-offs between multiple objective functions (such as code quality, compilation time and code size). The construction of these optimization levels, i.e., choosing which optimizations to activate at each level, is a manual process typically done using high-level heuristics based on the compiler developer's experience.This paper proposes COLE, Compiler Optimization Level Exploration, a framework for automatically finding Pareto optimal optimization levels through multi-objective evolutionary searching. Our experimental results using GCC and the SPEC CPU benchmarks show that the automatic construction of optimization levels is feasible in practice, and in addition, yields better optimization levels than GCC's manually derived (-Os, -O1, -O2 and -O3) optimization levels, as well as the optimization levels obtained through random sampling. We also demonstrate that COLE can be used to gain insight into the effectiveness of compiler optimizations as well as to better understand a benchmark's sensitivity to compiler optimizations.

show abstract

Section: Dynamic Optimizationmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Cole

Hoste

Eeckhout

2008

Proceedings of the 6th Annual IEEE/ACM International Symposium on Code Generation and Optimization

110

View full text Add to dashboard Cite

show abstract

“…In advanced dynamic compilers such as the IBM Java Just-in-Time (JIT) compiler [34,16,35,12,17], we can estimate the failure ratio by inspecting a small amount of input data at compilation time. To avoid degradation when the characteristic of the input data changes after compiling the methods, we can recompile the methods with high failure ratios without applying FP speculation by monitoring the failure ratio in the compensation code.…”

Section: Dealing With Frequent Failuresmentioning

confidence: 99%

A new speculation technique to optimize floating-point performance while preserving bit-by-bit reproducibility

Takeuchi

Komatsu

Nakatani

2003

Proceedings of the 17th Annual International Conference on Supercomputing

Self Cite

View full text Add to dashboard Cite

The bit-by-bit reproducibility of floating-point results, which is defined by the IEEE 754 standard, prohibits optimizations such as reassociation and the use of native operations such as fused multiplyadd (FMA), and thus it significantly impairs floating-point performance. Recent network-oriented languages such as Java strictly conform to the standard, and thus their numerical computing performance becomes inherently lower than conventional languages.In this paper, we propose a new software technique, called floatingpoint (FP) speculation, to optimize floating-point performance while preserving the bit-by-bit reproducibility of the results. We execute the fast unsafe code and the slow verification code in parallel. The unsafe code does not wait for the verification code, and is immediately followed by the subsequent code that uses the probable result from the unsafe code assuming the speculation will succeed. The improvement from FP speculation results from this earlier start of the subsequent code.Unlike other speculation techniques, FP speculation does not require any special instructions or hardware support. Rather, it exploits unused floating-point registers and execution units. Therefore it is generally applicable for processor architectures that have sufficient floating-point resources.

show abstract

“…For example, many VMs capture basic block counts during the initial executions of a method and later use this information to bias optimizations such as code layout, register allocation, inlining, method splitting, and alignment of branch targets [6]. Although these techniques are widely used in today's highperformance VMs [42,50,1,33,25], their speculative nature further increases the possibility that an optimization may degrade performance if the profile data was incorrect or if the program behavior changes during execution.…”

Section: Introductionmentioning

confidence: 99%

Online performance auditing

Lau

Arnold²,

Hind³

et al. 2006

Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

As hardware complexity increases and virtualization is added at more layers of the execution stack, predicting the performance impact of optimizations becomes increasingly difficult. Production compilers and virtual machines invest substantial development effort in performance tuning to achieve good performance for a range of benchmarks. Although optimizations typically perform well on average, they often have unpredictable impact on running time, sometimes degrading performance significantly. Today's VMs perform sophisticated feedback-directed optimizations, but these techniques do not address performance degradations, and they actually make the situation worse by making the system more unpredictable.This paper presents an online framework for evaluating the effectiveness of optimizations, enabling an online system to automatically identify and correct performance anomalies that occur at runtime. This work opens the door for a fundamental shift in the way optimizations are developed and tuned for online systems, and may allow the body of work in offline empirical optimization search to be applied automatically at runtime. We present our implementation and evaluation of this system in a product Java VM.

show abstract

Effectiveness of cross-platform optimizations for a java just-in-time compiler

Cited by 4 publications

References 0 publications

Cole

Cole

A new speculation technique to optimize floating-point performance while preserving bit-by-bit reproducibility

Online performance auditing

Contact Info

Product

Resources

About