Large Number Of Processors Research Articles

Teraflops Sustained Performance With Real World Applications

This paper provides a comprehensive performance evaluation of the NEC SX-8 system at the High Performance Computing Center Stuttgart which has been in operation since July 2005. It provides a description of the installed hardware together with its performance for some synthetic benchmarks and five real world applications. All the applications achieved sustained Tflop/s performance. Additionally, the measurements presented show the ability of the system to solve not only large problems with a very high performance, but also medium sized problems with high efficiency using a large number of processors.

Large-Scale Phylogenetic Analysis on Current HPC Architectures

Phylogenetic inference is considered a grand challenge in Bioinformatics due to its immense computational requirements. The increasing popularity and availability of large multi-gene alignments as well as comprehensive datasets of single nucleotide polymorphisms (SNPs) in current biological studies, coupled with rapid accumulation of sequence data in general, pose new challenges for high performance computing. By example of RAxML, which is currently among the fastest and most accurate programs for phylogenetic inference under the Maximum Likelihood (ML) criterion, we demonstrate how the phylogenetic ML function can be efficiently scaled to current supercomputer architectures like the IBM BlueGene/L (BG/L) and SGI Altix. This is achieved by simultaneous exploitation of coarse- and fine-grained parallelism which is inherent to every ML-based biological analysis. Performance is assessed using datasets consisting of 270 sequences and 566,470 base pairs (haplotype map dataset), and 2,182 sequences and 51,089 base pairs, respectively. To the best of our knowledge, these are the largest datasets analyzed under ML to date. Experimental results indicate that the fine-grained parallelization scales well up to 1,024 processors. Moreover, a larger number of processors can be efficiently exploited by a combination of coarse- and fine-grained parallelism. We also demonstrate that our parallelization scales equally well on an AMD Opteron cluster with a less favorable network latency to processor speed ratio. Finally, we underline the practical relevance of our approach by including a biological discussion of the results from the haplotype map dataset analysis, which revealed novel biological insights via phylogenetic inference.

PT-S cotch: A tool for efficient parallel graph ordering

The parallel ordering of large graphs is a difficult problem, because on the one hand minimum degree algorithms do not parallelize well, and on the other hand the obtainment of high quality orderings with the nested dissection algorithm requires efficient graph bipartitioning heuristics, the best sequential implementations of which are also hard to parallelize. This paper presents a set of algorithms, implemented in the PT-S cotch software package, which allows one to order large graphs in parallel, yielding orderings the quality of which is only slightly worse than the one of state-of-the-art sequential algorithms. Our implementation uses the classical nested dissection approach but relies on several novel features to solve the parallel graph bipartitioning problem. Thanks to these improvements, PT-S cotch produces consistently better orderings than P arM eT iS on large numbers of processors.

Parallel Performance Modeling using a Genetic Programming-based Error Correction Procedure

Performance models of high performance computing (HPC) applications are important for several reasons. First, they provide insight to designers of HPC systems on the role of subsystems such as the processor or the network in determining application performance. Second, they allow HPC centers more accurately to target procurements to resource requirements. Third, they can be used to identify application performance bottlenecks and to provide insights about scalability issues. The suitability of a performance model, however, for a particular performance investigation is a function of both the accuracy and the cost of the model. A semi-empirical model previously published by the authors for an astrophysics application was shown to be inaccurate when predicting communication cost for large numbers of processors. It is hypothesized that this deficiency is due to the inability of the model adequately to capture communication contention (threshold effects) as well as other unmodeled components such as noise and I/O contention. In this paper we present a new approach to capture these unknown features to improve the predictive capabilities of the model. This approach uses a systematic model error-correction procedure that uses evolutionary algorithms to find an error correction term to augment the eXisting model. Four variations of this procedure were investigated and all were shown to produce better results than the original model. Successful cross-platform application of this approach showed that it adequately captures machine dependent characteristics. This approach was then successfully demonstrated for a second application, further showing its versatility.

Free-Energy Profile of Small Solute Molecules at the Free Surfaces of Water and Ice, as Determined by Cavity Insertion Widom Calculations

The solvation free-energy profiles of 15 different small solutes (i.e., Ar, HF, H2O, H2S, NH3, CH4, CH2F2, CH2Cl2, CHCl3, methanol, formaldehyde, formic acid, CO2, acetone, and acetonitrile) have been calculated across the water/vapor and ice/vapor interfaces by means of Monte Carlo simulations and cavity insertion Widom (CIW) calculations. The CIW calculations have been performed using a new, efficiently parallelized algorithm, which can provide linear speedup on a large number of processors in a distributed memory system. All the solutes considered show preference for being adsorbed at the surface of both liquid water and ice. The free-energy gain of this adsorption relative to the isolated state of the solute molecule is found to be independent of the state (i.e., liquid versus frozen) of the condensed phase, and it is larger for solutes that are able to form stronger or more hydrogen bonds with the water molecules at the surface. On the other hand, the free-energy gain of the adsorption from the bulk ...

