Contact David Bernholdt
Program translation is central to nearly all computing. In its simplest and most familiar form, a compiler translates a program into executable code. But similar techniques can be used to manipulate programs in other ways, transforming one program into another at the source code level or into other intermediate representations, as well as analyzing them in various ways.
Translation approaches most often target the programmability and the performance of software, but can also impact resilience, verification and debugging, and other important aspects of software development. A common feature of most translation-based approaches is that they are based on compilers or compiler-like tools that can process the code with appropriate awareness of the syntax and semantics of the programming language used.
Program translation research in the Computer Science and Mathematics Division spans a broad range of topics. Research on optimization and code generation techniques helps produce code that runs faster or more efficiently on the target platform with constrained power or other resources. Extending programming languages (including, for example, the OpenMP and OpenACC directive languages) to make new abstractions available allows programmers to express their computations more succinctly, while allowing the compiler to generate better code. Although there are already a lot of programming languages, there are sometimes good reasons to create new ones, especially small languages specialized to address key needs of scientific applications. One example is a directive language which can be embedded in a traditional language, like C, C++, or Fortran, allowing the programmer to express inter-process communications in a simple abstract form, which can be translated and optimized to efficiently target multiple communications libraries, such as one- or two-sided MPI, OpenSHMEM, or others. Another example is domain-specific languages (DSLs), which provide specialized constructs tailored to facilitate expressing complex programs in a given scientific or problem domain. While providing the programmer with potentially huge benefits in programmability and correctness, DSLs also provide a means to capture and convey key domain knowledge to the compiler system to allow it to perform domain-specific optimization and generate better code -- information that is unavailable, and cannot be inferred in a general-purpose language environment.
The program translation approach can also be used to help understand programs, and to transform them into new programs. For example, the maintenance of large-scale programs, and porting them to new hardware platforms is often tedious and error-prone when done by hand. We are, therefore, studying use of translation tools to identify code patterns of interest and refactor them in an automated fashion. We are also interested in approaches that will allow us to more effectively capture and transfer the experience of porting and tuning one code to a new platform to other applications needing to make the same transition.