A Progressive Register Allocator for Irregular Architectures

Transcription

1 A Progressive Register Alloctor for Irulr Architectures Dvid Koes nd Seth Copen Goldstein Computer Science Deprtment Crnegie Mellon University Abstrct Register lloction is one of the most importnt optimiztions compiler performs. Conventionl grphcoloring bsed ister lloctors re fst nd do well on ulr, RISC-like, rchitectures, but perform poorly on irulr, CISC-like, rchitectures with few isters nd nonorthogonl instruction sets. At the other extreme, optiml ister lloctors bsed on integer liner progrmming re cpble of fully modeling nd exploiting the peculirities of irulr rchitectures but do not scle well. We introduce the ide of progressive lloctor. A progressive lloctor finds n initil lloction of qulity comprble to conventionl lloctor, but s more time is llowed for computtion the qulity of the lloction pproches optiml. This pper presents progressive ister lloctor which uses multi-commodity network flow model to elegntly represent the intriccies of irulr rchitectures. We evlute our lloctor s substitute for gcc s locl ister lloction pss. 1. Introduction Register lloction is one of the most importnt optimiztions compiler performs. Trditionl ister lloctors were designed for ulr, RISC-like rchitectures with lrge uniform ister sets. Embedded rchitectures, such s the 68k, ColdFire, x86, ARM Thumb, MIPS16, nd NEC V8 rchitectures, tend to be irulr, CISC rchitectures. These rchitectures my hve smll ister sets, restrictions on how nd when isters cn be used, support for ory opernds within rbitrry instructions, vrible sized instructions or other fetures tht complicte ister lloction. The irulrities of these rchitectures mke the ister lloction problem prticulrly difficult nd increse the effect of ister lloction on qulity code genertion. A ister lloctor typiclly reduces the ister lloction problem to more redily solved clss of problem (for exmple, grph coloring). Idelly, the reduction produces problem tht is proper, expressive, nd progressive. We define these properties s follows-ister lloctor is: Proper if n optiml solution to the reduced problem is lso n optiml ister lloction. Since optiml ister lloction is NP-complete [25, 2], it is unlikely tht efficient lgorithms will exist for solving the reduced problem. The optimlity criterion cn be ny metric tht cn be stticlly evluted t compile time such s code size or compiler-estimted execution time. Expressive if the reduced problem is cpble of explicitly representing rchitecturl irulrities nd costs. For exmple, such ister lloctor would be ble to utilize informtion bout the cost of ssigning vrible to different ister clsses. Progressive if the solution procedure for solving the reduced problem is cpble of mking progress s more time is llotted for computtion. Idelly, resonble solution is found quickly nd the best solution converges to optiml s more time is llotted. Existing ister lloctors re not progressive; they either quickly find suboptiml solution using heuristics, or fter extensive computtion find n optiml solution. A progressive ister lloctor fills this gp. A fully expressive, proper nd progressive ister lloctor is more flexible nd powerful thn current ister lloctors. The progressive nture of the lloctor results in comprble code qulity to conventionl ister lloctors without scrificing compile time, yet when fst compiles re not necessry, it cn generte substntilly better qulity code. We present n expressive, proper nd progressive ister lloctor which reduces ister lloction to the problem of finding the minimum flow of multiple commodities through network. Relted work is presented in Section 2. The multicommodity network flow (MCNF) model is described in

