An efficient and scalable parallel algorithm for discrete-event simulation

This paper resolves a long-standing open problem on whether the concurrent write capability of parallel random access machine (PRAM) is essential for solving fundamental graph problems like connected components and minimum spanning trees in O (log n ) time. Specifically, we present a new algorithm to solve these problems in O (log n ) time using a linear number of processors on the exclusive-read exclusive-write PRAM. The logarithmic time bound is actually optimal since it is well known that even computing the “OR” of n bit requires Ω(log n time on the exclusive-write PRAM. The efficiency achieved by the new algorithm is based on a new schedule which can exploit a high degree of parallelism.

In this paper, we present algorithms for parsing general tree-adjoining languages (TALs). Tree-adjoining grammars (TAGs) have been proposed as an elegant formalism for natural languages. It was an open question for the past ten years as to whether TAL parsing can be done in time $O(n^6 )$. We settle this question affirmatively by presenting an $O(n^3 M(n))$-time algorithm, where $M(k)$ is the time needed for multiplying two Boolean matrices of size $k \times k$ each. Since $O(k^{2.376} )$ is the current best-known value for $M(k)$, the time bound of our algorithm is $O(n^{5.376} )$. On an exclusive-read exclusive-write parallel random-access machine (EREW PRAM), our algorithm runs in time $O(n\log n)$ using ${{(n^2 M(n))} / {\log n}}$ processors. In comparison, the best-known previous parallel algorithm had a run time of $O(n)$ using $n^5 $ processors (on a systolic-array machine). We also present algorithms for parsing context-free languages (CFLs) and TALs whose worst-case run times are $O(n^3 )$ and $O(n^6 )$, respectively, but whose average run times are better. Therefore, these algorithms may be of practical interest.

The Parallel Priority Queue (PPQ) data structure supports parallel operations for manipulating data items with keys, such as inserting n new items, deleting n items with the first n smallest keys, creating a new PPQ that contains a set of items, and melding two PPQ’s into one. In this paper, we present fast and efficient parallel algorithms for performing operations on the PPQ’s that maintain data items with real-valued keys. The data structures that we use for implementing the PPQ’s are the unmeldable and meldable parallel heaps. Our algorithms have considerably less time and/or work bounds than the previously best known algorithms, and use a less powerful parallel computational model (EREW PRAM). The new ideas that make our improvement possible are two partition schemes dynamically maintained on the parallel heap structures: the minimal- path partition and the right-path partition. These partition schemes could be of interest in their own right. Our results also lead to optimal parallel algorithms for implementing sequential operations on several commonly-used heap structures.

On Efficient Parallel Algorithms for Solving Set Recurrence Equations

We present an O((log log N)/sup 2/) -time algorithm for computing the distance transform of an N /spl times/ N binary image. Our algorithm is designed for the common concurrent read concurrent write parallel random access machine (CRCW PRAM) and requires O(N/sup 2+/spl epsi///log log N) processors, for any /spl epsi/ such that 0 < /spl epsi/ < 1. Our algorithm is based on a novel deterministic sampling scheme and can be used for computing distance transforms for a very general class of distance functions. We also present a scalable version of our algorithm when the number of processors is available p/sup 2+/spl epsi///log log p for some p < N. In this case, our algorithm runs in O((N/sup 2//p/sup 2/)+(N/p) log log p + (log log p)/sup 2/) time. This scalable algorithm is more practical since usually the number of available processors is much less than the size of the image.

The efficient parallel algorithms proposed for many fundamental problems, such as list ranking, computing preorder numberings on trees and integer sorting, are very sensitive to processor failures. The requirements of efficiency (commonly formalized using {\em Parallel-time x Processors} as a cost measure) has led to the design of highly tuned PRAM algorithms which, given the additional constraint of simple processor failures, unfortunately become inefficient or even incorrect. We propose a new notion of {\em robustness} that combines efficiency with fault tolerance. For the common case of fail-stop errors, we develop a general and easy-to-implement technique to make robust many efficient parallel algorithms, e.g., algorithms for all the problems listed above. More specifically,{\em for any dynamic pattern of fail-stop errors on} a CRCW PRAM {\em with at least one surviving processor}, our method increases the original algorithm''s cost by at most a {\em polylog} multiplicative factor. We also show that at least a {\em log/loglog} multiplicative overhead will be incurred for certain patterns of failures by any algorithm that implements robust solutions to the problems listed.

We describe an efficient parallel algorithm to solve the single function coarsest partition problem. The algorithm runs in O (log n) time using O(n log log n) operations on the arbitrary CRCW PRAM. The previous best-known algorithms run in O(log2 n) time using O(n log2n) operations on the CREW PRAM, and O(log n) time using O (n log n) operations on the arbitrary CRCW PRAM. Our solution is based on efficient algorithms for solving several subproblems that are of independent interest. In particular, we present efficient parallel algorithms to find a minimal starting point of a circular string with respect to lexicographic ordering and to sort lexicographically a list of strings of different lengths.

In this paper we prove lower bounds on the computational complexity of symmetric functions on parallel machines. The parallel models considered are PRIORITY and ARBITRARY, both widely used versions of the Parallel Random Access Machine (PRAM). We first consider PRIORITY. We prove that a PRIORITY PRAM with one shared memory cell and O(n) processors requires Ω(g(n)) time in order to decide if a binary vector of length n has at least g(n) 1's, for the case g(n)=o(n1/4). This is the decision problem for the threshold language Lg. Our lower bound is tight. For PRIORITY with m shared memory cells we prove an Ω(g(n)/m) lower bound. The limitation on the number of processors is essential, since with enough processors Lg can be decided by the same model in O(√g(n)) time. The limitation on g is important: for instance, for g(n)=n/2 Lg can be decided in time O(√g(n)), which is optimal [VW].

Simulating the CRCW PRAM on reconfigurable networks

A major concern in generation of realistic graphics displays is how to identify those parts of a scene that are visible from a chosen viewing position. There have been various algorithms for identification of visible objects on both sequential and parallel computation models, all with different time and space requirements, depending on the properties of the underlying machine architectures and types of the objects. In this paper, we propose an efficient parallel algorithm for implementation of the popular depth-buffer method on the general PRAM model that detects visible surfaces by projecting pixels on all surfaces to a 2D view plane and removing all hidden surfaces. For a total of n pixels on the surfaces of an object, our algorithm runs cost-optimally in time in the average case, and in time in the worst case, using p processors on the EREW PRAM. We analyze the scalability of the algorithm and show that it is highly scalable in the average case.

PARALLEL AND LARGE SCALE MATRIX COMPUTATIONS IN CONTROL: SOME IDEAS

An efficient algorithm for multiscale flow simulation of dilute polymeric solutions using bead-spring chains

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.

We define a new restricted type of algebraic circuit (AC) problems, called linear algebraic circuits (LACs), and consider the problem of obtaining efficient solutions for their parallel evaluation. The term efficiency indicates that for some fixed number of processors, the algorithm can compete with the sequential evaluation of ACs. While parallel evaluation of general ACs is P-complete, there are restricted types of ACs such as prefix-sums circuits (ACs in the form of chains) and arithmetic expressions (ACs in the form of trees) for which efficient parallel evaluation algorithms exist. In this work, we consider a restricted type, other than chains or trees, of ACs where at least one input of each multiplication must be a constant. We show that LACs can be evaluated in n/18p1/3 log2 p steps, where n is the size of the circuit and p < n is the number of processors. Thus, for suitable values of p, this algorithm can compete with the sequential evaluation of LACs and achieve speedups of about p1/3.It follows that LACs can be represented by a product of matrices. Thus, computing this product in parallel yields a possible evaluation algorithm for LACs. Parallel computation of a product of matrices is also the main engine used in existing parallel evaluation algorithms for ACs. We show, via a lower bound, that such a naive solution based on matrix multiplication alone, is inherently inefficient regardless of the order in which the product of the matrices is computed and hence a tool complex solution must be devised. Finally, useful applications for parallelizing sequential code are given.

We provide efficient parallel algorithms for the minimum separation, offset range, and optimal offset problems for single-layer channel routing. We consider all the variations of these problems that have linear-time sequential solutions rather than limiting attention to the “river-routing” context, where single-sided connections are disallowed. For the minimum separation problem, we obtain O(lg N) time on a CREW PRAM or O(lg N/lg lg N) time on a CRCW PRAM, both with optimal work (processor-time product) of O(N), where N is the number of terminals. For the offset range problem, we obtain the same time and processor bounds as long as only one side of the channel contains single-sided nets. For the optimal offset problem with single-sided nets on one side of the channel, we obtain time O(lg N lg lg N) on a CREW PRAM or O(lg N) time on a CRCW PRAM with O(N lg lg N) work. Not only does this improve on previous results for river routing, but we can obtain an even better time of O((lg lg N)2) on the CRCW PRAM in the river routing context.KeywordsParallel AlgorithmMinimum SeparationChannel BoundaryConvex CornerEfficient Parallel AlgorithmThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.