Advanced Compiler Techniques

LIU Xianhua

School of EECS, Peking University

“Advanced Compiler Techniques”

Content

• Concepts:– Dominators– Depth-First Ordering– Back edges– Graph depth– Reducibility

• Natural Loops• Efficiency of Iterative Algorithms• Dependences & Loop Transformation

Loops are Important!

• Loops dominate program execution time– Needs special treatment during

optimization• Loops also affect the running time of

program analyses– e.g., A dataflow problem can be solved

in just a single pass if a program has no loops

Dominators

• Node d dominates node n if every path from the entry to n goes through d.– written as: d dom n

• Quick observations: Every node dominates itself. The entry dominates every node.

• Common Cases:– The test of a while loop dominates all blocks

in the loop body.– The test of an if-then-else dominates all

blocks in either branch.4

Dominator Tree

• Immediate dominance: d idom n – d dom n, d n, no m s.t. d dom m and m

dom n• Immediate dominance relationships form a

Finding Dominators

• A dataflow analysis problem: For each node, find all of its dominators.– Direction: forward– Confluence: set intersection– Boundary: OUT[Entry] = {Entry}– Initialization: OUT[B] = All nodes– Equations:• OUT[B] = IN[B] U {B}• IN[B] = p is a predecessor of B OUT[p]

Example: Dominators

{1,2,3}

{1}{1} {1}

{1} {1,2}

Depth-First Search

• Start at entry.• If you can follow an edge to an

unvisited node, do so.• If not, backtrack to your parent

(node from which you were visited).

Depth-First Spanning Tree

• Root = entry.• Tree edges are the edges along

which we first visit the node at the head.

Depth-First Node Order

• The reverse of the order in which a DFS retreats from the nodes.

1-4-5-2-3• Alternatively, reverse of postorder

traversal of the tree.3-2-5-4-1

Four Kinds of Edges

