Uday Khedker

Asst. Professor, Department of Computer Science & Engg., IIT Bombay

Seminar Topics

  1. Dynamic Type Inferencing

    • 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


  2. Specifying Optimizations

    • 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


  3. Post Link Optimizations

    • 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


  4. Program Partitioning for Limited Memory Embedded Systems

    • 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 .
      Ph.D. Student
      Bageshri Sathe


  5. Back to top of the page

    Back to details of teaching

    Back to the main page

    Last updated on 19 November 2001.