Parallel space‐filling curve generation through sorting

AbstractIn this paper we consider the scalability of parallel space‐filling curve generation as implemented through parallel sorting algorithms. Multiple sorting algorithms are studied and results show that space‐filling curves can be generated quickly in parallel on thousands of processors. In addition, performance models are presented that are consistent with measured performance and offer insight into performance on still larger numbers of processors. At large numbers of processors, the scalability of adaptive mesh refined codes depends on the individual components of the adaptive solver. One such component is the dynamic load balancer. In adaptive mesh refined codes, the mesh is constantly changing resulting in load imbalance among the processors requiring a load‐balancing phase. The load balancing may occur often, requiring the load balancer to perform quickly. One common method for dynamic load balancing is to use space‐filling curves. Space‐filling curves, in particular the Hilbert curve, generate good partitions quickly in serial. However, at tens and hundreds of thousands of processors serial generation of space‐filling curves will hinder scalability. In order to avoid this issue we have developed a method that generates space‐filling curves quickly in parallel by reducing the generation to integer sorting. Copyright © 2007 John Wiley & Sons, Ltd.

Enabling scalable parallel implementations of structured adaptive mesh refinement applications

Parallel implementations of dynamic structured adaptive mesh refinement (SAMR) methods lead to significant runtime management challenges that can limit their scalability on large systems. This paper presents a runtime engine that addresses the scalability of SAMR applications with localized refinements and high SAMR efficiencies on large numbers of processors (upto 1024 processors). The SAMR runtime engine augments hierarchical partitioning with bin-packing based load-balancing to manage the space-time heterogeneity of the SAMR grid hierarchy, and includes a communication substrate that optimizes the use of MPI non-blocking communication primitives. An experimental evaluation on the IBM SP2 supercomputer using the 3-D Richtmyer-Meshkov compressible turbulence kernel demonstrates the effectiveness of the runtime engine in improving SAMR scalability.

Solving Three-Dimensional Large-Scale Neutron Transport Problems Using Hybrid Shared-Distributed Parallelism and Characteristics Method

The design of new generations of nuclear reactors will involve fine representations of the theoretical models. Advanced computational methods capable of solving large-scale problems dealing with large and complex systems are required. Therefore, the solution to challenging large-scale neutron transport problems is becoming more and more pressing in nuclear engineering applications. The increase in high-performance computing resources have made possible direct application of transport methods to large-scale computational models. However, many numerical acceleration techniques common to lattice transport codes are not applicable to three-dimensional geometries with heterogeneous material zones, especially for the eigenvalue problems with high-dominance scattering ratio. Consequently, large heterogeneous reactor problems have remained computationally intensive and impractical for routine engineering applications. One of the alternatives is to use high-performance computing methods to solve such problems in reasonable time.In this context, we propose an approach based on high-performance computing techniques to solve large-scale neutron transport problems using a three-dimensional characteristics method. A performance model is then introduced to analyze the three-dimensional characteristics solvers in the context of hybrid shared/distributed memory modern architectures. Several numerical results and discussions are presented including a scalability analysis done to predict the performance on a large number of processors.

Lagrangian 기법에 의한 충돌 해석 시 접촉처리의 병렬화 및 병렬효율 평가

The evaluation of parallel performance of a high speed impact simulation is not an easy task because not only the development of parallel explicit code is difficult but also a large number of processors is not easily accessible. In this paper, the parallel performance of a new Lagrangian FEM impact code carried out on cluster supercomputer has been described in high speed range. In the case of metal sphere impacting to oblique plate, the overall speed-up continuously increases even up to 128 CPUs. Investigation of elapsed time of each part reveals that most of the inefficiency comes from the load imbalance of contact.

Some variants of the Bank–Holst parallel adaptive meshing paradigm

The Bank–Holst adaptive meshing paradigm is an efficient approach for parallel adaptive meshing of elliptic partial differential equations. It is designed to keep communication costs low and to take advantage of existing sequential adaptive software. While in principle the procedure could be used in any parallel environment, it was mainly conceived for use on small Beowulf clusters with a relatively small number of processors and a slow communication network. A typical calculation on such a machine might involve, say p = 32 processors, an adaptive fine mesh with a few million vertices, and use 2–3 min of computational time. In this work we, discuss a variant of the original scheme that could be used in situations where a much larger number of processors, say p > 100 is available. In this case the problem size could be much larger, say 10–100 million, with still a low to moderate computation time.

