Parallel Data Structures Research Articles

DAP Phoenics: Porting a CFD code to a SIMD computer

A port of the Phoenics CFD package to a massively parallel SIMD computer, the DAP, is described. The general principles under which the port was performed are discussed. These principles aim for balance between performance, ease of use and maintainability. Usability and maintainability considerations result in the desire to minimise the user visible changes. The parallel data structures to achieve this aim are discussed. However, in some cases — such as the Linear Equation Solver — the performance is most important and new algorithms need to be developed with the potential of changing the way the user perceives Phoenics. The characteristics of the performance of Phoenics on the DAP are analysed and the extent to which the primary porting goals have been met is reviewed.

Type checking concurrent I/O

In parallel programming languages multityped data structures may be shared by two or more processes. Process I/O to these structures is assumed to be physically interleaved but logically parallel. This article addresses a syntactic mechanism to specify a type for such structures and extends an example language and its type-checking algorithm to these structures.

Parallel adaptive finite element computations with hierarchical preconditioning

A parallel implementation of an adaptive finite element program is treated which is characterized by an underlying parallel dynamic data structure based on linked lists and tree structures. In conjunction with a conjugate gradient solver an efficient methodology for treating adaptive finite element systems is shown. This is achieved by preconditioning using hierarchical bases with and without a coarse grid solver and by new methods of quasi-optimal load balancing. The different levels of nested meshes needed for preconditioning are governed either by global or by adaptive refinements. A termination algorithm based on the vector method is implemented for the non deterministic adaptive mesh refinement procedure. The problems concerning load balancing due to adaptive refinement are solved by a dynamic load balancing for the nodes.

Parallel computation of impact dynamics

This paper discusses a parallel algorithm and data structures for implementing multimaterial, two-step Eulerian finite difference solution schemes on hypercube architectures. Selected problems in impact dynamics have been modeled on the Connection Machine model CM5, and the results are compared with computational results reported in the literature, as well as direct comparison with experimental data.

Multisearch Techniques: Parallel Data Structures on Mesh-Connected Computers

The multisearch problem is defined as follows. Given a data structure D modeled as a graph with n constant-degree nodes, perform O( n) searches on D. Let r be the length of the longest search path associated with a search process, and assume that the paths are determined "on-line." That is, the search paths may overlap arbitrarily. In this paper, we solve the multisearch problem for certain classes of graphs in O([formula] + r ([formula]/log n)) time on a [formula] × [formula] n mesh-connected computer. For many data structures, the search path traversed when answering one search query has length r = O(log n). For these cases, our algorithm processes O( n) such queries in asymptotically optimal Θ([formula]) time. The classes of graphs we consider contain many of the important data structures that arise in practice, ranging from simple trees to Kirkpatrick hierarchical search DAGs. Multisearch is a useful abstraction that can be used to implement parallel versions of standard sequential data structures on a mesh. As example applications, we consider a variety of parallel on-line tree traversals, as well as hierarchical representations of polyhedra and its myriad of applications (line-polyhedron intersection queries, multiple tangent plane determination, intersecting convex polyhedra, and three-dimensional convex hull).

A REAL-TIME NETWORK TRAFFIC SIMULATION MODEL FOR ATMS APPLICATIONS: PART II—MASSIVELY PARALLEL MODEL

Abstract This paper presents three traffic network simulation models implemented on massively parallel computer, the Connection Machine CM-2. The proposed simulation models have been parallelized to take advantage of the parallel computers since they can offer the required computational power at an economical cost/performance ratio. The paper presents detailed discussion of parallel data structure and parallel logic for each simulation model. Several simulation experiments have been carried out to compare the execution speed of each methodology. The preliminary research results indicate that parallel computing architecture offers a very promising alternative for the implementation of real-time traffic simulation.

Recursive Star-Tree Parallel Data Structure