1. Tree edges.2. Advancing edges (node to proper

descendant).3. Retreating edges (node to

ancestor, including edges to self).4. Cross edges (between two nodes,

neither of which is an ancestor of the other.

A Little Magic

• Of these edges, only retreating edges go from high to low in DF order.– Example of proof: You must retreat from

the head of a tree edge before you can retreat from its tail.

• Also surprising: all cross edges go right to left in the DFST.– Assuming we add children of any node

from the left.12

Example: Non-Tree Edges

Retreating

Forward

Back Edges

• An edge is a back edge if its head dominates its tail.

• Theorem: Every back edge is a retreating edge in every DFST of every flow graph.– Converse almost always true, but not

always. Backedge

Head reached beforetail in any DFST

Search must reach thetail before retreatingfrom the head, so tail isa descendant of the head

Example: Back Edges

{1,2,3}

Reducible Flow Graphs

• A flow graph is reducible if every retreating edge in any DFST for that flow graph is a back edge.

• Testing reducibility: Remove all back edges from the flow graph and check that the result is acyclic.

• Hint why it works: All cycles must include some retreating edge in every DFST.– In particular, the edge that enters the

first node of the cycle that is visited.“Advanced Compiler Techniques”

DFST on a Cycle

Depth-first searchreaches here first

Search must reachthese nodes beforeleaving the cycle

So this is aretreating edge

Why Reducibility?

• Folk theorem: All flow graphs in practice are reducible.

• Fact: If you use only while-loops, for-loops, repeat-loops, if-then(-else), break, and continue, then your flow graph is reducible.

Example: Remove Back Edges

Remaining graph is acyclic.

Example: Nonreducible Graph

In any DFST, oneof these edges willbe a retreating edge.

But no heads dominate their tails, so deletingback edges leaves the cycle.

Why Care AboutBack/Retreating Edges?1. Proper ordering of nodes during

iterative algorithm assures number of passes limited by the number of “nested” back edges.

2. Depth of nested loops upper-bounds the number of nested back edges.

DF Order and Retreating Edges Suppose that for a RD analysis, we visit

nodes during each iteration in DF order. The fact that a definition d reaches a

block will propagate in one pass along any increasing sequence of blocks.

When d arrives at the tail of a retreating edge, it is too late to propagate d from OUT to IN. The IN at the head has already been

computed for that round.

Example: DF Order

Definition d isGen’d by node 2. The first pass

The second pass

Depth of a Flow Graph

• The depth of a flow graph with a given DFST and DF-order is the greatest number of retreating edges along any acyclic path.

• For RD, if we use DF order to visit nodes, we converge in depth+2 passes.– Depth+1 passes to follow that number

of increasing segments.– 1 more pass to realize we converged.24

Example: Depth = 2

1->4->7 ---> 3->10->17 ---> 6->18->20

increasing

retreating

increasingincreasing

retreating

Pass 1 Pass 2 Pass 3

Similarly . . .

• AE also works in depth+2 passes.– Unavailability propagates along retreat-

free node sequences in one pass.• So does LV if we use reverse of DF

order.– A use propagates backward along paths

that do not use a retreating edge in one pass.

In General . . .

• The depth+2 bound works for any monotone framework, as long as information only needs to propagate along acyclic paths.– Example: if a definition reaches a point,

it does so along an acyclic path.

However . . . Constant propagation does not have this

property.

L: a = b b = c c = 1 goto L

Why Depth+2 is Good

• Normal control-flow constructs produce reducible flow graphs with the number of back edges at most the nesting depth of loops.– Nesting depth tends to be small.

– A study by Knuth has shown that average depth of typical flow graphs =~2.75.

Example: Nested Loops

3 nested while-loops; depth = 3

3 nested repeat-loops; depth = 1

Natural Loops

• A natural loop is defined by:– A single entry-point called header• a header dominates all nodes in the loop

– A back edge that enters the loop header• Otherwise, it is not possible for the flow of

control to return to the header directly from the "loop" ; i.e., there really is no loop.

Find Natural Loops

• The natural loop of a back edge a->b is {b} plus the set of nodes that can reach a without going through b

• Remove b from the flow graph, find all predecessors of a

• Theorem: two natural loops are either disjoint, identical, or nested.

Example: Natural Loops

Natural loopof 3 -> 2

Natural loopof 5 -> 1

Relationship between Loops

• If two loops do not have the same header– they are either disjoint, or– one is entirely contained (nested within) the

other– innermost loop: one that contains no other

loop.• If two loops share the same header– Hard to tell which is the inner loop– Combine as one

Basic Parallelism Examples:

FOR i = 1 to 100a[i] = b[i] + c[i]FOR i = 11 TO 20a[i] = a[i-1] + 3FOR i = 11 TO 20a[i] = a[i-10] + 3

Does there exist a data dependence edge between two different iterations?

A data dependence edge is loop-carried if it crosses iteration boundaries

DoAll loops: loops without loop-carried dependences

Data Dependence of Variables

• True dependence

• Anti-dependence

a = = a

= aa =

a = a =

= a = a

Output dependence

Input dependence

Affine Array Accesses Common patterns of data accesses: (i, j, k

are loop indexes)A[i], A[j], A[i-1], A[0], A[i+j], A[2*i], A[2*i+1], A[i,j], A[i-1, j+1]

Array indexes are affine expressions of surrounding loop indexes Loop indexes: in, in-1, ... , i1 Integer constants: cn, cn-1, ... , c0

Array index: cnin + cn-1in-1+ ... + c1i1+ c0 Affine expression: linear expression + a

constant term (c0)

Formulating DataDependence AnalysisFOR i := 2 to 5 do

A[i-2] = A[i]+1; Between read access A[i] and write access A[i-2]

there is a dependence if: there exist two iterations ir and iw within the loop bounds, s.t. iterations ir & iw read & write the same array element, respectively

∃integers iw, ir 2≤iw,ir≤5 ir=iw-2 Between write access A[i-2] and write access A[i-

2] there is a dependence if:∃integers iw, iv 2≤iw,iv≤5 iw–2=iv–2

To rule out the case when the same instance depends on itself:

add constraint iw ≠ iv“Advanced Compiler Techniques”

Memory Disambiguation Undecidable at Compile Time

read(n)For i = …

a[i] = a[n]

Domain of Data Dependence Analysis Only use loop bounds and array indexes that are

affine functions of loop variablesfor i = 1 to nfor j = 2i to 100

a[i + 2j + 3][4i + 2j][i * i] = …… = a[1][2i + 1][j]

Assume a data dependence between the read & write operation if there exists:

∃integers ir,jr,iw,jw 1 ≤ iw, ir ≤ n 2iw ≤ jw ≤ 1002ir ≤ jr ≤ 10iw + 2jw + 3 = 1 4iw + 2jw = 2ir + 1

Equate each dimension of array access; ignore non-affine ones No solution No data dependence Solution There may be a dependence

Iteration Space

An abstraction for loops

Iteration is represented as coordinates in iteration space.

for i= 0, 5 for j = 0, 3 a[i, j] = 3

Iteration Space An abstraction for

loops for i = 0, 5 for j = i, 3 a[i, j] = 0

Iteration Space An abstraction for

loops for i = 0, 5 for j = i, 7 a[i, j] = 0

10110101

Affine Access

Affine Transform

Loop Transformation

for i = 1, 100 for j = 1, 200 A[i, j] = A[i, j] + 3 end_forend_for

for u = 1, 200 for v = 1, 100 A[v,u] = A[v,u]+ 3 end_forend_for

Old Iteration Space

10100101

New Iteration Space

01011010

10100101

Old Array Accesses

]10,01[

011010,

011001[

New Array Accesses

011010,

011001[

]01,10[

Interchange Loops?

for i = 2, 1000 for j = 1, 1000 A[i, j] = A[i-1, j+1]+3 end_forend_for

• e.g. dependence vector dold = (1,-1)

jfor u = 1, 1000 for v = 2, 1000 A[v, u] = A[v-1, u+1]+3 end_forend_for

Interchange Loops? A transformation is legal, if the new dependence

is lexicographically positive, i.e. the leading non-zero in the dependence vector is positive.

Distance vector (1,-1) = (4,2)-(3,3) Loop interchange is not legal if there exists

dependence (+, -)

oldnew dd

GCD Test

Is there any dependence?

Solve a linear Diophantine equation 2*iw = 2*ir + 1

for i = 1, 100 a[2*i] = … … = a[2*i+1] + 3

GCD The greatest common divisor (GCD) of

integers a1, a2, …, an, denoted gcd(a1, a2, …, an), is the largest integer that evenly divides all these integers.

Theorem: The linear Diophantine equation

has an integer solution x1, x2, …, xn iff gcd(a1, a2, …, an) divides c

cxaxaxa nn ...2211

Examples

Example 1: gcd(2,-2) = 2. No solutions

Example 2: gcd(24,36,54) = 6. Many solutions

122 21 xx

30543624 zyx

Loop Fusion

for i = 1, 1000 A[i] = B[i] + 3end_for

for j = 1, 1000 C[j] = A[j] + 5end_for

for i = 1, 1000 A[i] = B[i] + 3 C[i] = A[i] + 5end_for

Better reuse between A[i] and A[i]

Loop Distribution

for i = 1, 1000 A[i] = A[i-1] + 3end_for

for i = 1, 1000 C[i] = B[i] + 5end_for

for i = 1, 1000 A[i] = A[i-1] + 3 C[i] = B[i] + 5end_for

2nd loop is parallel

Register Blocking

for j = 1, 2*m for i = 1, 2*n A[i, j] = A[i-1, j] + A[i-1, j-1] end_forend_for

for j = 1, 2*m, 2 for i = 1, 2*n, 2 A[i, j] = A[i-1,j] + A[i-1,j-1] A[i, j+1] = A[i-1,j+1] + A[i-1,j] A[i+1, j] = A[i, j] + A[i, j-1] A[i+1, j+1] = A[i, j+1] + A[i, j] end_forend_for

Better reuse between A[i,j] and A[i,j]

“Advanced Compiler Techniques” 58

Virtual Register Allocation

for j = 1, 2*M, 2 for i = 1, 2*N, 2 r1 = A[i-1,j] r2 = r1 + A[i-1,j-1] A[i, j] = r2 r3 = A[i-1,j+1] + r1 A[i, j+1] = r3 A[i+1, j] = r2 + A[i, j-1] A[i+1, j+1] = r3 + r2 end_forend_for

Memory operations reduced to register load/store

8MN loads to 4MN loads

Scalar Replacement

for i = 2, N+1 = A[i-1]+1 A[i] =end_for

t1 = A[1]for i = 2, N+1 = t1 + 1 t1 = A[i] = t1end_for

Eliminate loads and stores for array references

Unroll-and-Jam

for j = 1, 2*M for i = 1, N A[i, j] = A[i-1, j] + A[i-1, j-1] end_forend_for

for j = 1, 2*M, 2 for i = 1, N A[i, j]=A[i-1,j]+A[i-1,j-1] A[i, j+1]=A[i-1,j+1]+A[i-1,j] end_forend_for

Expose more opportunity for scalar replacement

Large Arrays

for i = 1, 1000 for j = 1, 1000 A[i, j] = A[i, j] + B[j, i] end_forend_for

Suppose arrays A and B have row-major layout

B has poor cache locality. Loop interchange will not help.

Loop Blocking

for v = 1, 1000, 20 for u = 1, 1000, 20 for j = v, v+19 for i = u, u+19 A[i, j] = A[i, j] + B[j, i] end_for end_for end_forend_for

Access to small blocks of the arrays has good cache locality.

Loop Unrolling for ILP

for i = 1, 10 a[i] = b[i]; *p = ... end_for

for I = 1, 10, 2 a[i] = b[i]; *p = … a[i+1] = b[i+1]; *p = …end_for

Large scheduling regions. Fewer dynamic branches

Increased code size

Next Time

• Homework– 9.6.2, 9.6.4, 9.6.7

• Single Static Assignment (SSA)– Readings: Cytron'91, Chow'97

Advanced Compiler Techniques

Documents

Transcript of Advanced Compiler Techniques

Compiler Techniques for ILP

p1184-Padua - Advanced Compiler Optimizations for Supercomputers

Enhancing Compiler Techniques for Memory Energy Optimizations

Articles ADVANCED COMPILER OPTIMIZATIONS FOR SUPERCOMPUTERSpolaris.cs.uiuc.edu/~padua/cs320/p1184-padua.pdf · SPECIAL ISSUE Articles ADVANCED COMPILER OPTIMIZATIONS FOR SUPERCOMPUTERS

Compiler Principles, Techniques and Tools

Compiler Techniques for Exposing ILP.ppt

Maya Advanced Techniques - wam.autodesk.comwam.autodesk.com/adsk/files/nparticlesadvancedtechniques2011.pdf · Autodesk Maya Advanced Techniques ... nParticles Advanced Techniques

Advanced Compiler Design

Advanced Compiler Techniques

Compiler Techniques for Loosely-CoupledMulti ... · Compiler Techniques for Loosely-CoupledMulti-ClusterArchitectures Bryan Chow Scalable Concurrent Programming Laboratory ... 1.5

CSCI565 -- Advanced Compiler Design

263-2810: Advanced Compiler Design - ETH Z

Compiler Techniques and Branch Prediction

EECC551 - Shaaban #1 Fall 2005 lec#7 10-11-2005 Static Compiler Optimization Techniques We examined the following static ISA/compiler techniques aimed.

Lecture 15: Instruc.on Level Parallelism -- Introducon ......Lecture 15: Instruc.on Level Parallelism -- Introducon, Compiler Techniques, and Advanced Branch Predic.on CSE 564 Computer

Instruction-Level Parallelism compiler techniques and branch prediction

CS738: Advanced Compiler Optimizations - SSA Continued

Compiler Techniques for Code Compaction - UGentusers.elis.ugent.be/~brdsutte/.../publications/2000TOPLASdebray.pdf · Compiler Techniques for Code Compaction SAUMYA K. DEBRAY and

Language, Compiler and Advanced Data Structure …eprints.cs.univie.ac.at/1561/1/REPORT.pdf · Language, Compiler and Advanced Data ... (High Performance Fortran) ... Compiler and

COMPILER TECHNIQUES FOR MATLAB PROGRAMS - CiteSeer