OOPSLA 2002


Tracks
Technical Program
Tutorials
Workshops
DesignFest
Educators' Symposium
Doctoral Symposium
Demonstrations
Posters
Student Research
Competition

Student Volunteers
Special Events
Exhibits
Housing Information
Registration Information
Transportation

Monday, 4 November – 13:30-17:00 Afternoon

17 The Design and Implementation of the Jikes RVM Optimizing Compiler

Michael Hind
IBM T.J. Watson Research Center, hind@watson.ibm.com
David Grove
IBM T.J. Watson Research Center, groved@us.ibm.com

The Jikes Research Virtual Machine (RVM) is a software infrastructure designed to execute Java programs typically used in programming language implementation research. The Jikes RVM is available as an open source project. The Jikes RVM provides the academic and research communities with a flexible open testbed to prototype new virtual machine technologies and experiment with various design alternatives. A large number of academic research groups have already adopted it. It runs on AIX and Linux platforms and demonstrates industrial strength performance for many benchmark programs. The Jikes RVM includes state-of-the-art technologies for dynamic compilation, adaptive optimization, garbage collection, thread scheduling, and synchronization.

This tutorial presents an overview of the Jikes RVM optimizing compiler. The first part of the tutorial covers the structure of the compiler, focusing on the requirements, goals, and design of its intermediate representation (IR). The second part of the tutorial covers some of the compiler's extensive set of analyses and optimizations, ranging from simple local analyses to SSA-based flow-sensitive optimizations with type-based heap analysis. The last part covers the integration of the optimizing compiler into the adaptive optimization system, focusing on instrumentation compilation and feedback-directed optimizations.

Specific issues to be covered include: optimizing the memory model, precise exceptions, and dynamic class loading; compiler requirements for runtime support of garbage collection maps, scheduling (yield points), exception tables, line number information; compiler/runtime system cooperation for fast object allocation and runtime services (for example dynamic type checking or invokeinterface); compiler structure for multiple platforms; tracing an interesting method (for example, one of our enumeration loops from the compiler) through key optimizations to illustrate how type analysis, inlining, scalar replacement, plus a set of traditional optimizations work together; etc.

Attendee background

Attendees should have a general knowledge of basic compiler analysis and optimization technology and general familiarity with the issues in optimizing object-oriented languages. Detailed knowledge of Java is not required.

Format

The tutorial will be lecture based.

Presenters

Michael Hind is a Research Staff Member at IBM's Thomas J. Watson Research Center. He received his Ph.D. from New York University in 1991 and was a professor of computer science at the State University of New York at New Paltz from 1992-1998. He is currently working on the Jikes RVM at IBM, where he is managing the Dynamic Optimization group. His research interests include program analysis, adaptive optimization, and programming languages. Michael was one of two presenters of a full day tutorial at PACT'01 on the Jikes RVM.

David Grove is a Research Staff Member at IBM's Thomas J. Watson Research Center. He received his M.S. and Ph.D. from the University of Washington in 1994 and 1998, respectively, and a B.S. from Yale in 1992. He is one of the implementers of Jikes RVM, focusing on the adaptive optimization system, optimizing compiler, and the interface between the virtual machine and the compilers. His research interests include program language design and implementation, and adaptive optimization.