Conclusion

We are building DyC by modifying the Multiflow compiler [LFKLNOR93].
We began with a detailed design, covering every aspect of the system,
with the implementation being performed in stages.  We currently have
a restricted monovariant version of the BTA working that computes all
of the outputs required by the run-time specializer.  We should soon
be able to generate code for simple dynamic regions.  Over the next
few months, we hope to complete the system.

In the near future, we plan to work out the annotations for static
fields of data structures and for pointers and add them to our system.
We also would like to add alias and side-effect analysis, and
interprocedural analysis as well.  Beyond those analyses, there are a
number of analyses we could add such as termination and exception
analysis to eliminate unnecessary lazy specialization, analysis of
relational expressions [Sakharov:1996:Specialization], or even theorem
proving.  We also would like a better solution to the problem of
clustering specialization-unit boundaries.  However, at this time we
do not know whether these analyses will be useful.

In addition to more aggressive analyses, we would like to add more
run-time optimizations, controlled by the annotations through
policies.  In particular, we would like to implement run-time register
allocation and run-time inlining.

Our annotations' design resulted from a search for a small set of
flexible primitive directives to govern dynamic compilation, suitable
for use by both human programmers and tools (such as a semi-automatic
dynamic-compilation front end).  With the exception of support for
static data structures, we believe that our make_static annotation
provides the flexibility we require in a concise, even elegant manner.
Furthermore (and to our surprise), most of the run-time optimizations
(e.g., multi-way loop unrolling) and other features we desired (e.g.,
conditional specialization) fit neatly into the framework of partial
evaluation.

We feel that DyC's main contribution lies in the flexibility achieved
by its blend of features:
	- the ability to promote dynamic variables to static or demote
	  static variables to dynamic at arbitrary program points by
	  use of simple annotations inserted into the program text,
	  permitting nested and overlapping dynamic regions, 
	- automatic dynamic-to-static promotion of specialization
	  variables, substantially reducing the number of annotations
	  necessary to continue specialization and permitting the
	  programmer to be ignorant of the accuracy of the system's
	  analyses,
	- polyvariant program-point specialization and division,
	  permitting, in particular, multi-way loop unrolling and
	  conditional specialization,
	- automatic caching and reuse of specialized code,
	- on-demand as well as speculative specialization, and
	- programmer control over these features through
	  straightforward policies on specialization variables
	  included in the annotations.

The result is a system far easier to use than a code-generation system
like `C and one that can be easily applied to existing programs.
Furthermore, the annotations and their corresponding array of policies
provide a convenient mechanism for experimenting with dynamic
compilation, and a potential target for future tools or a fully
automatic system.