Anna Morajko

Design and implementation of a dynamic tuning environment

The main goal of parallel/distributed applications is to solve a considered problem as fast as possible using the minimum amount of system resources. In this context, the application performance becomes a crucial issue and developers of parallel/distributed applications must optimize them to provide high performance computation. Typically, to improve performance, developers analyze the application behavior, search for bottlenecks, determine their causes and change the source code. In this paper, we present the dynamic, automatic tuning approach. This approach aims at automating these tasks and minimizing user intervention. An application is monitored, its performance bottlenecks are detected and it is modified automatically during the execution, without recompiling or re-running it. The modifications introduced adapt the application behavior to the changing conditions. This paper describes design and implementation of the MATE environment (Monitoring, Analysis and Tuning Environment), which we have developed as a step towards dynamically tuning parallel/distributed applications.

MATE: Monitoring, Analysis and Tuning Environment for parallel/distributed applications

The main goal of parallel/distributed applications is to solve the considered problem as fast as possible using the available resources. In this context, the application performance becomes a crucial issue. Developers of these applications must optimize them if they are to fulfill the promise of high‐performance computation. To improve performance, developers search for bottlenecks by analyzing application behavior, try to identify performance problems, determine their causes and overcome them by changing the source code of the application. Current approaches require developers to do these tasks manually and imply a high degree of expertise. Therefore, another approach is needed to help developers during the optimization process. This paper presents the dynamic tuning approach that addresses these issues. In this approach, many tasks are automated and the user intervention and required experience may be significantly reduced. An application is monitored, its performance bottlenecks are detected and it is modified automatically during execution, without recompiling or re‐running it. The introduced modifications adapt the application behavior to changing conditions. We present an environment called MATE (Monitoring, Analysis and Tuning Environment) that has been developed to provide dynamic tuning of parallel/distributed applications. We also show practical experiments conducted with MATE to prove its effectiveness and profitability. Copyright

MATE: Dynamic Performance Tuning Environment

Performance is a key issue in the development of parallel/distributed applications. The main goal of these applications is to solve the considered problem as fast as possible utilizing a certain minimum of parallel system capacities. Therefore, developers must optimize these applications if they are to fulfill the promise of high performance computation. To improve performance, programmers search for bottlenecks by analyzing application behavior, finding problems and solving them by changing the source code. These tasks are especially difficult for non-expert programmers. Current approaches require developers to perform optimizations manually and to have a high degree of experience. Moreover, applications may be executed in dynamic environments. Therefore, it is necessary to provide tools that automatically carry out the optimization process by adapting application execution to changing conditions. This paper presents the dynamic tuning approach that addresses these issues. We also describe an environment called MATE (Monitoring, Analysis and Tuning Environment), which provides dynamic tuning of applications.

Dynamic Performance Tuning Environment

Performance analysis and tuning of parallel/distributed applications are very difficult tasks for non-expert programmers. It is necessary to provide tools that automatically carry out these tasks. Many applications have a different behavior according to the input data set or even change their behavior dynamically during the execution. Therefore, it is necessary that the performance tuning can be done on the fly by modifying the application according to the particular conditions of the execution. A dynamic automatic performance tuning environment supported by dynamic instrumentation techniques is presented. The environment is completed by a pattern based application design tool that allows the user to concentrate on the design phase and facilitates on the fly overcoming of performance bottlenecks.

Automatic tuning of master/worker applications

The Master/Worker paradigm is one of the most commonly used by parallel/distributed application developers. This paradigm is easy to understand and is fairly close to the abstract concept of a wide range of applications. However, to obtain adequate performance indexes, such a paradigm must be managed in a very precise way. There are certain features, such as data distribution or the number of workers, that must be tuned properly in order to obtain such performance indexes, and in most cases they cannot be tuned statically since they depend on the particular conditions of each execution. In this context, dynamic tuning seems to be a highly promising approach since it provides the capability to change the parameters during the execution of the application to improve performance. In this paper, we demonstrate the usage of a dynamic tuning environment that allows for adaptation of the number of workers based on a theoretical model of Master/Worker behavior. The results show that such an approach significantly improves the execution time when the application modifies its behavior during execution.

Dynamic performance tuning supported by program specification

Performance analysis and tuning of parallel/distributed applications are very difficult tasks for non-expert programmers. It is necessary to provide tools that automatically carry out these tasks. These can be static tools that carry out the analysis on a post-mortem phase or can tune the application on the fly. Both kind of tools have their target applications. Static automatic analysis tools are suitable for stable application while dynamic tuning tools are more appropriate to applications with dynamic behaviour. In this paper, we describe KappaPi as an example of a static automatic performance analysis tool, and also a general environment based on parallel patterns for developing and dynamically tuning parallel/distributed applications.

Scalable dynamic Monitoring, Analysis and Tuning Environment for parallel applications

Parallel/distributed systems are continuously growing. This allows and enables the scalability of the applications, either by considering bigger problems in the same period of time or by solving the problem in a shorter time. In consequence, the methodologies, approaches and tools related to parallel paradigm should be brought up to date to support the increasing requirements of the applications and the users. MATE (Monitoring, Analysis and Tuning Environment) provides automatic and dynamic tuning for parallel/distributed applications. The tuning decisions are made according to performance models, which provide a fast means to decide what to improve in the execution. However, MATE presents some bottlenecks as the application grows, due to the fact that the analysis process is made in a full centralized manner. In this work, we propose a new approach to make MATE scalable. In addition, we present the experimental results and the analysis to validate the proposed approach against the original one.

Workload Balancing Methodology for Data-Intensive Applications with Divisible Load

Data-intensive applications are those that explore, query, analyze, and, in general, process very large data sets. Generally in High Performance Computing (HPC), the main performance problem associated to these applications is the load unbalance or inefficient resources utilization. This paper proposes a methodology for improving performance of data-intensive applications based on performing multiple data partitions prior to the execution, and ordering the data chunks according to their processing times during the application execution. As a first step, we consider that a single execution includes multiple related explorations on the same data set. Consequently, we propose to monitor the processing of each exploration and use the data gathered to dynamically tune the performance of the application. The tuning parameters included in the methodology are the partition factor of the data set, the distribution of these data chunks, and the number of processing nodes to be used by the application. The methodology has been initially tested using the well-known bioinformatics tool BLAST, obtaining encouraging results (up to a 40% of improvement).

Dynamic performance tuning of distributed programming libraries

The use of distributed programming libraries is very common in the development of scientific and engineering applications. These libraries, from message passing libraries to numerical libraries, are designed in a very general way to be useful for a wide range of applications. Therefore, there are several polices that must be adapted to the particular application, system and input data to provide the expected performance. Our objective is develop an environment for tuning the use of a distributed library on the fly according to the dynamic behavior of the applications. In this paper, we present as an example a tuning environment for PVM-based applications. We show potential bottlenecks when using PVM. We also include tuning scenarios that describe the evaluation of the application behavior and the solutions that can improve the performance.

On-Line Performance Modeling for MPI Applications

To develop an efficient parallel application is not an easy task. Applications rarely achieve a good performance immediately therefore, a careful performance analysis and optimization are crucial. These tasks are difficult and require a thorough understanding of the programs behavior. In this paper, we propose an on-line performance modeling technique, which enables the automated discovery of causal execution flows, composed of communication and computational activities, in MPI parallel programs. Our model reflects an application behavior and is made up of elements correlated with high-level program structures, such as loops and communication operations. Moreover, our approach enables an assortment of on-line diagnosis techniques which may further automate the performance understanding process.