This paper introduces a novel parallel data structure called the recursive star-tree (denoted “${}^ * $-tree”). For its definition a generalization of the $ * $ functional is used (where for a function $f * f(n) = \min \{ {i|f^{(i)} (n) \leqslant 1} \}$ and $f^{(i)} $ is the ith iterate of f). Recursive ${}^ * $-trees are derived by using recursion in the spirit of the inverse Ackermann function. The recursive ${}^ * $-tree data structure leads to a new design paradigm for parallel algorithms. This paradigm allows for extremely fast parallel computations, specifically, $O(\alpha (n))$ time (where $\alpha (n)$ is the inverse of the Ackermann function), using an optimal number of processors on the (weakest) concurrent-read, concurrent-write parallel random-access machine (CRCW PRAM). These computations need only constant time, and use an optimal number of processors if the following nonstandard assumption about the model of parallel computation is added to the CRCW PRAM: an extremely small number of processors each can write simultaneously into different bits of the same word. Applications include finding lowest common ancestors in trees by a new algorithm that is considerably simpler than the known algorithms for the problem, restricted domain merging, parentheses matching, and a new parallel reducibility.

Parallel Functional Programming with Arrays

AbstractWe present an algebraic theory of arrays for data-parallel functionalprogramming. Non-nested arrays simplify the mapping problem toregular architectures, avoid nested list representations and prevent theoccurrence of an explosive number of algebraic laws. The MOA formal-ism describes arrays in a dimension-independent algebra. A new styleof functional programming is described with MOA operators, allowingrecursion equations to describe the meaning as well as the structure ofalgorithms for mesh- or hypercube-connected multiprocessors. 1 Introduction In a recent study, Marino and Succi [19] have enumerated requirements foruseful parallel data structures. Data structures should:match existing and future computer architectures;allow for ecient parallel implementations;be formally de ned in an applicative language;allow the de nition of complex objects in a constructive way. Work supported by an NSERC operating granty G. Hains, Universite de Montreal, Informatique et Recherche Operationnelle, casepostale 6128,succursale A, Montreal, Quebec, Canada H3C 3J7, hains@iro.umontreal.ca. L.M.R.Mullin, Computer Science and Electrical Engineering, University of Vermont, Burlington,Vermont, 05405 USA lenore@newton.uvm.edu

A data parallel finite element method for computational fluid dynamics on the Connection Machine system

A finite element method for computational fluid dynamics has been implemented on the Connection Machine systems CM-2 and CM-200. An implicit iterative solution strategy, based on the preconditioned matrix-free GMRES algorithm, is employed. Parallel data structures built on both nodal and elemental sets are used to achieve maximum parallelization. Communication primitives provided through the Connection Machine Scientific Software Library substantially improved the overall performance of the program. Computations of three-dimensional compressible flows using unstructured meshes having close to one million elements, such as a complete airplane, demonstrate that the Connection Machine systems are suitable for these applications. Performance comparisons are also carried out with the vector computers Cray Y-MP and Convex C-1.

Two-dimensional, viscous, incompressible flow in complex geometries on a massively parallel processor

We describe the parallel implementation of a numerical method, known as the random vortex method, for simulating fluid flow in arbitrary, complex geometries. The code is implemented on the Connection Machine CM-2, a massively parallel processor. The numerical method is particularly suited for computing complex viscous, incompressible flow across a wide range of flow regimes and characteristics. In this method, the vorticity of the flow is approximated by a collection of particles whose positions and strengths induce an underlying flow. As such, it is a Lagrangian scheme, in which the position of each particle is affected by all others at each time step. The efficient execution of this method on the Connection Machine results from a parallel N body solver, parallel elliptic solvers, and a parallel data structure for the adaptive creation of computational elements on the boundary of the confining region. Using this method, we analyze the generation of large vortex structures, mixing and shedding under various flow geometries and inlet/outlet profiles. The data from our simulations are visualized using the real-time flow visualization environment developed on the Connection Machine.

Parallel heap: An optimal parallel priority queue

We describe a new parallel data structure, namely parallel heap, for exclusive-read exclusive-write parallel random access machines. To our knowledge, it is the first such data structure to efficiently implement a truly parallel priority queue based on a heap structure. Employing p processors, the parallel heap allows deletions of θ(p) highest priority items and insertions of θ(p) new items, each in O(log n) time, where n is the size of the parallel heap. Furthermore, it can efficiently utilize processors in the range 1 through n.

A parallel implementation of the random vortex method

We report on a parallel implementation of the random vortex method for viscous, incompressible flow. The code is implemented on the Connection Machine CM-2, a massively parallel processor, and allows the simulation of two-dimensional flow in arbitrary rectilinear geometries. The efficient execution of this method on the Connection Machine results from a parallel N-body solver, parallel elliptic solvers, and a parallel data structure for the adaptive creation of computational elements on the boundary of the confining region.

