Hiroshi Okuda, Kazuteru Garatani, Masaki Nagata · TRANSACTIONS OF THE JAPAN SOCIETY OF MECHANICAL ENGINEERS Series A · 2002
In recent years, more large-scale and complicated numerical analysis came to be performed in connection with fast development of technology. Such a large-scale problem is carrying out parallel computing, and has realized a short time and highly precise analysis. However, since the knowledge of parallel computing and experience are needed for development of a parallel analysis program, for a common user, it becomes the work which spends a remarkable labor and time. Then, in this study, the parallel FEM analysis code was developed using the plug-in function of GeoFEM. The plug-in function here is for developing parallel FEM analysis code without the knowledge of parallel computing. And parallel performance evaluation of the developed program was performed, and it checked that the high parallel performance of 80% or more of the rates of CPU usage came out also under a low communication performance like PC cluster.
Cited by 1Open access
John Darlington, Moustafa M. Ghanem, Shamimabi Paurobally · 1996
Profess is a parallel program simulation tool designed to help application programmers in evaluating the performance of candidate implementations of their programs on a parallel machine. Users provide a high-level description of each program as structured compositions of known programming skeletons and program components. The system then uses a mixture of performance models and actual runs on the parallel machine to estimate the total time required for executing each implementation. In this paper we present the underlying language and basic components of the tool, describe an initial implementation on the AP1000 parallel machine and discuss preliminary results of using the system. 1 Introduction With the diversity of existing parallel machines there is a growing need for tools that help programmers in choosing between alternative implementations of their programs. Writing portable parallel programs requires choosing appropriate algorithms, implementation strategies and resource alloca...
Cited by 0
Marian Bubak, Wlodzimierz Funika, Jacek Moscinski · 2007
We present a view on building a performance analysis tools for parallel applications running on networked workstations under message passing environments (PVM and MPI). Instrumenting a parallel program's components is carried out with a graphical tool. An execution trace is processed using a special trace handling language. A series of metrics and visualizations help infer about application behavior. We show the results of applying the environment facilities to performance analysis of a lattice gas simulation parallel program.
Cited by 0
Liubomyr Tsyhylyk · Advances in Cyber-Physical Systems · 2016
Method of parallelism extraction from sequential program is proposed. The definition of three address code is given. The requirements to the sequential and parallel program are determined. The structure and design performance of the parallel program are given. The description of two stages of the parallelism extraction method is proposed: stage of preliminary field
Cited by 0Open access
Asma Dab, Yosr Slama · 2017
Multicore machines are becoming more and more common. Ideally, all applications benefit from these advances in computer architecture. A complex challenge in parallel computing is cores load balancing to minimize the overall execution time called Make span of the parallel program. As multicores may have different architectures, an effective mapping should support this unknown variation to avoid drawbacks on make span. In fact, mapping or static load balancing method may not be effective when the target state machine changes during program execution. Thread affinity has appeared as an important technique to improve the program performance and for better performance stability. In this context, we propose a predictive approach using iterations chunking at runtime allowing parallel code adaptation to processor's performance. Our approach is based on thread pinning and performance detection at execution time. From a parallel program, we define a set of loop nest iterations, forming what is called chunk, and we run it using a first mapping assuming homogeneous cores. Then, performance assessment would correct mapping by speculating the future core's state. The new mapping would be then applied to a new chunk for further evaluation and prediction. The process would stop when the program is fully executed or when judging that chunking is no longer effective.
Cited by 1
Lawrence Crowl · 1992
People use parallel computers for improved program performance, so effective presentation of parallel performance is important. This paper gives advice on how to effectively present parallel performance in a manner that reduces distortion over common practice. The paper concentrates primarily on visual aspects of presentation, and secondarily on methodological aspects. Computing Reviews Categories and Subject Descriptors: C.4 [Performance of Systems ] --- measurement techniques, performance attributes D.1.3 [Programming Techniques]: Concurrent Programming Keywords: parallel performance, performance graphs, benchmarking 1 Introduction People use parallel computers to improve the performance of programs, that is, to make them solve a single problem in less time or to solve more problems in a fixed time. Because performance is so important to parallel programming, people devote substantial effort to measuring, presenting, and comparing the performance of parallel systems. Unfortunatel...
Cited by 0
Allen D. Malony, V. Mertsiotakis, Andreas Quick · 2002
Testing the performance scalability of parallel programs can be a time consuming task, involving many performance runs for different computer configurations, processor numbers, and problem sizes. Ideally, scalability issues would be addressed during parallel program design, but tools are not presently available that allow program developers to study the impact of algorithmic choices under different problem and system scenarios. Hence, scalability analysis is often reserved to existing (and available) parallel machines as well as implemented algorithms. In this paper we propose techniques for analyzing scaled parallel programs using stochastic modeling approaches. Although allowing more generality and flexibility in analysis, stochastic modeling of large parallel
Cited by 3
Thomas Rauber, Gudula Rünger · 2023
The most important motivation for using a parallel system is the reduction of the execution time of computation-intensive application programs. In this chapter, performance measures for an analysis and comparison of different versions of a parallel program are considered in more detail. The topics covered include the quantitative performance evaluation of computer systems with performance metrics and benchmarks, performance metrics for evaluating parallel programs, execution times for global communication operations, the analysis of parallel execution times, parallel computation models, as well as loop scheduling and loop tiling methods.
Cited by 0Open access
Mani Chandy, Rajit Manohar, Berna L. Massingill et al. · 1994
A parallel program archetype aids in the development of reliable, efficient parallel applications with common computation/communication structures by providing stepwise refinement methods and code libraries specific to the structure. The methods and libraries help in transforming a sequential program into a parallel program via a sequence of refinement steps that help maintain correctness while refining the program to obtain the appropriate level of granularity for a target machine. The specific archetype discussed here deals with the integration of task and data parallelism by using collective (or group) communication. This archetype has been used to develop several applications. 1 Introduction Archetypes. Many parallel applications share common features in design, testing, debugging, performance tuning, and program structuring. A parallel program archetype is an abstraction that embodies common features shared by parallel applications within a domain. An archetype aids the develop...
Cited by 0
Jaspal Subhlok · 1993
For a wide variety of applications, both task and data parallelism must be exploited to achieve the best possible performance on a multicomputer. Recent research has underlined the importance of exploiting task and data parallelism in a single compiler framework, and such a compiler can map a single source program in many different ways onto a parallel machine. There are several complex tradeoffs between task and data parallelism, depending on the characteristics of the program to be executed and the performance parameters of the target parallel machine. This makes it very difficult for a programmer to select a good mapping for a task and data parallel program. In this paper we isolate and examine specific characteristics of executing programs that determine the performance for different mappings on a parallel machine, and present an automatic system to obtain good mappings. The process consists of two steps: First, an instrumented input program is executed a fixed number of times with different mappings, to build an execution model of the program. Next, the model is analyzed to obtain a good final mapping of the program onto the processors of the parallel machine. The current implementation is static, feedback driven, although the approach can be extended to a dynamic system. We demonstrate the system with an example program that is a model for many applications in the domains of signal processing and image processing.
Cited by 18
Šeinauskas, Vytenis, · KTUePubl (Repository of Kaunas University of Technology) · 2008
Parallel program execution is often used to overcome the constraints of processing speed and memory size when executing complex and time-consuming algorithms. The downside to this approach is the increased overall complexity of programs and their implementations. Parallel execution introduces a new class of software bugs and performance shortcomings, that are usually difficult to trace using traditional methods and tools. Hence, new tools and methods need to be introduced, which deal specifically with problems encountered in parallel programs. The goal of this project is the development of MPI-based parallel program performance monitoring tool and research into the ways this tool can be used for measuring, comparing and improving the performance of target programs.
Cited by 0Open access
Magnus Broberg, Lars Lundberg, Håkan Grahn · 2007
. Efficient performance tuning of parallel programs is often hard, as noted in i.e. [2]. We present a performance prediction and visualization tool called VPPB (Visualization of Parallel Program Behaviour). Based on a monitored uni- processor execution, the VPPB shows the (predicted) behaviour of a multithreaded Solaris program using any number of processors, thus making the tool very flexible. The speed-up is predicted, and the program behaviour is visualized as a graph. The graph can be used in the performance tuning process. To the best of our knowledge, VPPB is the only available tool that supports this kind of flexible performance tuning of parallel programs developed for shared memory multiprocessors using a widely spread standardized parallel programming environment; C or C++ programs that uses the built-in thread package in the Solaris 2.X operating system. In the previous version we were unable to trace I/O, by tracing the kernel threads this is now possible. 1 Intoduction T...
Cited by 0
Per Brinch Hansen · Concurrency Practice and Experience · 1993
Abstract We develop a model program for parallel execution of cellular automata on a multicomputer. The model program is then adapted for simulation of forest fires 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.
Cited by 36
Abdul Waheed, Diane T. Rover · 2024
Parallel and distributed computing is becoming popular to achieve a level of performance for a number of applications that is unimaginable with conventional sequential computing. As parallel and distributed computing are helping define new paradigms to fully benefit from the performance gains, the need for tools and technologies to make this type of computing simple and effective for the users can not be understated. Due to the complex nature of concurrent systems and the inherent difficulty in comprehending concurrent activities by human users, development of monitoring tools for parallel and distributed system is a formidable task. These tools are needed to perform diverse tasks, such as program debugging and steering, analysis of bottlenecks in a program, performance prediction, measurement-based performance evaluation, program or performance visualization and animation, etc. There is one common denominator in the complete range of these tools: each relies on runtime information collected from concurrent programs. Unlike data collection from a sequential program, data collection from a parallel or distributed system involves the management of multiple monitoring modules and operating system services. Depending on the nature of an application, this data collection can adversely impact the performance and correctness of the actual program. In order to develop reliable tools, the behavior and oveihead of the data collection (monitoring) facility need to be characterized and accounted for.
Cited by 0
N. Cabibbo, N. Cabibbo, A. Mathis et al. · 1994
The Parallel Computing as the basis for High Performance Computing is discussed. An evaluation of Distributed vs. Massively Parallel Computing is outlined, with special reference to the requirements of the so-called Grand Challenge computational problems. A comparison is then carried on the USA's High Performance Computing and Communications (HPCC) vs. Europe's High Performance Computing and Networking Programs. The weaknesses, but also the potentialities, of the European scene are discussed. Finally, a proposal is presented for a comprehensive initiative to start an all-European massively parallel supercomputing program, based on the relevant industrial assets presently active in Europe (among them, the Italian Quadrics Massively Parallel Supercomputers, derived from the APE100 Project of the Italian National Institute for Nuclear Physics). Key Words: Parallel computing; Distributed computing; Computer simulation; Massively parallel supercomputing program; Transputer; Quadrics. 1. Hi...
Cited by 0
Refson, Keith · Data Archiving and Networked Services (DANS) · 2019
This program has been imported from the CPC Program Library held at Queen's University Belfast (1969-2018) Abstract Moldy is a highly portable C program for performing molecular-dynamics simulations of solids and liquids using periodic boundary conditions. It runs in serial mode on a conventional workstation or on a parallel system using an interface to a parallel communications library such as MPI or BSP. The “replicated data” parallelization strategy is used to achieve reasonable performance with a minimal difference between serial and parallel code. The code has been optimized for high performance in bo... Title of program: Moldy Catalogue Id: ADLT_v1_0 Nature of problem Statistical thermodynamics of liquids and solids. Versions of this program held in the CPC repository in Mendeley Data ADLT_v1_0; Moldy; 10.1016/S0010-4655(99)00496-8
Cited by 0Open access
Vladimir Korkhov, Ivan Gankevich, Anton Gavrikov et al. · Algorithms · 2023
Bottlenecks and imbalance in parallel programs can significantly affect performance of parallel execution. Finding these bottlenecks is a key issue in performance analysis of MPI programs especially on a large scale. One of the ways to discover bottlenecks is to analyze the critical path of the parallel program: the longest execution path in the program activity graph. There are a number of methods of finding the critical path; however, most of them suffer a performance drop when scaled. In this paper, we analyze several methods of critical path finding based on classical Dijkstra and Delta-stepping algorithms along with the proposed algorithm based on topological sorting. Corresponding algorithms for each approach are presented including additional enhancements for increasing performance. The implementation of the algorithms and resulting performance for several benchmark applications (NAS Parallel Benchmarks, CP2K, OpenFOAM, LAMMPS, and MiniFE) are analyzed and discussed.
Cited by 0Open access
Hahn Kim, Albert Reuther · 2008
The most common reason to write parallel programs is to improve performance. Consequently, the ability to measure the runtime performance of a parallel program is of primary importance. One of the most common ways to measure performance of serial programs is to use a profiler. MATLAB © contains a built-in profiler, which can also be used to profile parallel MATLAB programs written with pMatlab
Cited by 0
Tong , Sing Teik · Siti Hasmah Digital Library-MMU Institutiona Repository (Multimedia University) · 2012
This study describes about a parallel implementation of the deflate loss less compression program is described. The performance of the parallel implementation is compared to the sequential deflate program running on Intel Quad Core processor. The parallel deflate algorithm works by taking the input data and running them through the ZIV-Lempel algorithm simultaneously on multiple cores using threads. The results show that a speedup is achieved by using the parallel deflate program on systems with multiple cores. This will greatly reduce the time taken to compress large amounts of data.
Cited by 0
Junjun Cao, Shanshan Fan, Xuan Yang · 2012
Matlab Parallel Toolbox is an effective tool for developing parallel program under a multi-processor environment, in which SPMD is the key statement for single instruction multiple data parallel implementation. However, when using spmd to achieve parallel program, beginners may find that it can hardly improve the speedup of program, and is even worse than the serial one. In this paper, we analyze the matrix operation, for-loop control and the influence the computing scale has on the performance of SPMD, and explain why SPMD speedup is hard to be improved through plenty of experiments. Finally we propose effective methods using spmd to improve parallel program speedup and give sample code of joint histogram on image application.
Cited by 5