Efficient Task Scheduling in the Parallel Result-Verifying Solution of Nonlinear Systems

Nonlinear systems occur in diverse applications, e.g., in the steady state analysis of chemical processes. If safety concerns require the results to be provably correct then result-verifying algorithms relying on interval arithmetic should be used for solving these systems. Since such algorithms are very computationally intensive, the coarse-grained inter-box parallelism should be exploited to make them feasible in practice. In this paper we briefly describe our framework SONIC for the verified solution of nonlinear systems and give detailed information about its parallelization with OpenMP and MPI. Our numerical results show that the implemented parallelization schemes are indeed successful. The more sophisticated MPI implementation seems to be superior to the easy-to-implement OpenMP version and shows almost linear speedup up to a large number of processors.

Parallel asynchronous particle swarm optimization

The high computational cost of complex engineering optimization problems has motivated the development of parallel optimization algorithms. A recent example is the parallel particle swarm optimization (PSO) algorithm, which is valuable due to its global search capabilities. Unfortunately, because existing parallel implementations are synchronous (PSPSO), they do not make efficient use of computational resources when a load imbalance exists. In this study, we introduce a parallel asynchronous PSO (PAPSO) algorithm to enhance computational efficiency. The performance of the PAPSO algorithm was compared to that of a PSPSO algorithm in homogeneous and heterogeneous computing environments for small- to medium-scale analytical test problems and a medium-scale biomechanical test problem. For all problems, the robustness and convergence rate of PAPSO were comparable to those of PSPSO. However, the parallel performance of PAPSO was significantly better than that of PSPSO for heterogeneous computing environments or heterogeneous computational tasks. For example, PAPSO was 3.5 times faster than was PSPSO for the biomechanical test problem executed on a heterogeneous cluster with 20 processors. Overall, PAPSO exhibits excellent parallel performance when a large number of processors (more than about 15) is utilized and either (1) heterogeneity exists in the computational task or environment, or (2) the computation-to-communication time ratio is relatively small.

Communication Benchmarking and Performance Modelling of MPI Programs on Cluster Computers

This paper gives an overview of two related tools that we have developed to provide more accurate measurement and modelling of the performance of message-passing communication and application programs on distributed memory parallel computers. MPIBench uses a very precise, globally synchronised clock to measure the performance of MPI communication routines. It can generate probability distributions of communication times, not just the average values produced by other MPI benchmarks. This allows useful insights to be made into the MPI communication performance of parallel computers, and in particular how performance is affected by network contention. The Performance Evaluating Virtual Parallel Machine (PEVPM) provides a simple, fast and accurate technique for modelling and predicting the performance of message-passing parallel programs. It uses a virtual parallel machine to simulate the execution of the parallel program. The effects of network contention can be accurately modelled by sampling from the probability distributions generated by MPIBench. These tools are particularly useful on clusters with commodity Ethernet networks, where relatively high latencies, network congestion and TCP problems can significantly affect communication performance, which is difficult to model accurately using other tools. Experiments with example parallel programs demonstrate that PEVPM gives accurate performance predictions on commodity clusters. We also show that modelling communication performance using average times rather than sampling from probability distributions can give misleading results, particularly for programs running on a large number of processors.

Vectorization and Parallelization of the Adaptive Mesh Refinement N-Body Code

Abstract We describe our vectorized and parallelized adaptive mesh refinement (AMR) $N$-body code with shared time steps, and report its performance on a Fujitsu VPP5000 vector-parallel supercomputer. Our AMR $N$-body code puts hierarchical meshes recursively where higher resolution is required and the time step of all particles are the same. The parts that are the most difficult to vectorize are loops that access the mesh data and particle data. We vectorized such parts by changing the loop structure, so that the innermost loop steps through the cells instead of the particles in each cell, in other words, by changing the loop order from the depth-first order to the breadth-first order. We also parallelized our code for distributed memory machines. The important part of parallelization is data decomposition. We sorted the hierarchical mesh data by the Morton order, or the recursive N-shaped order, level by level and split and allocated the mesh data to the processors. Particles are allocated to the processor to which the finest refined cells including the particles are also assigned. Our timing analysis using $\Lambda$-dominated cold dark matter simulations shows that our parallel code speeds up almost ideally up to 32 processors, the largest number of processors in our test.

Simulation-Based Performance Prediction for Large Parallel Machines