2 Section 3. Severl solution procedures re discussed in Section 4. We evlute our lloctor s substitute for gcc s locl lloctor. The detils of the gcc implementtion re provided in Section 5. Results re given in Section Relted Work Trditionl grph coloring [7, 8] works well in prctice for ulr rchitectures, but lcks the expressiveness to fully model irulr rchitecture fetures. Vrious reserchers hve proposed extensions to trditionl grph coloring ister lloction to improve lloction on irulr rchitectures [5, 6, 26]. These pproches either modify the heuristics used to color, modify the spilling heuristics, or modify the interference grph to prevent illegl lloctions. There is no explicit optimiztion of spill code, nor do these techniques ddress ll the fetures of irulr rchitectures. Spill code optimiztion hs been ddressed by modifying the spilling heuristic [4] nd by splitting the live rnge of vrible so tht vrible will only be prtilly spilled to ory [9, 3]. Although these techniques cn significntly improve the qulity of the ister lloctor, they re limited in tht they re bsed on grph coloring. They re not proper or progressive, nor do they fully represent ll the fetures of irulr rchitecture. Register lloctors which re proper nd solve the ister lloction problem optimlly hve been implemented by (1) performing guided exhustive serch through the configurtion spce, potentilly using exponentil spce [15, 17], (2) formulting ister lloction s n integer liner progrm nd then solving this formultion optimlly using powerful solution techniques [13, 21], nd (3) formulting ister lloction s prtitioned boolen qudrtic optimiztion problem which cn thn be solved either pproximtely or optimlly [24]. Both the integer liner progrmming nd prtitioned boolen qudrtic optimiztion pproches hve been shown to be cpble of precisely modeling fetures of irulr rchitectures [22, 2, 18]. Unfortuntely, these solution techniques re not progressive; the solvers do not quickly find fesible solutions nd then improve upon them. ILP solvers first must solve the liner relxtion of the integer progrm, which, lthough polynomil in time complexity, cn be time-consuming nd generlly does not result in fesible (ll integer) solution. Once the solution to the liner relxtion is found, n optiml fesible solution is serched for, potentilly tking exponentil time. Although increses in processing power nd improvements in integer liner progrmming solution softwre hve improved the performnce of this pproch by orders of mgnitude [11], its performnce is still fr from being competitive with trditionl lloctors. In some cses it tkes hours to llocte single function. In this pper we develop multi-commodity network flow formultion of the ister lloction problem which is both expressive nd proper while llowing the use of progressive solution lgorithms. Network flows hve been used to model nd solve wide rnge of problems, from trnsporttion nd distribution problems [1] to communictions nd routing in specilized computing networks [23]. Single commodity network flows hve been used to llocte isters for improved energy efficiency [12]. A 2-commodity network flow formultion solved using stndrd ILP techniques hs been used to solve the locl ister lloction problem on ulr rchitecture [1]. 3. Multi-commodity Network Flow The multi-commodity network flow (MCNF) problem is: find the minimum cost flow of commodities through constrined network. The network is defined by nodes nd edges where ech edge hs costs nd cpcity. The costs nd cpcities cn be specific to ech commodity, but edges lso hve bundle constrints which constrin the totl cpcity of the edge. Ech commodity hs source nd sink such tht the flow from the source must equl the flow into the sink. Although finding the minimum cost flow of single commodity is redily solved in polynomil time, finding solution to the MCNF problem where ll flows re integer is NP-complete [1]. Formlly, the MCNF problem is to minimize the costs of the flows through the network: min k c k x k subject to the constrints: x k ij u ij k x k ij v k ij N x k = b k where c k is the cost vector contining the cost of ech edge for commodity k, x k is the flow vector for commodity k where x k ij is the flow of commodity k long edge (i, j), u ij is the bundle constrint for edge (i, j), vij k is n individul constrint on commodity k over edge (i, j), the mtrix N represents the network topology, nd the vector b k contins the inflow nd outflow constrints (source nd sink informtion). A simplified exmple of our MCNF representtion of ister lloction is shown in Figure 1. In this exmple there re two isters, r nd r1, nd ory lloction clss. The cost of moving between isters is two nd the cost of moving between isters nd ory is

