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… 

Figures and Tables from this paper

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.

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.

Selective just-in-time compilation for client-side mobile JavaScript engine

  • Seong-Won LeeSoo-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.

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.

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.

Thread-level parallel execution in co-designed virtual machines

  • Thomas S. HallK. 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.

A Hardware-Software Integrated Design for a High-Performance Java Processor

  • A. FongC. YauYijun 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.

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.

CAOS: combined analysis with online sifting for dynamic compilation systems

TLDR
A novel dynamic compilation scheduling algorithm called combined analysis with online sifting (CAOS) consists of a combined priority analysis model and an online sifted mechanism, aiming at reconciling responsiveness with the average delay of compilation queue.

Using event-based translation to support dynamic protocol evolution

  • Nathan D. RyanA. Wolf
  • Computer Science
    Proceedings. 26th International Conference on Software Engineering
  • 2004
TLDR
The goal of the work described here is to contribute techniques that can support protocol evolution, based on a method for isolating the syntactic details of a protocol from the semantic concepts manipulated within components.

References

SHOWING 1-10 OF 26 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.