Shared Memory Parallel Systems Research Articles

High Order Anchoring and Reinitialization of Level Set Function for Simulating Interface Motion

A second order interface anchoring method has been developed and used with fast sweeping algorithm for reinitialization of a level set function. The algebraic anchoring formulation ensures that the location of the actual interface is preserved, leading to better mass conservation property. It also provides high order accurate algebraic constraint for solving the Eikonal equation on a finite difference grid. Geometric properties of the interface such as surface normal and curvature are subsequently computed from the reinitialized distance function. Various analytical functions for modeling distortion in level set field are considered and accuracy of reinitialization is evaluated using first and second order anchoring schemes. It is also shown that accurate computation of interface curvature requires a high order anchor in addition to a high order fast sweeping method. Mass conservation property of reinitialization is also analyzed by considering test problems from literature including the classic Rider–Kothe single vortex problem. The formulation is suitable for efficient parallelization for both distributed memory and on-node shared memory parallel systems. Scalability and performance of the reinitialization scheme on multiple architectures are demonstrated.

Parallel multilevel recursive approximate inverse techniques for solving general sparse linear systems

In this article, a new parallel multilevel algebraic recursive generic approximate inverse solver (PMARGAIS) is proposed. PMARGAIS utilizes the parallel modified generic factored approximate sparse inverse (PMGenFAspI) matrix technique designed for shared memory parallel systems. PMARGAIS requires a block independent set reordering scheme, to create a hierarchy of levels. A modified block breadth first search (MBBFS) is proposed for reducing memory requirements and retaining load balancing. The SVD method is used to compute the inverse of the independent blocks that are formed from the reordering scheme, and computes accurately the Schur complement that is used as a coefficient matrix on the next level, resulting in a hybrid direct-iterative method for large linear systems. The solution of the linear system at the last level is performed with the parallel explicit preconditioned BiCGSTAB method in conjunction with the PMGenFAspI matrix. The parallelization of the proposed methods uses the vector units of modern CPUs. Implementation details are provided and numerical results are given demonstrating the applicability and effectiveness of the proposed schemes.

An Efficient Multicore Implementation of a Novel HSS-Structured Multifrontal Solver Using Randomized Sampling

We present a sparse linear system solver that is based on a multifrontal variant of Gaussian elimination and exploits low-rank approximation of the resulting dense frontal matrices. We use hierarchically semiseparable (HSS) matrices, which have low-rank off-diagonal blocks, to approximate the frontal matrices. For HSS matrix construction, a randomized sampling algorithm is used together with interpolative decompositions. The combination of the randomized compression with a fast ULV HSS factorization leads to a solver with lower computational complexity than the standard multifrontal method for many applications, resulting in speedups up to sevenfold for problems in our test suite. The implementation targets many-core systems by using task parallelism with dynamic runtime scheduling. Numerical experiments show performance improvements over state-of-the-art sparse direct solvers. The implementation achieves high performance and good scalability on a range of modern shared memory parallel systems, including ...

Dynamic threshold for imbalance assessment on load balancing for multicore systems

The introduction of multicore microprocessors has enabled smaller organizations to invest in high performance shared memory parallel systems. These systems ship with standard operating systems using preset thresholds for task imbalance assessment to activate load balancing. Unfortunately, this will unnecessarily trigger task migrations when the number of tasks is a few multiples of the number of processing cores. We illustrate this unnecessary task migration behavior through simulation and introduce a dynamic threshold for task imbalance assessment that is dependent on the number of tasks and the number of processing cores. This is as a replacement for the static threshold that is used by standard operating systems. With the dynamic threshold method, we are able to illustrate a performance gain of up to 17% on a synthetic benchmark and up to 25% gain using the Integer Sort Benchmark from the National Aeronautics and Space Administration (NASA) Advanced Supercomputing Parallel Benchmark Suite.

Accurate and robust CFD algorithms applied to 3D arbitrary polyhedral grids

