The simplest heuristics may be the best in Java JIT compilers

@article{Schilling2003TheSH,
  title={The simplest heuristics may be the best in Java JIT compilers},
  author={Jonathan L. Schilling},
  journal={ACM SIGPLAN Notices},
  year={2003},
  volume={38},
  pages={36-46}
}
The simplest strategy in Java just-in-time (JIT) compilers is to compile each Java method the first time it is called. However, better performance can often be obtained by selectively compiling methods based on heuristics of how often they are likely to be called during the rest of the program's execution. Various heuristics are examined when used as part of the Caldera UNIX Java JIT compiler. The simplest heuristics involving the number of times the method has executed so far and the size of… Expand
Selective compilation via fast code analysis and bytecode tracing
TLDR
This work introduces two heuristics aimed at detecting hot spots both statically, via bytecode analysis, and dynamically, via profiling information, and shows that their method selection strategy is more accurate than known strategies, and not significantly slower. Expand
PAYJIT: space-optimal JIT compilation and its practical implementation
TLDR
The PAYJIT compilation policy for method-based JIT compilers is proposed, which scales compilation hotness thresholds with method sizes, and includes two-point tuning, a mechanism for determining thosehotness thresholds. Expand
Exploration of the Relationship Between Just-in-Time Compilation Policy and Number of Cores
TLDR
The goal of this work is to explore the relationship between the number of microprocessor cores on modern machines and the suitable JIT compilation policies that can enable existing as well as future VMs to realize better program performance. Expand
Enhanced hot spot detection heuristics for embedded java just-in-time compilers
TLDR
A new hot spot detection heuristic is proposed which can estimate the running time more precisely than others with a relatively low overhead and dynamically counts only important bytecodes interpreted, but with a simple arithmetic calculation it can obtain the precise count of all interpreted bytecodes. Expand
Selective just-in-time compilation for client-side mobile JavaScript engine
  • Seong-Won Lee, Soo-Mook Moon
  • Computer Science
  • 2011 Proceedings of the 14th International Conference on Compilers, Architectures and Synthesis for Embedded Systems (CASES)
  • 2011
TLDR
It is found that JITC actually increases the loading time tangibly for some JavaScript-heavy web pages compared to interpretation, while it can still reduce the running time for JavaScript benchmarks, and selective compilation to the SFX engine is introduced. Expand
Heuristic optimisation algorithm for Java dynamic compilation
TLDR
A method-size and execution-time heuristic algorithm for dynamic compilation that shows an overall advantage in performance speedup when testing benchmarks and gain speedup by 19.1% on average when extended to the whole benchmark suite. Expand
Flow‐sensitive runtime estimation: an enhanced hot spot detection heuristics for embedded Java just‐in‐time compilers
TLDR
A new hot spot detection heuristic called flow‐sensitive runtime estimation is proposed, which can estimate the running time more precisely than others with a relatively low overhead, and it can obtain the precise count of all interpreted bytecode instructions with a simple arithmetic calculation. Expand
Thread-level parallel execution in co-designed virtual machines
  • Thomas S. Hall, K. Kent
  • Computer Science
  • 16th IEEE International Workshop on Rapid System Prototyping (RSP'05)
  • 2005
TLDR
This paper describes research work to further improve the performance of the co-designed virtual machine by adding thread-level parallel execution and a prototype of the design, based on the Java virtual machine, utilizing software simulation is constructed and tested. Expand
A Hardware-Software Integrated Design for a High-Performance Java Processor
  • A. Fong, C. Yau, Yijun Liu
  • Computer Science
  • 2012 Ninth International Conference on Information Technology - New Generations
  • 2012
TLDR
This research proposes a high-performance computer architecture with hybrid system co-design for Java processing with FPGA model implemented in VHDL, jHISC, which originates hardware support for object-oriented bytecodes, object referencing and method invocation. Expand
The Taint Rabbit: Optimizing Generic Taint Analysis with Dynamic Fast Path Generation
TLDR
The Taint Rabbit is presented, which supports highly customizable user-defined taint policies and combines a JIT with fast context switching and suggests that this combination outperforms notable existing implementations of generic taint analysis and bridges the performance gap to specialized trackers. Expand
...
1
2
...

References

SHOWING 1-10 OF 31 REFERENCES
A small hybrid JIT for embedded systems
TLDR
A simple technique of combining interpretation with compilation to get a hybrid interpretation strategy that gives a JIT compiler that is very small and suitable for Java Virtual Machines for embedded systems. Expand
Overview of the IBM Java Just-in-Time Compiler
TLDR
The design and implementation of several optimizations and techniques included in the latest IBM JavaTM Just-in-Time (JIT) Compiler are presented, including code generation techniques targeting Intel architectures, and the effectiveness of the individual optimizations is described. Expand
A dynamic optimization framework for a Java just-in-time compiler
TLDR
The design and implementation of a dynamic optimization framework in a production-level Java JIT compiler to employ a mixed mode interpreter and a three level optimizing compiler, supporting quick, full, and special optimization, each of which has a different set of tradeoffs between compilation overhead and execution speed. Expand
Does “just in time” = “better late than never”?
TLDR
A new method is introduced--the continuous compiler-- that can outperform just-in-time systems by overlapping compilation with program interpretation and native execution, thereby obtaining improved performance. Expand
Using annotations to reduce dynamic optimization time
TLDR
The annotations the authors present reduce compilation overhead incurred at all stages of compilation and optimization as well as enable complex optimizations to be performed dynamically. Expand
Fail-safe programming in compiler optimization
TLDR
A technique is presented that accomplishes this goal and the compiler contexts in which it may be used, and the benefits resulting from it, are discussed. Expand
LaTTe: a Java VM just-in-time compiler with fast and efficient register allocation
TLDR
LaTTe is introduced, a Java JIT compiler that performs fast and efficient register mapping and allocation for RISC machines and includes an enhanced object model, a lightweight monitor, a fast mark-and-sweep garbage collector, and an on-demand exception handling mechanism, all of which are closely coordinated with LaTTe's JIT compilation. Expand
Java bytecode to native code translation: the Caffeine prototype and preliminary results
TLDR
This paper presents the initial prototyping experience with Caffeine, an optimizing translator from Java bytecode to native machine code, and discusses the major technical issues involved in stack to register mapping, run-time memory structure mapping and exception handlers. Expand
Comprehensive Profiling Support in the Java Virtual Machine
TLDR
A general-purpose, portable, and extensible approach for obtaining comprehensive profiling information from the Java virtual machine, which can uncover CPU usage hot spots, heavy memory allocation sites, unnecessary object retention, contended monitors, and thread deadlocks. Expand
The Java Virtual Machine Specification
TLDR
This second edition specifies the newest version of the Java virtual machine and provides a fascinating view into the inner workings of theJava 2 platform. Expand
...
1
2
3
4
...