Register Alloca.on. CMPT 379: Compilers Instructor: Anoop Sarkar. anoopsarkar.github.io/compilers-class

Transcription

1 Register Alloca.on CMPT 379: Compilers Instructor: Anoop Sarkar anoopsarkar.github.io/compilers-class 1

2 Register Alloca.on Intermediate code uses unlimited temporaries Simplifying code genera.on and op.miza.on Complicates final transla.on to assembly 2

3 Register Alloca.on The problem: Rewrite the intermediate code to use no more temporaries than there are machine registers Method: Assign mul.ple temporaries to each register But without changing the program behavior 3

4 Example Consider the program a = c + d e = a + b f = e - 1 Assume a & e dead ater use A dead temporary can be reused Can allocate a, e and f all to one register (r1) r1 = r 2 + r 3 r 1 = r 1 + r 4 r 1 = r 1-1 4

5 History Register alloca.on is as old as compilers Register alloca.on was used in the original FORTRAN compiler in 1950 s Very crude algorithm A breakthrough came in 1980 Register alloca.on scheme based on graph coloring Rela.vely simple, global and works well in prac.ce 5

6 Principles of Register Alloca.on Temporaries t 1 can t 2 can share the same register if at any point in the program at most one of t 1 or t 2 is live If t 1 and t 2 are live at the same 8me, they cannot share a register We need liveness analysis 6

7 Live Variables Compute live variables for each point {a,f,c} {d,f,c} {c,e} f = 2*e {f,c} a = b+c d = -a e = d+f {f,c} {d,e,f,c} b = d+e e = e-1 {b,c,f} {b,e,f,c} {b} b = f+c 7

8 Register Interference Graph Construct an undirected graph A node for each temporary An edge between t 1 and t 2 if they are live simultaneously at some point in the program This is the register interference graph (RIG) Two temporaries can be allocated to the same register if there is no edge connec.ng them 8

9 Register Interference Graph For our example f a b e c a and c cannot be in the same register a and d could be in the same register d 9

10 Register Interference Graph Extracts exactly the informa.on we need to characterize legal register alloca.on Gives the global view (i.e., over the en.re control flow graph) picture of the register requirements ATer RIG construc.on the register alloca.on algorithm is architecture independent 10

11 Graph Coloring A coloring of a graph is an assignment of colors to nodes, such that nodes connected by an edge have different colors A graph is k-colorable if it has a coloring with k colors f a c 11

12 Register Alloca.on as Graph Coloring In our problem, colors = registers We need to assign colors (registers) to graph nodes (temporaries) Let k = number of machine registers If the RIG is k-colorable then there is a register assignment that uses no more than k registers 12

13 Example For our example r 2 a r 1 f b r 3 r 2 e c r 4 d r 3 There is no coloring with less than 4 colors There is a 4-coloring of this graph 13

14 Control Flow Graph a = b+c d = -a e = d+f f = 2*e b = d+e e = e-1 b = f+c 14

15 Register Alloca.on r 2 = r 3 +r 4 r 3 = -r 2 r 2 = r 3 + r 1 r 1 = 2* r 2 r 3 = r 3 + r 2 r 2 = r 2-1 r 3 = r 1 + r 4 15

16 Graph Coloring How do we compute graph coloring? It is not easy : The problem is NP-hard. No efficient algorithms are known Solu.on: use heuris.cs A coloring might not exist for a given number of registers Solu.on: register spilling 16

17 Register Alloca.on as Graph Coloring Main idea for solving whether a graph G is k- colorable: Pick any node t with fewer than k neighbors Remove n adjacent edges to create a new graph G If G is k-colorable, then so is G (the original graph) Let c 1,,c n be the colors assigned to the neighbors of t in G Since n<k we can pick some color for t that is different from its neighbors 17

18 Register Alloca.on as Graph Coloring Heuris.c for graph coloring: Ordering nodes (in an stack) 1. Pick a node t with fewer than k neighbors 2. Put t on a stack and remove it from the register interference graph (RIG) 3. Repeat un.l the graph is empty Assigning color to nodes on the stack: 1. Start with the last node added 2. At each step pick a color different from those assigned to already colored neighbors 18

