Compiler Principles Fall 2015-2016 Compiler Principles Lecture 11: Register Allocation Roman Manevich Ben-Gurion University of the Negev.

Slides:



Advertisements
Similar presentations
Register Allocation COS 320 David Walker (with thanks to Andrew Myers for many of these slides)
Advertisements

School of EECS, Peking University “Advanced Compiler Techniques” (Fall 2011) SSA Guo, Yao.
Register Usage Keep as many values in registers as possible Register assignment Register allocation Popular techniques – Local vs. global – Graph coloring.
P3 / 2004 Register Allocation. Kostis Sagonas 2 Spring 2004 Outline What is register allocation Webs Interference Graphs Graph coloring Spilling Live-Range.
Register allocation Morgensen, Torben. "Register Allocation." Basics of Compiler Design. pp from (
Register Allocation CS 320 David Walker (with thanks to Andrew Myers for most of the content of these slides)
Compiler Principles Winter Compiler Principles Loop Optimizations and Register Allocation Mayer Goldberg and Roman Manevich Ben-Gurion University.
Compilation 2011 Static Analysis Johnni Winther Michael I. Schwartzbach Aarhus University.
Coalescing Register Allocation CS153: Compilers Greg Morrisett.
Register Allocation Mooly Sagiv Schrierber Wed 10:00-12:00 html://
COMPILERS Register Allocation hussein suleman uct csc305w 2004.
Graph-Coloring Register Allocation CS153: Compilers Greg Morrisett.
Stanford University CS243 Winter 2006 Wei Li 1 Register Allocation.
Register Allocation CS 671 March 27, CS 671 – Spring Register Allocation - Motivation Consider adding two numbers together: Advantages: Fewer.
Carnegie Mellon Lecture 6 Register Allocation I. Introduction II. Abstraction and the Problem III. Algorithm Reading: Chapter Before next class:
1 CS 201 Compiler Construction Lecture 12 Global Register Allocation.
Register Allocation Mooly Sagiv html://
Improving code generation. Better code generation requires greater context Over expressions: optimal ordering of subtrees Over basic blocks: Common subexpression.
Register Allocation (Slides from Andrew Myers). Main idea Want to replace temporary variables with some fixed set of registers First: need to know which.
Register Allocation Mooly Sagiv Make-Up Class Optional Material Friday 10:00-13:00 Schriber 6 html://
Prof. Bodik CS 164 Lecture 171 Register Allocation Lecture 19.
Register Allocation (via graph coloring)
CMPUT Compiler Design and Optimization1 CMPUT680 - Fall 2003 Topic 7: Register Allocation and Instruction Scheduling José Nelson Amaral
U NIVERSITY OF M ASSACHUSETTS, A MHERST Department of Computer Science Emery Berger University of Massachusetts, Amherst Advanced Compilers CMPSCI 710.
Register Allocation (via graph coloring). Lecture Outline Memory Hierarchy Management Register Allocation –Register interference graph –Graph coloring.
Compiler Construction Recap Rina Zviel-Girshin and Ohad Shacham School of Computer Science Tel-Aviv University.
1 Liveness analysis and Register Allocation Cheng-Chia Chen.
Improving Code Generation Honors Compilers April 16 th 2002.
Improving code generation. Better code generation requires greater context Over expressions: optimal ordering of subtrees Over basic blocks: Common subexpression.
Register Allocation Recap Mooly Sagiv html:// Special Office Hours Wednesday 12-14, Thursday 12-14, Schriber.
4/29/09Prof. Hilfinger CS164 Lecture 381 Register Allocation Lecture 28 (from notes by G. Necula and R. Bodik)
Register Allocation Mooly Sagiv html://
Register Allocation and Spilling via Graph Coloring G. J. Chaitin IBM Research, 1982.
CS745: Register Allocation© Seth Copen Goldstein & Todd C. Mowry Register Allocation.
Λλ Fernando Magno Quintão Pereira P ROGRAMMING L ANGUAGES L ABORATORY Universidade Federal de Minas Gerais - Department of Computer Science P ROGRAM A.
Supplementary Lecture – Register Allocation EECS 483 University of Michigan.
Spring 2014Jim Hogg - UW - CSE - P501P-1 CSE P501 – Compiler Construction Register allocation constraints Local allocation Fast, but poorer code Global.
U NIVERSITY OF D ELAWARE C OMPUTER & I NFORMATION S CIENCES D EPARTMENT Optimizing Compilers CISC 673 Spring 2009 Register Allocation John Cavazos University.
CMPE 511 Computer Architecture A Faster Optimal Register Allocator Betül Demiröz.
ANALYSIS AND IMPLEMENTATION OF GRAPH COLORING ALGORITHMS FOR REGISTER ALLOCATION By, Sumeeth K. C Vasanth K.
Compiler Principles Fall Compiler Principles Lecture 0: Local Optimizations Roman Manevich Ben-Gurion University.
Graph Colouring L09: Oct 10. This Lecture Graph coloring is another important problem in graph theory. It also has many applications, including the famous.
Global Register Allocation via Graph Coloring Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. Students enrolled in Comp.
Compilation (Semester A, 2013/14) Lecture 10: Register Allocation Noam Rinetzky Slides credit: Roman Manevich, Mooly Sagiv and Eran Yahav.
Register Usage Keep as many values in registers as possible Keep as many values in registers as possible Register assignment Register assignment Register.
Register Allocation CS 471 November 12, CS 471 – Fall 2007 Register Allocation - Motivation Consider adding two numbers together: Advantages: Fewer.
Compiler Principles Fall Compiler Principles Lecture 12: Register Allocation Roman Manevich Ben-Gurion University.
Register Allocation: Graph Coloring Compiler Baojian Hua
2/22/2016© Hal Perkins & UW CSEP-1 CSE P 501 – Compilers Register Allocation Hal Perkins Winter 2008.
Compiler Principles Fall Compiler Principles Lecture 8: Intermediate Representation Roman Manevich Ben-Gurion University.
1 Liveness analysis and Register Allocation Cheng-Chia Chen.
COMPILERS Liveness Analysis hussein suleman uct csc3003s 2009.
Compilation (Semester A, 2013/14)
Global Register Allocation Based on
Mooly Sagiv html://
Fall Compiler Principles Lecture 9: Register Allocation
Register Allocation Hal Perkins Autumn 2009
Register Allocation Noam Rinetzky Text book:
Topic 12: Register Allocation
Compilation /17a Lecture 10
CSC D70: Compiler Optimization Register Allocation
Register Allocation Hal Perkins Autumn 2011
Liveness Analysis and Register Allocation
Compiler Construction
Lecture 17: Register Allocation via Graph Colouring
COMPILERS Liveness Analysis
Fall Compiler Principles Lecture 13: Summary
(via graph coloring and spilling)
CS 201 Compiler Construction
Presentation transcript:

Compiler Principles Fall Compiler Principles Lecture 11: Register Allocation Roman Manevich Ben-Gurion University of the Negev

Syllabus Front End Scanning Top-down Parsing (LL) Bottom-up Parsing (LR) Intermediate Representation Lowering Operational Semantics Lowering Correctness Optimizations Dataflow Analysis Loop Optimizations Code Generation Register Allocation 2 mid-termexam

Previously Dataflow framework – Loop optimizations 3

agenda The need for register allocation Global register allocation 4

5 Register allocation motivation

Registers Most machines have a set of registers, dedicated memory locations that – can be accessed quickly, – can have computations performed on them, and – exist in small quantity Using registers intelligently is a critical step in any compiler – A good register allocator can generate code orders of magnitude better than a bad register allocator 6

Register allocation In TAC, there are an unlimited number of variables On a physical machine there are a small number of registers: – x86 has four general-purpose registers and a number of specialized registers – MIPS has twenty-four general-purpose registers and eight special-purpose registers Register allocation is the process of assigning variables to registers and managing data transfer in and out of registers 7

Challenges in register allocation Registers are scarce – Often substantially more IR variables than registers – Need to find a way to reuse registers whenever possible Registers are complicated – x86: Each register made of several smaller registers; can't use a register and its constituent registers at the same time – x86: Certain instructions must store their results in specific registers; can't store values there if you want to use those instructions – MIPS: Some registers reserved for the assembler or operating system – Most architectures: Some registers must be preserved across function calls 8

9 naive register allocation

Simple approach Problem: program execution very inefficient – moving data back and forth between memory and registers 10 x := y + z mov 16(%ebp), %eax mov 20(%ebp), %ebx add %ebx, %eax mov %eax, 24(%ebx) Straightforward solution: Allocate each variable in activation record At each instruction: bring values needed into registers (rematerialization), perform operation, then store result to memory

11 Reusing registers

Find a register allocation 12 b := a + 2 c := b * b b := c + 1 Ret b * a eax ebx register variable ?a ?b ?c

Is this a valid allocation? eax ebx register 13 b := a + 2 c := b * b b := c + 1 Ret b * a registervariable eaxa ebxb eaxc ebx := eax + 2 eax := ebx * ebx ebx := eax + 1 Ret ebx * eax Overwrites previous value of ‘a’ also stored in eax

Is this a valid allocation? eax ebx register 14 b := a + 2 c := b * b b := c + 1 Ret b * a registervariable ebxa eaxb c eax := ebx + 2 eax := eax * eax eax := eax + 1 Ret eax * ebx Value of ‘c’ stored in eax is not needed anymore so reuse it for ‘b’

15 Register interference graph

Main idea For every node n in CFG, we have out[n] – Set of temporaries live out of n Two variables interfere if they appear in the same out[n] of any node n – Cannot be allocated to the same register Conversely, if two variables do not interfere with each other, they can be assigned the same register – We say they have disjoint live ranges How to assign registers to variables? 16

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 17

Liveness analysis b := a + 2 c := b * b b := c + 1 Ret b * a 18

Liveness analysis b := a + 2 c := b * b b := c + 1 {b, a} Ret b * a 19

Liveness analysis b := a + 2 c := b * b {a, c} b := c + 1 {b, a} Ret b * a 20

Liveness analysis b := a + 2 {b, a} c := b * b {a, c} b := c + 1 {b, a} Ret b * a 21

Liveness analysis {a} b := a + 2 {b, a} c := b * b {a, c} b := c + 1 {b, a} Ret b * a 22

Interference graph a cb eax ebx color register 23 {a} b := a + 2 {b, a} c := b * b {a, c} b := c + 1 {b, a} Ret b * a

Colored graph a cb eax ebx color register 24 {a} b := a + 2 {b, a} c := b * b {a, c} b := c + 1 {b, a} Ret b * a

25

26

27 Graph coloring

This problem is equivalent to graph-coloring, which is NP-hard if there are at least three registers No good polynomial-time algorithms (or even good approximations!) are known for this problem We have to be content with a heuristic that is good enough for RIGs that arise in practice 28

Coloring by simplification [Kempe 1879] How to find a K-coloring of a graph Intuition: – Suppose we are trying to K-color a graph and find a node with fewer than K edges – If we delete this node from the graph and color what remains, we can find a color for this node if we add it back in – Reason: fewer than K neighbors  some color must be left over 29

Coloring by simplification [Kempe 1879] How to find a K-coloring of a graph Phase 1: Simplify – Repeatedly simplify graph – When a variable (i.e., graph node) is removed, push it on a stack Phase 2: Select – Unwind stack and reconstruct the graph as follows: Pop variable from the stack Add it back to the graph Color the node for that variable with a color that it doesn’t interfere with 30 simplify select

31 Coloring example

Coloring for K=2 b ed a c stack: eax ebx color register 32

Coloring for K=2 b ed a stack: c c eax ebx color register 33

Coloring for K=2 b ed a stack: e c c eax ebx color register 34

Coloring for K=2 b ed a stack: a e c c eax ebx color register 35

Coloring for K=2 b ed a stack: b a e c c eax ebx color register 36

Coloring for K=2 b ed a stack: d b a e c c eax ebx color register 37

Coloring for K=2 b ed eax ebx color register a stack: b a e c c 38

Coloring for K=2 b e a stack: a e c c eax ebx color register d 39

Coloring for K=2 e a stack: e c c eax ebx color register b d 40

Coloring for K=2 e stack: c c eax ebx color register a b d 41

Coloring for K=2 stack: c eax ebx color register e a b d 42

43 spilling

Failure of heuristic 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

Example where Kempe’s approach fails stack: c eax ebx color register e a b d 45

Example of non 2-colorable graph c eax ebx color register e a b d stack: c b e a d Some graphs can’t be colored in K colors: 46

Example of non 2-colorable graph c eax ebx color register e a b d Some graphs can’t be colored in K colors: stack: b e a d 47

Example of non 2-colorable graph c eax ebx color register e a b d Some graphs can’t be colored in K colors: stack: e a d 48

Example of non 2-colorable graph c eax ebx color register e a b d Some graphs can’t be colored in K colors: stack: e a d no colors left for e! What can we do? 49

Chaitin’s algorithm [CC’82] Choose and remove an arbitrary node, marking it “troublesome” – Use heuristics to choose which one: – When adding node back in, it may be possible to find a valid color – Otherwise, we have to spill that node 50 ?

Chaitin’s algorithm [CC’82] Choose and remove an arbitrary node, marking it “troublesome” – Use heuristics to choose which one: – When adding node back in, it may be possible to find a valid color – Otherwise, we have to spill that node (lowest priority) 51 spill priority = (uo + 10 ui) / deg uo = #use+defs outside of loop ui = #use+defs inside of loop

Spilling Phase 3: Spill – once all nodes have K or more neighbors, pick a node for spilling There are many heuristics that can be used to pick a node Try to pick node not used much, not in inner loop Assign its storage to activation record – Remove it from graph and mark it as potential spill (technically, push on a spill stack) We can now repeat phases 1-2 without this node 52

Chaitin’s algorithm [CC’82] Phase 1: Simplify Phase 2: Select – Unwind stack and reconstruct the graph as follows: Pop (non-spill) variable from the stack Add it back to the graph Color the node for that variable with a color that it doesn’t interfere with its neighbors – Unwind spill stack Pop spill variable If there is an available color add back to graph Otherwise mark variable as actual spill Phase 3: Spill – If all nodes have K or more neighbors, pick a “heavy” node for spilling and add to potential spill stack Phase 4: Rewrite – Rewrite code for actual spill variables – Recompute liveness information – Repeat phases

Chaitin’s algorithm [CC’82] 54 Simplify Mark potential spills Select colors and detect actual spills Rewrite code to implement actual spills Liveness analysis any actual spill done any potential spill done

55 Potential spill example

Color the following graph 56 c a b e AX BX color register CX d f (color) stack: potential spill:

Potential spill example Pick a for potential spill 57 c a b e AX BX color register CX d f (color) stack: potential spill:

Potential spill example Simplify d 58 c a b e AX BX color register CX d f (color) stack: potential spill: a

Potential spill example Simplify e 59 c a b e AX BX color register CX d f (color) stack: d potential spill: a

Potential spill example Simplify b 60 c a b e AX BX color register CX d f (color) stack: e d potential spill: a

Potential spill example Simplify c 61 c a b e AX BX color register CX d f (color) stack: b e d potential spill: a

Potential spill example Simplify f 62 c a b e AX BX color register CX d f (color) stack: c b e d potential spill: a

Potential spill example Select color for f 63 c a b e AX BX color register CX d f (color) stack: f c b e d potential spill: a

Potential spill example Select color for c 64 c a b e AX BX color register CX d f (color) stack: c b e d potential spill: a

Potential spill example Select color for b 65 c a b e AX BX color register CX d f (color) stack: b e d potential spill: a

Potential spill example Select color for e 66 c a b e AX BX color register CX d f (color) stack: e d potential spill: a

Potential spill example Select color for d 67 c a b e AX BX color register CX d f (color) stack: d potential spill: a

Potential spill example Select color for a 68 c a b e AX BX color register CX d f (color) stack: potential spill: a

Potential spill example Done – no actual spill 69 c a b e AX BX color register CX d f (color) stack: potential spill:

70 actual spill example

Actual spill example Apply Chaitin’s algorithm for the following program – The set of registers is AX, BX, CX – Use the Briggs criterion for conservative coalescing – Upon any non-deterministic choice, choose by lexicographic order 71 c := e; a := a + e; d := a + c; d := a + b; d := d + b; // live = {d}

Step 1: compute liveness Let’s compute liveness information 72 {a, b, e} c := e; {a, b, c, e} a := a + e; {a, b, c} d := a + c; {a, b, d} d := a + b; {b, d} d := d + b; // live = {d}

Step 2: draw RIG Simplify d 73 c e a b d (color) stack: potential spill: AX BX color register CX

Potentially spill b #use+def(a)=4, #use+def(b)=2, #use+def(c)=2, #use+def(d)=5, #use+def(e)=2 (potentially) spill b 74 c e a b d (color) stack: d potential spill: AX BX color register CX c := e; a := a + e; d := a + c; d := a + b; d := d + b; // live = {d}

Simplify Simplify a 75 c e a b d (color) stack: d potential spill: b AX BX color register CX

Simplify Simplify c 76 c e a b d (color) stack: a d potential spill: b AX BX color register CX

Simplify Simplify e 77 c e a b d (color) stack: c a d potential spill: b AX BX color register CX

Attempt to color nodes on stack Select color for e 78 c e a b d (color) stack: e c a d potential spill: b AX BX color register CX

Attempt to color nodes on stack Select color for c 79 c e a b d (color) stack: c a d potential spill: b AX BX color register CX

Attempt to color nodes on stack Select color for a 80 c e a b d (color) stack: a d potential spill: b AX BX color register CX

Attempt to color nodes on stack Select color for d 81 c e a b d (color) stack: potential spill: b AX BX color register CX

b cannot be colored Cannot color b – actual spill 82 c e a b d (color) stack: potential spill: b AX BX color register CX

Actual spill: rich assembly Suppose assembly allows commands of the form x:=y+M[offset] Rewrite program for spilled variable b – Choose location on frame: b_loc 83 c := e; a := a + e; d := a + c; d := a + M[b_loc]; d := d + M[b_loc]; // live = {d} c := e; a := a + e; d := a + c; d := a + b; d := d + b; // live = {d}

Actual spill: basic assembly Rewrite program for spilled variable b – Choose location on frame: b_loc – Use temporaries for reading from frame: b1, b2 – Now attempt to color all variables, including temporaries If unable don’t spill temporaries, choose other variables to spill, otherwise can go into infinite spill-color loop 84 c := e; a := a + e; d := a + c; b1 := M[b_loc]; d := a + b1; b2 := M[b_loc]; d := d + b2; // live = {d} c := e; a := a + e; d := a + c; d := a + b; d := d + b; // live = {d}

Compute liveness for new program 85 {a, e} c := e; {a, c, e} a := a + e; {a, c} d := a + c; {a} b1 := M[b_loc]; {a, b1} d := a + b1; {d} b2 := M[b_loc]; {d, b2} d := d + b2; // live = {d}

Attempt to color Simplify b1, b2, d, a, c, e Select colors 86 c e a b2 d AX BX color register CX b1

Attempt to color Simplify b1, b2, d, a, c, e Select colors 87 c e a b2 d AX BX color register CX b1

Emit code based on colors 88 c e a b2 d AX BX color register CX b1 BX := AX; CX := CX + AX; AX := CX + BX; BX := M[b_loc]; AX := CX + BX; BX := M[b_loc]; AX := AX + BX; c := e; a := a + e; d := a + c; b1 := M[b_loc]; d := a + b1; b2 := M[b_loc]; d := d + b2;

89 Register constraints

Handling precolored nodes Some variables are pre-assigned to registers – e.g.: mul on x86/pentium Uses eax; defines eax, edx – e.g.: call on x86/pentium Defines (trashes) caller-save registers eax, ecx, edx To properly allocate registers, treat these register uses as special temporary variables and enter into interference graph as precolored nodes 90

Handling precolored nodes Simplify. Never remove a pre-colored node – it already has a color, i.e., it is a given register Select. Once simplified graph has all colored nodes, add other nodes back in and color them using precolored nodes as starting point 91

92 Optimizing moves

Optimizing move instructions Code generation produces a lot of extra MOVE instructions MOVE t5, t9 If we can assign t5 and t9 to same register, we can get rid of the MOVE – Effectively, copy propagation at the register allocation level Idea: if t5 and t9 are not connected in inference graph, coalesce them into a single variable; the move will be redundant 93

RIG with MOVE edges Add a second type of edges – MOVE edges 94 b ed a c eax ebx color register

Coalescing Problem: coalescing nodes can make a graph un-colorable – Conservative coalescing heuristic What should we do ? 95 aba/b coalesce MOVE

Conservative coalescing Coalesce MOVE edge (a,b) if it does not affect colorability A node is heavy if its degree is ≥K and light otherwise Briggs criterion: coalesce only if the merged node ab has <K heavy neighbors Reason: – Simplify will first remove all light neighbors – ab will then be adjacent to <K neighbors – Simplify can remove ab 96

Conservative coalescing Coalesce MOVE edge (a,b) if it does not affect colorability A node is heavy if its degree is ≥K and light otherwise George criterion: coalesce only if all heavy neighbors of a are also neighbors of b Reason: – Simplify can remove all light neighbors of a – Remaining heavy neighbors of a are neighbors of b so coalescing does not increase the degree of any node 97

Coalescing criterion example c eax ebx color register e a b 98 Can we coalesce (a,e) ? By the Briggs criterion? – #(heavy-neighbors(a,e) < K By the George criterion? – All heavy neighbors of a are also neighbors of e

Coalescing criterion example c eax ebx color register e a b 99 Can we coalesce (a,e) ? By the Briggs criterion? NO – #(heavy-neighbors(a,e) < K By the George criterion? YES – All heavy neighbors of a are also neighbors of e

Simplify, coalesce and freeze Phase 1: Simplify – 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 a MOVE-related edge provided low-degree node results – Step 3 (freeze): if neither steps 1 or 2 apply, freeze a MOVE instruction: low-degree nodes involved are marked not MOVE-related (remove MOVE edge) and try step 1 again – Step 4 (spill): if all nodes are heavy select a candidate for spilling using a priority function and move to potential spill stack Phase 2: Select – Unwind stack and reconstruct the graph as follows: Pop variable from the stack Add it back to the graph Color the node node with a color that it doesn’t interfere with – Unwind potential spill stack and attempt to color node – if unable mark corresponding variable as actual spill Phase 4: Rewrite – Allocate position in frame for spilled variable v – On each usage of v load to v i from frame 100

Simplify, coalesce and freeze 101 Simplify: recursively remove non-MOVE nodes with <K neighbors, pushing them onto stack Coalesce: conservatively merge unconstrained MOVE-related nodes with <K “heavy” neighbors Freeze: give up coalescing on some low-degree MOVE-related node any coalesce done any freeze done any simplify done

Overall algorithm 102 Simplify, freeze and coalesce Simplify, freeze and coalesce Mark potential spills Select colors and detect actual spills Rewrite code to implement actual spills Liveness analysis any actual spill done any potential spill done

103 Coalesce example

Apply Chaitin’s algorithm for the following program – The set of registers is AX, BX, CX – Use the Briggs criterion for conservative coalescing – Upon any non-deterministic choice, choose by lexicographic order 104 a := e; d := a + c; d := d + b; // live = {d}

Step 1: compute liveness 105 {b, c, e} a := e; {a, b, c} d := a + c; {b, d} d := d + b; // live = {d}

Attempt to color Simplify d 106 c e a b d (color) stack: potential spill: AX BX color register CX

Coalesce step Cannot simplify a or e because they are MOVE-related Coalesce (a,e) 107 c e a b d (color) stack: d potential spill: AX BX color register CX

Simplify Simplify ae 108 c ae b d (color) stack: d potential spill: AX BX color register CX

Simplify Simplify b 109 c ae b d (color) stack: ae d potential spill: AX BX color register CX

Simplify Simplify c 110 c ae b d (color) stack: b ae d potential spill: AX BX color register CX

Select Color c 111 c ae b d (color) stack: c b ae d potential spill: AX BX color register CX

Select Color b 112 c ae b d (color) stack: b ae d potential spill: AX BX color register CX

Select Color ae 113 c ae b d (color) stack: ae d potential spill: AX BX color register CX

Select Color d 114 c ae b d (color) stack: d potential spill: AX BX color register CX

Select 115 c ae b d (color) stack: potential spill: AX BX color register CX

Emit code 116 CX := CX; AX := CX + AX; AX := AX + BX; c AX BX color register ae b d CX a := e; d := a + c; d := d + b;

117 Freeze example

Step 1: compute liveness 118 {b, c, e} a := e; {a, b, c} d := a + c; {b, d} d := d + b; // live = {d}

Attempt to color Simplify d 119 c e a b d (color) stack: potential spill: AX BX color register

Attempt to color Can we coalesce a and e according to Briggs? Let’s try 120 c e a b (color) stack: d potential spill: AX BX color register

Unsuccessful attempt to color No, node becomes heavy Undo coalesce and try something else 121 c a&e b (color) stack: d potential spill: AX BX color register

Freeze: simplify a 122 c e a b (color) stack: d potential spill: AX BX color register

Simplify c 123 c e b (color) stack: a d potential spill: AX BX color register

Simplify b 124 e b (color) stack: c a d potential spill: AX BX color register

Simplify e 125 e (color) stack: b c a d potential spill: AX BX color register

Select color for e 126 (color) stack: e b c a d potential spill: AX BX color register

Select color for b 127 (color) stack: b c a d potential spill: AX BX color register e

Select color for c 128 (color) stack: c a d potential spill: AX BX color register e b

Select color for a 129 (color) stack: a d potential spill: AX BX color register e bc

Select color for d 130 (color) stack: d potential spill: AX BX color register e bc a

Select color for d 131 (color) stack: potential spill: AX BX color register e bc a d

132 Linear scan register allocation

Live ranges and live intervals The live range for a variable is the set of program points at which the variable is alive The live interval for a variable is the smallest sub-range of the IR code containing all of a variable’s live ranges – A property of the IR code, not the CFG – Less precise than live ranges, but simpler to work with 133

d Live ranges and live intervals 134 e := d + a f := b + c f := f + b IfZ e Goto _L0 d := e + f d := e – f Goto _L1 _L0: d := e-f _L1: g := d Ret g abc e fg

Register allocation with live ranges 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 We can't always fit everything into a register (spill) 135 dabc e fg

Example 136 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 137 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 138 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 139 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 140 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 141 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 142 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 143 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 144 R0R0 R1R1 R2R2 R3R3 dabc e fg Free registers

Example 145 dabc e fg Free registers R0R0 R1R1 R2R2 R3R3

Example 146 dabc e fg Free registers R0R0 R1R1 R2R2 R3R3

Example 147 dabc e fg Free registers R0R0 R1R1 R2R2 R3R3

Another example 148 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 149 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 150 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 151 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 152 R0R0 R1R1 R2R2 dabc e fg Free registers Which register should we use?

Another example 153 R0R0 R1R1 R2R2 dabc e fg Free registers Which variable should we spill? One with longer interval

Another example 154 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 155 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 156 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 157 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 158 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 159 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 160 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 161 R0R0 R1R1 R2R2 dabc e fg Free registers

Another example 162 R0R0 R1R1 R2R2 dabc e fg Free registers

Linear scan register allocation A relatively new algorithm (Polleto and Sarkar) Advantages: – Very efficient (after computing live intervals, runs in linear time) – Produces good code in many instances – Allocation step works in one pass; can generate code during iteration – Often used in JIT compilers like Java HotSpot Disadvantage – Imprecise due to use of live intervals rather than live ranges 163

Comparison to RA by coloring 164

RA recap Graph-coloring Linear scan 165

Advertisement 1 Program Analysis and Verification course next semester – How to verify programs do what they are supposed to do – How to verify they don’t loop forever – Automatically, without ever running the program 166

Advertisement 2 Are you looking to do some cool research? I am looking for enthusiastic students for M.Sc. Come talk to me 167

Good luck with the exam and the final project! 168