You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 7 Next »

Publications of the Johannes Kepler University

In close collaboration with Sun Microsystems, several research projects of the Institute for System Software at the Johannes Kepler University Linz (JKU) are based on the Java HotSpot™ VM. Parts of the research are already included in the product version of the VM. This page lists all publications that describe the research projects. Some of them might be of general interest because they describe the current production version, especially of the client compiler. The publications of the projects are ordered by relevance, i.e. the most complete and most recent publications are first.

SSA Form and Register Allocation for the Client Compiler

We changed the high-level intermediate representation of the client compiler to use static single assignment (SSA) form, which simplifies global optimizations. Additionally, we implemented a global register allocator that uses the linear scan algorithm. This work is part of the production version since Java 6.

  • Thomas Kotzmann, Christian Wimmer, Hanspeter Mössenböck, Thomas Rodriguez, Kenneth Russell, David Cox: Design of the Java HotSpot™ Client Compiler for Java 6. In ACM Transactions on Architecture and Code Optimization, volume 5, issue 1, article 7. ACM Press, 2008. doi:10.1145/1369396.1370017
    Explains the structure of the client compiler, its intermediate representations, and the optimization algorithms. It describes the client compiler of the Java HotSpot™ VM of Java 6. Java 7 and OpenJDK contain no significant changes, so all information up-to-date.
  • Christian Wimmer: Linear Scan Register Allocation for the Java HotSpot™ Client Compiler. Master's thesis, Institute for System Software, Johannes Kepler University Linz, 2004.
    Extended description of the client compiler, with a focus on the register allocator. Read Chapter 4 for if you are interested in the details of the compiler and the intermediate representations. The term "research compiler" in this thesis refers to the product version of Java 6 (which was not released at the time of writing).

Client Compiler Visualizer

Visualization tool for the internal data structures of the Java HotSpot™ client compiler. The tool shows the high-level and the low-level intermediate representations as well as the lifetime intervals used for register allocation. Additionally, the bytecodes of the compiled methods can be shown. Both textual and graphical views are available. The tool uses information emitted by the debug version of the Java HotSpot™ VM, starting with Java 6.

  • Homepage of the Java HotSpot™ Client Compiler Visualizer: https://c1visualizer.dev.java.net/
    The homepage contains the binary download, the source code repository, and the documentation (several bachelor theses and master's theses).

Ideal Graph Visualizer

The Java HotSpot™ server compiler uses a single intermediate representation in all compiler phases, called ideal graph. The tool saves snapshots of the graph during the compilation. It displays the graphs and provides filtering mechanisms based on customizable JavaScript code and regular expressions. High performance and sophisticated navigation possibilities enable the tool to handle large graphs with thousands of nodes. The tool will be part of the OpenJDK soon, but there is no release available yet.

  • Thomas Würthinger: Visualization of Program Dependence Graphs. Master's thesis, Institute for System Software, Johannes Kepler University Linz, 2007.
    This thesis describes the architecture and implementation of the tool and also contains a user guide. It does not describe the final version, but is still up-to-date.

Array Bounds Check Elimination for the Client Compiler

We added a fast algorithm for array bounds check elimination to the client compiler that optimizes frequently used patterns of array accesses and uses the deoptimization facilities of the Java HotSpot™ VM. This is a research project, but the algorithm could be part of a future product version.

Optimization of Strings

We implemented an optimization that fuses the string object with its character array that holds the actual content. New bytecodes access the characters and allocate the strings. Nevertheless, the optimization is implemented completely inside the VM. The necessary bytecode rewriting is performed by the class loader. Optimized string objects are significantly smaller than the old string and its character array. This eliminates field loads, reduces the memory pressure, and the time necessary for garbage collection. It is a research project, but could show up in a future product version because it has a high impact on the performance.

  • Christian Häubl: Optimized Strings for the Java HotSpot™ Virtual Machine. Master's thesis, Institute for System Software, Johannes Kepler University Linz, 2008.
    This thesis describes the complete architecture and implementation of the optimization, together with a comprehensive evaluation.

Escape Analysis for the Client Compiler

In this research project, we implemented a fast algorithm for escape analysis. It detects objects that are accessible only by a single method or thread. Its results are used to replace fields of objects with scalar variables, to allocate objects on the stack instead of the heap, and to remove synchronization. The produced machine code is smaller and executes faster because fewer objects are allocated on the heap and the garbage collector runs less frequently. Deoptimization is used to handle dynamic class loading. There are currently no plans to integrate this work into the product version, however it influenced the implementation of escape analysis for the server compiler.

Automatic Object Inlining

We designed a feedback-directed optimization system for object inlining and array inlining that utilizes the just-in-time compiler and the garbage collector. Object inlining reduces the costs of field accesses by combining referenced objects with their referencing object. The order of objects on the heap is changed by the garbage collector so that they are placed next to each other. Then their offset is fixed, i.e. the objects are colocated. This allows field loads to be replaced by address arithmetic using the just-in-time compiler. Array inlining expands the concepts of object inlining to arrays, which are frequently used for the implementation of dynamic data structures. There are currently no plans to integrate this work into the product version.

  • Christian Wimmer, Hanspeter Mössenböck: Feedback-Directed Object Inlining and Array Inlining. Technical Report, Institute for System Software, Johannes Kepler University Linz, 2008.
    Summary report that covers all parts of the optimization, but does not describe the algorithmic details. Read this if you want to get familiar with the topic.
  • Christian Wimmer: Automatic Object Inlining in a Java Virtual Machine. PhD thesis, Institute for System Software, Johannes Kepler University Linz, 2008.
    Describes the details of all algorithms and contains an extensive evaluation as well as a survey of related work. Read this if you are interested in the implementation details.
  • Christian Wimmer, Hanspeter Mössenböck: Automatic Object Colocation Based on Read Barriers. In Proceedings of the Joint Modular Languages Conference, LNCS 4228, pages 326-345. Springer-Verlag, 2006. doi:10.1007/11860990_20
    Conference paper that covers only the object colocation part. It describes an early version of the work, so it does not fully reflect the final version.
  • No labels


Terms * Trademarks * License: GPLv2 * Contact Us * Privacy