EECS 583 Lecture 8 Dataflow Analysis Opti II

1
EECS 583 Lecture 8Dataflow Analysis Opti II

• University of Michigan
• February 4, 2002

2
Last time

• Liveness variables that contain useful values
  (i.e., they are consumed)
• USE used before defined
• DEF defined
• IN USE (OUT-DEF)
• OUT Union(IN(successors))
• backward dataflow
• any-path relation
• variable-level info on edges

r1 r2 r3 r6 r4 r5
r2, r3, r5 are live
r4 4 r6 8
r6 r2 r3 r7 r4 r5
r2, r3, r4, r5 are live
3
Last time (2)

• Reaching defs particular definition of a
  variable that is visible at a point
• GEN definition created by an op
• KILL definitions destroyed by an op
• IN Union(OUT(predecessors))
• OUT GEN (IN KILL)
• forward dataflow
• any-path relation
• operation idenifier info on edges

1r1 r2 r3 2r6 r4 r5
1,2 reach
3r4 4 4r6 8
5r6 r2 r3 6r7 r4 r5
1,3,4 reach
4
Generalizing dataflow analysis

• Transfer function
• How information is changed by something (BB)
• OUT GEN (IN KILL) / forward analysis /
• IN GEN (OUT KILL) / backward analysis /
• Meet function
• How information from multiple paths is combined
• IN Union(OUT(predecessors)) / forward
  analysis /
• OUT Union(IN(successors)) / backward analysis
  /
• Generalized dataflow algorithm
• while (change)
• change false
• for each BB
• apply meet function
• apply transfer functions
• if any changes ? change true

5
Liveness using GEN/KILL

• Liveness upward exposed uses

for each basic block in the procedure, X, do
up_use_GEN(X) 0 up_use_KILL(X) 0 for
each operation in reverse sequential order in X,
op, do for each destination operand of
op, dest, do up_use_GEN(X) - dest
up_use_KILL(X) dest
endfor for each source operand of op,
src, do up_use_GEN(X) src
up_use_KILL(X) - src endfor
endfor endfor
6
Example - Liveness with GEN/KILL
meet OUT Union(IN(succs)) xfer IN GEN
(OUT KILL)
r1 MEMr20 r2 r2 1 r3 r1 r4
BB1
up_use_GEN(1) r2,r4
up_use_KILL(1) r1,r3
up_use_GEN(2) r1,r5
up_use_KILL(2) r3,r7
BB2
BB3
r1 r1 5 r3 r5 r1 r7 r3 2
r2 0 r7 23 r1 4
up_use_GEN(3) 0
up_use_KILL(3) r1, r2, r7
BB4
r3 r3 r7 r1 r3 r8 r3 r1 2
up_use_GEN(4.3) r3,r7,r8
up_use_KILL(4.3) r1
up_use_GEN(4.2) r3,r8
up_use_KILL(4.2) r1
up_use_GEN(4.1) r1
up_use_KILL(4.1) r3
7
Beyond liveness (upward exposed uses)

• Upward exposed defs
• Walk ops reverse order
• GEN dest KILL dest
• IN GEN (OUT KILL)
• OUT Union(IN(successors))
• Downward exposed uses
• IN Union(OUT(predecessors))
• OUT GEN (IN-KILL)
• Walk ops forward order
• GEN src KILL - src
• GEN - dest KILL dest
• Downward exposed defs
• IN Union(OUT(predecessors))
• OUT GEN (IN-KILL)
• Walk ops forward order
• GEN dest KILL dest

8
Example Upward exposed defs
r1 MEMr20 r2 r2 1 r3 r1 r4
BB1
BB2
BB3
r1 r1 5 r3 r5 r1 r7 r3 2
r2 0 r7 23 r1 4
BB4
r3 r3 r7 r1 r3 r8 r3 r1 2
9
Example Downward exposed uses
r1 MEMr20 r2 r2 1 r3 r1 r4
BB1
BB2
BB3
r1 r1 5 r3 r5 r1 r7 r3 2
r2 0 r7 23 r1 4
BB4
r3 r3 r7 r1 r3 r8 r3 r1 2
10
Liveness in Elcor

• Calculating the info
• delete_local_analysis_info_for_all_hbs_bbs(Region
  )
• create_local_analysis_info_for_all_hbs_bbs(Region
  )
• Analysis/pred_analysis.cpp
• Calculates intra-BB info (i.e., GEN/KILL)
• el_flow_compute_liveness(Region,
  ANALYZE_ALLREG)
• Analysis/flow_analysis_solver.cpp
• Applies meet/transfer functions to compute IN/OUT
• Generally liveness always done on a Procedure
• Accessing the info
• Stored as an attribute on Control edges from
  branches
