DaCapo Project

Object-oriented programming languages, notably Java, are gaining greater acceptance because of their software engineering benefits. Java's high-level features such as dynamic class loading, dynamic instantiation of interfaces, automatic memory management, and polymorphism, enable code reuse and an extensible programming style, but make achieving high performance with static compiler analysis much more challenging than for imperative languages such as Fortran and C. A significant source of the performance gap is due to poor memory behavior. Our experiments show a collection of Java programs in the Jikes RVM and in a static compiler (ahead-of-time) spend 40-95% of their time waiting for the memory hierarchy to provide needed data on an aggressive processor. Unfortunately, modern and future processors are only exacerbating the impact of poor memory behavior. We are investigating an integrated attack on this problem that incorporates new memory management techniques, new compiler analyses with both static and dynamic optimizations, profile feedback, run-time techniques that optimize running programs including adaptive garbage collection algorithms, and ways of communicating high-level static and dynamic predictions of program behavior to architectures that can exploit it.

Because of features such as dynamic class loading and polymorphism, a compiler may know less about which pieces of code execute and which data are accessed. We are developing a compiler, run-time system, and enhanced architectural features that react quickly and gracefully to compiler predictions and actual run-time behavior to achieve high performance. For example, we are investigation compile and run-time system cooperation to maintain a preferred memory layout and prefetching policy for objects and their fields. We are using class annotations to instantiate policies at execution time, maintaining them through any reorganization of memory by the garbage collector. To further quantify performance bottlenecks, we are developing tools that associate hardware loads and stores with high-level code and data structures as well as the usual architectural behaviors (but with more detail). We are exploring:

• New garbage collection algorithms to reduce the cost of automatic memory management.

• New performance measurement tools that yield deep understanding of program performance, phase behavior, object demographics, and memory hierarchy performance.

• An integrated compiler/run-time system with feedback, significantly improving performance.

• Mechanisms for communicating among the compiler, run-time, and architecture to enhance memory hierarchy behavior.

These artifacts will enhance the use of object-oriented languages beyond their software engineering benefits and make them competitive for use on important real, large, and data-intensive applications.

Overview of Activities:

We have made significant progress in all the above areas. Most of our work has been designed and implemented in the Jikes RVM, a Java-in-Java virtual machine developed by IBM [AAC⁺99,AAB⁺00]. With respect to Java memory management, we have four major thrusts:

• Object demographic analysis tools for understanding memory management opportunities and problems.
• Collector toolkit designs and implementations to enable us to build new collectors quickly and for research dissemination.
• New garbage collection algorithms to improve performance.
• New collector-neutral optimizations to improve performance.

In the intersection of JIT and ahead-of-time compilation, run-time, and memory system interactions, we have the following activities:

• Performance and memory system analysis tools to understand and tease apart application and garbage collection performance issues.
• Cooperative locality improving garbage collection.
• Compiler optimization evaluation.
• New compiler performance optimizations.
• New compiler energy saving optimizations.
• New cooperative hardware/software memory system optimizations

We also have complementary work on:

• Scalable explicit memory management for parallel C programs
• A memory management toolkit for C
• Molecular computing

We organize our web pages on DaCapo's reseach contributions as follows: (1) memory management, (2) dynamic and cooperative optimizations, and (3) complementary work. Unless otherwise noted, we implement our algorithms and perform our experiments in the IBM Jikes RVM [AAC⁺99,AAB⁺00] which is written in Java. It is a publicly available high performance virtual machine which includes an effective Just-in-Time (JIT) and adaptive optimizing compiler.

Acknowledgments and Disclaimer

This work is supported by NSF ITR CCR-0085792 (this grant). In addition, this work is synergistic with the following grants and support from NSF ACI-9982028, NSF EIA-9726401, NSF CDA-9502639, NSF Career CCR-0133457, NSF IIS-9988637, an IBM faculty partnership award, DARPA F30602-98-1-0101, DARPA F33615-01-C-1892, DARPA F33615-01-C-1894, IBM, Microsoft, and Compaq. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the sponsors.