CS253r: Advanced Programming-Language Compilation
Fall 2001
This Fall we will have a somewhat unusual edition of
CS 253r.
Instead of focusing on optimization, we will focus on run-time systems
and especially on compiler support for run-time systems.
We will have several
ends in mind:
- To understand the fundamental problems of building a modern
run-time system
- To identify related opportunities for research in language compilation
- To learn how to read the research literature
CS 253r will be run as a seminar; participants will meet twice weekly
to discuss papers.
Participants will also be expected to complete a substantial
semester project.
Because the seminar will be a collaborative effort,
we'll coordinate everything using a
WikiWikiWeb.
Students' grades will be based on their projects and on their class
participation, including their contributions to the Wiki.
No examinations are planned.
Topics
The seminar will range over three topics, moving from well-understood
problems to the frontiers of research.
- Compile-time and run-time strategies for implementing exceptions
and exception handling.
These strategies are well understood, and the related papers will
serve as an introduction to our study of compiler support for run-time
services.
- Implementation of and compiler support for garbage collection.
Although the basic techniques are well understood,
garbage collection is still a very active area of research.
We will focus on compiler support for garbage collection.
- Debugging.
Although many language implementations provide debuggers, many more do
not.
Outside the domain of C and Fortran, support for debugging is largely
an unsolved problem.
Class participation
Our primary classroom activity will be analysis and discussion of
papers from the professional literature.
Participants will be expected to
- Post comments and questions on the
Wiki
before class
- Come to class prepared to discuss papers
- Take turns putting summaries of discussions on the Wiki
(either during
or after class)
Project
The project will provide an opportunity for you to undertake research
in the interaction between compilation and run-time systems.
You may work in teams of any size;
my expectations will be commensurate with the size of your team.
More information about the project will be forthcoming, but
the following notes may be helpful.
The project will include research, a paper, and an oral presentation.
In addition, members of the class will review each other's papers.
If time permits and the number of projects is suitable, we will hold a
mock program committee to
discuss the papers.
I encourage experimental research using either Quick C--,
Machine
SUIF, or the infrastructure of your choice.
An interesting project might address a question of the following form:
- What is the cost of recording compile-time information that the
run-time system needs? (Example information: locations and liveness of
variables.)
How can this cost be reduced?
- What has to be done differently in the compiler to make it
possible to keep track of information to be recorded?
How do the record-keeping requirements affect traditional optimization
algorithms?
- Does information need to be available at every instruction or only
at certain points? If only at certain points, how can we specify a
precise semantics that makes it clear what an optimizer can do with those points?
- Is it possible to reduce run-time requirements for information by
analyzing the machine instructions themselves?
For example, if we record variable locations only at join points, can
we then find the locations of all variables by looking at the machine
instructions?
Other questions are possible with the concurrence of the instructor.
The following timetable for projects is tentative and preliminary:
Prerequisite
Prospective participants must have compiler-construction experience,
e.g., as provided by
CS 153 (Principles of Programming-Language Compilation).
Students without 153 or equivalent background must have the
instructor's permission to enroll in the course.