The Jalapeño virtual machine

Jalapeno is a virtual machine for JavaTM servers written in the Java language. To be able to address the requirements of servers (performance and scalability in particular), Jalapeno was designed "from scratch" to be as self-sufficient as possible. Jalapeno's unique object model and memory layout allows a hardware null-pointer check as well as fast access to array elements, fields, and methods. Run-time services conventionally provided in native code are implemented primarily in Java. Java threads are multiplexed by virtual processors (implemented as operating system threads). A family of concurrent object allocators and parallel type-accurate garbage collectors is supported. Jalapeno's interoperable compilers enable quasi-preemptive thread switching and precise location of object references. Jalapeno's dynamic optimizing compiler is designed to obtain high quality code for methods that are observed to be frequently executed or computationally intensive.

[1]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[2]  John Cocke,et al.  Register Allocation Via Coloring , 1981, Comput. Lang..

[3]  John Cocke,et al.  A methodology for the real world , 1981 .

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

[5]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

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

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

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

[9]  J PritchardD.  Concurrency: Practice and Experience , 1991 .

[10]  Mark N. Wegman,et al.  Efficiently computing static single assignment form and the control dependence graph , 1991, TOPL.

[11]  Christopher W. Fraser,et al.  BURG: fast optimal instruction selection and tree parsing , 1992, SIGP.

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

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

[14]  Ken Arnold,et al.  The Java Programming Language , 1996 .

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

[16]  Frank Yellin,et al.  The Java Virtual Machine Specification , 1996 .

[17]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .

[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.  Whole-program optimization of object-oriented languages , 1996 .

[20]  Frank Tip,et al.  Class hierarchy specialization , 1997, OOPSLA '97.

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

[22]  John Maloney,et al.  Back to the Future The Story of Squeak, A Practical Smalltalk Written in Itself , 1997 .

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

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

[25]  David Grove,et al.  Call graph construction in object-oriented languages , 1997, OOPSLA '97.

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

[27]  Antero Taivalsaari.  Implementing a Java TM Virtual Machine in the Java Programming Language , 1998 .

[28]  Frank Tip,et al.  A study of dead data members in C++ applications , 1998, PLDI.

[29]  Ken Arnold,et al.  The Java programming language (2nd ed.) , 1998 .

[30]  Samuel P. Midkiff,et al.  Optimizing Array Reference Checking in Java Programs , 1998, IBM Syst. J..

[31]  M. Anton Ertl.  Optimal code selection in DAGs , 1999, POPL '99.

[32]  Jong-Deok Choi,et al.  Escape analysis for Java , 1999, OOPSLA '99.

[33]  John Whaley,et al.  Dynamic Optimization through the use of Automatic Runtime Specialization , 1999 .

[34]  Jong-Deok Choi,et al.  Efficient and precise modeling of exceptions for the analysis of Java programs , 1999, PASTE '99.

[35]  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).

[36]  Vivek Sarkar,et al.  Linear scan register allocation , 1999, TOPL.

[37]  Kiyokuni Kawachiya,et al.  A study of locking objects with bimodal fields , 1999, OOPSLA '99.

[38]  Bowen Alpern,et al.  Implementing jalapeño in Java , 1999, OOPSLA '99.

[39]  Samuel P. Midkiff,et al.  Efficient support for complex numbers in Java , 1999, JAVA '99.

[40]  Frank Tip,et al.  Practical experience with an application extractor for Java , 1999, OOPSLA '99.

[41]  Vivek Sarkar,et al.  Dependence Analysis for Java , 1999, LCPC.

[42]  Jong-Deok Choi,et al.  Dynamic linking on a shared-memory multiprocessor , 1999, 1999 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.PR00425).

[43]  Toshiaki Yasue,et al.  Overview of the IBM Java Just-in-Time Compiler , 2000, IBM Syst. J..

[44]  Markus Mock,et al.  DyC: an expressive annotation-directed dynamic compiler for C , 2000, Theor. Comput. Sci..

[45]  Michael H. Kalantar,et al.  Java server benchmarks , 2000, IBM Syst. J..