Anthony Hosking         
Purdue University, USA
hosking@cs.purdue.edu

Program Optimizations Enabling/Enabled by Object Persistence


Techniques for aggressive optimization of programs often rely on analyses and
transformations that cut across the natural abstraction boundaries that allow
for separate compilation of the source programming language.  These atomic
compilation units typically correspond to natural encapsulation boundaries,
such as procedures in procedural languages, or classes in class-based
object-oriented languages like Java.  Such aggressive analyses and
optimizations then take into account the particular combination of units that
make up a given application program, and specialize the code from each unit
to that particular combination.  For statically-linked languages such as C
and Modula-3, where the units that make up a given program are known
statically, aggressive (and possibly expensive) analysis and optimization can
be performed off-line.  Unfortunately, execution environments for more
dynamic languages such as Java link code into the application as it executes,
precluding analyses and optimizations that may prove too expensive to apply
on-line.  Moreover, even for analyses that are not too expensive to apply
on-line, some candidate optimizing transformations that are safe to apply at
one time may subsequently become invalid if the code base evolves in a way
that violates their safety.
  
Fortunately, persistent object systems usually treat the code base as an
integral part of the persistent store.  For example, the PJama prototype of
orthogonal persistence for Java captures all classes loaded by a persistent
application and stores them in the persistent store.  This code base
approximates the notion of ``whole-program'' that has been exploited in other
optimization frameworks.  We argue for an analysis and optimization framework
that operates against the code base of the PJama persistent store, and which
couples the results of analysis and optimization with PJama's run-time system
to ensure continued correctness of the resulting code.  The framework can
perform extensive analysis over the code in the persistent store, supporting
optimizations that cut across class boundaries in ways that could not be
safely achieved with stand-alone Java classes.