A brief history of just-in-time

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.

[1]  James G. Mitchell.  The Design and Construction of Flexible and Efficient Interactive Programming Systems , 1970, Outstanding Dissertations in the Computer Sciences.

[2]  B. Ramakrishna Rau,et al.  Levels of representation of programs and the architecture of universal host machines , 1978, MICRO 11.

[3]  Susan J. Eggers,et al.  A case for runtime code generation , 1993 .

[4]  Urs Hölzle,et al.  Adaptive optimization for self: reconciling high performance with exploratory programming , 1994 .

[5]  Ron Cytron,et al.  Does “just in time” = “better late than never”? , 1997, POPL '97.

[6]  John McCarthy,et al.  Recursive functions of symbolic expressions and their computation by machine, Part I , 1960, Commun. ACM.

[7]  Urs Hölzle,et al.  A third-generation SELF implementation: reconciling responsiveness with performance , 1994, OOPSLA 1994.

[8]  Robert Wilson,et al.  Compiling Java just in time , 1997, IEEE Micro.

[9]  David Keppel,et al.  Shade: a fast instruction-set simulator for execution profiling , 1994, SIGMETRICS.

[10]  Robert G. Burger,et al.  Efficient compilation and profile-driven dynamic recompilation in scheme , 1997 .

[11]  Peter J. Brown.  Throw‐away compiling , 1976, Softw. Pract. Exp..

[12]  Bell Telephone,et al.  Regular Expression Search Algorithm , 1968 .

[13]  Joe L. Armstrong.  The development of Erlang , 1997, ICFP '97.

[14]  Peter Van Roy,et al.  The Wonder Years of Sequential Prolog Implementation , 1996 .

[15]  Peter Van Roy,et al.  1983-1993: The Wonder Years of Sequential Prolog Implementation , 1994, J. Log. Program..

[16]  Urs Hölzle,et al.  Type feedback vs. concrete type inference: a comparison of optimization techniques for object-oriented languages , 1995, OOPSLA.

[17]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[18]  Charles Consel,et al.  A general approach for run-time specialization and its application to C , 1996, POPL '96.

[19]  Craig Chambers,et al.  The design and implementation of the self compiler, an optimizing compiler for object-oriented programming languages , 1992 .

[20]  Craig Chambers,et al.  Making pure object-oriented languages practical , 1991, OOPSLA '91.

[21]  Mark Leone,et al.  Dynamo: A Staged Compiler Architecture for Dynamic Program Optimization , 1997 .

[22]  Michael Franz,et al.  Slim binaries , 1997, CACM.

[23]  Robert W. Sebesta,et al.  Concepts of programming languages (2. ed.) , 1993, Benjamin/Cummings series in computer science.

[24]  Terrence C. Miller.  Tentative compilation: A design for an APL compiler , 1979, APL '79.

[25]  Peter J. Brown.  Writing Interactive Compilers and Interpreters , 1979 .

[26]  Dawson R. Engler,et al.  Derive: a tool that automatically reverse-engineers instruction encodings , 2000, Dynamo.

[27]  Antonio Cantoni,et al.  Run Time Interaction with FORTRAN Using Mixed Code , 1976, Comput. J..

[28]  Randall B. Smith,et al.  Programming as an Experience: The Inspiration for Self , 1995, ECOOP.

[29]  Christopher W. Fraser,et al.  Finite-state code generation , 1999, PLDI '99.

[30]  David A. Patterson,et al.  Computer Architecture: A Quantitative Approach , 1969 .

[31]  Donald E. Knuth,et al.  An empirical study of FORTRAN programs , 1971, Softw. Pract. Exp..

[32]  Urs Hijlzle.  A Third-Generation SELF Implementation: Reconciling Responsiveness with Performance , 1998 .

[33]  Brian N. Bershad,et al.  Fast, effective dynamic compilation , 1996, PLDI '96.

[34]  Charles Consel,et al.  Tempo: specializing systems applications and beyond , 1998, CSUR.

[35]  Peter Lee,et al.  Lightweight Run-Time Code Generation , 1994, PEPM.

[36]  Ralph Clarke Haygood.  Native Code Compilation in SICStus Prolog , 1994, ICLP.

[37]  Cindy Zheng,et al.  PA-RISC to IA-64: Transparent Execution, No Recompilation , 2000, Computer.

[38]  Peter Lee,et al.  Run-time code generation and modal-ML , 1998, PLDI.