3 c c int exmple(int, int b) { int c = - b; return c; } b r r1 r r1 r r1 c: -2 r r1 c c : 4 b b b: 2 b crossbr SUB,b -> c b MOVE c -> r Figure 1. A simplified exmple ister lloction problem formulted s multicommodity network flow problem. Thin edges hve cpcity of one (s only one vrible cn be llocted to ister nd the SUB instruction supports only single ory opernd). The thick rc indictes tht ory is uncpcitted. For clrity, edges not used by the displyed solution re in gry. The commodity nd cost long ech edge used in the solution re shown if the cost is non-zero. In this exmple the cost of lod is four, the cost of using ory opernd in the SUB instruction is two, nd the benefit of llocting c to r in the MOVE instruction is two since the move cn be deleted in tht cse. The totl cost of this solution is four. four. The rguments nd b re pssed on the stck nd thus re initilly in ory. The SUB instruction cn only support single ory opernd nd the cost of using ory opernd is two. The cost of commodity using n edge corresponds to the cost of the corresponding opertion (move, lod, store). For simplicity nd ese of evlution, we only consider the strightforwrd cost metric of progrm size (lthough ny metric tht cn be evluted t compile time could be used). The commodities of the MCNF problem correspond to the vribles, nd b. The source node of vrible connects to the network t the defining instruction nd the sink node of vrible removes the vrible from the network immeditely fter the lst instruction to use the vrible. The design of the network nd individul commodity constrints re dictted by how vribles re used. The bundle constrints enforce the limited number of isters vilble, nd the edge costs re used to model both the cost of spilling nd the costs of ister preferences. A node in the network represents n lloction clss: ister, ister clss, or ory spce to which vrible cn be llocted. Nodes re grouped into either instruction or crossbr groups. There is n instruction group for every instruction in the progrm nd crossbr group for every point between instructions. The nodes in n instruction group constrin which lloction clsses re legl for the vribles used by tht instruction. For exmple, if n instruction does not support ory opernds no vribles re llowed to flow through the ory lloction clss node. Vribles used by n instruction must flow through the nodes of the corresponding instruction group. Crossbr groups re inserted between every instruction nd llow vribles to chnge lloction groups. For exmple, the bility to store vrible to ory is represented by n edge within crossbr group from ister lloction clss node to ory lloction clss node. Vribles which re not used by n instruction bypss the corresponding instruction group nd flow directly between the crossbrs surrounding the instruction. The cost of n opertion, such s move, cn usully be represented by cost on the edge tht represents the move between lloction clsses. However, this is not the correct model for storing to ory. If vrible hs lredy been stored to ory nd its vlue hs not chnged it is not necessry to py the cost of n dditionl store. Tht is, vlues in ory re persistent, unlike those in isters which re ssumed to be overwritten. In order to model the persistence of dt in ory, we introduce the notion of nti-vribles which re used s shown in Figure 2. An nti-vrible is restricted to the ory subnetwork nd is constrined such tht it cnnot coexist with its corresponding vrible long ny ory edge. An nti-vrible cn either leve the ory sub-network when the vrible itself exits the network or the cost of store cn be pid to leve the ory sub-network erly. There is no cost ssocited with edges from isters to ory, but for these edges to be usble, the nti-vrible must be evicted. The cost of evicting the nti-vrible is just the cost of single store. This wy vrible my flow from isters to ory multiple times nd yet py the cost of only single store (of course, every trnsition from ory

4 4 4 ' Figure 2. An illustrtive exmple of ntivribles. The nti-vrible of,, is restricted to the ory subnetwork (dshed edges). The r edge is redundnt nd would not be in the ctul grph. The cost of the second store cn just s well be pid by the first edge. If the r edge is left in the grph, it would hve to hve cost of four in this exmple. Multiple nti-vrible eviction edges cn lso be used to model the cse where stores hve different costs depending on their plcement in the instruction strem. to ister pys the cost of lod). An ctul store is only generted for the first move to ory. The MCNF formultion of ister lloction is proper, expressive, nd hs progressive solution procedures Properness An optiml solution of the ister lloction problem finds the ssignment of isters nd ory to vribles t every progrm point for given instruction strem tht results in the minimum cost. The cost is function of wht the user wishes to optimize for. For exmple, in this pper we mesure cost strictly in terms of progrm size s this metric is strightforwrd to define nd mesure. However, progrm execution time or energy usge could lso be optimized, given some function tht cn stticlly evlute these metrics t compile time. It is importnt to note tht our definition of optimlity is restricted by the instruction strem provided to the ister lloctor nd the limited types of opertions the lloctor r ' 4 is llowed to perform, such s moves, lods nd stores. In some cses it is desirble for instruction selection decisions to be mde during ister lloction. It is possible to model these decisions, but the ister lloction represented by the optiml solution to the corresponding MCNF problem is only optiml with respect to those instruction selection decisions we choose to model. It is cler tht if the MCNF problem is constructed properly the optiml solution will correspond to the optiml ister lloction ttinble using our restricted set of opertions (inserting moves, lods, nd stores between instructions nd some limited locl instruction selection decisions), so s long s the optiml solution never lloctes the sme vrible to multiple isters t the sme progrm point. This is the cse becuse there is direct correspondence between the flow of vrible through the MCNF problem nd vrible s lloction t ech progrm point. The ssumption tht it will not be beneficil to llocte vrible to multiple isters t the sme progrm point seems resonble for rchitectures with few isters, but cn be removed by using technique similr to the ntivribles used to model stores Expressiveness The MCNF model is cpble of expressing mny of the pertinent fetures of irulr rchitectures. Since movement mong isters nd ory is precisely nd flexibly modeled, spill code plcement is explicitly optimized. Requirements on wht types of isters n instruction cn support nd whether ory opernds cn be supported re lso strightforwrd to model. If vrible must reside in certin ister clss in n instruction, only edges to tht ister clss node in the instruction group hve ny cpcity for tht vrible. If n instruction cn only support certin number of ory opernds, then the bundle constrint for the edge entering the ory node of the instruction group is set to limit the number of vribles tht cn be in ory when the instruction is executed. In ddition, if using n opernd in ory rther thn ister hs some cost ssocited with it (for exmple, if it increses the size of the instruction), this cn be modeled with cost long this edge. For exmple, the SUB instruction in Figure 1 hs cost of 2 ssocited with using ory opernd. The MCNF model is lso cpble of modeling ister preferences. If n instruction cn use ny ister, but some re more expensive thn others (for exmple, severl x86 instructions re only one byte if one of the opernds is in ex), this cn be represented with costs long the edges leding into those ister nodes in the instruction group. In some cses, instruction selection is influenced by ister lloction. For exmple, in the 68k rchitecture move with sign extend is implemented with two instructions if the destintion is in dt ister but cn be implemented

5 with single move if the destintion is n ddress ister. A MCNF lloctor cn represent this decision s simple preference for n ddress ister where the cost of using dt ister is equl to the cost of using the lrger instruction sequence. The MCNF model is not s fully expressive s full ILP formultion of the problem. In prticulr, dependent constrints, where the cost of specific vrible lloction depends upon the lloction of other vribles, re not esily modeled. For exmple, consider n dd, = b + c, on the x86 rchitecture. The cost of llocting to the ister ex is zero if either b or c gets llocted to ex, but is one otherwise since le instruction, which is one byte lrger thn n dd, would be used to perform the ddition in this cse. This sitution cnnot be modeled by simple edge cost since the cost depends upon which vribles use the edge in the finl solution. Contrry to good prctice in grph coloring lloctors, the MCNF model does not ttempt to perform copy colescing (where the source nd destintion of move instruction cn be llocted to the sme ister llowing for the deletion of the move). Insted, the lloctor is provided with n instruction strem with ll possible moves colesced. It will then insert splitting moves t the optiml plces. Tht is, becuse the MCNF model nturlly expresses the costs ssocited with inserting moves into the instruction strem, moves cn be ggressively colesced with the expecttion tht the ister lloctor will correctly del with the resulting extended lifetimes. Lod nd constnt propgtion cn be modeled by ssigning negtive cost equl in mgnitude to the cost of the ory/constnt lod instruction when the vrible being defined enters the ory network Progressiveness To be useful, it must be possible to quickly find fesible solution to the MCNF model. Idelly, it would be possible to stedily improve upon this solution until eventully n optiml solution is found. Such solution procedure would llow the user to consciously trde compile time for code qulity. Existing integer liner progrmming solvers do not hve this property since they do not immeditely find fesible solution nd only serch for integer, s opposed to frctionl, solutions t the end of the solution procedure. The MCNF-bsed solution procedures evluted in this pper combine the Lgrngin relxtion method of solving MCNF problems with lgorithms for finding fesible solutions to our MCNF problems. These methods immeditely find fesible solution nd then ttempt to improve upon it s the Lgrngin relxtion converges to the optiml vlue. Although this method is not gurnteed to find n optiml solution, it cn determine bound on how close the solution is to optiml. 4. Solution Procedures The specific form of our MCNF representtion llows us to quickly find fesible, though possibly low qulity, solution. We build up solution to the multi-commodity flow problem by solving the single commodity flow problem for ech vrible. This is simply shortest-pth computtion. We will lwys be ble to find fesible solution becuse the ory network is uncpcitted. If no pth is vilble for vrible (becuse the edges re ll lredy llocted to other vribles), it is lwys possible to loclly evict nother vrible to ory (or nother ister) nd continue to mke progress. Alterntively, we cn constrin our shortest pth finding lgorithm to conservtively ignore pths tht potentilly will mke the network infesible for the vribles tht still need to be llocted. For exmple, if n instruction requires its opernd to be in ister nd tht opernd hs not yet been llocted nd there is only one ister left tht is vilble for lloction, ll other vribles would be required to be in ory t tht point. Although we cn lwys find fesible solution this wy, it is unlikely tht we will find good solution. The vribles we llocte first will sty in isters the longest. The shortest pth computtions we perform hve no wy of being influenced by the costs to other vribles. Idelly, we would like to build solution from series of simple shortest pth computtions. Ech individul vrible s shortest pth would need to tke into ccount not only the immedite costs for tht vrible, but lso the mrginl cost of tht specific lloction with respect to ll the other vribles. Lgrngin relxtion provides forml wy of computing these mrginl costs Lgrngin Relxtion Lgrngin relxtion is generl solution technique [1]. It works by removing one or more constrints from the problem nd integrting them into the objective function using Lgrngin multipliers resulting in more esily solved Lgrngin subproblem. In the cse of MCNF, the Lgrngin subproblem is to find price vector w such tht L(w) is mximl, where L(w) is defined: L(w) =min c k x k + ( ) w ij x k ij u ij (1) k (i,j) k L(w) =min k subject to ( ) c k ij + w ij x k ij w ij u ij (2) (i,j) x k ij N x k = b k (i,j)

6 The bundle constrints hve been integrted into the objective function. If n edge x ij is over-llocted then the term k xk ij u ij will increse the vlue of the objective function, mking it less likely tht n over-llocted edge will exist in the solution tht minimizes the objective function. The w ij terms re the Lgrngin multipliers, clled prices in the context of MCNF. The prices, w, re rguments to the subproblem nd it is the flow vectors, x k, tht re being minimized over. The subproblem is still subject to the network nd individul flow constrints s in the MCNF problem. As cn be seen in (2), the minimum solution to the Lgrngin subproblem decomposes into the minimum solutions of the individul single commodity problems. The function L(w) hs severl useful properties [1]: Lgrngin Bounding Principle. For ny set of prices w, the vlue of L(w) is lower bound on the optiml vlue of the objective function of the originl MCNF problem. Wek Dulity. Let L = mx w L(w). L is lwys lower bound on the optiml objective function of the originl MCNF problem. Optimlity Test. Let x be solution to L.Ifx is lso fesible solution to the originl MCNF problem (does not violte the bundle constrints) nd stisfies the condition w ij ( k x k ij u ij) =(only fully utilized edges in the solution hve nonzero prices in L ), then x is n optiml solution to the MCNF problem. In short, the Lgrngin relxtion provides strong theoreticl lower bound for the optiml solution vlue. Solutions to the relxed subproblem which re fesible in the originl MCNF problem re likely to be optiml nd, under certin conditions, cn be proven optiml. A resonble solution procedure is to find the price vector which mximizes L(w) nd then construct fesible solution tht is lso solution to L (or t lest close to it). First we must solve for L using n itertive subgrdient optimiztion lgorithm. At step q in the lgorithm, we strt with price vector, w q, nd solve L(w q ) for x k to get n optiml flow vector, y k, by performing multiple shortest pths computtion. We then updte w using the rule: ( ( ) w q+1 ij =mx w q ij + θ q k ) yij k u ij, where θ q is the current step size. This lgorithm is gurnteed to converge if θ q stisfies the conditions: lim θ q = q lim q i=1 q θ i = q b c w SUB L(w q ) Tble 1. The price of the shortest pths for ech vrible, the price of the edge entering the SUB instruction s ory node, nd L(w q ) for ech itertion q of the itertive subgrdient optimiztion lgorithm. For ese of explntion, in this exmple the step size is fixed to 1 nd prices re ll initilized to. We evlute two methods which meet these conditions for clculting the step size: Rtio Method The step size t itertion q is simply θ q =1/q. To void lrge initil step sizes, different strting points cn be considered, such s θ q =1/(q + 1). Newton s Method A vrition of Newton s method is used to choose θ with the formul: θ q = δ q[ub L(w q ij ( )] i,j k x k ij u ij where UB is n upper bound on the vlue of the objective function. An upper bound cn be clculted using ny fesible solution finder. As n exmple, consider the simple network in Figure 1. The lloctor would first find fesible solution. Assuming we process the vribles in the order (c, b, ), we first find the shortest pth for c, llocting it to r, then the shortest pth for b, which leves b in ory, nd then the shortest pth for, which would require lod since b hs sturted the edge into the ory node of the SUB instruction (this is the solution shown in the figure). The totl cost of this solution is 4, which is optiml in this cse. However, the lgorithm hs not yet proven tht this result is optiml. In the next step, the solution to the Lgrngin subproblem is found by finding the shortest pths ignoring the bundle constrints. We initilize our prices to be zero. As result, the pths for nd b both hve cost of 2 nd the pth for c hs cost of -2. This gives us totl cost for L(w ) of 2. The prices re then updted. Since only one edge (the ory to ory edge into the SUB instruction) is over-constrined, this is the only edge tht hs its price chnge. For this exmple we use fixed step size of 1 resulting in new edge price of 1 for tht edge. The lgorithm is then repeted with the results shown in Tble 1. We stop the lgorithm when L(w 3 )=4since this proves tht the first fesible solution we found ws, in fct, optiml. ) 2

7 Note tht there re multiple solutions to the Lgrngin subproblem which hve the optiml vlue 4, but not ll of these solutions re fesible Fesible Solution Finding The fesible solution finder constructs fesible solution by llocting vribles individully (using shortest pths computtion). As ech vrible is llocted, the shortest pths of the remining vribles re constrined, but cre is tken to ensure there will lwys be some (possibly very expensive) lloction vilble for the remining vribles. The order in which vribles re llocted is therefore importnt. We considered severl different heuristics for constructing good fesible solution: Greedy Shortest: The shortest pth through the priced grph is computed simultneously for ll vribles. Vribles re inspected strting with the vribles with the most expensive pths. If the vrible s pth would not mke further lloction infesible nd does not overlp with n lredy llocted vrible, then tht pth is chosen. Once s mny vribles re llocted s possible, the shortest pths for the remining, unllocted, vribles re recomputed voiding the lredy llocted edges, nd the procedure is repeted until ll vribles re llocted. The ssumption behind this heuristic is tht it is beneficil to llocte s mny vribles s possible to pths tht re identicl to the pths in the relxed solution. If the relxed solution is fesible or very close to being fesible, then this heuristic should do well. Itertive Shortest: This heuristic lloctes the vribles with the most expensive lloctions first. The order vribles re llocted is fixed by single llvrible shortest pths computtion t the onset. A single vrible shortest pth computtion is performed before vrible is llocted. This finds the current shortest fesible pth, which my be different from the pth found by the initil ll-vrible shortest pth computtion due to the previous lloction of other vribles. This heuristic gives lloction preference to the most expensive vribles nd does not require multiple ll-vrible shortest pth computtions. Lowest Cost k-choice: Similr in structure to Itertive Shortest, but k-shortest pths computtion is performed. Becuse the prices re only converging to the optimum vlues nd re not ctully optiml, pths with costs close to the shortest re likely to be good choices. Of the k pths whose price is within threshold of the shortest pth, the pth with the lowest unpriced cost is chosen. An lterntive to the heuristic bsed fesible solution finders is to exhustively serch the spce of lloctions with good prices. The exhustive serch procedure fixes n order of vribles (bsed on their unconstrined shortest pths cost). The k-shortest priced pths re computed for vrible, then for ech of these pths the remining vribles re recursively llocted. Thus the Lgrngin prices re used to nrrow the serch spce of lloctions of vribles. Insted of considering ll possible lloctions of ech vrible, only mximum of k lloctions re considered. Although the serch is exponentil, if n upper bound is known then it is possible to void visiting the entire serch tree. 5. Implementtion We hve implemented our MCNF lloction frmework s replcement for the locl ister lloctor in gcc 3.4. The gcc ister lloctor divides the ister lloction process into locl nd globl psses. In the locl pss, only vribles tht re used in single bsic block re llocted. After locl lloction, the remining vribles re llocted using single-pss grph coloring lgorithm. Before lloction, we execute preconditioning pss which colesces moves nd trnsltes instructions tht re not in n llocble form. For exmple, internlly instructions re represented s three opernd instructions even when the rchitecture only supports two opernd instructions. If ll three opernds re live out of the instruction, it is not possible to llocte these three vribles to distinct isters nd still generte n x86 two opernd instruction. The preconditioning pss will trnslte such instructions so tht two of the three opernds re the sme vrible. Then, for ech bsic block, we build n MCNF model tht models ll the vribles, both globl nd locl, tht re used in the block. After running our solver on the model, we insert the pproprite moves, stores, nd lods nd ssign isters to the locl vribles. The MCNF model is simplified without loss of generlity by only llowing lods of vrible before instructions tht use the vrible nd only llowing stores fter instructions tht define it. The solver first finds fesible solution both in the unpriced MCNF model nd in n MCNF model where the first store to ory is priced the cost of store. For these initil solution vribles re llocted in the sme order used by the gcc locl lloction heuristic. 6. Results 6.1 Exmple Throughout this section, unless otherwise stted, the results re for the sme smll exmple compiled for the x86

8 Minimum Overhed of Optiml Register Alloction Optiml Rtio Method Newton s Method Itertion Cost of Register Alloction Overhed Itertive 2-choice Optiml Itertion Figure 3. The convergence of the Lgrngin subproblem to the optiml vlue over 1 itertions using two different methods for clculting the step size. rchitecture. All code is compiled with the -Os option (optimize for size). The code for this exmple ws isolted from much lrger exmple (the squreencrypt function in the pegwit benchmrk from the MediBench benchmrk suite [19]) nd provides resonble ister usge pttern tht is complex enough to be interesting but simple enough to understnd. The exmple hs 56 instructions nd 26 vribles of which mximum of 8 re simultneously live t ny progrm point. The minimum possible ister lloction for this exmple is 21 bytes nd the code size fter ister lloction is 248 bytes Convergence For the solution procedure to be effective, the vlue of the Lgrngin subproblem L(w) should converge quickly towrds the ctul optiml vlue. The convergence properties of both the rtio method nd Newton s method of determining step sizes re shown in Figure 3. Although the rtio method begins poorly becuse of the lrge initil step sizes, it quickly converges towrds the optiml solution of 21. By itertion 466 it hs found lower bound lrger thn 2 which is evidence tht fesible solution of cost 21 is optiml. Newton s method, by contrst, does not find lower bound greter thn 2 until itertion In generl, Newton s method performed more poorly thn the rtio method; for the reminder of this section we provide results for the rtio method only Heuristics As the Lgrngin subproblem converges towrds the optimum vlue it is expected to provide better guidnce to the fesible solution finders. The behvior of the Itertive Number of Solutions Found Figure 4. The behvior of the Itertive Shortest fesible solution finder over 1 itertions. As the Lgrngin subproblem converges, the qulity of the found solutions improve Greedy Shortest Itertive Shortest 2-choice 4-choice 8-choice 16-choice Fesible Solution Finder > 5% of Optiml Within 5% of Optiml Within 4% of Optiml Within 3% of Optiml Within 2% of Optiml Within 1% of Optiml Optiml Figure 5. The performnce of different fesible solution finders s mesured by how often optiml nd ner optiml solutions re found over 1 itertions. Shortest heuristic is shown in Figure 4. All the solution finders hve similr pttern of behving errticlly loclly, but showing generl trend of improvement. A good solution finder will find the optiml solution nd solutions close to optiml multiple times. The vrious solution finders re evluted by this metric in Figure 5. The Greedy Shortest nd Itertive Shortest heuristics consider only the shortest fesible pth of ech vrible through the priced network. The itertive solution performs significntly better thn the simple greedy solution. The k- Choice solution finders generlly do better s k is incresed, but t the expense of incresed execution time.

9 2.% 1% 15.% 9% 8% 1.% 5.%.% -5.% -1.% Itertive 2-choice 4-choice 8-choice 16-choice 7% 6% 5% 4% 3% 2% 1% % >25% Within 2% Within 15% Within 1% Within 5% Optiml -15.% 5-1 conflicts (355 blocks) 1-15 conflicts (23 blocks) 15-2 conflicts (7 blocks) >= 2 conflicts (5 blocks) 5-1 conflicts (355 blocks) 1-15 conflicts (23 blocks) 15-2 conflicts (7 blocks) >= 2 conflicts (5 blocks) Figure 6. The overll percentge improvement in totl size of bsic blocks, grouped bsed on the number of locl conflicts, s the mximum number of itertions of the solver is incresed for different solution finders Code Qulity The solutions found by these procedures re, t best, only optiml in the nrrowly defined context of the MCNF formultion of the ister lloction problem. Becuse not ll possible ister relted trnsformtions re modeled in the implemented MCNF formultion, the ctul overhed of ister lloction might be different thn the theoreticl overhed. For exmple, in the model ll ccesses to the stck re ssumed to only cost one byte which is only true if fewer thn 32 vribles re spilled to the stck. A more sophisticted model might hve two ory clsses to ddress this issue. In ddition, errors in the interfce between the Lgrngin solver nd gcc s ister lloctor my lso distort the results. Despite the mny sources of noise, the Lgrngin solver genertes significntly smller code thn gcc s defult lloctor. We evlute the lloctor using bsic blocks from MiBench [14], MediBench [19], SpecInt 95, nd SpecInt 2 [27, 28]. The bse for comprison is the defult gcc lloctor operting on n uncolesced version of the preconditioned instruction strem used by the Lgrngin solver (the results re similr if the unconditioned instruction strem is used for bse of comprison). All results re bsed on the code size immeditely fter ister lloction. Becuse we re only interested in locl lloction, the lloctor is only run on the 39 blocks which contin five or more simultneously live locl vribles. The code im- Figure 7. The percentge of bsic blocks, grouped by the mximum number of conflicts between locl vribles, whose solution cn be proven to be certin percentge from optiml. As more itertions re used, the lgorithm finds better solutions nd better bounds on the optimlity of the solutions. The 2-choice solution finder ws used; the results re representtive of ll the itertive solution finders. provement for blocks contining fewer simultneously live locl vribles ws slight (less thn 1% improvement). Furthermore, more thn 9% of these blocks hd provbly optiml solutions within 1 itertions. The results using different fesible solution finders re shown in Figure 6. Somewht surprisingly, there is not lrge difference between the vrious solution finders. As expected, the code qulity improves s more time is llotted for execution. In ddition, s shown in Figure 7, mny of these solutions cn be shown to be optiml or ner-optiml. The poor results for the 15-2 conflicts cse re n rtifct of the current implementtion s preconditioning pss. We currently do not colesce vribles which hve different sizes. Although this is not common occurrence, it is vitl for one of the blocks in this ctegory Running Times If the Lgrngin pproch is to be useful for ister lloction, it must offer both competitive performnce nd scle s the problem size increses. We evlute the performnce of the vrious solution finders operting on both the smll exmple from the previous sections nd the function, squreencrypt, from which it is derived. This lrge

10 Register Alloctor Smll Exmple Time (s) Lrge Exmple Time (s) gcc defult (locl/globl) <.1.2 gcc -fnew-r (Briggs/Chitin).1.15 Lgrngin: 15% from Optiml Lgrngin: 1% from Optiml Lgrngin: 5% from Optiml Lgrngin: Proven Optiml 14.6 N/A ILP Solver, CPLEX (5.62) 949 (1699) Tble 3. The totl time, in seconds, of the ister lloction pss for vrious lloctors on 1.8Ghz Pentium 4 system. Times re given for both of gcc s lloctors, for the Lgrngin bsed pproch using two different stopping criterion, nd for the CPLEX 7.1 [16] ILP solver. The CPLEX solver ws run on 1Ghz Pentium 3. To mke more ccurte comprison, the CPLEX times were extrpolted to the expected vlues on the fster system using the bogomips rtio of the two mchines. The originl times re shown in prentheses. Technique Smll Lrge L(w) mximiztion Greedy Shortest Itertive Shortest Choice Choice Choice Choice MCNF formultion of the ister lloction problem. The solution time for the commercil CPLEX [16] solver is lso shown in Tble 3. The Lgrngin pproch compres fvorbly with the optiml solver nd hs the dded dvntge of being progressive (tht is, cpble of producing suboptiml solution with gurnteed optimlity bounds t ny point). Tble 2. The time, in seconds, of performing single itertion of Lgrngin mximiztion nd of ech fesible solution finder for both smll nd lrge exmple on 1.8Ghz Pentium 4 system. exmple hs 38 instructions nd 15 vribles of which s mny s 14 re simultneously live. The vlue of the optiml solution is 428. The running times of the vrious techniques per n itertion re shown in Tble 2. An dequte lower bound for proving optimlity of the smll exmple is found in itertion 466 (28 seconds) but using the 2-choice solution finder n optiml fesible solution is not found until itertion 1744 (15 seconds). However, solution tht is proven to be within 1% of optiml nd is ctully within 5% of optiml is found within 3 seconds. The lrge exmple does not find n optiml solution within 5 itertions, but will be ble to provide solution tht is gurnteed to be within 15% of optiml t itertion 99 (bout 6 seconds). To put these times in perspective, the totl ister lloction times for both of gcc s lloctors re shown in Tble 3. These lloctors cn produce decent lloctions well before the Lgrngin pproch hs hd chnce to rmp up, but they cn mke no clims bout optimlity. Trditionl integer liner progrm solvers cn be used to solve for the Figure 8. The progressive nture of the Lgrngin solution pproch run on the squreencrypt function. As the lgorithm computes, better solution nd better optimlity bound on the solution re found. 7. Conclusion As shown in Figure 8, the current implementtion of our ister lloctor effectively bridges the gp between gcc, which is fst, but neither expressive nor proper, nd the slow, but fully expressive nd proper, ILP pproch. The Lgrngin pproch quickly finds solution comprble

11 with the gcc solution nd continues to improve the result s more time psses. The Lrgrngin pproch is not gurnteed to find n optiml solution nd, even when n optiml solution is found, it my tke longer thn commercil ILP solver. However, unlike with the ILP solver, vlid intermedite result is lwys vilble. In conclusion, we hve developed n pproch to ister lloction which llows user to mke conscious trdeoff between compile-time nd code qulity. Our lloctor, bsed on reducing the ister lloction problem to multicommodity network flow problem, is expressive, proper, nd progressive; no other lloctor combines ll three properties. References [1] R. K. Ahuj, T. L. Mgnnti, nd J. B. Orlin. Network flows: theory, lgorithms, nd pplictions. Prentice-Hll, Inc., [2] A. W. Appel nd L. George. Optiml spilling for cisc mchines with few isters. In Proceedings of the ACM SIG- PLAN 21 conference on Progrmming lnguge design nd implementtion, pges ACM Press, 21. [3] P. Bergner, P. Dhl, D. Engebretsen, nd M. T. O Keefe. Spill code minimiztion vi interference ion spilling. In SIGPLAN Conference on Progrmming Lnguge Design nd Implementtion, pges , [4] D. Bernstein, M. Golumbic, Y. Mnsour, R. Pinter, D. Goldin, H. Krwczyk, nd I. Nhshon. Spill code minimiztion techniques for optimizing compliers. In Proceedings of the ACM SIGPLAN 1989 Conference on Progrmming lnguge design nd implementtion, pges ACM Press, [5] P. Briggs. Register lloction vi grph coloring. Technicl Report CRPC-TR92218, Rice University, Houston, TX, April [6] P. Briggs, K. D. Cooper, nd L. Torczon. Coloring ister pirs. ACM Lett. Progrm. Lng. Syst., 1(1):3 13, [7] P. Briggs, K. D. Cooper, nd L. Torczon. Improvements to grph coloring ister lloction. ACM Trns. Progrm. Lng. Syst., 16(3): , [8] G. J. Chitin. Register lloction & spilling vi grph coloring. In Proceedings of the 1982 SIGPLAN symposium on Compiler construction, pges ACM Press, [9] K. D. Cooper nd L. T. Simpson. Live rnge splitting in grph coloring ister lloctor. In Proceedings of the 1998 Interntionl Compiler Construction Converence, [1] M. Frch nd V. Libertore. On locl ister lloction. In SODA: ACM-SIAM Symposium on Discrete Algorithms (A Conference on Theoreticl nd Experimentl Anlysis of Discrete Algorithms), [11] C. Fu nd K. Wilken. A fster optiml ister lloctor. In Proceedings of the 35th nnul ACM/IEEE interntionl symposium on Microrchitecture, pges IEEE Computer Society Press, 22. [12] C. H. Gebotys. Low energy ory nd ister lloction using network flow. In Proceedings of the 34th nnul conference on Design utomtion conference, pges ACM Press, [13] D. W. Goodwin nd K. D. Wilken. Optiml nd ner-optiml globl ister lloction using -1 integer progrmming. Softwre: Prctice nd Experience, 26(8): , [14] M. R. Guthus, J. S. Ringenberg, D. Ernst, T. M. Austin, T. Mudge, nd R. B. Brown. MiBench: A free, commercilly representtive embedded benchmrk suite. In IEEE 4th Annul Workshop on Worklod Chrcteriztion, Austin, TX, December 21. [15] W.-C. Hsu, C. N. Fisher, nd J. R. Goodmn. On the minimiztion of lods/stores in locl ister lloction. IEEE Trns. Softw. Eng., 15(1): , [16] ILOG CPLEX. cplex. [17] D. J. Kolson, A. Nicolu, N. Dutt, nd K. Kennedy. Optiml ister ssignment to loops for embedded code genertion. ACM Trnsctions on Design Automtion of Electronic Systems., 1(2): , [18] T. Kong nd K. D. Wilken. Precise ister lloction for irulr rchitectures. In Proceedings of the 31st nnul ACM/IEEE interntionl symposium on Microrchitecture, pges IEEE Computer Society Press, [19] C. Lee, M. Potkonjk, nd W. H. Mngione-Smith. MediBench: tool for evluting nd synthesizing multimedi nd communictions systems. In Micro, pges , [2] V. Libertore, M. Frch, nd U. Kremer. Hrdness nd lgorithms for locl ister lloction. [21] V. Libertore, M. Frch-Colton, nd U. Kremer. Evlution of lgorithms for locl ister lloction. In Compiler Construction, 8th Interntionl Conference, CC 99, Held s Prt of the Europen Joint Conferences on the Theory nd Prctice of Softwre, ETAPS 99, Amsterdm, The Netherlnds, Mrch, 1999, Proceedings, volume 1575 of Lecture Notes in Computer Science. Springer, [22] M. Nik nd J. Plsberg. Compiling with code-size constrints. In Proceedings of the joint conference on Lnguges, compilers nd tools for embedded systems, pges ACM Press, 22. [23] A. E. Ozdglr nd D. P. Bertseks. Optiml solution of integer multicommodity flow problems with ppliction in opticl networks. In Proc. of Symposium on Globl Optimiztion, June 23. [24] B. Scholz nd E. Eckstein. Register lloction for irulr rchitectures. In Proceedings of the joint conference on Lnguges, compilers nd tools for embedded systems, pges ACM Press, 22. [25] R. Sethi. Complete ister lloction problems. In Proceedings of the fifth nnul ACM symposium on Theory of computing, pges ACM Press, [26] M. D. Smith nd G. Hollowy. Grph-coloring ister lloction for irulr rchitectures. [27] Stndrd Performnce Evlution Corp. SPEC CPU95 Benchmrk Suite, [28] Stndrd Performnce Evlution Corp. SPEC CPU2 Benchmrk Suite, 2.