check

all.bib

@@ -2,13 +2,75 @@
 %% http://bibdesk.sourceforge.net/
 
 
-%% Created for Jeremy Siek at 2021-01-25 11:35:47 -0500 
+%% Created for Jeremy Siek at 2021-01-25 16:46:49 -0500 
 
 
 %% Saved with string encoding Unicode (UTF-8) 
 
 
 
+@article{Kempe:1879aa,
+	author = {A. B. Kempe},
+	date-added = {2021-01-25 16:46:31 -0500},
+	date-modified = {2021-01-25 16:46:33 -0500},
+	issn = {00029327, 10806377},
+	journal = {American Journal of Mathematics},
+	number = {3},
+	pages = {193--200},
+	publisher = {Johns Hopkins University Press},
+	title = {On the Geographical Problem of the Four Colours},
+	url = {http://www.jstor.org/stable/2369235},
+	volume = {2},
+	year = {1879},
+	Bdsk-File-1 = {YnBsaXN0MDDRAQJccmVsYXRpdmVQYXRoWzIzNjkyMzUucGRmCAsYAAAAAAAAAQEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAACQ=},
+	Bdsk-Url-1 = {http://www.jstor.org/stable/2369235}}
+
+@article{George:1996aa,
+	abstract = {An important function of any register allocator is to target registers so as to eliminate copy instructions. Graph-coloring register allocation is an elegant approach to this problem. If the source and destination of a move instruction do not interfere, then their nodes can be coalesced in the interference graph. Chaitin's coalescing heuristic could make a graph uncolorable (i.e., introduce spills); Briggs et al. demonstrated a conservative coalescing heuristic that preserves colorability. But Briggs's algorithm is too conservative and leaves too many move instructions in our programs. We show how to interleave coloring reductions with Briggs's coalescing heuristic, leading to an algorithm that is safe but much more aggressive.},
+	address = {New York, NY, USA},
+	author = {George, Lal and Appel, Andrew W.},
+	date-added = {2021-01-25 16:28:10 -0500},
+	date-modified = {2021-01-25 16:28:12 -0500},
+	doi = {10.1145/229542.229546},
+	issn = {0164-0925},
+	issue_date = {May 1996},
+	journal = {ACM Trans. Program. Lang. Syst.},
+	keywords = {register coalescing, register allocation, graph coloring, copy propagation},
+	month = may,
+	number = {3},
+	numpages = {25},
+	pages = {300--324},
+	publisher = {Association for Computing Machinery},
+	title = {Iterated Register Coalescing},
+	url = {https://doi.org/10.1145/229542.229546},
+	volume = {18},
+	year = {1996},
+	Bdsk-File-1 = {YnBsaXN0MDDRAQJccmVsYXRpdmVQYXRoXxARMjI5NTQyLjIyOTU0Ni5wZGYICxgAAAAAAAABAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAALA==},
+	Bdsk-Url-1 = {https://doi.org/10.1145/229542.229546}}
+
+@article{Allen:1976aa,
+	abstract = {The global data relationships in a program can be exposed and codified by the static analysis methods described in this paper. A procedure is given which determines all the definitions which can possibly ``reach'' each node of the control flow graph of the program and all the definitions that are ``live'' on each edge of the graph. The procedure uses an ``interval'' ordered edge listing data structure and handles reducible and irreducible graphs indistinguishably.},
+	address = {New York, NY, USA},
+	author = {Allen, F. E. and Cocke, J.},
+	date-added = {2021-01-25 13:51:01 -0500},
+	date-modified = {2021-01-25 13:51:04 -0500},
+	doi = {10.1145/360018.360025},
+	issn = {0001-0782},
+	issue_date = {March 1976},
+	journal = {Commun. ACM},
+	keywords = {data flow analysis, algorithms, flow graphs, compilers, program optimization},
+	month = mar,
+	number = {3},
+	numpages = {11},
+	pages = {137},
+	publisher = {Association for Computing Machinery},
+	title = {A Program Data Flow Analysis Procedure},
+	url = {https://doi.org/10.1145/360018.360025},
+	volume = {19},
+	year = {1976},
+	Bdsk-File-1 = {YnBsaXN0MDDRAQJccmVsYXRpdmVQYXRoXxARMzYwMDE4LjM2MDAyNS5wZGYICxgAAAAAAAABAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAALA==},
+	Bdsk-Url-1 = {https://doi.org/10.1145/360018.360025}}
+
 @incollection{Matula:1972aa,
 	abstract = {Publisher Summary
 This chapter focuses on sequential vertex colorings, where vertices are sequentially added to the portion of the graph already colored, and the new colorings are determined to include each newly adjoined vertex. Considerable literature in the field of graph theory has dealt with the coloring of graphs. The majority of this effort has been devoted to the theory of graph coloring, and relatively little study has been directed toward the design of efficient graph coloring procedures. Because numerous proofs of properties relevant to graph coloring are constructive, many coloring procedures are at least implicit in the theoretical development. The chapter describes the concept of sequential colorings is formalized and certain upper bounds on the minimum number of colors needed to color a graph, the chromatic number x(G). The chief results show that the recursive-smallest-vertex-degree-last-ordering-with-interchange coloring algorithm will color any planar graph in five or fewer colors. The algorithm is evidently quite efficient even on large planar graphs.},
@@ -45,6 +107,7 @@ This chapter focuses on sequential vertex colorings, where vertices are sequenti
 	url = {https://doi.org/10.1145/2402.322385},
 	volume = {30},
 	year = {1983},
+	Bdsk-File-1 = {YnBsaXN0MDDRAQJccmVsYXRpdmVQYXRoXxAPMjQwMi4zMjIzODUucGRmCAsYAAAAAAAAAQEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAACo=},
 	Bdsk-Url-1 = {https://doi.org/10.1145/2402.322385}}
 
 @article{Mitchem:1976aa,
@@ -24705,7 +24768,7 @@ semantics was validated.},
 	title = {Register allocation via coloring},
 	volume = {6},
 	year = {1981},
-	Bdsk-File-1 = {YnBsaXN0MDDRAQJccmVsYXRpdmVQYXRoXWNoYWl0aW44MS5wZGYICxgAAAAAAAABAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAJg==}}
+	Bdsk-File-1 = {YnBsaXN0MDDRAQJccmVsYXRpdmVQYXRoXxAgMS1zMi4wLTAwOTYwNTUxODE5MDA0ODUtbWFpbi5wZGYICxgAAAAAAAABAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAOw==}}
 
 @phdthesis{Briggs:1992yf,
 	author = {Preston Briggs},

book.tex

@@ -4455,13 +4455,14 @@ Early register allocation algorithms were developed for Fortran
 compilers in the 1950s~\citep{Horwitz:1966aa,Backus:1978aa}.  The use
 of graph coloring began in the late 1970s and early 1980s with the
 work of \citet{Chaitin:1981vl} on an optimizing compiler for PL/I. The
-algorithm is based on an observation of \citet{Kempe:1879aa}.  If a
-graph $G$ has a vertex $v$ with degree lower than $k$ (e.g. the number
-of registers), then $G$ is $k$ colorable if the subgraph of $G$ with
-$v$ removed is also $k$ colorable. Suppose that the subgraph is $k$
-colorable.  In the worst case the neighbors of $v$ are assigned
-different colors, but since there are less than $k$ of them, there
-will be one or more colors left over to use for coloring $v$ in $G$.
+algorithm is based on an observation of \citet{Kempe:1879aa} from the
+1870s.  If a graph $G$ has a vertex $v$ with degree lower than $k$
+(e.g. the number of registers), then $G$ is $k$ colorable if the
+subgraph of $G$ with $v$ removed is also $k$ colorable. Suppose that
+the subgraph is $k$ colorable.  At worst the neighbors of $v$ are
+assigned different colors, but since there are less than $k$ of them,
+there will be one or more colors left over to use for coloring $v$ in
+$G$.
 
 The algorithm of \citet{Chaitin:1981vl} removes a low-degree vertex
 $v$ from the graph and recursively colors the rest of the graph. Upon