(SUMMARY -- SHORT)
We have designed a complex dynamic-compilation system.  I want to understand
what features and optimizations are important.  This will involve both turning
features and optimizations on and off and also annotating programs in several
different ways.  (I'll coordinate with Matthai to minimize overlap with his
architectural study.)

On the implementation side, I would like to implement the rest of the current
design, add run-time inlining, tweak the BTA, and add a few new optimizations.


(DETAILS -- LONG)

Examples of things I would like to study:

-- Importance of ascribing weak policies to derived run-time constants; ease
   of control over costs and code growth for different derived policies
-- Performance benefit of unsafe annotations; when can safe annotations be
   converted to unsafe ones?
-- What benefit do we receive from reachability analysis?
-- "    "       "  "  "       "    direct handling of unstructured code?
-- "    "       "  "  "       "    unit-boundary clustering?
-- "    "       "  "  "       "    linearization?
-- How useful is demand-driven specialization:
	- For avoiding non-termination?
	- For controlling aggressive code generation (such as in binary)?

Etc.

Things that remain to be implemented:

-- One-time lazy edges
-- Single run-time predecessor optimizations (now that reachability analysis is
   implemented)
-- Unit-boundary clustering; this will require improving the interface between
   the BTA and GEgen.  Markus has already started working on this to allow us
   to keep derived TEMPs with changed or evicted SourceRoots in the
   run-time-constants set (StaticVarInfo) at least until unit boundaries.
-- Unit linearization
-- Interprocedural specialization (function annotations)
-- Run-time inlining
-- I'd like to look at automatically deducing when it is safe to remove cache
   checks and lazy points so that our safe annotations can be used most of
   the time
-- PromoteOneUncheckedEager for eliminating MayDefs
-- Faster caching implementation
-- Other caching optimizations (e.g., the fix to the ms CacheAllUnchecked
   problem, and relative caching in general)
-- CacheOne
-- More realistic and robust memory management