We present a performance prediction environment for large scale computers such as the Blue Gene machine. It consists of a parallel simulator, BigSim, for predicting performance of machines with a very large number of processors, and BigNetSim, which incorporates a pluggable module of a detailed contention-based network model. The simulators provide the ability to make performance predictions for very large machines such as Blue Gene/L. We illustrate the utility of our simulators using validation and prediction studies of several applications using smaller numbers of processors for simulations.

EFFICIENT SIMULATION OF AN ACYCLIC DIRECTED RECONFIGURABLE MODEL ON AN UNDIRECTED RECONFIGURABLE MODEL

In this paper we present a simulation of an acyclic n×n DR-Mesh on an n×n LR-Mesh. The simulation is efficient in regards to size since both models use the same number of processors. The worst execution time for this simulation is O(n2) time, but we demonstrate that its average execution time is O( log n). The fastest existing simulation takes O( log n) time, but it uses an extremely large number of processors. On the other hand, the most efficient simulation in terms of size takes O( log 2n) time with O(n4/ log 2n) processors. Both of the existing simulations are for the unrestricted DR-Mesh. This paper provides an important step towards efficiently simulating the unrestricted DR-Mesh on weaker models such as the R-Mesh and the LR-Mesh.

On exploring inter-iteration parallelism within rate-balanced multirate multidimensional DSP algorithms

Although the notion of the parallelism in multidimensional applications has existed for a long time, it is so far unknown what the bound (if any) of inter-iteration parallelism in multirate multidimensional digital signal processing (DSP) algorithms is, and whether the maximum inter-iteration parallelism can be achieved for arbitrary multirate data flow algorithms. This paper explores the bound of inter-iteration parallelism within rate-balanced multirate multidimensional DSP algorithms and proves that this parallelism can always be achieved in hardware system given the availability of a large number of processors and the interconnections between them.

Communications overlapping in fast multipole particle dynamics methods

In molecular dynamics the fast multipole method (FMM) is an attractive alternative to Ewald summation for calculating electrostatic interactions due to the operation counts. However when applied to small particle systems and taken to many processors it has a high demand for interprocessor communication. In a distributed memory environment this demand severely limits applicability of the FMM to systems with O(10 K atoms). We present an algorithm that allows for fine grained overlap of communication and computation, while not sacrificing synchronization and determinism in the equations of motion. The method avoids contention in the communication subsystem making it feasible to use the FMM for smaller systems on larger numbers of processors. Our algorithm also facilitates application of multiple time stepping techniques within the FMM. We present scaling at a reasonably high level of accuracy compared with optimized Ewald methods.

ParCYCLIC: finite element modelling of earthquake liquefaction response on parallel computers

AbstractThis paper presents the computational procedures and solution strategy employed in ParCYCLIC, a parallel non‐linear finite element program developed based on an existing serial code CYCLIC for the analysis of cyclic seismically‐induced liquefaction problems. In ParCYCLIC, finite elements are employed within an incremental plasticity, coupled solid–fluid formulation. A constitutive model developed for simulating liquefaction‐induced deformations is a main component of this analysis framework. The elements of the computational strategy, designed for distributed‐memory message‐passing parallel computer systems, include: (a) an automatic domain decomposer to partition the finite element mesh; (b) nodal ordering strategies to minimize storage space for the matrix coefficients; (c) an efficient scheme for the allocation of sparse matrix coefficients among the processors; and (d) a parallel sparse direct solver. Application of ParCYCLIC to simulate 3‐D geotechnical experimental models is demonstrated. The computational results show excellent parallel performance and scalability of ParCYCLIC on parallel computers with a large number of processors. Copyright © 2004 John Wiley & Sons, Ltd.

Flexible Fast Multipole Method for Magnetic Simulations

The public-domain /spl psi/-Mag toolset uses generic-programming techniques to provide the computational magnetic-materials community an excellent opportunity for code reuse without loss of efficiency. /spl psi/-Mag provides a flexible implementation of the fast multipole method (FMM) for dipole-dipole calculations that does not depend on the geometry of the problem and is suitable for high-performance, parallel computers. Theoretically, the execution time for such a calculation should grow only linearly with the number of spins, and this is confirmed here for up to order 10/sup 5/ spins. In addition, the implementation efficiently uses a large number of processors. For a test case of 64 000 dipoles, the measured speedup is over 25 for 40 processors on a four-processor-per-node IBM SP; this compares quite favorably with less-flexible FMM implementations. The generic implementation allows for easy changes of the basis functions used to expand potentials specific to particular applications, facilitating direct comparison of different approaches. Here, the traditional spherical-harmonic expansions are compared to Cartesian expansions which reflect the cubic symmetries of meshes used in typical micromagnetic simulations.