Asst. Professor, Department of Computer Science & Engg., IIT Bombay
Seminar Topics
-
- Background.
Most languages require some form of type analysis to prevent execution
of improper operations in a program. For statically checked languages this
analysis is performed at compile time; for dynamically checked languages it
is performed at run time. This choice is a tradeoff between safety and
flexibility, efficiency being a by-product.
Some languages require type annotations of all operations and data.
Type analysis for such languages usually amounts to checking the mutual consistency of
annotations. Programs in other languages may have just a few or no annotations---for
such languages, type analysis (usually called type inferencing)
is a harder problem. It is typically based on solving systems of type constraints.
The best known and the most widely used type inference algorithm was first discovered by
Hindley; a generalized version was independently presented
by Milner.
Most statically checked language allow a name to have only one type in a given scope,
hence a type contraint has global influence. Most dynamically dynamically checked
languages allow names to have different types in the same scope, hence a type
constraints has a limited influence and the number of type constraints increases.
- Objective .
In this seminar the student is expected to understand the problem of
type inferencing for dynamically checked languages.
- Students .
M.Tech. Student | B.Tech. Student |
D. Praveen | Varun Katta |
-
- Background.
Most of the phases of a compiler can now be generated from specifications.
Scanner and parsers were to first to be generated. It is also possible to
generate semantic anlyzers and code generators.
With the optimizing compilers gaining importance, the task of
generating code optimizers from specifications has also received considerable
attention. There are at least a dozen or so
efforts in this direction.
The ones that are closer home are GENSAT and S Language (both concieved
at our own department) and Kshnu (conceived at Pune University).
- Objective .
The focus has been more on generation than on specification; language design
considerations have not been given due importance.
In this seminar the student is expected to look at the above three specifications
(and possibly some more) and evaluate them from the viewpoint of langauge
design.
- Students .
M.Tech. Student | B.Tech. Student |
Abhay Marode | Varun Singh |
-
- Background.
Many machine dependent optimizations are required to be performed on
an executable code. This may be necessititated by the fact that
- some optimizations may be conceived by the programmers (rather than the
compiler-writer) and it may not be possible to incorporate them into the compiler
(may be the compiler source is not available or is not modifiable), or
- the source code of the executable may not be available, or
- binary translation (i.e. translating the executable for one
machine to run as an executable on some other machine) may be
desired, or
- some optimizations can be preformed only after (static) linking, viz.
program partitioning to fit the usually small amount of
memory available on the embedded systems.
- Objective .
To survey some post link optimizations.
- Students .
M.Tech. Student |
Vinit Kapoor |
-
- Background.
Embedded systems have proved to be of great importance due to their
increasing use in building real time systems. However, the constraints on
resources such as time, available memory often affect their performance. These
restrictions on resources pose various challenges in application development,
compilation, memory management and other areas.
Restrictions on available run-time memory prevent large programs to
be loaded completely in the memory at execution time. It is required to
partition large programs into smaller fragments which can be accommodated in
the available run-time memory. Partitioning needs to be performed at procedure
level if the individual procedures are larger than the available memory. It is
desirable to break the program into minimum number of partitions in order to
minimize the time spent in loading program portions into memory at execution
time.
- Objective .
This seminar discusses in detail the various issues involved in the
problem of program partitioning and the possible strategies useful for
achieving the goal of optimal partitioning.
- Students .
Back to top of the page
Back to details of teaching
Back to the main page
Last updated on 19 November 2001.