Active Projects And Grants for Qing Yi

• Software download
• The language Manual and Tutorials
• Tutorials For Using POET to build a compiler project

• With Dr. Daniel Quinlan on the ROSE compiler
• Coadvising Mike Bell with Dr. Clint Whaley on automated timer generation supported by NSF REU Supplement for CNS-0551504.
• Coadvising Mike Stiles with Dr. Kleanthis Psarris on automated parallelization and the impact of dependence testing.
• With Dr. Apan Qasem on empirical tuning of software performance.
• With Dr. Jianwei Niu on automated code generation from finite state machine specifications.

• Title: Multilayer Code Synthesis For Correctness and Performance
• Total amount : $399,953
• Period : 08/01/08 - 07/31/13
• co-investigators: none
• Students supported: Anitha Ancha
• Project Summary : Correctness and performance are two of the most fundamental concerns in software development. In particular, the increasing complexity of modern computing environment has made it extremely difficult for software applications to be both correct and efficient. Software programs are frequently found to be flawed, and existing technology has fallen behind in providing the necessary programming language and tool support to ensure high quality software development.
  
  This research develops programming language as well as compiler analysis and optimization techniques to support the automated translation of software from high-level design to low-level efficient implementations. This research develops a multilayer code synthesis framework that systematically produces high-quality software by effectively combining software verification techniques with program analysis and compiler optimization in a three-phase translation process. First, starting from the software design phase, the framework automatically translates formal software semantic specifications into object-oriented or procedural implementations based on strategies selected by programmers. Then, based on knowledge from the software-design phase, a sequence of domain-specific optimizations is applied to the implementation to improve algorithm efficiency. Finally, architecture-specific optimizations are applied to performance-critical routines, and the optimized routines are empirically tuned as the application is ported to different machines. Different design and programming languages may be used in each translation phase, and software verification technology will be used to ensure the correctness of each translation. The research focuses on scientific computing and system software applications, where both correctness and performance are of critical concern. The integrated research is expected to significantly improve both the trustworthiness and performance of existing software development.

• Title: Programmable Code Optimization and Empirical Tuning For High-end Computing
• Total amount : $462,000
• Period : 09/01/08 - 08/31/11
• co-investigators: R. Clint Whaley and Daniel Quinlan
• Students supported: TBA
• Project Summary : The complexity of modern high-end computers has made it exceedingly difficult for scientific applications to effectively manage resources such as extreme-scale parallelism, single-chip multi-processors, and deep hierarchy of shared/distributed caches and memories. In particular, as machines and applications have both evolved to become complex and massively parallel, compilers have failed to automatically bridge the gap between complex software and diverse hardware platforms. Optimization models for parallel computing have lagged far behind those for serial applications, and conventional compilers are increasingly unable to accommodate emerging high-end architectures.
  
  This research develops a new optimization model that allows 1) developers to effectively interact with advanced optimizing compilers to provide both domain-specific knowledge and high-level optimization strategies (e.g., directions to enable new or choose amongst differing parallelization strategies); 2) computational specialists to easily define arbitrary domain-specific transformations to directly control performance optimizations to their code; 3) architecture-sensitive optimizations to be easily parameterized and empirically tuned to achieve portable high performance. The optimization model is supported with an integrated environment that contains two main components: ROSE, a C/C++/Fortran2003 source-to-source optimizing compiler developed at DOE/LLNL; and POET, a transformation language together with an empirical optimization engine developed at UTSA. This framework permits different levels of automation and programmer intervention, from fully-automated tuning to semi-automated development to fully programmable control. The research targets both the optimization needs of computational kernels and the more general requirements of whole program optimizations. The framework is integrated as an external development mechanism for the widely-adopted ATLAS library and is connected with empirical tuning research under DOE SciDAC program to improve the efficiency of large-scale scientific applications.

• Title: Program Analysis and Optimization For The Empirical Tuning of Scientific Applications
• Total amount : $51,710
• Period : 04/01/08 - 03/31/09
• co-investigators: Collaborated work with Daniel Quinlan
• Students supported: Brian Edwards
• Project Summary : Due to the increasing complexity of computer architectures, compilers have great difficulty statically predicting the dynamic behavior of applications on different computing platforms. Automated empirical tuning technology resolves this difficulty by experimentally applying different transformations to an input computation and then selecting the optimizations that produce the best-performing code. This contract will extend the ROSE compiler to effectively parameterize advanced optimizations so that differently transformed code can be dynamically generated and their performance empirically measured. Additionally, we will extend optimizations within ROSE to utilize results of advanced program analysis techniques to improve the effectiveness of these optimizations in understanding application semantics.