Preliminary Transformations

1
Preliminary Transformations

• Chapter 4 of Allen and Kennedy

2
Overview

• Why do we need this?
• Requirements of dependence testing
• Stride 1
• Normalized loop
• Linear subscripts
• Subscripts composed of functions of loop
  induction variables
• Higher dependence test accuracy
• Easier implementation of dependence tests

3
An Example

• Programmers optimized code
• Confusing to smart compilers

INC 2 KI 0 DO I 1, 100 DO J 1, 100
KI KI INC U(KI) U(KI) W(J)
ENDDO S(I) U(KI) ENDDO
4
An Example

• Applying induction-variable substitution
• Replace references to AIV with functions of loop
  index

INC 2 KI 0 DO I 1, 100 DO J 1,
100 ! Deleted KI KI INC U(KI
JINC) U(KI JINC) W(J) ENDDO KI
KI 100 INC S(I) U(KI) ENDDO
5
An Example

• Second application of IVS
• Remove all references to KI

INC 2 KI 0 DO I 1, 100 DO J 1, 100
U(KI (I-1)100INC JINC)
U(KI (I-1)100INC JINC) W(J) ENDDO
! Deleted KI KI 100 INC S(I) U(KI
I (100INC)) ENDDO KI KI 100 100 INC
6
An Example

• Applying Constant Propagation
• Substitute the constants

INC 2 ! Deleted KI 0 DO I 1, 100 DO J
1, 100 U(I200 J2 - 200)
U(I200 J2 -200) W(J) ENDDO S(I)
U(I200) ENDDO KI 20000
7
An Example

• Applying Dead Code Elimination
• Removes all unused code

DO I 1, 100 DO J 1, 100 U(I200
J2 - 200) U(I200 J2 - 200)
W(J) ENDDO S(I) U(I200) ENDDO
8
Information Requirements

• Transformations need knowledge
• Loop Stride
• Loop-invariant quantities
• Constant-values assignment
• Usage of variables

9
Loop Normalization

• Lower Bound 1 with Stride 1
• To make dependence testing as simple as possible
• Serves as information gathering phase

10
Loop Normalization

• Algorithm
• Procedure normalizeLoop(L0)
• i a unique compiler-generated LIV
• S1 replace the loop header for L0
• DO I L, U, S
• with the adjusted loop header
• DO i 1, (U L S) / S
• S2 replace each reference to I within the loop
  by
• i S S L
• S3 insert a finalization assignment
• I i S S L
• immediately after the end of the loop
• end normalizeLoop

11
Loop Normalization

• Caveat
• Un-normalized
• DO I 1, M
• DO J I, N
• A(J, I) A(J, I - 1) 5
• ENDDO
• ENDDO
• Has a direction vector of (lt,)
• Normalized
• DO I 1, M
• DO J 1, N I 1
• A(J I 1, I) A(J I 1, I 1)
  5
• ENDDO
• ENDDO
• Has a direction vector of (lt,gt)

12
Loop Normalization

• Caveat
• Consider interchanging loops
• (lt,) becomes (,gt) OK
• (lt,gt) becomes (gt,lt) Problem
• Handled by another transformation
• What if the step size is symbolic?
• Prohibits dependence testing
• Workaround use step size 1
• Less precise, but allow dependence testing

13
Definition-use Graph

• Traditionally called Definition-use Chains
• Provides the map of variables usage
• Heavily used by the transformations

14
Definition-use Graph

• Definition-use graph is a graph that contains an
  edge from each definition point in the program to
  every possible use of the variable at run time
• uses(b) the set of all variables used within the
  block b that have no prior definitions within the
  block
• defsout(b) the set of all definitions within
  block b that are not killed within the block
• killed(b) the set of all definitions that define
  variables killed by other definitions within
  block b

15
Definition-use Graph

• Computing reaches for one block b may immediately
  change all other reaches including b itself since
  reaches(b) is an input into other reaches
  equations
• Archiving correct solutions requires
  simultaneously solving all individual equations
• There is a workaround this

16
Definition-use Graph
17
Definition-use Graph
18
Dead Code Elimination

• Removes all dead code
• What is Dead Code ?
• Code whose results are never used in any Useful
  statements
• What are Useful statements ?
• Are they simply output statements ?
• Output statements, input statements, control flow
  statements, and their required statements
• Makes code cleaner

19
Dead Code Elimination
20
Constant Propagation

• Replace all variables that have constant values
  at runtime with those constant values

21
Constant Propagation
22
Constant Propagation
23
Static Single-Assignment

• Reduces the number of definition-use edges
• Improves performance of algorithms

24
Static Single-Assignment

• Example

25
Forward Expression Substitution

• Example

DO I 1, 100 K I 2 A(K)
A(K) 5 ENDDO
DO I 1, 100 A(I2) A(I2) 5 ENDDO
26
Forward Expression Substitution

• Need definition-use edges and control flow
  analysis
• Need to guarantee that the definition is always
  executed on a loop iteration before the statement
  into which it is substituted
• Data structure to find out if a statement S is in
  loop L
• Test whether level-K loop containing S is equal
  to L

27
Forward Expression Substitution
28
Forward Expression Substitution
29
Forward Expression Substitution
30
Forward Expression Substitution
31
Induction Variable Substitution

• Definition an auxiliary induction variable in a
  DO loop headed by DO I LB, UB, S is any
  variable that can be correctly expressed as cexpr
  I iexprL at every location L where it is used
  in the loop, where cexpr and iexprL are
  expressions that do not vary in the loop,
  although different locations in the loop may
  require substitution of different values of
  iexprL

32
Induction Variable Substitution

• Example
• DO I 1, N
• A(I) B(K) 1
• K K 4
• D(K) D(K) A(I)
• ENDDO

33
Induction Variable Recognition
34
Induction Variable Substitution

• Induction Variable Recognition

35
Induction Variable Substitution
36
Induction Variable Substitution
37
Induction Variable Substitution

• More complex example
• DO I 1, N, 2
• K K 1
• A(K) A(K) 1
• K K 1
• A(K) A(K) 1
• ENDDO
• Alternative strategy is to recognize region
  invariance
• DO I 1, N, 2
• A(K1) A(K1) 1
• K K1 1
• A(K) A(K) 1
• ENDDO

38
Induction Variable Substitution

• Driver

39
IVSub without loop normalization

• DO I L, U, S
• K K N
• A(K)
• ENDDO
• DO I L, U, S
• A(K (I L S) / S N)
• ENDDO
• K K (U L S) / S N

40
IVSub without loop normalization

• Problem
• Inefficient code
• Nonlinear subscript

41
IVSub with Loop Normalization

• I 1
• DO i 1, (U-LS)/S, 1
• K K N
• A (K)
• I I 1
• ENDDO

42
IVSub with Loop Normalization

• I 1
• DO i 1, (U L S) / S, 1
• A (K i N)
• ENDDO
• K K (U L S) / S N
• I I (U L S) / S

43
Summary

• Transformations to put more subscripts into
  standard form
• Loop Normalization
• Constant Propagation
• Induction Variable Substitution
• Do loop normalization before induction-variable
  substitution
• Leave optimizations to compilers