Fast Effective Dynamic CompilationFast Effective Dynamic Compilation

Joel Auslander, Mathai Philipose, Craig Chambers, etc. Joel Auslander, Mathai Philipose, Craig Chambers, etc. PLDI’96PLDI’96

Department of Computer Science and Engineering Univ. of Washington

Presented by Zhelong Pan April 12th, 2002

IntroductionIntroduction

• Enable optimizations based on the invariant Enable optimizations based on the invariant data computed at run-time:data computed at run-time:– Eliminate memory loadsEliminate memory loads– Perform constant propagation and foldingPerform constant propagation and folding– Remove branchesRemove branches– Fully unroll loopsFully unroll loops

• Overhead: the run-time cost of dynamic Overhead: the run-time cost of dynamic compilation.compilation.

• Goal: Fast compilation and high-quality Goal: Fast compilation and high-quality code.code.

Basic IdeasBasic IdeasStep 1: The programmer

annotates the dynamic regions.

Step 3: Compute and patch the run-time constants to the

template.

Step 2: Generate pre-optimized templates.

Step 4: Use the new code during the execution.

Templates: pre-compiled optimized machine-code containing holes to be filled by the run-time data.

Set-up code: calculating the values of derived run-time constants.

Directives: instructing the dynamic compiler to produce executable code.

AnnotationAnnotationDynamicRegion delineates the section of code to be dynamically compiled. Its arguments indicate the variables are constant at the entry of the dynamic region and remain unchanged.

The contents of arrays and pointer-based data are assumed to be run-time constants. Otherwise, the dereference operators should be used, e.g. x:=dynamic* p, x:=p dynamic->f, and x:=a dynamic[i]

Unroll directs to completely unroll a loop.

To produce several compiled versions, each optimized for a different set of run-time constants, key Variables are defined, e.g. dynamicRegion key(cache)

Static CompilerStatic Compiler

• Identify the constant variables and Identify the constant variables and expressions based on the annotated expressions based on the annotated constants.constants.

• Split into set-up and template code Split into set-up and template code subgraphs.subgraphs.

• Apply the standard optimizations with few Apply the standard optimizations with few restrictions.restrictions.

• Generate machine code and stitcher Generate machine code and stitcher directives.directives.

Computing Derived Run-Time Computing Derived Run-Time ConstantsConstants

Start with the initial set of constants through the Start with the initial set of constants through the control flow graph, updating the set after each control flow graph, updating the set after each instruction as follows:instruction as follows:+ x:=y iff y is a constant.+ x:=y iff y is a constant.+ x:=y op z iff y and z are constants, op is an + x:=y op z iff y and z are constants, op is an

idempotent, side- idempotent, side-effect-free, non-trapping effect-free, non-trapping operator. operator.+ x:=f(y1,…,yn) iff y’s are constants, f is an + x:=f(y1,…,yn) iff y’s are constants, f is an

idempotent, side- idempotent, side-effect-free, non-trapping effect-free, non-trapping function. function. + x:=*p iff p is a constant.+ x:=*p iff p is a constant.– x:=dynamic* p: x is not a constant.– x:=dynamic* p: x is not a constant.– *p:=x– *p:=x

A forward dataflow analysis on A forward dataflow analysis on control flow graphcontrol flow graph

test is not a constant test is a constant

After a control flow merge, if a variable has the same run-time constant reaching definition along all predecessors, it is considered a constant after the merge.

Reachability Analysis(1)Reachability Analysis(1)

A forward dataflow analysis to compute the branch conditions at each program point.

Reachability Analysis (2)Reachability Analysis (2)

If the reachability conditions for each merge predecessor are mutually exclusive, the merge is labeled as a constant merge.

For a constant merge, the union is taken.

For a non-constant merge, the intersection is taken.

(The paper implies it, although it is not given explicitly.)

Reachability Analysis (3)Reachability Analysis (3)

The reachability conditions of the loop entry arc and loop back edge arc are not normally mutually-exclusive, the loop head is treated as a non-constant merge.

For an unrolled loop, only one predecessor arc exists. So, its loop head is a constant merge.

Setup codes, templates, Setup codes, templates, directivesdirectives

Static compiler divides each dynamic region into setup code and template code.

Setup code computes the runtime constants.

Templates contain all the remaining code with “holes” embedded for runtime constants.

Stitcher directives are generated to inform the stitcher to patch the holes and unroll the loops.

OptimizationsOptimizations

• Optimizations (e.g. CSE) can be Optimizations (e.g. CSE) can be performed both before and after the performed both before and after the dynamic region is divided into setup dynamic region is divided into setup and template codes.and template codes.

• Optimizations performed afterwards Optimizations performed afterwards must be modified slightly to deal with must be modified slightly to deal with “holes”, marked as compile time “holes”, marked as compile time constants with unknown values.constants with unknown values.

Experimental ResultsExperimental Results

DiscussionDiscussion

+Using the run time data to do optimization.Using the run time data to do optimization.

+The idea of doing most work during static The idea of doing most work during static compilation is important for dynamic/adaptive compilation is important for dynamic/adaptive compilers.compilers.

– Run-time constant assumption limits its Run-time constant assumption limits its applicability. How much could the real application applicability. How much could the real application gain from it?gain from it?

– Annotation is not added automatically by the Annotation is not added automatically by the compiler, which may require inter-procedural compiler, which may require inter-procedural analysis and pointer analysis.analysis and pointer analysis.