A brief history of just-in-time

@article{Aycock2003ABH,
  title={A brief history of just-in-time},
  author={John Aycock},
  journal={ACM Comput. Surv.},
  year={2003},
  volume={35},
  pages={97-113}
}
  • John Aycock
  • Published 2003
  • Computer Science
  • ACM Comput. Surv.
Software systems have been using "just-in-time" compilation (JIT) techniques since the 1960s. Broadly, JIT compilation includes any translation performed dynamically, after a program has started execution. We examine the motivation behind JIT compilation and constraints imposed on JIT compilation systems, and present a classification scheme for such systems. This classification emerges as we survey forty years of JIT work, from 1960--2000. 
Verified just-in-time compiler on x86
TLDR
The tractability of the approach is demonstrated through, what is believed to be the first, verification of a JIT compiler with respect to a realistic semantics of self-modifying x86 machine code. Expand
Infrastructures and Compilation Strategies for the Performance of Computing Systems
This document presents our main contributions to the field of compilation, and more generally to the quest of performance of computing systems. It is structured by type of execution environment,Expand
Trace-based compilation and optimization in meta-circular virtual execution environments
TLDR
This dissertation explores an alternative approach in which only truly hot code paths are ever compiled, which compiles significantly less code and improves the performance of both statically and dynamically typed programming languages. 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
JIT through the ages Evolution of just-intime compilation from theoretical performance improvements to smartphone runtime and browser optimizations
This paper is a study on just-in-time compilation and traces its evolution from being a theoretical performance optimization to a technology that provides concrete speed-ups for constrainedExpand
Just-in-time compilation for SQL query processing
  • Stratis Viglas
  • Computer Science
  • 2014 IEEE 30th International Conference on Data Engineering
  • 2014
TLDR
The salient results of research in just-in-time compilation of SQL queries into native code has recently emerged as a viable technique for query processing and an alternative to the dominant interpretation-based approach, and the open research problems of the area are described. Expand
Just-in-time compilation for SQL query processing
TLDR
The salient results of research in just-in-time compilation of SQL queries into native code has recently emerged as a viable technique for query processing and an alternative to the dominant interpretation-based approach, and the open research problems of the area are described. Expand
Trace-based just-in-time compilation for lazy functional programming languages
TLDR
This thesis investigates the viability of trace-based just-in-time (JIT) compilation for optimising programs written in the lazy functional programming language Haskell and implemented Lambdachine, a trace- based JIT compiler which implements most of the pure subset of Haskell. Expand
Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator
TLDR
An industry-strength, LLVM-based parallel DBT implementing the ARCompact ISA is evaluated against three benchmark suites and speedups of up to 2.08 on a standard quad-core Intel Xeon machine are demonstrated. Expand
Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator
TLDR
An industry-strength, LLVM-based parallel DBT implementing the ARCompact ISA is evaluated against three benchmark suites and speedups of up to 2.08 on a standard quad-core Intel Xeon machine are demonstrated. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 143 REFERENCES
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
Dynamic Runtime Optimization
TLDR
This paper discusses a different approach in which optimization is no longer performed at compile-time, but is delayed until runtime, and reoptimized module versions are generated on-the-fly while the system is running, replacing earlier less optimized versions. Expand
The Wonder Years of Sequential Prolog Implementation
TLDR
This report surveys the major developments in sequential Prolog implementation during the period 1983-1993 and extrapolates current trends regarding the evolution of sequential logic languages, their implementation, and their role in the marketplace. Expand
Fast, effective code generation in a just-in-time Java compiler
TLDR
The structure of a Java JIT compiler for the Intel Architecture is presented, the lightweight implementation of JIT compilation optimizations are described, and the performance benefits and tradeoffs of the optimizations are evaluated. Expand
1983-1993: The Wonder Years of Sequential Prolog Implementation
  • P. V. Roy
  • Computer Science
  • J. Log. Program.
  • 1994
TLDR
In this decade, implementation technology has matured to such a degree that Prolog has left the university and become useful in industry. Expand
The Dynamic Incremental Compiler of APL\3000
Most APL implementations to date have been interpretive because of the dynamic nature of the language. APL\3000 employs a Dynamic Incremental Compiler to allow all the flexibility of change affordedExpand
A general approach for run-time specialization and its application to C
TLDR
This paper describes a general approach to run-time specialization that automatically produces source templates at compile time, and transforms them so that they can be processed by a standard compiler, and is efficient, as shown by the implementation for the C language. Expand
Design and Implementation of Pep, A Java Just-in-Time Translator
  • Ole Agesen
  • Computer Science
  • Theory Pract. Object Syst.
  • 1997
TLDR
Pep, a just-in-time compiler from Java bytecodes to Self, and following translation by Pep, Java programs can execute on the Self virtual machine and benefit from the optimizations performed by Self's compiler. Expand
Daisy: Dynamic Compilation For 10o?40 Architectural Compatibility
  • K. Ebcioğlu, E. Altman
  • Computer Science
  • Conference Proceedings. The 24th Annual International Symposium on Computer Architecture
  • 1997
TLDR
The architectural requirements for such a VLIW, to deal with issues including self-modifying code, precise exceptions, and aggressive reordering of memory references in the presence of strong MP consistency and memory mapped I/O are discussed. Expand
Adaptive systems for the dynamic run-time optimization of programs.
TLDR
This thesis investigates adaptive compiler systems that perform code optimizations based on the dynamic behavior of the program based on a fixed code generation strategy, i.e., one in which a predetermined set of code optimizations are applied at compile-time to an entire program. Expand
...
1
2
3
4
5
...