Transient finite element computations on 65536 processors: The connection machine

AbstractThis paper reports on our experience in solving large‐scale finite element transient problems on the Connection Machine. We begin with an overview of this massively parallel processor and emphasize the features which are most relevant to finite element computations. These include virtual processors, parallel disk I/O and parallel scientific visualization capabilities. We introduce a distributed data structure and discuss a strategy for mapping thousands of processors onto a discretized structure. The combination of the parallel data structure with the virtual processor mapping algorithm is shown to play a pivotal role in efficiently achieving massively parallel explicit computations on irregular and hybrid two‐ and three‐dimensional finite element meshes. The finite element kernels written in C*/Paris have run with success to solve several examples of linear and non‐linear dynamic simulations of large problem sizes. From these example runs, we have been able to assess in detail their performance on the Connection Machine. We show that mesh irregularities induce an MIMD (Multiple Instruction Multiple Data) style of programming which impacts negatively the performance of this SIMD (Single Instruction Multiple Data) machine. Finally, we address some important theoretical and implementational issues that will materially advance the application ranges of finite element computations on this highly parallel processor.

Application of parallel data structures to the finite element solution of circular flat plates

In this paper a direct solution method is presented with a guarantee that the solution of a set of linear simultaneous equations arising from the finite element analysis of circular flat plates is obtained. This solution is obtained in a finite number of steps. This method is programmed and implemented using parallel data structures.

DYNAMIC FINITE ELEMENT SIMULATIONS ON THE CONNECTION MACHINE

This paper reports on our early experience with solving large scale finite element dynamic problems on the Connection Machine. We describe a distributed data structure that allows very efficient massively parallel computations on irregular two and three dimensional finite element meshes. The often encountered mesh irregularities inhibit the use of the NEWS communication package. We propose an alternative approach to interprocessor communication that is based on an optimal mapping of the processors onto the finite elements of the irregular mesh. Our parallel data structure and processor mapping are applied to finite element wave propagation problems on the CM-2.

Parallel implementation of OPS5 on the encore multiprocessor: Results and analysis

Until now, most results reported for parallelism in production systems (rulebased systems) have been simulation results-very few real parallel implementations exist. In this paper, we present results from our parallel implementation of OPS5 on the Encore multiprocessor. The implementation exploits very finegrained parallelism to achieve significant speed-ups. For one of the applications, we achieve 12.4 fold speed-up using 13 processes. Our implementation is also distinct from other parallel implementations in that we parallelize a highly optimized C-based implementation of OPS5. Running on a uniprocessor, our C-based implementation is 10–20 times faster than the standard lisp implementation distributed by Carnegie Mellon University. In addition to presenting the performance numbers, the paper discusses the details of the parallel implementation-the data structures used, the amount of contention observed for shared data structures, and the techniques used to reduce such contention.

Numerical solution of hollow circular cylinders using finite element technique with parallel and columnly linked data structures

A procedure to obtain stiffness matrices for hollow circular cylinders is presented using finite element method. During the formation of the stiffness matrices a parallel data structure storage scheme is applied. After the completion of the stiffness matrix, Crout's method is employed to obtain the solution of a set of linear simultaneous equations. This method reduces the stiffness matrix or any other symmetric positive definite matrix to an upper triangular matrix. During the reduction procedure a columnly linked data structure is used in order to save computer storage. Finally, results are presented and compared with other methods.

Finding the convex hull of a sorted point set in parallel

We present a parallel algorithm for finding the convex hull of a sorted planar point set. Our algorithm runs in O(log n) time using O( n/log n) processors in the CREW PRAM computational model, which is optimal. One of the techniques we use to achieve these optimal bounds is the use of a parallel data structure which we call the hull tree.

A scalable dataflow structure store

A design for a highly parallel data structure store for the prototype Manchester Dataflow Computer is presented. The main design objective is to allow all storage functions to be performed concurrently. The functions include space allocation and garbage collection, as well as operations for reading and writing the store. The resulting design is scalable in that an incremental increase in performance for any function can be achieved by adding appropriate hardware modules into the system. A relative balance in performance between the different functions can therefore be achieved. In the hardware structure store, the logical and the physical function units are designed separately. This increases flexibility for configuring multiprocessor dataflow systems. A single hardware module performing all the functions has been constructed and attached to the prototype Manchester Dataflow Machine. The performance of this configuration is discussed.