Future Research Plans

I believe that the machine-level complexity of application development ought to be handled by programming systems and tools, freeing the programmer to concentrate on the higher-level, algorithmic aspects. Thus, I am primarily interested in building practical systems and tools that will enable high-performance computing to be effective. This is especially relevant for parallel processing, where the hardware infrastructure requirements have largely been met. To make parallel programming truly effective, we need tools.

Over the next few years, I will target prescriptive performance tuning as one of my research areas. I am convinced that this topic will have a significant impact, as prescriptive tools will enable programmers to rectify performance problems while requiring only source-level, rather than architecture-related, reasoning about the program. There are two avenues that I intend pursuing. I perceive both avenues as opening up opportunities for me to carry out research in related areas such as program analysis and compilation, and in other areas such as operating systems.

• Prescriptive tools for other domains

  As part of my dissertation research, I have developed a new approach for designing prescriptive tools. Rx is a tool based on this approach that prescribes source-level changes for reducing synchronization and some forms of data communication in explicitly parallel shared memory programs. I intend using my approach to design prescriptive tools for a wide variety of purposes:
  • Improving the cache behavior of sequential programs:
    It is well known that the memory performance of a program is affected by the layout of its data structures in memory. By changing this layout, the data accesses of a program can better exploit the memory hierarchy. Existing tools that target memory performance only present descriptive information, such as cache statistics, to the user. In contrast, a tool based on my approach can directly specify the best layout to use.

    A prescriptive tool can treat this as an optimization problem where the goal is to determine an optimal arrangement of the program data structures. This can be cast as a variant of the graph coloring problem, and optimally solved using integer programming techniques. The basis for the new layout can be access traces from a few executions of the application.
    
    

  • Improving the performance of concurrent programs:
    Parallel and distributed applications can be sped up by reducing inter-process interactions. Although the implementation described in my dissertation handles programs written in C, my techniques and ideas are directly applicable to other programming models and languages. Multithreaded Java programs are one example.

    I also plan to apply my technique to operating systems. Algorithmic complexity and the temporally distributed development process often cause operating systems to have large amounts of excess synchronization. I plan to demonstrate the feasibility of using my approach to reduce synchronization in an operating system; Digital Unix will be my most likely choice.
    
    

  • Prescribing the best communication primitive to use in message passing programs:
    Another problem domain where my approach will be useful is in the design of tools that facilitate the development and porting of message passing programs. With the increasing complexity of message-passing interfaces, the task of choosing the appropriate communication primitive is not easy. For instance, MPI, a widely implemented message-passing interface standard, specifies around 100 primitives for communication, including several complex ones for collective communication. A prescriptive tool can automatically analyze run-time data to specify the best primitive to use from among those provided by the library.

• Augmenting run-time tools with compile-time support

  Run-time analysis forms the basis of most performance tools. I want to complement this with compile-time analysis to yield an integrated approach to performance tuning. Such a combination has several potential benefits. The run-time analysis need then be carried out only for those parts of the program that cannot be precisely analyzed without running the program. Static analysis can also provide information about the program which can then be used to reduce the amount of data that must be collected at run-time.

Back home