Scalable Identification of Load Imbalance in Parallel Executions Using Call Path Profiles

Abstract—Applications must scale well to make efficient use of today’s class of petascale computers, which contain hundreds of thousands of processor cores. Inefficiencies that do not even appear in modest-scale executions can become major bottlenecks in large-scale executions. Because scaling problems are often difficult to diagnose, there is a critical need for scalable tools that guide scientists to the root causes of scaling problems. Load imbalance is one of the most common scaling problems. To provide actionable insight into load imbalance, we present post-mortem parallel analysis techniques for pinpointing and quantifying load imbalance in the context of call path profiles of parallel programs. We show how to identify load imbalance in its static and dynamic context by using only low-overhead asyn-chronous call path profiling to locate regions of code responsible for communication wait time in SPMD executions. We describe the implementation of these techniques within HPCTOOLKIT. I

Strategy for Improving Memory Locality Reuse and Exploiting Hidden Parallelism

In recent years, methods for analyzing and parallelizing sequential code using data analysis and loop transformations have been developed. These techniques have proved remarkably successful, and have been used to move from sequential to parallel codes, or to improve efficiency of existing parallel codes. Our research focuses on Fortran code optimisation for parallelisation in Shared Memory architectures by using data analysis and loop source-to-source transformations. Our optimisation strategy, although designed for OpenMP directives, is sufficiently general to be used for pure Fortran code. Our algorithm has been implemented as a tool called Automatic Guidance Module (AGM), and have received high evaluation scores from our industrial partner

Temporal Logic Model Checking of CSP: Tools and Techniques

We study the possibility of doing LTL model checking on CSP specifications in the context of refinement. We present a technique to perform LTL model checking of CSP processes using refinement checking in general and the FDR tool in particular. We present a tool which automates the translation process from LTL model checking to CSP refinement. Also, if time permits, we will present another tool which uses latest generation Prolog technology to symbolically animate, compile, and model check CSP specifications

Effectively presenting call path profiles of application performance

Abstract—Call path profiling is a scalable measurement technique that has been shown to provide insight into the performance characteristics of complex modular programs. However, poor presentation of accurate and precise call path profiles obscures insight. To enable rapid analysis of an execution’s performance bottlenecks, we make the following contributions for effectively presenting call path profiles. First, we combine a relatively small set of complementary presentation techniques to form a coherent synthesis that is greater than the constituent parts. Second, we extend existing presentation techniques to rapidly focus an analyst’s attention on performance bottlenecks. In particular, we (1) show how to scalably present three complementary views of callingcontext-sensitive metrics; (2) treat a procedure’s static structure as first-class information with respect to both performance metrics and constructing views; (3) enable construction of a large variety of user-defined metrics to assess performance inefficiency; and (4) automatically expand hot paths based on arbitrary performance metrics — through calling contexts and static structure — to rapidly highlight important program contexts. Our work is implemented within HPCTOOLKIT, which collects call path profiles using low-overhead asynchronous sampling. I

Animation and Model Checking of CSP and B using Prolog Technology

We describe practical experiences of using a logic programming based approach to model and reason about critical systems. We argue that logic programming with co-routining, constraints, and tabling is a good foundation for developing, animating, and model checking new specification languages. We present animators and model checkers currently being developed for two different extensions of CSP and for the B method