A parallel, accurate, robust and grid-transparent CFD solver was developed to solve compressible flow on 3D arbitrary polyhedral grids. To improve spacial accurate, a constrained least-squares reconstruction method is developed. To accelerate convergence, a matrix free implicit method GMRES+LU-SGS, and a parallel method using OpenMP are presented on shared-memory parallel systems with help of a special grid reordering technique. Several typical test cases, including subsonic, transonic and hypersonic flows, prove that the resulting solver performs fast, accurate and robust.

Block Locally Optimal Preconditioned Eigenvalue Xolvers (BLOPEX) in Hypre and PETSc

We describe our software package Block Locally Optimal Preconditioned Eigenvalue Xolvers (BLOPEX) publicly released recently. BLOPEX is available as a stand-alone serial library, as an external package to PETSc (``Portable, Extensible Toolkit for Scientific Computation'', a general purpose suite of tools for the scalable solution of partial differential equations and related problems developed by Argonne National Laboratory), and is also built into {\it hypre} (``High Performance Preconditioners'', scalable linear solvers package developed by Lawrence Livermore National Laboratory). The present BLOPEX release includes only one solver--the Locally Optimal Block Preconditioned Conjugate Gradient (LOBPCG) method for symmetric eigenvalue problems. {\it hypre} provides users with advanced high-quality parallel preconditioners for linear systems, in particular, with domain decomposition and multigrid preconditioners. With BLOPEX, the same preconditioners can now be efficiently used for symmetric eigenvalue problems. PETSc facilitates the integration of independently developed application modules with strict attention to component interoperability, and makes BLOPEX extremely easy to compile and use with preconditioners that are available via PETSc. We present the LOBPCG algorithm in BLOPEX for {\it hypre} and PETSc. We demonstrate numerically the scalability of BLOPEX by testing it on a number of distributed and shared memory parallel systems, including a Beowulf system, SUN Fire 880, an AMD dual-core Opteron workstation, and IBM BlueGene/L supercomputer, using PETSc domain decomposition and {\it hypre} multigrid preconditioning. We test BLOPEX on a model problem, the standard 7-point finite-difference approximation of the 3-D Laplacian, with the problem size in the range $10^5-10^8$.

Generating OpenMP code using an interactive parallelization environment

Code parallelization using OpenMP for shared memory systems is relatively easier than using message passing for distributed memory systems. Despite this, it is still a challenge to use OpenMP to parallelize application codes in a way that yields effective scalable performance when executed on a shared memory parallel system. We describe an environment that will assist the programmer in the various tasks of code parallelization and this is achieved in a greatly reduced time frame and level of skill required. The parallelization environment includes a number of tools that address the main tasks of parallelism detection, OpenMP source code generation, debugging and optimization. These tools include a high quality, fully interprocedural dependence analysis with user interaction capabilities to facilitate the generation of efficient parallel code, an automatic relative debugging tool to identify erroneous user decisions in that interaction and also performance profiling to identify bottlenecks. Finally, experiences of parallelizing some NASA application codes are presented to illustrate some of the benefits of using the evolving environment.

SPEC HPG benchmarks for high-performance systems

In this paper, we discuss the results and characteristics of the benchmark suites maintained by the Standard Performance Evaluation Corporation's (SPEC) High-Performance Group (HPG). Currently, SPECHPGhas two lines of benchmark suites for measuring performance of large-scale systems SPEC OMP and SPEC HPC2002. SPEC OMP uses the OpenMP API and includes benchmark suites intended for measuring performance of modern shared memory parallel systems. SPEC HPC2002 uses both OpenMP and MPI, and thus it is suitable for distributed memory systems, shared memory systems and hybrid systems. SPEC HPC2002 contains benchmarks from three popular application areas: chemistry, seismic and weather forecasting. Each of the three benchmarks in HPC2002 has a small and a medium data set in order to satisfy the need for benchmarking a wide range of high-performance systems. We analyse published results of these benchmark suites regarding scalability. We also present current efforts of SPEC HPG to create new releases of the benchmark suites.

Using an interactive parallelisation toolkit to parallelise an ocean modelling code

