Liveness Analysis and Register Allocation. Xiao Jia May 3 rd, 2013

Transcription

1 Liveness Analysis and Register Allocation Xiao Jia May 3 rd,

2 Outline Control flow graph Liveness analysis Graph coloring Linear scan 2

3 Basic Block The code in a basic block has: one entry point, meaning no instruction is the destination of a jump instruction one exit point, meaning only the last instruction can cause the program to begin executing code in a different basic block. The code may be assembly code or some other sequence of instructions. 3

4 Basic Block (cont.) Formally, a sequence of instructions forms a basic block if: the instruction in each position dominates, or always executes before, all those in later positions, and no other instruction executes between two instructions in the sequence (e.g., no jump destination) 4

5 Generating Basic Blocks (1) Step 1. Identify the leaders in the code. Leaders are instructions which come under any of the following 3 categories : 1. The first instruction is a leader. 2. The target of a conditional or an unconditional goto/ jump instruction is a leader. 3. The instruction that immediately follows a conditional or an unconditional goto/jump instruction is a leader. Step 2. Starting from a leader, the set of all following instructions until and not including the next leader is the basic block corresponding to the starting leader. 5

6 Generating Basic Blocks (2) Instructions that end a basic block include Unconditional and conditional branches, both direct and indirect Returns to a calling procedure The return instruction itself. 6

7 Generating Basic Blocks (3) Instructions which begin a new basic block include Procedure and function entry points Targets of jumps or branches "Fall-through" instructions following some conditional branches 7

8 Control Flow Graph Nodes: basic blocks Edges (directed): jumps * Image from h,p:// 8

9 Liveness Analysis (read 9.2.5) The first value of X is dead (never used) The second value of X is live (may be used) X := 3 X := 4 Live = may be used in the future Y := X 9

10 Liveness Analysis A variable X is live at statement s if There exists a statement s that uses X There is a path from s to s That path has no intervening assignment to X 10

11 use[s] and def[s] gen[s] is the set of variables that are used in s before any assignment kill[s] is the set of variables that are assigned a value in s live-in[s] = use[s] (live-out[s] def[s]) live-out[final] = live-out[s] = p succ[s] live-in[p] 11

12 12

13 13

14 use[b] and def[b] gen[b] is the set of variables that are used in B before any assignment kill[b] is the set of variables that are assigned a value in B live-in[b] = use[b] (live-out[b] def[b]) live-out[final] = live-out[b] = S succ[b] live-in[s] 14

15 Iterative Algorithm 15

16 Questions? 16

17 Register Allocation Want to replace temporary variables with some fixed set of registers Within a single function Interprocedural register allocation is possible! (try to get bonus here) 17

18 We will judge this phase by 1. Code review 2. Limiting # of executed instructions, e.g. no greater than 1 million (1,000,000) Compare: only 160,000 for my optimized 8-queen 18

19 Two Approaches 1. Graph coloring 2. Linear scan 19

20 Graph coloring First: need to know which variables are live after each instruction Two simultaneously live variables cannot be allocated to the same register 20

21 Graph coloring For every node n in CFG, we have out[n] Set of temporaries live out of n Two variables interfere if Control Flow Graph both initially live (i.e. function arguments), or both appear in out[n] for any n, or one is defined and the other is in out[n] x = b - c where x is dead & b is live interfere How to assign registers to variables? 21

22 Interference graph Nodes of the graph = variables Edges connect variables that interfere with one another Nodes will be assigned a color corresponding to the register assigned to the variable Two colors can t be next to one another in the graph 22

23 Interference graph Instructions Live vars b = a + 2 c = b * b b = c + 1 return b * a 23

24 Interference graph Instructions Live vars b = a + 2 c = b * b b = c + 1 return b * a b,a 24

25 Interference graph Instructions Live vars b = a + 2 c = b * b b = c + 1 return b * a a,c b,a 25

26 Interference graph Instructions Live vars b = a + 2 c = b * b b = c + 1 return b * a b,a a,c b,a 26

27 Interference graph Instructions Live vars a b = a + 2 b,a c = b * b a,c b = c + 1 b,a return b * a 27

28 Interference graph color register Instructions Live vars a b = a + 2 a,b c = b * b a,c b = c + 1 a,b return b * a b a $t1 $t2 c 28

29 Interference graph color register Instructions Live vars a b = a + 2 a,b c = b * b a,c b = c + 1 a,b return b * a b a $t1 $t2 c 29

30 Graph coloring Questions: Can we efficiently find a coloring of the graph whenever possible? Can we efficiently find the optimum coloring of the graph? What do we do when there aren t enough colors (registers) to color the graph? 30

31 Coloring a graph Kempe s algorithm [1879] for finding a K- coloring of a graph Step 1 (simplify): find a node with at most K-1 edges and cut it out of the graph. (Remember this node on a stack for later stages.) 31

32 Coloring a graph Once a coloring is found for the simpler graph, we can always color the node we saved on the stack Step 2 (color): when the simplified subgraph has been colored, add back the node on the top of the stack and assign it a color not taken by one of the adjacent nodes 32

33 Coloring color register $t1 $t2 a stack: b c d e 33

34 Coloring color register $t1 $t2 a stack: b c d e c 34

35 Coloring color register $t1 $t2 a d b e c stack: e c 35

36 Coloring color register $t1 $t2 a d b e c stack: a e c 36

37 Coloring color register $t1 $t2 a d b e c stack: b a e c 37

38 Coloring color register $t1 $t2 a d b e c stack: d b a e c 38

39 Coloring color register $t1 $t2 a stack: d b e c b a e c 39

40 Coloring color register $t1 $t2 a d b e c stack: a e c 40

41 Coloring color register $t1 $t2 a stack: b c d e e c 41

