ACM Home Page
Please provide us with feedback. Feedback
Staged compilation
Full text PdfPdf (80 KB)
Source ACM/SIGPLAN Workshop Partial Evaluation and Semantics-Based Program Manipulation archive
Proceedings of the 2002 ACM SIGPLAN workshop on Partial evaluation and semantics-based program manipulation table of contents
Portland, Oregon
SESSION: Invited talk table of contents
Pages: 1 - 8  
Year of Publication: 2002
ISBN:1-58113-455-X
Also published in ...
Author
Craig Chambers  University of Washington, Seattle, WA
Sponsors
ACM: Association for Computing Machinery
SIGPLAN: ACM Special Interest Group on Programming Languages
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 5,   Downloads (12 Months): 34,   Citation Count: 5
Additional Information:

abstract   references   cited by   collaborative colleagues  

Tools and Actions: Request Permissions Request Permissions    Review this Article  
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/503032.503045
What is a DOI?

ABSTRACT

Traditional compilers compile and optimize files separately, making worst-case assumptions about the program context in which a file is to be linked. More aggressive compilation architectures perform cross-file interprocedural or whole-program analyses, potentially producing much faster programs but substantially increasing the cost of compilation. Even more radical are systems that perform all compilation and optimization at run-time: such systems can optimize programs based on run-time program and system properties as well as static whole-program properties. However, run-time compilers (also called dynamic compilers or just-in-time compilers) suffer under severe constraints on allowable compilation time, since any time spent compiling steals from time spent running the program. None of these compilation models dominates the others: each has unique strengths and weaknesses not present in the other models.We are developing a new, staged compilation model which strives to combine high run-time code quality with low compilation overhead. Compilation is organized as a series of stages, with stages corresponding to, for example, separate compilation, library linking, program linking, and run-time execution. Any given optimization can be performed at any of these stages; to reduce compilation time while maintaining high effectiveness, an optimization should be performed at the earliest stage that provides the necessary program context information to carry out the optimization effectively. Moreover, a single optimization can itself be spread across multiple stages, with earlier stages performing preplanning work that enables the final stage to complete the optimization quickly. In this way, we hope to produce highly optimized programs, nearly as good as what could be done with a purely run-time compiler that had an unconstrained compilation time budget, but at a much more practical compile time cost.We are building the Whirlwind optimizing compiler as the concrete embodiment of this staged compilation model, initially targeting object-oriented languages. A key component of Whirlwind is a set of techniques for automatically constructing staged compilers from traditional unstaged compilers, including aggressive applications of specialization and other partial evaluation technology.


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

 
Aldrich et al.
 
Aldrich et al. 99
Arnold et al. 00
Auslander et al. 96
Blanchet 99
Bogda & Hölzle 99
 
Calder et al. 97
Choi et al. 99
 
Dean et al. 95
Dean et al. 96
DeFouw et al. 98
Diwan et al. 96
Dolby & Chien 98
Dolby & Chien 00
Dolby 97
Fernandez 95
 
Gay & Steensgaard 00
 
Gosling et al. 96
Grant et al. 97
Grant et al. 99
 
Grant et al. 00a
Grant et al. 00b
Grove & Chambers
Grove et al. 97
 
Jones et al. 93
 
Lindholm & Yellin 97
 
Mock et al. 99
M. Mock, M. Berryman, C. Chambers, and S.J. Eggers. Calpa: ATool for Automating Dynamic Compilation. In 2nd Workshop on Feedback-Directed Optimization, November 1999.
Mock et al. 00
 
OOP96
Proceedings of the 1996 ACM Conference on Object-Oriented Programming Systems, Languages, and Applications, San Jose, CA, October 1996.
 
OOP99
Proceedings of the 1999 ACM Conference on Object-Oriented Programming Systems, Languages, and Applications, Denver, CO, November 1999.
 
OOP00
Proceedings of the 2000 ACM Conference on Object-Oriented Programming Systems, Languages, and Applications, Minneapolis, MN, October 2000.
 
OOP01
Proceedings of the 2001 ACM Conference on Object-Oriented Programming Systems, Languages, and Applications, Tampa, FL, October 2001.
Pechtchanski & Sarkar 01
Philipose et al. 02
 
PLD00
Proceedings of the ACM SIGPLAN '00 Conference on Programming Language Design and Implementation, May 2000.
Ruf 00
Sodani & Sohi 98
Suganuma et al. 01
Sundaresan et al. 00
Tip & Palsberg 00
Whaley & Rinard 99
Whaley 01