Shared Memory Parallel Machines Research Articles

Parallel Reservoir Simulator Computations

Summary We describe the adaptation of a reservoir simulator for parallel computations. The simulator was originally designed for vector processors. It performs approximately 99% of its calculations in vector/ parallel mode, and, relative to scalar calculations, it achieves speedups of 65 and 81 for black oil and EOS simulations, respectively, on the CRAY C-90. This work also shows that it is easy to adapt a simulator designed for vector processing to parallel processing on shared memory parallel machines.

Matrix partitioning on a virtual shared memory parallel machine

The general problem considered in the paper is partitioning of a matrix operation between processors of a parallel system in an optimum load-balanced way without potential memory contention. The considered parallel system is defined by several features the main of which is availability of a virtual shared memory divided into segments. If partitioning of a matrix operation causes parallel access to the same memory segment with writing data to the segment by at least one processor, then contention between processors arises which implies performance degradation. To eliminate such situation, a restriction is imposed on a class of possible partitionings, so that no two processors would write data to the same segment. On the resulting class of contention-free partitionings, a load-balanced optimum partitioning is defined as satisfying independent minimax criteria. The main result of the paper is an algorithm for finding the optimum partitioning by means of analytical solution of respective minimax problems. The paper also discusses implementation and performance issues related to the algorithm, on the basis of experience at Kendall Square Research Corporation, where the partitioning algorithm was used for creating high-performance parallel matrix libraries.

Efficient parallel solution of structural eigenvalue problems

An efficient parallelisation of an existing sequential method for obtaining the eigenvalues of a structure by an exact analytical procedure is presented. Results are given which illustrate finding the undamped natural frequencies of a rigidly jointed plane frame, but the method is also applicable to buckling problems and to other types of structure. The parallel method is suited to both distributed and shared-memory parallel machines. It seeks to equate the workload of each processor (node) by initially sharing out the work and by subsequently passing work from working nodes to idle nodes. Experimental runs on an nCUBE2 computer show that reasonably high levels of efficiency are possible.

Migration of Vectorized Iterative Solvers to Distributed-Memory Architectures

Distributed-memory parallel processors (DMPPs) can deliver peak performance higher than vector supercomputers while promising a better cost-performance ratio. Programming, however, is harder than on traditional vector systems, especially when problems necessitating unstructured solution methods are considered. A class of such applications, with large resource requirements, is the numerical solution of partial differential equations (PDEs) on nonuniformly refined three-dimensional finite element discretizations. Porting an application of this class from vector and shared-memory parallel machines to DMPPs involves some fundamental algorithm changes, such as grid decomposition, mapping, and coloring strategies. In addition, no standardized language interface is available to ease the efficient parallelization and porting among DMPPs and between vector computers and DMPPs. This article describes how PILS-an existing package for the iterative solution of large unstructured sparse linear systems of equations on vector computers-was ported to DMPPs, using the parallelizing Fortran compiler Oxygen. Two DMPPs, namely an Intel Paragon and a Fujitsu AP1000, were used to evaluate the performance of the generated parallel program quantitatively. The results indicate how an application should be designed to be portable among supercomputers of different architecture. Several language and architecture features are essential for such a porting process and ease the parallelization of similar applications drastically.

A Linear Moving Adaptive Particle-Mesh N-Body Algorithm

view Abstract Citations (37) References (13) Co-Reads Similar Papers Volume Content Graphics Metrics Export Citation NASA/ADS A Linear Moving Adaptive Particle-Mesh N-Body Algorithm Pen, Ue-Li Abstract We present the theory, algorithm, and numerical experiments for the implementation of a new N-body algorithm, called APM. It scales linearly with the number of particles for the computational effort per time step. The resolution is fully adaptive, with a typical smoothing length comparable to the local interparticle separation. This is accomplished through the use of a dynamical coordinate system, which adjusts itself to the local density distribution. For the Poisson solver a multigrid iteration scheme is used. The scheme is fully data parallel and data local. A specific implementation of this algorithm is described which is available to the astrophysics community. It is optimized for scalar, vector, and shared memory parallel machines. Performance characteristics are compared to traditional particle-mesh (PM) algorithms. The algorithm inherently has a threefold higher computing cost than the PM method with the same number of grid cells, but offers much higher resolution, and currently appears to be amongst the fastest adaptive high-resolution N-body algorithms. Publication: The Astrophysical Journal Supplement Series Pub Date: September 1995 DOI: 10.1086/192219 Bibcode: 1995ApJS..100..269P Keywords: METHODS: NUMERICAL full text sources ADS |

Parallel Computation of Gröbner Bases on Distributed Memory Machines

This paper reports our work on parallelizing an algorithm computing Gröbner bases on a distributed memory parallel machine. When computing Gröbner bases, the efficiency of computation is dominated by the total number of S-polynomials. To decrease the total number of S-polynomials it is necessary to apply a selection strategy that selects the minimum polynomial as a new element of an intermediate base. On a distributed memory parallel machine, as opposed to a shared memory parallel machine, we have to take into account non-trivial communication costs between processors. To reduce such communication costs, it is better to employ coarse grained parallelism rather than fine grained parallelism. We adopt a manager-worker model. S-polynomials are reduced in worker processes in parallel, and the minimum polynomial is selected in the manager process. To implement the selection strategy in this parallel model, synchronization between worker processes is required for every selection of a new element of the intermediate base. However, in spite of synchronization, introducing the selection strategy produces not only a better absolute computation speed but also better speedup with multi-processors. We achieved about 8 times speedup with 64 processors for large problems, T-6 and Ex-17.