42 Coloring color register $t1 $t2 a stack: b c d e c 42

43 Coloring color register $t1 $t2 a stack: b c d e 43

44 Failure If the graph cannot be colored, it will eventually be simplified to graph in which every node has at least K neighbors Sometimes, the graph is still K-colorable! Finding a K-coloring in all situations is an NP-complete problem We will have to approximate to make register allocators fast enough 44

45 Coloring color register $t1 $t2 a stack: b c d e 45

46 Coloring color register $t1 $t2 a b c stack: d d e all nodes have 2 neighbours! 46

47 Coloring color register $t1 $t2 a stack: b c d e b d 47

48 Coloring color register $t1 $t2 a d b e c stack: c e a b d 48

49 Coloring color register $t1 $t2 a stack: d b e c e a b d 49

50 Coloring color register $t1 $t2 a d b e c stack: a b d 50

51 Coloring color register $t1 $t2 a stack: b c d e b d 51

52 Coloring color register $t1 $t2 a stack: b c d e d 52

53 Coloring color register $t1 $t2 a stack: b c d e We got lucky! 53

54 Coloring color register $t1 $t2 Some graphs can t be colored in K colors: a stack: d b e c c b e a d 54

55 Coloring color register $t1 $t2 Some graphs can t be colored in K colors: a d b e c stack: b e a d 55

56 Coloring color register $t1 $t2 Some graphs can t be colored in K colors: a stack: b c d e e a d 56

57 Coloring color register $t1 $t2 Some graphs can t be colored in K colors: a stack: b c d e e a d no colors left for e! 57

58 Spilling Step 3 (spilling): once all nodes have K or more neighbors, pick a node for spilling Storage on the stack There are many heuristics that can be used to pick a node not in an inner loop 58

59 Spilling code We need to generate extra instructions to load variables from stack and store them These instructions use registers themselves. What to do? dedicated registers Stupid approach: always keep extra registers handy for shuffling data in and out: what a waste! Better approach:? 59

60 Spilling code We need to generate extra instructions to load variables from stack and store them These instructions use registers themselves. What to do? Stupid approach: always keep extra registers handy for shuffling data in and out: what a waste! Better approach: rewrite code introducing a new temporary; rerun liveness analysis and register allocation 60

61 Rewriting code Consider: add t1, t1, t2 Suppose t2 is selected for spilling and assigned to stack location 24($fp) Introduce a new temporary t3 for just this instruction and rewrite: ld t3, 24($fp) add t1, t1, t3 Advantage: t3 has a very short live range and is much less likely to interfere. Rerun the algorithm; fewer variables will spill 61

62 Precolored Nodes See Tiger book for more details Some variables are pre-assigned to registers Frame pointer Arguments ($a0, $a1, $a2, $a3) Function call defines (trashes) caller-save registers Treat these registers as special temporaries; before beginning, add them to the graph with their colors 62

63 Precolored Nodes See Tiger book for more details Can t simplify a graph by removing a precolored node Precolored nodes are the starting point of the coloring process Once simplified down to colored nodes start adding back the other nodes as before 63

64 Optimizing Moves Code generation produces a lot of extra move instructions mov t1, t2 If we can assign t1 and t2 to the same register, we do not have to execute the mov Idea: if t1 and t2 are not connected in the interference graph, we coalesce into a single variable 64

65 Coalescing Problem: coalescing can increase the number of interference edges and make a graph uncolorable coalesce t1 t2 t1/t2 Solution 1 (Briggs): avoid creation of high-degree (>= K) nodes Solution 2 (George): a can be coalesced with b if every neighbour t of a: already interferes with b, or has low-degree (< K) 65

66 Simplify & Coalesce Step 1 (simplify): simplify as much as possible without removing nodes that are the source or destination of a move (move-related nodes) Step 2 (coalesce): coalesce move-related nodes provided low-degree node results Step 3 (freeze): if neither steps 1 or 2 apply, freeze a move instruction: registers involved are marked not move-related and try step 1 again 66

67 Overall Algorithm Read papers for more variations Simplify, freeze and coalesce Liveness Mark possible spills Color & detect actual spills Rewrite code to implement actual spills 67

68 Questions? 68

69 Linear scan Given the live ranges of variables in a function, the algorithm scans all the live ranges in a single pass, allocating registers to variables in a greedy fashion. M. Poletto, V. Sarkar. Linear scan register allocation

70 70

71 71

72 72

73 Example Initially, active is empty # of available registers is R=2 73

74 Example Step 1: active=<a> # of available registers is R=2 74

75 Example Step 2: active=<a,b> # of available registers is R=2 75

76 Example Step 3: 3 live intervals overlap # of available registers is R=2 76

77 Example # of available registers is R=2 Step 3: 3 live intervals overlap spills C, whose interval ends furthest away from the current point active=<a,b> 77

78 Example Step 4: A expires active=<a,b,d> # of available registers is R=2 78

79 Example Step 5: B expires active=<b,d,e> # of available registers is R=2 79

80 Example In the end, C is the only variable not allocated to a register. # of available registers is R=2 80

81 Example In the end, C is the only variable not allocated to a register. # of available registers is R=2 Otherwise, both one of A and B and one of D and E would have been spilled to memory. 81

82 Questions? 82

83 Conclusion # of slides Graph coloring: ~50 Linear scan: ~10 Linear scan is much simpler! Only about 10% slower than a perfectly implemented graph coloring algorithm And your code may not be that perfect J Try to get bonus by comparing extensively the two approaches 83

84 Acknowledgements Wikipedia: basic block, control flow graph Graph coloring slides are adapted from Register Allocation by David Walker Linear scan pseudo-code and example are adapted from Linear Scan Register Allocation by M. Poletto and V. Sarkar. 84