[39]  L. Peter Deutsch,et al.  Efficient implementation of the smalltalk-80 system , 1984, POPL.

[40]  S. C. Schroeder,et al.  A high order language optimal execution processor Fast Intent Recognition System (FIRST) , 1973, HLLCA '73.

[41]  Thomas Pittman.  Two-level hybrid interpreter/native code execution for combined space-time program efficiency , 1987, PLDI.

[42]  Mikael Pettersson,et al.  A high performance Erlang system , 2000, PPDP '00.

[43]  L. Geppert,et al.  Transmeta's magic show [microprocessor chips] , 2000 .

[44]  J. L. Dawson.  Combining Interpretive Code with Machine Code , 1973, Comput. J..

[45]  Ole Agesen,et al.  Concrete type inference: delivering object-oriented applications , 1995 .

[46]  Ole Agesen.  Design and Implementation of Pep, A Java Just-in-Time Translator , 1997, Theory Pract. Object Syst..

[47]  Thomas Kistler.  Dynamic Runtime Optimization , 1997, JMLC.

[48]  Markus Mock,et al.  Calpa: atool for automating dynamic compilation , 1999 .

[49]  Dawson R. Engler,et al.  C: a language for high-level, efficient, and machine-independent dynamic code generation , 1995, POPL '96.

[50]  Luca Cardelli,et al.  Compiling a functional language , 1984, LFP '84.

[51]  共立出版株式会社.  コンピュータ・サイエンス : ACM computing surveys , 1978 .

[52]  Michael Gschwind,et al.  Dynamic and Transparent Binary Translation , 2000, Computer.

[53]  C. May.  Mimic: a fast system/370 simulator , 1987, PLDI 1987.

[54]  Sorin Lerner,et al.  Mojo: A Dynamic Optimization System , 2000 .

[55]  Richard P. Gabriel,et al.  Performance and evaluation of Lisp systems , 1985 .

[56]  Peter C. Poole,et al.  A Mixed Code Approach , 1973, Comput. J..

[57]  Alexander V. Veidenbaum,et al.  Innovative Architecture for Future Generation High-Performance Processors and Systems , 2003, Innovative Architecture for Future Generation High-Performance Processors and Systems, 2003.

[58]  Julia L. Lawall,et al.  Static and Dynamic Program Compilation by Interpreter Specialization , 2000, High. Order Symb. Comput..

[59]  K. Ebcioglu,et al.  Daisy: Dynamic Compilation For 10o?40 Architectural Compatibility , 1997, Conference Proceedings. The 24th Annual International Symposium on Computer Architecture.

[60]  Dawson R. Engler,et al.  VCODE: a retargetable, extensible, very fast dynamic code generation system , 1996, PLDI '96.

[61]  Ken Thompson,et al.  Programming Techniques: Regular expression search algorithm , 1968, Commun. ACM.

[62]  Z. Kulpa.  Review of "Smalltalk-80: The Language and its Implementation by A. Goldberg, and D. Robson", Addison-Wesley Publ., Co., 1983, 0-201-11371-6 , 1985, COMG.

[63]  Toshiaki Yasue,et al.  Design, implementation, and evaluation of optimizations in a just-in-time compiler , 1999, JAVA '99.

[64]  Ali-Reza Adl-Tabatabai,et al.  Fast, effective code generation in a just-in-time Java compiler , 1998, PLDI.

[65]  Randall B. Smith,et al.  SELF: The power of simplicity , 1987, OOPSLA '87.

[66]  Hanspeter Mössenböck.  The Oberon System , 1992, TOOLS.

[67]  John C. Mitchell,et al.  Concepts in programming languages , 2002 .

[68]  John Hammond.  BASIC—an evaluation of processing methods and a study of some programs , 1977, Softw. Pract. Exp..

[69]  Erik R. Altman,et al.  Efficient Java exception handling in just-in-time compilation , 2000, JAVA '00.

[70]  David Keppel,et al.  A portable interface for on-the-fly instruction space modification , 1991, ASPLOS IV.

[71]  Wei Li,et al.  Briki: an optimizing Java compiler , 1997, Proceedings IEEE COMPCON 97. Digest of Papers.

[72]  Randall B. Smith,et al.  Self: The power of simplicity , 1987, OOPSLA 1987.