19 Example Assume k=4 a Remove a f b stack={} e c d 19

20 Example Assume k=4 Remove d f b stack={a} e c d 20

21 Example Assume k=4 Note: All nodes now have fewer than 4 neighbors The graph coloring is guaranteed to succeed f e b c Remove c stack={d,a} 21

22 Example Assume k=4 Remove b stack={c,d,a} f e b 22

23 Example Assume k=4 Remove e stack={b,c,d,a} f e 23

24 Example Assume k=4 Remove f f stack={e,b,c,d,a} 24

25 Example Assume k=4 Empty graph done with the first part Now we have the order for assigning colors to nodes, start coloring the nodes (from the top of the stack) stack={f,e,b,c,d,a} 25

26 Example Assume k=4 stack={e,b,c,d,a} r 1 f 26

27 Example Assume k=4 e must be in a different register from f r 1 f stack={b,c,d,a} r 2 e 27

28 Example Assume k=4 stack={c,d,a} r 1 f b r 3 r 2 e 28

29 Example Assume k=4 The ordering insures we can find a color for all nodes r 1 f b r 3 stack={d,a} r 2 e c r 4 29

30 Example Assume k=4 d can be in the same register as b r 1 f b r 3 stack={a} r 2 e c r 4 d r 3 30

31 Example Assume k=4 stack={} a r 2 r 1 f b r 3 r 2 e c r 4 d r 3 31

32 Register Alloca.on as Graph Coloring What happens if the graph coloring heuris.c fails to find a coloring? In this case we cannot hold all values in the registers Some values should be spilled to memory 32

33 K-coloring fails What if all nodes have k or more neighbors? Try to find a 3 coloring of this graph a Remove a f b e c d 33

34 Example of 3-coloring There is no node such that if we remove it then 3-coloring for the graph is available f b e c d 34

35 Op.mis.c Coloring If every node in G has more than k neighbors, k-coloring of G might not be possible Pick a node as candidate for spilling, remove it from the graph and con.nue k-coloring 35

36 Op.mis.c Coloring Remove f and con.nue: The ordering: {c,e,d,b,f,a} b e c d 36

37 Op.mis.c Coloring Color the nodes {c,e,d,b,f,a} Try to assign a color to f We hope that among 4 neighbors of f we use less than 3 colors (op8mis8c coloring) f b r 3 r 2 e c r 1 d r 3 37

38 Spilling If op.mis.c coloring fails, we spill f Allocate a memory loca.on for f Typically in the current stack frame Call this address fa Before each opera.on that reads f, insert f = load fa ATer each opera.on that writes f, insert store f, fa Spilling is slow but some.mes necessary. 38

39 Original Code a = b+c d = -a e = d+f f = 2*e b = d+e e = e-1 b = f+c 39

40 Code ater Spilling f a = b+c d = -a f1 = load fa e = d+f1 f2 = 2*e store f2, fa b = d+e e = e-1 f3 = load fa b = f3+c 40

41 Recompute the Liveness {a, c, f} {c, d, f} f2 = 2*e store f2, fa a = b+c d = -a f1 = load fa e = d+f1 {c, e} {c, d, e, f} {f, c} {b} {f, c} f3 = load fa b = f3+c b = d+e e = e-1 {b, c, f} {b, c, e, f} 41

42 Recompute the Liveness {c, f2} a = b+c {a, c, f} {c, d, f} d = -a f1 = load fa {c, d, f1} e = d+f1 {c, e} {c, d, e, f} f2 = 2*e store f2, fa {f, c} {c, f3} {b} {f, c} f3 = load fa b = f3+c b = d+e e = e-1 {b, c, f} {b, c, e, f} 42

43 Rebuild the Interference Graph New liveness informa.on is almost as before Note f has been split into three temporaries fi is live only Between a fi = load fa and the next instruc.on Between a store fi, fa and the preceding instr. Spilling reduces the live range of f And thus reduces its interferences Which results in fewer RIG neighbors 43

44 Rebuild the Interference Graph Some edges of the spilled nodes are removed In our case f s.ll interferes only with c and d And the new RIG is 3-colorable a f1 b f3 e d c f2 44

