Jeffrey K. Hollingsworth, Barton P. Miller · 1992
There are many metrics designed to assist in the performance debugging of large-scale parallel applica-tions. We describe a new technique, called True Zeroing, that permits direct quantitative comparison of the gui-dance supplied by these metrics on real applications. We apply this technique to three programs that include both numeric and symbolic applications. We compare three existing metrics: Gprof, Critical Path, and Quartz/NPT, and several new variations. Critical Path provided the best overall guidance, but it was not infallible. We also include a set of recommendations to tool builders based on the experience gained during our case study. 1.
Cited by 0
Austin, Todd M, Sohi, Gurindar S · Minds at UW (University of Wisconsin) · 1993
Tetra is a tool for evaluating serial program performance under the resource and control constraints of fine-grain parallel processors. Tetra's primary advantage to the architect is its ability to quickly generate performance metrics for yet to be designed architectures. All the user needs to specify is the capabilities of the architecture (e.g., number of functional units, issue model, etc.), rather than its implementation. Tetra first extracts a canonical form of the program from a serial instruction trace. It then applies control and resource constraint scheduling to produce an execution graph. The control and resource constraint scheduling is directed by a processor model specification supplied to the program. Once scheduled, Tetra provides a number of ways to analyze the program's performance under the specified processor model. These include parallelism profiles, storage demand profiles, data sharing distributions, data lifetime analysis, and control distance (branch, loop, and ...
Cited by 3Open access
Steve Vanderwiel, Dafna Nathanson, David J. Lilja et al. · 1996
It is commonly assumed that if a programmer is willing to invest the potentially significant effort required to port an application program to run on a multiprocessor system using a low-level parallel language or library, they will be able to take advantage of a larger degree of parallelism to achieve higher performance than when using a higher-level language or an automatically parallelizing compiler. However, there has been little work examining the relationship between programming complexity (or ease-of-use) and performance. As a first step towards quantifying this relationship, we use the cyclomatic program complexity metric, borrowed from the software engineering field, and the number of program source statements as measures of the relative complexity of a parallel implementation of a application program compared to it's equivalent sequential implementation. We compare several different programming paradigms across a common set of application programs executed on two workstation clusters, a shared-memory multiprocessor, an IBM SP2 and a Cray T3D. We find that message-passing languages tend to be both the most widely supported and the most complex. Other programming paradigms such as shared-memory and High-Performance Fortran produce more compact and easily understood programs than message-passing languages but are not yet well supported.
Cited by 0
Evangelos P. Markatos, T.J. LeBlanc · 1992
In this paper we quantify the effect of this trend in multiprocessor architecture on parallel program performance. Our experiments on bus-based, cache-coherent machines like the Sequent Symmetry, and large-scale distributed-memory machines like the BBN Butterfly, demonstrate that applications scale much better on previous-generation machines than on current machines. In addition, we show that some scalable machines support fine-grain, shared-memory programs better than some bus-based, cache-coherent machines, without significantly greater programming effort. From our experiments we conclude that communication has become a dominant source of inefficiency in shared-memory multiprocessors, with serious consequences for system software involved in scheduling and decomposition decisions. In particular, we argue that shared-memory programming models that could be implemented efficiently on the machines of yesterday do not readily port to state-of-the-art machines, and that current software trends in support of fine-grain parallel programming are at odds with hardware trends.
Cited by 18
Anna Hondroudakis · ERA · 1997
Cited by 1Open access
J. Xu, K. A. Robbins · 2007
This work describes the use of parallel program performance evaluation tools to visualize scientific data obtained from a combustion experiment. The work shows the close relationship between the qualitative behavior of pattern-forming systems and processor behavior in parallel computer systems. The visualization process requires the extraction of simple visual models based on features segmented during image processing. While the visualizations provide useful insight, the work also indicates the need for a common visualization language which is applicable to both scientific and performance visualization. 1 Introduction Although scientific visualization has a longer and more productive history than parallel performance visualization [8], there are some situations in which the paradigms developed for parallel performance visualization can provide useful insight into scientific data. Parallel performance problems are characterized by large numbers of interrelated events whose timing and s...
Cited by 0
Zhibo Xuan, Xin Sun, Xin You et al. · IEEE Transactions on Parallel and Distributed Systems · 2025
Performance inefficiencies can lead to performance anomalies in parallel programs. Existing performance analysis tools either have a limited detection scope or require significant domain knowledge to use, which constrains their practical adoption to identify performance inefficiencies. In this paper, we propose STAD, a performance analysis tool for parallel programs that considers both spatial and temporal patterns within trace data. STAD captures the spatial communication patterns between processes using a spatial communication pattern graph. It then adopts a dynamic graph neural network-based unsupervised model to learn the evolving temporal patterns along the timeline. Additionally, STAD diagnoses the root causes of performance anomalies by exploiting the aggregated feature of anomalies along the call tree. Our evaluation results demonstrate that STAD can effectively detect performance anomalies with acceptable overhead and diagnose the root causes attributed to both the program itself and the running environment.
Cited by 0
Mark Crovella, Ricardo Bianchini, T.J. LeBlanc et al. · 2003
The authors goal is to be able to predict the performance of a parallel program early in the program development process; to that end they require prediction methods that can be based on incomplete programs. They describe how a single method based on communication-to-computation (C/C) ratio can be used to predict performance accurately and yet fairly simply in some commonly encountered cases. They show how C/C-ratio-based methods are accomplished for both distributed-memory and coherent-memory multiprocessors. They show that focusing on C/C ratio simplifies the use of theory, machine benchmarking and application measurement necessary to provide good parallel performance prediction. In addition, the methods demonstrated are useful because they can be applied to program fragments, or serially executed code.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 23
Robert Procter, C. Halatsis · Research Explorer (The University of Manchester) · 1994
Cited by 0
Lin Sun, Chinh Tam Le, Faisal Saied et al. · Numerical Heat Transfer Part B Fundamentals · 2007
Abstract The parallel performance of classical molecular dynamics simulations of the thermal properties of solid-state materials is evaluated. Computations are validated by predicting the bulk silicon thermal conductivity as a function of temperature. The performance of the computational algorithm and software are tested on three different architectures, including the IBM BlueGene, the IBM Power 4 +, and an Intel Xeon Linux cluster, corresponding to different combinations of processor speeds, communications bandwidth, and latency. Two popular three-body potentials used for silicon simulation are evaluated and compared. In addition, the popular Lennard-Jones potential is used to investigate to role of cutoff distance on parallel performance. Acknowledgments Support of J. Murthy and L. Sun under NSF Grants CTS-0312420, CTS-0219098, EE-0228390, and Purdue's Network for computatuinal Nanotechnology (NCN) is gratefully acknoledged.
Cited by 5
Knüpfer, A., Nagel, W. E., Mohr, B. et al. · JuSER (Forschungszentrum Jülich) · 2006
Cited by 0
Kuan‐Ching Li, Hsun-Chang Chang, Chao‐Tung Yang et al. · 2005
In this paper, we present visual tool for performance measurement and analysis of MPI parallel programs in cluster environments. Most of tools available today for cluster systems show solely system performance data (e.g., CPU load, memory usage, network bandwidth, machine-room temperature, server average load, among others), being more suitable for system administrators who maintain such system. The visual tool is designed to show performance data of all computer nodes involved in the execution of MPI parallel program, such as CPU load level and memory usage. Additionally, this tool is able to display comparative performance data charts of multiple executions of the application (instrumented with MPI interface) under development.
Cited by 4
P. H. Worley, J. Levesque · 2004
We describe our experiences in repeated cycles of performance optimization, benchmarking, and performance analysis of the Parallel Ocean Program (POP) on the Cray X1 at Oak Ridge National Laboratory. We discuss the implementation and performance impact of Co-Array Fortran replacements for communication latency-sensitive routines. We also discuss the performance evolution of the system software from May 2003 to May 2004, and the impact that this had on POP performance. 1
Cited by 0
Xiaoji Ye, Peng Li · 2010
With the increasing popularity of multi-core processors and the promise of future many-core systems, parallel CAD algorithm development has attracted a significant amount of research effort. However, a highly relevant issue, parallel program performance modeling has received little attention in the EDA community. Performance modeling serves the critical role of guiding parallel algorithm design and provides a basis for runtime performance optimization. We propose a systematic composable approach for the performance modeling of a recently developed hierarchical multi-algorithm parallel circuit simulation (HMAPS) approach. The unique integration of inter- and intra-algorithm parallelisms allows a multiplicity of parallelisms to be exploited in HMAPS and also creates interesting modeling challenges in forms of complex performance tradeoffs and large runtime configuration space. We model the performances of key subtask entities as functions of workload and parallelism. We address significant complications introduced by inter-algorithm interactions in terms of memory contention and collaborative simulation behavior via novel penalty and statistical based modeling. The proposed approach is able to accurately predict the parallel performance of a given HMAPS configuration and hence enables the runtime optimization of the parallel simulation code.
Cited by 8
Fei Cai, Shaogang Wu, Longbing Zhang et al. · 2004
The OpenMP API is an emerging standard for parallel programming on shared memory multiprocessors. In order to run an OpenMP program on a cluster, one feasible scheme is to translate the OpenMP program into a software DSM program, then execute it on the cluster. Evaluating the performance of OpenMP programs and analyzing their behavior will help support the OpenMP programming model on a software DSM cluster efficiently. In this paper, we use an experimental approach to investigate how the characteristics of the software DSM cluster and the translation together with the original program behavior determine the performance of OpenMP programs on software DSM clusters.
Cited by 0
Sheng Zhu, Cheng Zhou, Weiwei Li et al. · 2024
With the increasing use of high-performance computing, users are turning to programs for concurrent execution enhance the speed and overall performance of large-scale programs. This trend is supported through the use of a portable messaging interface (MPI), communication can be facilitated in a convenient and efficient manner. We employ the MPI-based performance analysis tool mpiP for evaluating program performance, focusing on a matrix multiplication model through numerous targeted experiments with a fixed number of processors. Expanding the scale of the experimental use case matrix; fixing the scale of the matrix and scaling up the number of processors in order to clearly analyze the program performance and improve the performance analysis of mpiP. At the same time, the execution sequence detection and visualization functions are added in the improvement process. The mpiP report makes it easier for users to perform global performance analysis on the program. This not only improves the overall performance analysis efficiency, it also facilitates tracking the progress of individual processes throughout the program's execution.
Cited by 0
Rob F. VanderWijngaart, Rupak Biswas, Michael Frumkin et al. · NASA Technical Reports Server (NASA) · 2001
The contents include: 1) A brief history of NPB; 2) What is (not) being measured by NPB; 3) Irregular dynamic applications (UA Benchmark); and 4) Wide area distributed computing (NAS Grid Benchmarks-NGB). This paper is presented in viewgraph form.
Cited by 0
LeBlanc, Thomas J., Crovella, Mark E. · UR Research (University of Rochester)
Traditional performance debugging and tuning of parallel programs is based on the "measure-modify" approach, in which detailed measurements of program executions are used to guide incremental changes to the program that result in better performance. Unfortunately, the performance of a parallel algorithm is often related to its implementation, input data, and machine characteristics in surprising ways, and the "measure-modify" approach is unsuited to exploring these relationships fully: it is too heavily dependent on experimentation and measurement, which is impractical for studying the large number of variables that can affect parallel program performance. In this paper we argue that the problem of selecting the best implementation of a parallel algorithm requires a new approach to parallel program performance evaluation, one with a greater balance between measurement and modeling. We first present examples that demonstrate that different parallelizations of a program may be necessary to achieve the best possible performance as one varies the input data, machine architecture, or number of processors used. We then present an approach to performance evaluation based on lost cycles analysis, which involves measurement and modeling of all sources of overhead in a parallel program. We describe a measurement tool for lost cycles analysis that we have incorporated into the runtime environment for Fortran programs on the Kendall Square KSR1, and use this tool to analyze the performance tradeoffs among implementations of 2D FFT and parallel subgraph isomorphism. Using these examples, we show how lost cycles analysis can be used to solve the problems associated with selecting the best implementation in a variable environment. In addition, we show that this approach can capture large amounts of performance data using only a small number of measurements, and that it is flexible enough to allow conclusions to be drawn from empirical data in some cases, and analytic results in other cases.
Cited by 0
Kenneth L. Summers, John Andrew Greenfield, B.T. Smith · 2002
Performance tuning parallel programs is a challenging, often frustrating, endeavor. Many tools exist to assist in this area, most using text and 2D visualization to try and explain what is happening in an executing program. This paper summarizes several commonly used techniques for visualizing running parallel programs, with examples. These tools are an excellent resource, but still suffer from scalability limitations. The second part of this paper presents a proposed method for interacting with these types of visualizations in a virtual environment.
Cited by 7
Lucas A. Wilson, Jeffery von Ronne · Parallel Computing · 2015
Cited by 2