Mark Crovella, T.J. LeBlanc · 2002
Most performance debugging and tuning of parallel programs is based on the "measure-modify" approach, which is heavily dependent on detailed measurements of programs during execution. This approach is extremely time consuming and does not lend itself to predicting performance under varying conditions. Analytic modeling and scalability analysis provide predictive power, but are not widely used in practice, due primarily to their emphasis on asymptotic behavior and the difficulty of developing accurate models that work for real world programs. We describe a set of tools for performance tuning of parallel programs that bridges this gap between measurement and modeling. The approach is based on lost cycles analysis, which involves measurement and modeling of all sources of overhead in a parallel program. We first describe a tool for measuring overheads in parallel programs that we have incorporated onto the runtime environment for Fortran programs on the Kendall Square KSR1. We then describe a tool that fits these overhead measurements to analytic forms. We illustrate the use of these tools by analyzing the performance tradeoffs among parallel implementations of 2D FFT. These examples show how our tools enable programmers to develop accurate performance models of parallel applications without requiring extensive performance modeling expertise.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 12
David Poliakoff · Scholars' Bank (University of Oregon) · 2015
Modern computational software is increasingly large in terms of lines of code, number of developers, intended longevity, and complexity of intended architectures. While tools exist to mitigate the problems this type of software causes for the development of functional software, no solutions exist to deal with the problems it causes for performance. This thesis introduces a design called the Software Development Performance Analysis System, or SDPAS. SDPAS observes the performance of software tests as software is developed, tracking builds, tests, and developers in order to provide data with which to analyze a software development process. SDPAS integrates with the CMake build and test suite to obtain data about builds and provide consistent tests, with git to obtain data about how software is changing. SDPAS also integrates with TAU to obtain performance data and store it along with the data obtained from other tools. The utility of SDPAS is observed on two pieces of production software.
Cited by 0Open access
Weining Wu, Guozhi Song, Xingang Li · 2010
This paper presents a grid frame composed of a preprocessing database server and PC nodes. It divides the whole database into different parts for different PC nodes, where the corresponding data are stored. The server is responsible for the clients' interaction, order partition and management of the whole grid. It implements the parallel database in grid. The paper calculates the execution time of the operation in parallel database. It deduces the formula of the speedup, considering the network and the data interaction. The method derives the maximum of the speedup by calculating its limit in ideal state. Then for the fixed database size, with the number of grid processor nodes growing and the complexity of the database operation increasing, the speedup of this grid frame achieves its maximum value.
Cited by 0
B.J. Overeinder, P.M.A. Sloot · Lecture notes in computer science · 1995
Cited by 3
Geimer, M. · JuSER (Forschungszentrum Jülich) · 2009
Cited by 0
Khoshlessan, Mahzad, Paraskevakos, Ioannis, Fox, Geoffrey C. et al. · arXiv (Cornell University) · 2019
The performance of biomolecular molecular dynamics simulations has steadily increased on modern high performance computing resources but acceleration of the analysis of the output trajectories has lagged behind so that analyzing simulations is becoming a bottleneck. To close this gap, we studied the performance of parallel trajectory analysis with MPI and the Python MDAnalysis library on three different XSEDE supercomputers where trajectories were read from a Lustre parallel file system. Strong scaling performance was impeded by stragglers, MPI processes that were slower than the typical process. Stragglers were less prevalent for compute-bound workloads, thus pointing to file reading as a bottleneck for scaling. However, a more complicated picture emerged in which both the computation and the data ingestion exhibited close to ideal strong scaling behavior whereas stragglers were primarily caused by either large MPI communication costs or long times to open the single shared trajectory file. We improved overall strong scaling performance by either subfiling (splitting the trajectory into separate files) or MPI-IO with Parallel HDF5 trajectory files. The parallel HDF5 approach resulted in near ideal strong scaling on up to 384 cores (16 nodes), thus reducing trajectory analysis times by two orders of magnitude compared to the serial approach.
Cited by 0Open access
Manfred Jobmann, Johann Schumann · 1992
No abstract available.
Cited by 2Open access
BALSAMO, Maria Simonetta, L. DONATIELLO · ARCA (Università Ca' Foscari Venezia) · 1990
Cited by 0
Wolf, F. · JuSER (Forschungszentrum Jülich) · 2008
Cited by 0
Felician Alecu · 2008
Abstract: A grid is a collection of individual machines. The goal is to create the illusion of a powerful computer out of a large collection of connected systems sharing resources. Some resources may be used by all users of the grid while others may have specific restrictions. The most common resource is computing cycles provided by the processors. Grid computing represents unlimited opportunities in terms of business and technical aspects. The main reason of parallelization a sequential program is to run the program faster. The first criterion to be considered when evaluating the performance of a parallel program is the speedup used to express how many times a parallel program works faster than the corresponding sequential one used to solve the same problem. When running a parallel program on a real parallel system there is an overhead coming from processors load imbalance and from communication times needed for changing data between processors and for synchronization. This is the reason why the execution time of the program will be greater than the theoretical value. Key words: grid computing; grid network; parallel processing; performance analysis; parallel speedup; parallel efficiency The performance of parallel algorithms executed on multiprocessor systems The first criterion taken into consideration when the performances of the parallel systems are analyzed is the speedup used to express how many times a parallel program works faster than a sequential one, where both programs are solving the same problem. The most important reason of parallelization a sequential program is to run the program faster. The speedup formula is
Cited by 0
Becker, D. · JuSER (Forschungszentrum Jülich) · 2007
Cited by 0
Mohr, B. · JuSER (Forschungszentrum Jülich) · 2005
Cited by 0
Yu Lin, G. Joós, J.F. Lindsay · 2002
Parallel-processing inverter-based uninterruptible power supply (UPS) systems have advantages over the conventional rectifier-inverter systems. Control is more complex and design tools are not readily available. The modeling, control and performance of a typical system are analyzed, and important parameters are identified. This UPS consists of an inverter-battery subsystem in shunt between the AC mains and the load. Two control loops are employed to fully exploit the advantages of the proposed UPS system: (1) a fast load voltage regulation loop; and (2) a slower battery charging loop. Mathematical models are developed to design the required regulators and compensation networks for both loops. The predicted performance characteristics are verified by simulation. Experimental results on a 5 kVA unit confirm the theoretical analyses.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 21
Wei-Ming Lin, Bo Yang · International Journal of Parallel Programming · 1995
Cited by 4
Onur Cankur, Aditya Tomar, Daniel Nichols et al. · arXiv (Cornell University) · 2024
Developing efficient parallel applications is critical to advancing scientific development but requires significant performance analysis and optimization. Performance analysis tools help developers manage the increasing complexity and scale of performance data, but often rely on the user to manually explore low-level data and are rigid in how the data can be manipulated. We propose a Python-based API, Chopper, which provides high-level and flexible performance analysis for both single and multiple executions of parallel applications. Chopper facilitates performance analysis and reduces developer effort by providing configurable high-level methods for common performance analysis tasks such as calculating load imbalance, hot paths, scalability bottlenecks, correlation between metrics and CCT nodes, and causes of performance variability within a robust and mature Python environment that provides fluid access to lower-level data manipulations. We demonstrate how Chopper allows developers to quickly and succinctly explore performance and identify issues across applications such as AMG, Laghos, LULESH, Quicksilver and Tortuga.
Cited by 0Open access
Suneeta H. Angadi, G T Raju, B Abhishek · International Journal of Computer Science and Informatics · 2012
The term software performance engineering (SPE) is a systematic and quantitative approach for constructing software systems to meet the performance objectives such as response time, throughput, scalability and resource utilization. Optimization is major concern in achieving performance parameters. Optimization is performed during run-time, or in the design phase. This paper proposes the coding practices in Open Multi Processing (OpenMP) and Open Computing Language (OpenCL) that outperforms the conventional algorithms for searching, matrix multiplication and routing tasks in terms of response time.
Cited by 2Open access
B.J. Overeinder, P.M.A. Sloot · UvA-DARE (University of Amsterdam) · 1995
Cited by 0Open access
Jeffrey Bull · 2024
Comparison of Threading and MPI in MCNP6Threading MPI Ease of use Integrated into MCNP Requires additional software Versatility Limited to neutron, photon, and electron particles only --No model physics Works with all MCNP features CPU utilizationAll processes transport particles Manager process only sends and collects data; it does no particle transport Memory usageGeometry and cross section data memory is sharedNo memory shared CPU overheadRequires thread locks so that only one thread at a time can run certain sections of the code Each process runs independently Inter-process data transfer and collectionNone -done internally Manager broadcasts data to individual processes and collects the results when they are finished. Number of parallel processesLimited to one core None --can run across nodes of a cluster or computers on a networkExcept for UM preprocessing, only particle transport is run in parallel.
Cited by 0Open access
Patel, Jayeshkumar Madhubhai · Figshare · 2019
Considering the need of a better, GUI based and effective high performance computing solution, we created the Grid called SCADY (Scalable & Dynamic). Lot of grids are available with different specifications like multithreading, dynamic resource allocation, scheduling etc. But we found that in all the available grids, whenever a resource fails, a new resource is allocated through dynamic allocation but the job restarts. In Scady, we implemented dynamic resource allocation through caching. To obtain the best performance, both grid system and application-specific information can be considered in implementing high performance problems that meets the desired Quality of Service (QoS) requirements. Authors have implemented grid scenarios to solve parallel application problems like Monte Carlo Simulation etc. Authors also implemented the same in Alchemi.net, Unicore and Globus grid environments and have obtained favorable experiment results for Scady. Scenarios were created in such a manner that dynamic resource allocation can be tested.This paper gives the performance as well as the comparative analysis of Scady with other grid environments like Alchemi.net, Unicore, and Globus in executing high performance parallel applications.
Cited by 0Open access
Patel, Jayeshkumar Madhubhai · Figshare · 2019
Considering the need of a better, GUI based and effective high performance computing solution, we created the Grid called SCADY (Scalable & Dynamic). Lot of grids are available with different specifications like multithreading, dynamic resource allocation, scheduling etc. But we found that in all the available grids, whenever a resource fails, a new resource is allocated through dynamic allocation but the job restarts. In Scady, we implemented dynamic resource allocation through caching. To obtain the best performance, both grid system and application-specific information can be considered in implementing high performance problems that meets the desired Quality of Service (QoS) requirements. Authors have implemented grid scenarios to solve parallel application problems like Monte Carlo Simulation etc. Authors also implemented the same in Alchemi.net, Unicore and Globus grid environments and have obtained favorable experiment results for Scady. Scenarios were created in such a manner that dynamic resource allocation can be tested.This paper gives the performance as well as the comparative analysis of Scady with other grid environments like Alchemi.net, Unicore, and Globus in executing high performance parallel applications.
Cited by 0Open access