This paper describes an interactive parallelisation toolkit that can be used to generate parallel code suitable for either a distributed memory system (using message passing) or a shared memory system (using OpenMP). This study focuses on how the toolkit is used to parallelise a complex heterogeneous ocean modelling code within a few hours for use on a shared memory parallel system. The generated parallel code is essentially the serial code with OpenMP directives added to express the parallelism. The results show that substantial gains in performance can be achieved over the single thread version with very little effort.

Large system performance of SPEC OMP benchmark suites

Performance characteristics of application programs on large-scale systems are often significantly different from those on smaller systems. SPEC OMP includes benchmark suites intended for measuring performance of modern shared memory parallel systems. SPEC OMPM2001 is developed for medium-scale (4- to 16-way) systems whereas SPEC OMPL2001 is developed for large-scale systems (32-way and larger). We present our experiences on benchmark development in achieving good scalability using the OpenMP API. We also analyze the published results of these benchmark suites on large systems (32-way and larger), based on application program behavior and systems' architectural features.

Achieving performance under OpenMP on ccNUMA and software distributed shared memory systems

AbstractOpenMP is emerging as a viable high‐level programming model for shared memory parallel systems. It was conceived to enable easy, portable application development on this range of systems, and it has also been implemented on cache‐coherent Non‐Uniform Memory Access (ccNUMA) architectures. Unfortunately, it is hard to obtain high performance on the latter architecture, particularly when large numbers of threads are involved. In this paper, we discuss the difficulties faced when writing OpenMP programs for ccNUMA systems, and explain how the vendors have attempted to overcome them. We focus on one such system, the SGI Origin 2000, and perform a variety of experiments designed to illustrate the impact of the vendor's efforts. We compare codes written in a standard, loop‐level parallel style under OpenMP with alternative versions written in a Single Program Multiple Data (SPMD) fashion, also realized via OpenMP, and show that the latter consistently provides superior performance. A carefully chosen set of language extensions can help us translate programs from the former style to the latter (or to compile directly, but in a similar manner). Syntax for these extensions can be borrowed from HPF, and some aspects of HPF compiler technology can help the translation process. It is our expectation that an extended language, if well compiled, would improve the attractiveness of OpenMP as a language for high‐performance computation on an important class of modern architectures. Copyright © 2002 John Wiley & Sons, Ltd.

An Adaptive Algorithm for Mining Association Rules on Shared-Memory Parallel Machines

Mining association rules from large databases is very costly. We propose to develop parallel algorithms for this task on shared-memory multiprocessor (SMP). All proposed parallel algorithms for other paradigms follow the conventional level-wise approach: they need as many iterations as the length of the maximum large itemset. To make matter worse, they impose a synchronization in every iteration which would cause serious I/O contention on shared-memory parallel system. An adaptive asynchronous parallel mining algorithm APM has been proposed for SMP. All processors generate candidates dynamically and count itemset supports independently without synchronization. Two optimization techniques have been proposed for the reduction of database scanning and the number of candidates. The algorithm APM has been implemented on a Sun Enterprise 4000 shared-memory multiprocessor with 12 nodes. The experiments show that the optimizations have very good effects and APM has a substantial lead in performance over other proposed level-wise algorithms.

Parallelization of multi-reference coupled-cluster method

A parallel computer program performing orthogonally spin-adapted two-reference state-universal coupled-cluster calculations with singly and doubly excited clusters (SUCCSD) is described. It is demonstrated that a significant speedup of the SUCCSD calculations on shared-memory parallel systems having 16–32 CPUs can be achieved with relatively few changes in a serial code, if the OpenMP directives are used. The parallel efficiency of the SUCCSD calculations improves with the basis set. The results of parallel SUCCSD calculations for the low lying electronic states of simple quasi-degenerate molecular systems are reported.

Program Development Tools for Clusters of Shared Memory Multiprocessors

Applications are increasingly being executed on computational systems that have hierarchical parallelism. There are several programming paradigms which may be used to adapt a program for execution in such an environment. In this paper, we outline some of the challenges in porting codes to such systems, and describe a programming environment that we are creating to support the migration of sequential and MPI code to a cluster of shared memory parallel systems, where the target program may include MPI, OpenMP or both. As part of this effort, we are evaluating several experimental approaches to aiding in this complex application development task.