• Liveness_info live get_liveness_info(Edge)
• Liveness_info ? ListltOperandgt
• Iterate over it, check for membership, etc.

11
Liveness in Elcor (2)

• Calculate all up/down info
• delete_local_analysis_info_for_all_hbs_bbs(Region
  )
• create_local_analysis_info_for_all_hbs_bbs(Region
  )
• el_flow_compute_four_dataflow_sets(Region,
  ANALYZE_ALLREG)
• Generally only liveness useful for straight-line
  code
• Other sets come into play when scheduling loops
• Moving code across the backedge

12
DU/UD chains

• Convenient way to access/use reaching defs info
• Def-Use chains
• Given a def, what are all the possible consumers
  of the operand produced
• Maybe consumer
• Use-Def chains
• Given a use, what are all the possible producers
  of the operand consumed
• Maybe producer

13
Example DU/UD chains
1 r1 MEMr20 2 r2 r2 1 3 r3 r1 r4
4 r1 r1 5 5 r3 r5 r1 6 r7 r3 2
7 r7 r6 8 r2 0 9 r7 r7 1
10 r8 r7 5 11 r1 r3 r8 12 r3 r1 2
14
DU/UD chains in Elcor

• Calculating the info (Analysis/reaching_defs_solve
  r.cpp)
• Compute liveness first on the procedure
• El_do_reaching_defs(Region, ANALYZE_ALLREG)
• Generally, done on small region, like BB or HB
• Accessing the info
• Stored as an attribute on a Region
• Reaching_defs_info rdi get_reaching_defs_info(R
  egion)
• Reference (El_ref, Graph/ref.h)
• Operand cross operation
• More fine grain that operation (handles multiple
  dests/srcs)
• Given a ref
• ListltEl_refgt defs rdi-gtget_ud_chain(ref)
• Should be a src ref
• ListltEl_refgt uses rdi-gtget_du_chain(ref)
• Should be a dest ref

15
DU/UD chains in Elcor (2)

• Region-level analysis
• Efficiency just analyze over what you are
  interested in
• What about uses/defs outside the region of
  analysis??
• Cant have direct connection, or its not region
  analysis
• But, cant ignore them
• External def/use refs
• El_ref has a type
• EXP_SRC, EXP_DEST (explicit)
• IMP_SRC, IMP_DEST (implicit)
• LIVEIN_DEST (outside def)
• LIVEOUT_SRC (outside use)
• Use global liveness info to create external
  def/use refs
• UD/DU chains contain both inside and outside refs

1 r1 MEMr20 2 r2 r2 1 3 r3 r1 r4
4 r1 r1 5 5 r3 r5 r1 6 r7 r3 2
7 r7 r6 8 r2 0 9 r7 r7 1
10 r8 r7 5 11 r1 r3 r8 12 r3 r1 2
16
What about all-path problems?

• Up to this point
• Any path problems (maybe relations)
• Definition reaches along some path
• Some sequence of branches in which def reaches
• Lots of defs of the same variable may reach a
  point
• Use of Union operator in meet function
• All-path Definition guaranteed to reach
• Regardless of sequence of branches taken, def
  reaches
• Can always count on this
• Only 1 def can be guaranteed to reach
• Availability (as opposed to reaching)
• Available definitions
• Available expressions (could also have reaching
  expressions, but not that useful)

17
Reaching vs available definitions
1r1 r2 r3 2r6 r4 r5
1,2 reach 1,2 available
3r4 4 4r6 8
1,2 reach 1,2 available
1,3,4 reach 1,3,4 available
5r6 r2 r3 6r7 r4 r5
1,2,3,4 reach 1 available
18
Available definition analysis (adefs)

• A definition d is available at a point p if along
  all paths from d to p, d is not killed
• Remember, a definition of a variable is killed
  between 2 points when there is another definition
  of that variable along the path
• r1 r2 r3 kills previous definitions of r1
• Algorithm
• Forward dataflow analysis as propagation occurs
  from defs downwards
• Use the Intersect function as the meet operator
  to guarantee the all-path requirement
• GEN/KILL/IN/OUT similar to reaching defs
• Initialization of IN/OUT is the tricky part

