A highly flexible, parallel virtual machine: design and experience of ILDJIT

ILDJIT, a new‐generation dynamic compiler and virtual machine designed to support parallel compilation, is introduced here. Our dynamic compiler targets the increasingly popular ECMA‐335 specification. The goal of this project is twofold: on one hand, it aims at exploiting the parallelism exposed by multi‐core architectures to hide the dynamic compilation latencies by pipelining compilation and execution tasks; on the other hand, it provides a flexible, modular and adaptive framework for dynamic code optimization. The ILDJIT organization and the compiler design choices are presented and discussed highlighting how adaptability and extensibility can be achieved. Thanks to the compilation latency masking effect of the pipeline organization, our dynamic compiler is able to mask most of the compilation delay, when the underlying hardware exposes sufficient parallelism. Even when running on a single core, the ILDJIT adaptive optimization framework manages to speedup the computation with respect to other open‐source implementations of ECMA‐335. Copyright © 2010 John Wiley & Sons, Ltd.

[1]  Matthew Arnold,et al.  Adaptive optimization in the Jalapeno JVM , 2000, SIGP.

[2]  Evelyn Duesterwald.  Dynamic Compilation , 2002, The Compiler Design Handbook.

[3]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[4]  Christopher A. Vick,et al.  The Java HotSpotTM Server Compiler , 2001 .

[5]  Toshiaki Yasue,et al.  A region-based compilation technique for dynamic compilers , 2006, TOPL.

[6]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[7]  Grigori Fursin.  Collective Tuning Initiative: automating and accelerating development and optimization of computing systems , 2009 .

[8]  Vivek Sarkar,et al.  Reducing the overhead of dynamic compilation , 2001, Softw. Pract. Exp..

[9]  W. Richard Stevens,et al.  Unix network programming , 1990, CCRV.

[10]  Ole Agesen,et al.  A comparison of software and hardware techniques for x86 virtualization , 2006, ASPLOS XII.

[11]  Trevor Mudge,et al.  MiBench: A free, commercially representative embedded benchmark suite , 2001 .

[12]  Brian T. Lewis,et al.  The Open Runtime Platform: a flexible high-performance managed runtime environment: Research Articles , 2005 .

[13]  Daryl Maier,et al.  Experiences with multi-threading and dynamic class loading in a Java just-in-time compiler , 2006, International Symposium on Code Generation and Optimization (CGO'06).

[14]  Richard Johnson,et al.  The Transmeta Code Morphing/spl trade/ Software: using speculation, recovery, and adaptive retranslation to address real-life challenges , 2003, International Symposium on Code Generation and Optimization, 2003. CGO 2003..

[15]  Jens Palsberg,et al.  Register allocation by puzzle solving , 2008, PLDI '08.

[16]  Mauricio J. Serrano,et al.  Thin locks: featherweight synchronization for Java , 1998, PLDI '98.

[17]  Hans-Juergen Boehm,et al.  Garbage collection in an uncooperative environment , 1988, Softw. Pract. Exp..

[18]  Bertil Folliot,et al.  Designing highly flexible virtual machines: the JnJVM experience , 2008 .

[20]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[21]  Kenneth R. Anderson,et al.  Performing Lisp analysis of the FANNKUCH benchmark , 1994, LIPO.

[22]  Giovanni Agosta,et al.  Dynamic Look Ahead Compilation: A Technique to Hide JIT Compilation Latencies in Multicore Environment , 2009, CC.

[23]  Michael Gschwind,et al.  Dynamic Binary Translation and Optimization , 2001, IEEE Trans. Computers.

[24]  Giovanni Agosta,et al.  Just-In-Time compilation on ARM processors , 2009, ICOOOLPS@ECOOP.

[25]  Giovanni Agosta,et al.  Jelatine: a virtual machine for small embedded systems , 2006, JTRES '06.

[26]  John H. Hartman,et al.  Toba: Java for Applications - A Way Ahead of Time (WAT) Compiler , 1997, COOTS.

[27]  John Aycock,et al.  A brief history of just-in-time , 2003, CSUR.

[28]  Matthew Arnold,et al.  Dynamic compilation: the benefits of early investing , 2007, VEE '07.

[29]  Priti Shankar,et al.  The Compiler Design Handbook: Optimizations and Machine Code Generation , 2002, The Compiler Design Handbook.

[30]  R. Devaney,et al.  Chaos and Fractals: The Mathematics Behind the Computer Graphics , 1989 .

[31]  P. A. Lee.  Exception handling in C programs , 1983, Softw. Pract. Exp..

[32]  Matthew Arnold,et al.  Adaptive Optimization in the Jalapeo JVM: The Controller's Analytical Model , 2000 .

[33]  David F. Bacon,et al.  Compiler transformations for high-performance computing , 1994, CSUR.

[34]  Lorna Smith,et al.  Benchmarking Java Grande Applications , 2000 .