45 Spilling Addi.onal spilling might be required before a coloring is found 45

46 Example K=3 remove a a Stack: {} f e b c d 46

47 Example K=3 remove c Stack: {a} f e b c d 47

48 Example K=3 remove b Stack: {c,a} f e b d 48

49 Example K=3 remove e Stack: {b,c,a} f e d 49

50 Example K=3 remove f Stack: {e,b,c,a} f d 50

51 Example K=3 remove d Stack: {f,e,b,c,a} d 51

52 Example K=3 Stack: {d,f,e,b,c,a} 52

53 Example K=3 Stack: {f,e,b,c,a} d r1 53

54 Example K=3 Stack: {e,b,c,a} r2 f d r1 54

55 Example K=3 Stack: {b,c,a} r2 f r3 e d r1 55

56 Example K=3 Stack: {c,a} r2 f r3 e b r3 d r1 56

57 Example K=3 Stack: {a} r2 f r3 e b r3 c Spilled! d r1 57

58 Example K=3 Stack: {} r2 f r3 e a Spilled! b r3 c Spilled! d r1 58

59 Example K=3 Stack: {d,f,e,b,c,a} 59

60 Example K=3 Stack: {f,e,b,c,a} d r1 60

61 Example K=3 Stack: {e,b,c,a} r1 f d r1 61

62 Example K=3 Stack: {b,c,a} r1 f r2 e d r1 62

63 Example K=3 Stack: {c,a} r1 f r2 e b r2 d r1 63

64 Example K=3 Stack: {a} r1 f r2 e b r2 c r3 d r1 64

65 Example K=3 a r3 Stack: {} r1 f r2 e b r2 c r3 d r1 65

66 Spilling Many different heuris.cs for picking a node to spill Spill temporaries with most conflicts Spill temporaries with few defini.ons and uses Avoid spilling in inner loops (heavily visited regions of the code) C allows a register keyword to direct the compiler whether a variable contains a value that is heavily used. 66

67 Live Ranges and Live Intervals The live range for a variable is the set of program points at which that variable is live. The live interval for a variable is the smallest subrange of the IR code containing all a variable's live ranges. A property of the IR code, not CFG. Less precise than live ranges, but simpler to work with 67

68 Live Intervals {a,b,c,d} e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 68

69 e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a Live Intervals {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 69

70 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 70

71 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b c {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 71

72 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b c d {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 72

73 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b c d {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 73

74 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b c d e {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 74

75 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b c d e f {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 75

76 Live Intervals e = d + a f = b + c f = f + b if e==0 goto _L0 d = e + f goto _L1 a b c d e f g {a,b,c,d} {b,c,e} {b,c,e} {b,e,f} {b,e,f} {e,f} _L0: d = e - f _L1: g = d {e,f} {d} {e,f} {d} {d} {g} 76

77 Register Alloca.on with Live Intervals Given the live intervals for all the variables in the program, we can allocate registers using a simple greedy algorithm. Idea: Track which registers are free at each point. When a live interval begins, give that variable a free register. When a live interval ends, the register is once again free. a b c d e f g 77

78 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 78

79 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 79

80 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 80

81 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 81

82 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 82

83 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 83

84 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 84

85 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 85

86 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 86

87 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 87

88 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 88

89 Register Alloca.on with Live a b c d e f g Intervals r1 r2 r3 r4 89

90 Linear Scan Register Alloca.on If a register cannot be found for a variable v, we may need to spill a variable. This algorithm is called linear scan register alloca.on and is a compara.vely new algorithm. Pros: Very efficient Works well in many cases Alloca.on needs one pass, the code can be generated simultaneously Used in JIT compilers like Java HotSpot Cons: Not as good as graph coloring approach 90

91 Summary Register alloca.on is a must have in compilers, because: Intermediate code uses too many temporaries It makes a big difference in performance The liveness at each loca.on can be used for register alloca.on Register alloca.on as heuris.c graph coloring uses live ranges The basis for the technique used in GCC Linear scan register alloca.on uses live intervals OTen used in JIT compilers due to efficiency 91