19
Compute GEN/KILL sets for each BB (adefs)
Exactly the same as reaching defs
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!
for each basic block in the procedure, X, do
GEN(X) 0 KILL(X) 0 for each operation
in sequential order in X, op, do for each
destination operand of op, dest, do
G op K all ops which define
dest op GEN(X) G (GEN(X)
K) KILL(X) K (KILL(X) G)
endfor endfor endfor
20
Compute IN/OUT sets for all BBs (adefs)
U universal set of all operations in the
Procedure IN(0) 0 OUT(0) GEN(0) for each
basic block in procedure, W, (W ! 0), do
IN(W) 0 OUT(W) U KILL(W) change
1 while (change) do change 0 for each
basic block in procedure, X, do old_OUT
OUT(X) IN(X) Intersect(OUT(Y)) for all
predecessors Y of X OUT(X) GEN(X)
(IN(X) KILL(X)) if (old_OUT ! OUT(X))
then change 1 endif
endfor endfor
21
Example adefs calculation
1 r1 MEMr20 2 r2 r2 1 3 r3 r1 r4
4 r1 r1 5 5 r3 r5 r1 6 r8 r3 2
7 r7 0 8 r1 r1 5 9 r7 r1 - 6
10 r8 r7 r8 11 r1 r3 r8 12 r3 r1 2
22
Available expression analysis (aexprs)

• An expression is a RHS of an operation
• r2 r3 r4, r3r4 is an expression
• An expression e is available at a point p if
  along all paths from e to p, e is not killed
• An expression is killed between 2 points when one
  of its source operands are redefined
• r1 r2 r3 kills all expressions involving r1
• Algorithm
• Forward dataflow analysis as propagation occurs
  from defs downwards
• Use the Intersect function as the meet operator
  to guarantee the all-path requirement
• Looks exactly like adefs, except GEN/KILL/IN/OUT
  are the RHSs of operations rather than the LHSs

23
Example aexprs calculation
1 r1 r6 r9 2 r2 r2 1 3 r5 r3 r4
4 r1 r2 1 5 r3 r3 r4 6 r8 r3 2
7 r7 r3 r4 8 r1 r1 5 9 r7 r1 - 6
10 r8 r2 1 11 r1 r3 r4 12 r3 r6 r9
24
Efficient calculation of dataflow

• Order basic blocks are visited is important
  (faster convergence)
• Forward analysis DFS order
• Visit a node only when all its predecessors have
  been visited
• Visit(n)
• mark n as visited
• for each successor of n not yet visited, s, do
• Visit (s)
• postorder(n) count
• count 1
• count 1 Visit(entry)
• Backward analysis PostDFS order
• Visit a node only when all of its successors have
  been visited

25
Classical optimization

• 3 classes
• Redundancy elimination
• Creating simpler operations
• Removing unnecessary operations
• 1. Local
• Intra-block (BB, SB, HB)
• Could use dataflow analysis
• Rather just identify occurrences manually in
  Impact/Elcor
• Like a pattern match in the block
• Dataflow for external behavior
• 2. Global
• Inter-block
• Use dataflow analysis for the heavy lifting
• 3. Loop
• Body of a loop, any level of nesting
• Some dataflow, some manual detection

26
Constant propagation

• Forward propagation of moves of the form
• rx L (where L is a literal)
• Maximally propagate
• Assume no instruction encoding restrictions
• When is it legal?
• SRC Literal is a hard coded constant, so never a
  problem
• DEST Must be available
• Guaranteed to reach
• May reach not good enough

r1 5 r2 r1 r3
r1 r1 r2
r7 r1 r4
r8 r1 3
r9 r1 r11
27
Local constant propagation

• Consider 2 ops, X and Y in a BB, X is before Y
• 1. X is a move
• 2. src1(X) is a literal
• 3. Y consumes dest(X)
• 4. There is no definition of dest(X) between X
  and Y
• 5. No danger betw X and Y
• When dest(X) is a Macro reg, BRL destroys the
  value

r1 5 r2 _x r3 7 r4 r4 r1 r1 r1
r2 r1 r1 1 r3 12 r8 r1 - r2 r9 r3
r5 r3 r2 1 r10 r3 r1
28
Global constant propagation

• Consider 2 ops, X and Y in different BBs
• 1. X is a move
• 2. src1(X) is a literal
• 3. Y consumes dest(X)
• 4. X is in a_in(BB(Y))
• 5. Dest(x) is not modified between the top of
  BB(Y) and Y
• 6. No danger betw X and Y
• When dest(X) is a Macro reg, BRL destroys the
  value

r1 5 r2 _x
r1 r1 r2
r7 r1 r2
r8 r1 r2
r9 r1 r2
29
Next time

• Opti, opti, opti
• We wont go over them all, well hit the high
  points
• If time
• How predicates affect dataflow analysis
• Next next time
• Dependence edges
• Flow, anti, output
• Scheduling a basic block

30
Problem of the day (adefs, constant prop)
r1 3 r2 10 r3 r1
r1 r1 1 r7 r1 r2
r2 0
r3 r2 1
r4 r2 r1
r9 r3 r8