Hardware support for load sharing in parallel systems

Abstract Providing a tightly-coupled parallel system with support for load sharing poses some problems related to the nature of inter-processor communication and task granularity. In a recent work, the authors have proposed a hybrid adaptive load sharing algorithm for distributed-memory systems based on a centralized component, the broker. Simulations have shown that the proposed algorithm performs remarkably well and does not suffer from scalability problems for a wide range of operating conditions. In order to make the hybrid algorithm behave efficiently on a shared-memory parallel system, where the availability of faster communication makes it feasible to implement task migration and to use a finer task granularity, we have devised a hardware implementation of the broker component upon which the algorithm is based. The hardware broker, which is seen as a low-cost, additional peripheral in the system, is able to improve the performance, with respect to a software implementation, by at least two orders of magnitude. This makes it possible to run the centralized part of our load sharing algorithm in one bus cycle and deal with task granularities in the milliseconds range and systems with 50… 100 nodes. In this paper we present two different architectures for the broker, and discuss their simulated performance in the use of our load sharing algorithm on multiprocessor systems.

Parallel algorithms for solving large linear systems

The solution of linear systems continues to play an important role in scientific computing. The problems to be solved often are of very large size, so that solving them requires large computer resources. To solve these problems, at least supercomputers with large shared memory or massive parallel computer systems with distributed memory are needed. This paper gives a survey of research on parallel implementation of various direct methods to solve dense linear systems. In particular are considered: Gaussian elimination, Gauss-Jordan elimination and a variant due to Huard (1979), and an algorithm due to Enright (1978), designed in relation to solving (stiff) ODEs, such that stepsize and other method parameters can easily be varied. Some theoretical results are mentioned, including a new result on error analysis of Huard's algorithm. Moreover, practical considerations and results of experiments on supercomputers and on a distributed-memory computer system are presented.

An approach to scalability study of shared memory parallel systems

The overheads in a parallel system that limit its scalability need to be identified and separated in order to enable parallel algorithm design and the development of parallel machines. Such overheads may be broadly classified into two components. The first one is intrinsic to the algorithm and arises due to factors such as the work-imbalance and the serial fraction. The second one is due to the interaction between the algorithm and the architecture and arises due to latency and contention in the network. A top-down approach to scalability study of shared memory parallel systems is proposed in this research. We define the notion of overhead functions associated with the different algorithmic and architectural characteristics to quantify the scalability of parallel systems; we isolate the algorithmic overhead and the overheads due to network latency and contention from the overall execution time of an application; we design and implement an execution-driven simulation platform that incorporates these methods for quantifying the overhead functions; and we use this simulator to study the scalability characteristics of five applications on shared memory platforms with different communication topologies.

The effect of scheduling discipline on spin overhead in shared memory parallel systems

Spinning, or busy waiting, is commonly employed in parallel processors when threads of execution must wait for some event, such as synchronization with another thread. Because spinning is purely overhead, it is detrimental to both user response time and system throughput. The effects of two environmental factors, multiprogramming and data-dependent execution times, on spinning are discussed, and it is shown how the choice of scheduling discipline can be used to reduce the amount of spinning in each case.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Optimal parallel merging and sorting algorithms using √ N processors without memory contention

A multi-way parallel merging algorithm is described to merge two sorted lists each with size N on a shared-memory parallel system. The structure of this algorithm is very regular and highly parallel. It is shown that using P processors, the time complexity of this algorithm is O( N/ P) when N ⩾ P 2, which is known to be optimal. This approach for parallel merging leads to a multi-way parallel sorting algorithm with time complexity O( N log N)/ P) when N ⩾ P 2. Clearly this is also optimal. In addition, these two algorithms do not require reading from or writing into the same memory location simultaneously, hence they can be applied on a EREW machine. In cases when N < P 2, we recursively apply this merging algorithm to show that for P = N (2 k −1)/ 2 k , the complexities of the merging algorithm the sorting algorithm are O(3 k N/ P) and O(3 k ( N log N)/ P) respectively.