[73]  Craig Chambers,et al.  Iterative type analysis and extended message splitting; optimizing dynamically-typed object-oriented programs , 1990, PLDI '90.

[74]  Gilbert Joseph Hansen,et al.  Adaptive systems for the dynamic run-time optimization of programs. , 1974 .

[75]  Charles Consel,et al.  Efficient incremental run-time specialization for free , 1999, PLDI '99.

[76]  J. G. Mitchell,et al.  LC2: a language for conversational computing , 1967 .

[77]  Vasanth Bala,et al.  Transparent Dynamic Optimization , 1999 .

[78]  John McCarthy,et al.  History of LISP , 1978, SIGP.

[79]  Erik R. Altman,et al.  Daisy: Dynamic Compilation For 10o?40 Architectural Compatibility , 1997, Conference Proceedings. The 24th Annual International Symposium on Computer Architecture.

[80]  Dawson R. Engler,et al.  Derive: a tool that automatically reverse-engineers instruction encodings , 2000 .

[81]  Alexandru Nicolau,et al.  Java annotation-aware just-in-time (AJIT) complilation system , 1999, JAVA '99.

[82]  David A. Patterson,et al.  Computer Architecture - A Quantitative Approach, 5th Edition , 1996 .

[83]  Alan J. Perlis,et al.  LC2: a language for conversational computing , 1967, Symposium on Interactive Systems for Experimental Applied Mathematics.

[84]  Michael Franz,et al.  Continuous program optimization , 1999 .

[85]  S. C. Schroeder,et al.  A high order language optimal execution processor: Fast Intent Recognition System (FIRST) , 1973, HLLCA '73.

[86]  Cathy May,et al.  Mimic: a fast system/370 simulator , 1987, SIGPLAN '87.

[87]  Cristina Cifuentes,et al.  Machine-adaptable dynamic binary translation , 2000 .

[88]  Peter Lee,et al.  Optimizing ML with run-time code generation , 1996, PLDI '96.

[89]  Urs Hölzle,et al.  Optimizing dynamically-dispatched calls with run-time type feedback , 1994, PLDI '94.

[90]  James R. Bell,et al.  Threaded code , 1973, CACM.

[91]  Ian Piumarta,et al.  Optimizing direct threaded code by selective inlining , 1998, PLDI 1998.

[92]  Craig Chambers,et al.  An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes , 1989, OOPSLA 1989.

[93]  Erik R. Altman,et al.  LaTTe: a Java VM just-in-time compiler with fast and efficient register allocation , 1999, 1999 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.PR00425).

[94]  Philip S. Abrams,et al.  An APL machine , 1970 .

[95]  Michael Steffen Oliver Franz,et al.  Code_generation On_the_fly: a Key to Portable Software , 1994 .

[96]  Erik R. Altman,et al.  BOA: The Architecture of a Binary Translation Processor , 1999 .

[97]  Erik R. Altman,et al.  Welcome to the Opportunities of Binary Translation , 2000, Computer.

[98]  Peter Sestoft,et al.  Partial evaluation and automatic program generation , 1993, Prentice Hall international series in computer science.

[99]  Andreas Krall,et al.  Efficient JavaVM just-in-time compilation , 1998, Proceedings. 1998 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.98EX192).

[100]  Urs Hölzle,et al.  The Space Overhead of Customization , 1997 .

[101]  Urs Hölzle,et al.  A third-generation SELF implementation: reconciling responsiveness with performance , 1994, OOPSLA '94.

[102]  Norman Ramsey,et al.  The New Jersey Machine-Code Toolkit , 1995, USENIX.

[103]  Dawson R. Engler,et al.  DCG: an efficient, retargetable dynamic code generation system , 1994, ASPLOS VI.

[104]  Ronald L. Johnston.  The Dynamic Incremental Compiler of APL\3000 , 1979, APL '79.

[105]  David A. Patterson,et al.  Computer architecture (2nd ed.): a quantitative approach , 1996 .

[106]  Anoop Gupta,et al.  Complete computer system simulation: the SimOS approach , 1995, IEEE Parallel Distributed Technol. Syst. Appl..

[107]  Paul Týma.  Why are we using Java again? , 1998, CACM.

[108]  Dawson R. Engler,et al.  tcc: a system for fast, flexible, and high-level dynamic code generation , 1997, PLDI '97.

[109]  Craig Chambers,et al.  Object, message, and performance: how they coexist in Self , 1992, Computer.