A Framework for Distributed VLSI Simulation on a Network of Workstations

A distributed framework for logic simulation is presented. Switch-level simulation has been mapped to a distributed platform using a network of workstations on an Ethernet bus. Model parallelism is used with preprocessing to partition the circuit to be simulated among the processors. The simulation algorithm is decoupled from the communication layers to ensure easy portability. We have proposed a high level pipelining scheme with multiple buffers to overcome the effects of a low bandwidth network. Speedups of up to 4.1 with 5 processors have been obtained for medium sized ISCAS benchmark circuits. The speedups achieved using distributed simulation are very close to that obtained by the same switch-level simulator imple mented on a shared memory parallel machine. Novel techniques to improve the performance of distributed simulation have also been implemented on a shared memory parallel machine.

Optimal algorithms for the many-to-one routing problem on two-dimensional meshes

In this paper, we consider the many-to-one packet routing problem on the mesh parallel architecture. This problem has not been considered before. It models the communication pattern that occurs when many processors try to write on the same memory location on a concurrent-read concurrent-write shared memory parallel machine. We show that there is an instance of the many-to-one packet routing problem that requires n√ k/2 routing steps to be solved, where k is the maximum number of packets a processor can receive. We give an algorithm that solves the problem in asymptotically optimal time. Furthermore, our algorithm uses queues of small constant size. This queue bound is very important since the ability to expand the mesh is preserved. Finally, we consider two variations of the many-to-one packet routing problem, namely, the case where k is not known in advance, and the case where combining the packets that are destined for the same processor is allowed.

Fast parallel implementation of lazy languages—the EQUALS experience

This paper describes EQUALS, a fast parallel implementation of a lazy functional language on a commercially available shared-memory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we detect parallelism automatically by propagating exhaustive (normal form) demand. Another important difference between EQUALS and previous implementations is the use of reference counting for memory management instead of garbage collection. Our implementation shows that reference counting leads to very good scalability, low memory requirements and improved locality. We compare our results with sequntial SML/NJ as well as parallel ( v, G -machine and GAML implementations.

Parallel techniques for computational geometry

A survey of techniques for solving geometric problems in parallel is given, both for shared memory parallel machines and for networks of processors. Parallel models are reviewed, and basic subproblems that tend to arise in the solution of geometric problems on any parallel model, are discussed. PRAM techniques, techniques for mesh-connected arrays of processors, and the hybrid RAM/ARRAY model and its connection to I/O complexity are considered. Open problems are also discussed, as well as directions for future research. >

Li + HCl RIOSA cross section calculations on parallel computers

Reactive Infinite Order Sudden Approximation calculations have been performed using a computational procedure restructured to run on parallel computers. Computationally intensive sections of the code are analyzed and speedups obtained from a parallel restructuring discussed. The significant speedup obtained on a shared-memory parallel machine has allowed us to perform extensive calculations of the energy dependence of the integral and differential reactive cross sections of the Li+HCl system. A comparison with results of a quasiclassical and an experimental study is also performed.

A portable environment for developing parallel FORTRAN programs

The emergence of commercially produced parallel computers has greatly increased the problem of producing transportable mathematical software. Exploiting these new parallel capabilities has led to extensions of existing languages such as FORTRAN and to proposals for the development of entirely new parallel languages. We present an attempt at a short term solution to the transportability problem. The motivation for developing the package has been to extend capabilities beyond loop based parallelism and to provide a convenient machine independent user interface. A package called SCHEDULE is described which provides a standard user interface to several shared memory parallel machines. A user writes standard FORTRAN code and calls SCHEDULE routines which express and enforce the large grain data dependencies of his parallel algorithm. Machine dependencies are internal to SCHEDULE and change from one machine to another but the users code remains essentially the same across all such machines. The semantics and usage of SCHEDULE are described and several examples of parallel algorithms which have been implemented using SCHEDULE are presented.

The NYU Ultracomputer—Designing an MIMD Shared Memory Parallel Computer

We present the design for the NYU Ultracomputer, a shared-memory MIMD parallel machine composed of thousands of autonomous processing elements. This machine uses an enhanced message switching network with the geometry of an Omega-network to approximate the ideal behavior of Schwartz's paracomputer model of computation and to implement efficiently the important fetch-and-add synchronization primitive. We outine the hardware that would be required to build a 4096 processor system using 1990's technology. We also discuss system software issues, and present analytic studies of the network performance. Finally, we include a sample of our effort to implement and simulate parallel variants of important scientific p̀rograms.

The NYU Ultracomputer—designing a MIMD, shared-memory parallel machine (Extended Abstract)

We present the design for the NYU Ultracomputer, a shared-memory MIMD parallel machine composed of thousands of autonomous processing elements. This machine uses an enhanced message switching network with the geometry of an Omega-network to approximate the ideal behavior of Schwartz's paracomputer model of computation and to implement efficiently the important fetch-and-add synchronization primitive. We outline the hardware that would be required to build a 4096 processor system using 1990's technology. We also discuss system software issues, and present analytic studies of the network performance. Finally, we include a sample of our effort to implement and simulate parallel variants of important scientific programs.