Tutorial 4

Optimizing Compilation of Java programs
 
Instructors: 
Vivek Sarkar, IBM T.J. Watson Research Center

 
Who Should Attend: 
Conference attendees who are interested in understanding the
the state of the art in optimizing compilation of Java programs,
including capabilities and limitations of current techniques.
This topic will likely be of interest to application developers, compiler writers and researchers interested in improving Java performance.

 
Prerequisites:
Basic knowledge of Java language semantics and runtime environment (including exceptions, threads, synchronization, garbage collection). Basic knowledge of optimizing compilers.

 
Benefits:
After taking this tutorial, you should gain:
  1. an in-depth understanding of the impact of different Java language features on the effectiveness of compiler optimizations, and
  2. an overview of new Java optimizations that are have been developed for the dynamic compilation context.

 
Outline:
1/2 day
  • Impact of Java's novel language features on
    • (static or dynamic) compiler optimizations
    • Optimization in presence of Exceptions
    • GC Maps and Liveness Analysis
    • Optimization of Synchronization Operations (and memory model)
  • Impact of dynamic class loading and dynamic compilation on compiler optimizations
    • Optimistic dynamic analyses with Invalidation
    • Preexistence Analysis and Extant Analysis for devirtualization
    • Fast algorithms for efficient dynamic compilation
Abstract:
In this tutorial, we describe the state of the art in optimizing compilation of Java programs. The tutorial is divided into two parts. In the first part, we discuss Java optimization issues that are relevant to both static and dynamic compilation. There are several aspects of Java semantics that cause complications for traditional optimizations e.g., dynamically allocated arrays, nested arrays,
exceptions, garbage collection, threads, and synchronization. We describe aggressive models for these language features that allow more code motion and optimization to occur, compared to simpler models.

In the second part of the tutorial, we discuss Java optimization issues that are specific to dynamic compilation and to complying with Java's dynamic class loading semantics. We discuss some optimistic analyses that are well-suited to dynamic compilation, along with invalidation/recovery techniques that can guarantee correctness when speculative assumptions are violated. We discuss special cases that only require recompilation, but not invalidation, when dynamic class loading occurs. We also summarize new algorithms for classical optimizations (e.g., global data flow analysis, global register allocation) that are significantly faster than their traditional counterparts, and thus more appropriate for dynamic compilation. The material in this tutorial will be covered using examples from current research Java optimizing compilers --- notably, Jalapeno and Marmot.