The Dynamo Project   

Dynamic Optimization
via Staged Compilation

Principal Investigators

Project Overview

The Dynamo project focuses on the design and implementation of a compiler architecture for dynamically optimizing stand-alone programs. Dynamic optimization uses run-time values and invariants to improve code as it executes, yielding performance superior to that of statically optimal code.

Of course, dynamic optimization incurs run-time overhead: time spent optimizing and compiling code at run time detracts from any resulting improvement. The Dynamo compiler reduces this overhead using a staged compilation model, which permits static compilation to be suspended after reaching a high-level, mid-level, or low-level intermediate representation. This technique supports lightweight optimizations, which are fast but typically yield minor improvements, as well as heavyweight optimizations, which are time consuming but often provide substantial performance benefits.

The first stage of the Dynamo project was supported by the National Science Foundation under Grant No. 9711269. Any opinions, findings and conclusions or recomendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation (NSF)

Related Publications

A practical and flexible flow analysis for higher-order languages. J. Michael Ashley and R. Kent Dybvig. ACM Transactions on Programming Languages and Systems, 20(4), 845-868, 1998. [abstract]

Efficient Compilation and Profile-Driven Dynamic Recompilation in Scheme. Robert G. Burger. PhD thesis, Indiana University Computer Science Department, March 1997.

An infrastructure for profile-driven dynamic recompilation. Robert G. Burger and R. Kent Dybvig. In IEEE Computer Society 1998 International Conference on Computer Languages, pages 240-251, May 1998. [abstract]

Optimizing ML with Run-Time Code Generation. Peter Lee and Mark Leone. In Proceedings of the ACM SIGPLAN '96 Conference on Programming Language Design and Implementation, pp. 137-148, Philadelphia, May 1996. [abstract]

Dynamo: A Staged Compiler Architecture for Dynamic Program Optimization. Mark Leone and R. Kent Dybvig. Technical Report #490, Department of Computer Science, Indiana University, September 1997. [abstract]

A Declarative Approach to Run-Time Code Generation. Mark Leone and Peter Lee. In Workshop Record of WCSSS'96: The Inaugural Workshop on Compiler Support for System Software, pp. 8-17, Tucson, February 1996. [abstract]

Lightweight Run-Time Code Generation. Mark Leone and Peter Lee. In Proceedings of the ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation, pages 97-106, June 1994. [abstract]

Dynamic specialization in the Fabius system. Mark Leone and Peter Lee. ACM Computing Surveys Symposium on Partial Evaluation, 30(3es):18-es, September 1998.

Visualizing the performance of higher-order programs. Oscar Waddell and J. Michael Ashley. In ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering, pages 75-83, June 1998.

Fast and Effective Procedure Inlining. Oscar Waddell and R. Kent Dybvig. Proceedings of the Fourth International Symposium on Static Analysis (SAS '97) Springer-Verlag Lecture Notes in Computer Science 1302, 35-52, September 1997. [abstract]

Visualizing partial evaluation. Oscar Waddell and R. Kent Dybvig. ACM Computing Surveys Symposium on Partial Evaluation, 30(3es):24-es, September 1998.

Extending the scope of syntactic abstraction. Oscar Waddell and R. Kent Dybvig. In Conference Record of the Twenty Sixth Annual ACM Symposium on Principles of Programming Languages, January 1999. To appear. [abstract]

Local Project Info (group members only)