A simple interprocedural register allocation algorithm and its effectiveness for LISP

Register allocation is an important optimization in many compilers, but with per-procedure register allocation, it is often not possible to make good use of a large register set. Procedure calls limit the improvement from global register allocation, since they force variables allocated to registers to be saved and restored. This limitation is more pronounced in LISP programs due to the higher frequency of procedure calls. An interprocedural register allocation algorithm is developed by simplifying a version of interprocedural graph coloring. The simplification corresponds to a bottom-up coloring of the interference graph. The scheme is evaluated using a number of LISP programs. The evaluation considers the scheme's limitations and compares these “software register windows” against the hardware register windows used in the Berkeley RISC and SPUR processors.

[1]  Johannes M. Mulder.  Tradeoffs in processor-architecture and data-buffer design , 1988 .

[2]  James R. Larus,et al.  Register allocation in the SPUR Lisp compiler , 1986, SIGPLAN '86.

[3]  Richard P. Gabriel,et al.  Performance and evaluation of Lisp systems , 1985 .

[4]  James R. Larus,et al.  Evaluation of the SPUR Lisp Architecture , 1986, ISCA.

[5]  Richard Karl Johnsson.  An approach to global register allocation. , 1976 .

[6]  Richard D. Greenblatt,et al.  LISP Machine Progress Report. , 1977 .

[7]  David A. Patterson,et al.  Architecture of SOAR: Smalltalk on a RISC , 1984, ISCA '84.

[8]  Alfred V. Aho,et al.  Data Structures and Algorithms , 1983 .

[9]  Michael J. Flynn,et al.  And Now a Case for More Complex Instruction Sets , 1987, Computer.

[10]  Eugene Charniak,et al.  Artificial Intelligence Programming , 1987 .

[11]  E. Basart,et al.  Ridge 32 architecture-a risc variation , 1983 .

[12]  Robert R. Kessler,et al.  EPIC - a retargetable, highly optimizing Lisp compiler , 1986, SIGPLAN '86.

[13]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[14]  Peter Steenkiste,et al.  Lisp on a reduced-instruction-set processor: characterization and optimization , 1988, Computer.

[15]  David W. Wall,et al.  Global register allocation at link time , 1986, SIGPLAN '86.

[16]  Paul Chow.  MIPS-X instruction set and programmer''s manual , 1986 .

[17]  Fred C. Chow,et al.  A portable machine-independent global optimizer--design and measurements , 1984 .

[18]  Ifor Williams,et al.  The design and evaluation of a high-performance smalltalk system , 1988 .

[19]  Gerald J. Sussman,et al.  The dream of a lifetime: A lazy variable extent mechanism , 1980, LISP Conference.

[20]  David Ungar,et al.  The design and evaluation of a high performance Smalltalk system , 1987 .

[21]  Martin L. Griss,et al.  Current status of a portable LISP compiler , 1982, SIGPLAN '82.

[22]  David A. Moon,et al.  Architecture of the Symbolics 3600 , 1985, ISCA '85.

[23]  Tomás Lang,et al.  Reduced register saving/restoring in single-window register files , 1986, CARN.

[24]  David R. Ditzel,et al.  Register allocation for free: The C machine stack cache , 1982, ASPLOS I.

[25]  William A. Wulf,et al.  The Design of an Optimizing Compiler , 1975 .

[26]  James R. Larus,et al.  Evaluation of the SPUR Lisp architecture , 1986, ISCA '86.

[27]  Martin L. Griss,et al.  A portable lisp compiler , 1981, Softw. Pract. Exp..

[28]  Fred C. Chow,et al.  Engineering a RISC Compiler System , 1986, COMPCON.

[29]  David R. Ditzel,et al.  Design tradeoffs to support the C programming language in the CRISP microprocessor , 1987 .

[30]  Allen Newell,et al.  Computer Structures: Principles and Examples , 1983 .

[31]  William M. Waite.  Code Generation , 1976, Compiler Construction.

[32]  Deborah S. Coutant,et al.  Compilers for the New Generation of Hewlett-Packard Computers , 1986, COMPCON.

[33]  Fred C. Chow.  Minimizing register usage penalty at procedure calls , 1988, PLDI '88.

[34]  Peter Steenkiste,et al.  LISP on a reduced-instruction-set-processor , 1986, LFP '86.

[35]  John L. Hennessy,et al.  Register allocation by priority-based coloring , 1984, SIGPLAN '84.

[36]  Carlo H. Séquin,et al.  A VLSI RISC , 1982, Computer.

[37]  David A. Patterson,et al.  Architecture of SOAR: Smalltalk on a RISC , 1984, ISCA 1984.

[38]  Andrew H. Reiner.  Cost-minimization in register assignment for retargetable compilers , 1984 .

[39]  Gregory J. Chaitin,et al.  Register allocation and spilling via graph coloring , 2004, SIGP.

[40]  David R. Ditzel,et al.  Architectural Innovations in the CRISP Microprocessor , 1987, COMPCON.

[41]  David A. Moon,et al.  Architecture of the Symbolics 3600 , 1985, ISCA '85.

[42]  Thomas Richard Wilcox.  Generating machine code for high-level programming languages , 1971 .

[43]  Norman P. Jouppi,et al.  MIPS: a VLSI processor architecture , 1981 .

[44]  Bruce Wallace Leverett.  Register Allocation in Optimizing Compilers , 1983 .

[45]  Martin L. Griss,et al.  PSL: A Portable LISP System , 1982, LFP '82.

[46]  Steven W. K. Tjiang,et al.  A 32b microprocessor with on-chip 2Kbyte instruction cache , 1987, 1987 IEEE International Solid-State Circuits Conference. Digest of Technical Papers.

[47]  Drew McDermott,et al.  Introduction to artificial intelligence , 1986, Addison-Wesley series in computer science.

[48]  JOHN L. HENNESSY,et al.  VLSI Processor Architecture , 1984, IEEE Transactions on Computers.

[49]  Charles N. Fischer,et al.  Crafting a Compiler , 1988 .

[50]  Gregory J. Chaitin,et al.  Register allocation & spilling via graph coloring , 1982, SIGPLAN '82.

[51]  Thomas P. Murtagh.  A less dynamic memory allocation scheme for algol-like languages , 1984, POPL '84.

[52]  Richard L. Sites.  How to Use 1000 Registers , 1979 .

[53]  David R. Ditzel,et al.  Design tradeoffs to support the C programming language in the CRISP microprocessor , 1987, ASPLOS.