Zheng Wang · Kongqi donglixue xuebao · 2002
We parallelized LM_NS3D, a program for three dimensional low mach flow simulation, with PVM as the message passing environment. Communication is carefully optimized. Data locality is achieved. Load balance is considered. Tests done on tow parallel platforms show that the program has a good scalability and a high speedup. Analysis of the results is given. Several routes to improve the performance of parallel programs are discussed. Methods for the parallel implementation for CFD program of this type are summarized.
Cited by 1
Kim,K H, Jenson,M J · Defense Technical Information Center (DTIC) · 1977
A parallel (multiprocessor) system processing fault-tolerant programs was previously developed. The system performance is evaluated in this paper, using an analytic approach based on stochastic models. The analysis confirms the high effectiveness of a parallel system, under all practical circumstances, in reducing the program execution time increase due to run-time validation and system state saving. It also shows how the system performance is affected by various program characteristics.
Cited by 1
Hans‐Wolfgang Loidl · Parallel Processing Letters · 2001
The performance of data parallel programs often hinges on two key coordination aspects: the computational costs of the parallel tasks relative to their management overhead — task granularity; and the communication costs induced by the distance between tasks and their data — data locality. In data parallel programs both granularity and locality can be improved by clustering, i.e. arranging for parallel tasks to operate on related sub-collections of data.The GPH parallel functional language automatically manages most coordination aspects, but also allows some high-level control of coordination using evaluation strategies. We study the coordination behavior of two typical data parallel programs, and find that while they can be improved by introducing clustering evaluation strategies, further performance improvements can be achieved by restructuring the program.We introduce a new generic Cluster class that allows clustering to be systematically introduced, and improved by program transformation. In contrast to many other parallel program transformation approaches, we transform realistic programs and report performance results on a 32-processor Beowulf cluster. The cluster class is highly-generic and extensible, amenable to reasoning, and avoids conflating computation and coordination aspects of the program.
Cited by 1
Neil J. Gunther · 2011
A parallel program can be represented as a directed acyclic graph. An im-portant performance bound is the time T ∞ to execute the critical path through the graph. We show how this performance metric is related to Amdahl speedup and the degree of average parallelism. These bounds formally exclude superlinear performance. 1 Computational DAG A parallel program can be represented as a directed acyclic graph (DAG), where nodes correspond to tasks (or subtasks) and arrows represent control or communication be-tween tasks. Leiserson [1] characterizes the performance of parallel programs by the elapsed time T1 to execute all the nodes in a DAG (e.g., Fig. 1), and the time T ∞ to execute the critical path.
Cited by 0
Insung Park, Michael J. Voss, Brian Armstrong et al. · 2000
We present our effort to advance the tool support for performance tuning of parallel programs by providing (1) intergrated views for both performance and static program analysis data and (2) support for users' deductive reasoning in identifying performance bottlenecks and finding solutions. New features incorporated into the Ursa Minor tool assist users in understanding the behavior of parallel applications in terms of the performance results and the program structure. An extensive set of operations can be applied on the gathered data that combines many different types of information in meaningful ways. With these new utilities, we provide more comprehensive support for performance evaluation and optimization of parallel programs. Ursa Minor can be invoked on a Web-computing infrastructure at http://punch.ecn.purdue.edu/Netcare/parHub.html .
Cited by 0
Per Brinch Hansen, Per Brinch Hansen, Per Brinch Hansen · 1993
We develop a model program for parallel execution of cellular automata on a mul-ticomputer. The model program is then adapted for simulation of forest fires and numerical solution of Laplace's equation for stationary heat fl.ow. The performance of the parallel program is analyzed and measured on a Computing Surface configured as a matrix of transputers with distributed memory.
Cited by 0
2008
We develop a generic program for parallel execution of cellular automata on a multicomputer. The generic program is then adapted for simulation of a forest fire and numerical solution of Laplace’s equation for stationary heat flow. The performance of the parallel program is analyzed and measured on a Computing Surface configured as a matrix of transputers with distributed memory. 1
Cited by 0
Daniel S. Katz, Edwin Tisdale, Charles D. Norton · NASA Technical Reports Server (NASA) · 2004
Parallel Component Performance Benchmarks is a computer program developed to aid the evaluation of the Common Component Architecture (CCA) - a software architecture, based on a component model, that was conceived to foster high-performance computing, including parallel computing. More specifically, this program compares the performances (principally by measuring computing times) of componentized versus conventional versions of the Parallel Pyramid 2D Adaptive Mesh Refinement library - a software library that is used to generate computational meshes for solving physical problems and that is typical of software libraries in use at NASA s Jet Propulsion Laboratory.
Cited by 0
Girija Narlikar, Guy E. Blelloch · 1998
Abstract : Expressing a large number of lightweight, parallel threads in a shared address space significantly eases the task of writing a parallel program. Threads can be dynamically created to execute individual parallel tasks; the implementation schedules these threads onto the processors and effectively balances the load. However, unless the threads scheduler is designed carefully, such a parallel program may suffer poor space and time performance. Th this paper, we evaluate the performance of a native, lightweight POSIX threads (Pthreads) library on a shared memory machine using a set of parallel benchmarks that dynamically create a large number of threads. By studying the performance of one of the benchmarks, matrix multiply, we show how simple, yet provably good modifications to the library can result in significantly improved space and time performance. With the modified Pthreads library, each of the parallel benchmarks performs as well as its coarse-grained, hand-partitioned counterpart. These results demonstrate that, provided we use a good scheduler, the rich functionality and standard API of Pthreads can be combined with the advantages of dynamic, lightweight threads to result in high performance.
Cited by 6
Tisdale, Edwin, Norton, Charles, Katz, Daniel · NASA Technical Reports Server (NASA)
Parallel Component Performance Benchmarks is a computer program developed to aid the evaluation of the Common Component Architecture (CCA) - a software architecture, based on a component model, that was conceived to foster high-performance computing, including parallel computing. More specifically, this program compares the performances (principally by measuring computing times) of componentized versus conventional versions of the Parallel Pyramid 2D Adaptive Mesh Refinement library - a software library that is used to generate computational meshes for solving physical problems and that is typical of software libraries in use at NASA s Jet Propulsion Laboratory.
Cited by 0Open access
D.C. Cann, Rich Wolski, John Feo · OSTI OAI (U.S. Department of Energy Office of Scientific and Technical Information) · 1992
Sisal (Streams and Iterations in Single Assignment Language) is a functional language for numerical computation on both conventional and novel multiprocessor systems. In this paper, we discuss the Sisal project; illustrate SISAL`s performance in comparison to sequential and parallel FORTRAN; and identify the project`s future directions. We demonstrate that one can raise the level of program abstraction without sacrificing performance. SISAL programs are efficient, portable, determinate, and free of the burden thwarting parallel program is development. Without question, functional programming can resolve today`s parallel programming crisis.
Cited by 1
A. Ferscha, J. Johnson · 1995
The CAPSE (Computer Aided Parallel Software Engineering) environment aims to assist a perfor-mance oriented parallel program development approach by integrating tools for performance prediction in the design phase, analytical or simulation based perfor-mance analysis in the detailed specification and coding phase, and finally monitoring in the testing and cor-rection phase. In this work, the N-MAP tool as part of the CAPSE environment is presented. N-MAP covers the crucial aspect of performance prediction to support a perfor-mance oriented, incremental development process of parallel applications such that implementation design choices can be investigated far ahead of the full coding of the application. Methodologically, N-MAP in an automatic parse and translate step generates a simu-lation program from a skeletal SPMD program, with which the programmer expresses just the constituent and performance critical program parts, subject to an incremental refinement. The simulated execution of the SPMD skeleton supports a variety of performance studies. We demonstrate the use and performance of the N-MAP tool by developing a linear system solver for the CM-5. 1
Cited by 0
Greg Eisenhauer, Karsten Schwan, Weiming Gu et al. · 2002
The paper focuses on the opportunities and costs of online steering as applied to a substantial parallel application. We demonstrate potential performance improvements through the use of the Falcon system, an experimental system for the online monitoring and steering of parallel programs. The visual presentation of program output along with animated displays of program performance information via Falcon's monitoring system enables the online capture, analysis, and display of program information required for program steering. Falcon also provides the mechanisms for the manipulations of program state that accomplish this online steering.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 30
Luo Chen · 2012
In the field of geographic raster data processing,the data I/O performance significantly impacts the perfor-mance of a parallel program,especially when data are massive.Currently,the research on parallel optimizations for geographic raster data I/O is quite limited.By combining the data I/O paradigms in parallel programs with the characteristics of the geographic raster logical and physical models,we proposed a parallel I/O architecture for geographic raster data,and implemented four parallel access methods based on message passing model.Massive experiments verify that our methods outperform not only the conventional sequential I/O method but also the time-sharing multi-processes data access method.Our work can be used to promote the I/O efficiency of a parallel raster processing algorithm and thus improve the parallel performance of the program.
Cited by 1
Yamazaki, Hiroyuki, Yoshida, Masahiro, Iwamiya, Toshiyuki et al. · JAXA Repository (JAXA) · 1998
A DNS (Direct Numerical Simulation) solver based on the Navier-Stokes equations was parallelized in two ways: one uses PVM (Parallel Virtual Machine) message passing library and the other NWT (Numerical Wind Tunnel)-Fortran compiler directives. By employing both one- and two-dimensional partitioning methods, the performance of the program on NAL vector parallel computer 'NWT' was analyzed, and vector tuning and parallel tuning was applied to it to be suitable for NWT. Then a performance model of the program to estimate the consuming time of the program was made. By comparing the estimation time derived from the model and the actual time consumed, applicability of the performance model was evaluated and a good agreement was obtained. This work was done in the collaboration between ONERA (Office National d'Etudes et de Recherches Aerospatiales) and NAL. The program treated in this work is called 'PEGASE' developed by ONERA.
Cited by 0Open access
Thomas Fahringer · 1995
The area of parallelizing compilers for distributed memory multicomputers has seen considerable research activity during the last few years. Most of the current compilers do not provide any support for estimating performance impacts of code changes that they apply. In this paper, we present P³T, which is a static and automatic performance estimator for data parallel programs. It computes at compile time a set of parallel program parameters that characterize the behavior of the parallel program. This includes work distribution, number of data transfers, amount of data transferred, transfer times, network contention, and number of cache misses. These parameters can be selectively obtained for statements, loops, procedures, and the entire program; furthermore, their effect with respect to individual processors can be examined. Based on these parameters the programmer can apply well-directed program changes to eliminate or alleviate every specific performance drawback as indicated by ...
Cited by 0
Magnus Broberg, Lars Lundberg, Håkan Grahn · KTH Publication Database DiVA (KTH Royal Institute of Technology) · 2008
Efficient performance tuning of parallel programs is often hard. Optimization is often done when the program is written as a last effort to increase the performance. With sequential programs each (executed) code segment will affect the total execution time of the program. Thus, any code segment that is optimized in a sequential program will decrease the execution time. In the case of a parallel program executed on a multiprocessor this is not always true. This is due to dependencies between the different threads. As a result, certain code segments of the execution may not affect the total execution time of the program. Thus, optimization of such code segments will not increase the performance. In this paper we present a new approach to perform the optimization phase. Our approach finds the critical path of the multithreaded program and the optimization is only done on those specific code segments of the program. We have implemented the critical path analysis in a performance optimization tool. 1.
Cited by 0Open access
Celso L. Mendes, Daniel A. Reed · 1997
Despite the performance potential of multicomputers, several factors have limited their widespread adoption. Of these, performance variability is among the most significant. Execution of some programs may yield only a small fraction of peak system performance, whereas others approach the system’s theoretical performance peak. Moreover, the observed performance may change substantially as application program parameters vary. Data parallel languages, which facilitate the programming of multicomputers, increase the semantic distance between the program’s source code and its observable performance, thus aggravating the performance problem. In this paper, we propose a new methodology to automatically predict the performance scalability of data parallel applications on multicomputers. Our technique represents the execution time of a program as a symbolic expression that is a function of the number of processors (P), problem size (N), and other system-dependent parameters. This methodology is based on information collected at compile time. By extending an existing data parallel compiler (Fortran D95), we derive, during compilation, a symbolic model that represents the cost of each high-level program section and, inductively, of the complete program. These symbolic expressions may be simplified externally with current symbolic tools. Predicting performance of the program for a given pait (P,N) requires simply the evaluation of its corresponding cost expression. We validate our implementation by predicting scalability of a variety of loop nests, with distinct computation and communication patterns.
Cited by 0Open access
Edward Michael Williams · 1990
Abstract : Algorithm animation is a visualization method used to enhance understanding of functioning of an algorithm or program. Visualization is used for many purposes, including education, algorithm research, performance analysis, and program debugging. This research applies algorithm animation techniques to programs developed for parallel architectures, with specific on the Intel iPSC/2 hypercube. While both P-time and NP-time algorithms can potentially benefit from using visualization techniques, the set of NP-complete problems provides fertile ground for developing parallel applications, since the combinatoric nature of the problems makes finding the optimum solution impractical. The primary goals for this visualization system are: Data should be displayed as it is generated. The interface to the targe program should be transparent, allowing the animation of existing programs. Flexibility - the system should be able to animate any algorithm. The resulting system incorporates and extends two AFIT products: the AFIT Algorithm Animation Research Facility (AAARF) and the Parallel Resource Analysis Software Environment (PRASE). AAARF is an algorithm animation system developed primarily for sequential programs, but is easily adaptable for use with parallel programs. PRASE is an instrumentation package that extracts system performance data from programs on the Intel hypercubes. Since performance data is an essential part of analyzing any parallel program, views of the performance data are provided as an elementary part of the system. Custom software is designed to interface these systems and to display the program data. The program chosen as the example for this study is a member of the NP-complete problem set; it is a parallel implementation of a general Set Covering Problem (SCP).
Cited by 1
An Hong · 2002
Parallel computing is about 20 years old. Till now, there is a lack of effective parallel programming methods and tools in high performance computing as a result that it is very difficulty to parallel programming, understanding behaviors of parallel program, debugging parallel codes and optimizing performance. In this paper, the reasons why so difficulty parallel programming is are analyzed, while the issues about parallel programming methods existing in recent high performance parallel machines are addressed, the current status of parallel programming models and languages are surveyed, the view of the criteria is offered to evaluate parallel programming models, the challenge problems in this area are brought forward, and some future research directions are pointed out.
Cited by 6