Alvaro Wong

Extraction of Parallel Application Signatures for Performance Prediction

Predicting performance of parallel applications is becoming increasingly complex and the best performance predictor is the application itself, but the time required to run it thoroughly is a onerous requirement. We seek to characterize the behavior of message-passing applications on different systems by extracting a signature which will allow us to predict what system will allow the application to perform best. To achieve this goal, we have developed a method we called Parallel Application Signatures for Performance Prediction (PAS2P) that strives to describe an application based on its behavior. Based on the application’s message-passing activity, we have been able to identify and extract representative phases, with which we created a Parallel Application Signature that has allowed us to predict the application’s performance. We have experimented with different signature-extraction algorithms and found a reduction in the prediction error using different scientific applications on different clusters. We were able to predict execution times with an average accuracy of over 98%.

Parallel application signature

We seek to achieve characterization or application signature from a parallel application that will allow us, through the execution of this signature, to evaluate its performance in different computers. Sequential applications behavior can be understood by means of tools such as SimPoint. This tool can identify and select significant phases describing the applications behavior. Our proposal is to extend those concepts towards parallel applications, with the goal of modeling and predicting the parallel application. To achieve this, we developed a methodology, enabling us to identify and extract repetitive behavior to create the application signature. We have validated our proposal using scientific applications such as the NAS Parallel Benchmarks, Sweep3D. We could predict the execution time of the entire application.

Parallel Application Signature for Performance Analysis and Prediction

Predicting the performance of parallel scientific applications is becoming increasingly complex. Our goal was to characterize the behavior of message-passing applications on different target machines. To achieve this goal, we developed a method called parallel application signature for performance prediction (PAS2P), which strives to describe an application based on its behavior. Based on the applications message-passing activity, we identified and extracted representative phases, with which we created a parallel application signature that enabled us to predict the applications performance. We experimented with using different scientific applications on different clusters. We were able to predict execution times with an average accuracy greater than 97 percent.

A Tool for Selecting the Right Target Machine for Parallel Scientific Applications

Abstract Analyzing and predicting performance in parallel applications is a great challenge for scientific programmers due to its com- plexity. Analyzing parallel application behavior is not a trivial process and it requires spending a large amount of time and effort to understand the behavior of the application algorithms during execution. We have developed PAS2P toolkit from PAS2P methodology. This methodology strives to characterize the behavior of MPI applications to identify and extract repre- sentative phases and create a signature, which will be used to analyze the application behavior and predict its execution time in different target systems. Applying this methodology is a non-trivial process for users, for this reason we have developed the proposal toolkit, which allows users to make the whole process, from creating a signature to executing it on target systems, in user-space in an easy and fully automatic way. PAS2P toolkit has been validated, making clear the advantages of the signature, with its execution time being much lower than the whole application execution time (around 7% of the total execution time), with a high quality prediction of around 96%.

Predicting parallel applications performance using signatures: The workload effect

Being able to accurately estimate how an application will perform in a specific computational system provides many useful benefits and can result in smarter decisions. In this work we present a novel approach to model the behavior of message passing parallel applications. Based in the concept of signatures, which are the most relevant parts of an application (phases), we are able to build a model that allows us to predict the application execution time in different systems with variable input data size. Executing these signatures with different input data sizes defines a programs behavior partial function. Using regression we can generalize this behavior function to predict an application performance in a target system with other input data size within a predefined range. We explain our methodology and in order to validate the proposal present results using a synthetic program and well known applications.

P3S: A Methodology to Analyze and Predict Application Scalability

Executing message-passing parallel applications on a large number of resources in an efficient way is not a trivial task. Due to the complex interaction between the parallel applications and the HPC system, many applications may suffer performance inefficiencies when they scale. To achieve an efficient use of these large-scale systems using thousands of cores, a point to consider before executing an application is to know its behavior in the system. In this work, we propose a novel methodology called P3S (Prediction of Parallel Program Scalability), which allows us to analyze and predict the scalability of message-passing applications on a given system. The methodology strives to use a bounded analysis time, and a reduced set of resources to predict the application behavior for large-scale. The experimental validation proves that the P3S is able to predict the application scalability with an average accuracy greater than 95 percent using a reduced set of resources.

Using the Application Signature to Detect Inefficiencies Generated by Mapping Policies in Parallel Applications

The execution of HPC applications in multicore environments can occasionally use the resources in an inefficient way. There are idle times during the application execution that can be caused by synchronization or message passing collisions. We define this idle time as an application inefficiency and may be caused by the message passing collisions at different types of interconnections in the compute nodes. We propose a methodology to characterize the applications execution in order to analyze and detect these inefficiencies in a bounded time as well as to locate on which parallel segments of the application code (phases) these inefficiencies are generated. The parallel segments of code (phases) represent the most relevant application behavior and are obtained by the applications characterization using the PAS2P tool. The tool allows us to predict the execution time by the generation of the application signature, which is composed of phases. Taking advantage of the prediction quality and the time to obtain the prediction of application performance, we propose modeling the factors that potentially influence the applications execution time, especially characterizing the behavior during the execution time of these phases. We performed experimental validation using signatures of NAS Parallel benchmarks in order to detect and model the inefficiencies in the application phases.

Predicting robustness against transient faults of MPI based programs

The evaluation of a programs behaviour in the presence of transient faults is often a very time consuming work. In order to achieve significant data, thousands of executions are required and each execution will have the significant overhead of the fault injection environment. A previously published methodology reduced significantly the time needed to evaluate the robustness of a program execution by exhaustively analysing its execution trace instead of using fault injection. In this paper we present a further improvement in the evaluation time of parallel programs robustness against transient faults by combining this methodology with PAS2P - a method that strives to describe an application based on its message-passing activity. This combination allowed us to predict the robustness of larger parallel programs, reducing in some cases by more than 20 times the time needed to calculate the robustness while obtaining a robustness prediction error of less than 4%.

Evaluation of performance and response capacity in emergency deparments

The saturation of Emergency Departments, due to the increasing demand of the service, is a current problem in the healthcare system. We propose an analytical model to obtain information from data obtained through the simulation of a Hospital Emergency Department. The model defines how to calculate the theoretical throughput of a particular sanitary staff configuration, that is, the number of patients it can attend per unit time given its composition. This index is a reference to measure indicators concerning to performance and emergency response capacity of the system. The data for the analysis will be generated by the simulation of any possible scenario of the real system, taking into account all valid sanitary staff configurations and different number of patients entering into the emergency service.

Synthetic Signature Program for Performance Scalability

Due to the complexity of message-passing applications, prediction of the scalability is becoming an increasingly complex goal. To make an efficient use of the system, it is important to predict the application scalability in a target system. Based on prediction models, such as PAS2P (Parallel Application Signature for Performance Prediction), we propose to create a Synthetic Signature (SS) program that allows us to predict the application performance using a limited set of resources and in a bounded analysis time. The SS uses the Scalable Logical Traces (SLT) as input, containing the relevant behavior of the communications and compute of the application. We model this information given by the process’s small-scaled PAS2P signatures to generate a Scaled Trace for N number of processes. Basically, the SS will be executed per iterations in order to obtain the performance prediction. The prediction error was 3.59 % for all applications tested using 4 nodes of the system.