Exclusive-read Exclusive-write Parallel Random-access Machine Research Articles

Pipeline Givens sequences for computing the QR decomposition on a EREW PRAM

Parallel Givens sequences for computing the QR decomposition of an m × n ( m > n) matrix are considered. The Givens rotations operate on adjacent planes. A pipeline strategy for updating the pair of elements in the affected rows of the matrix is employed. This allows a Givens rotation to use rows that have been partially updated by previous rotations. Two new Givens schemes, based on this pipeline approach, and requiring respectively n 2/2 and n processors, are developed. Within this context a performance analysis on an exclusive-read, exclusive-write (EREW) parallel random access machine (PRAM) computational model establishes that the proposed schemes are twice as efficient as existing Givens sequences.

Parallel Self-Index Integer Sorting

We consider the problem of sorting n integers when the elements are drawn from the restricted domain [1…n]. A new deterministic parallel algorithm for sorting n integers is obtained. Its running time is O(lognlog(n/logn)) using n/logn processors on EREW (exclusive read exclusive write) PRAM (parallel random access machine). Also, our algorithm was modified to become optimal when we use \sqrt{n} processors. This algorithm belongs to class EP (Efficient, Polynomial fast).

Concurrent threads and optimal parallel minimum spanning trees algorithm

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.

Tree-Adjoining Language Parsing in $O(n^6 )$ Time

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.

Ultra-fast parallel contour tracking, with applications to thinning

This paper proposes a parallel algorithm for contour tracking of binary pictures. Given an object contour composed by O(N) pixels, our algorithm computes in constant time the next layer of the contour of that object, using the weakest parallel model, i.e. an Exclusive Read Exclusive Write (EREW) Parallel Random Access Machine (PRAM). As an application of the technique we show a work-optimal parallel thinning algorithm for binary pictures, based on Pavlidis' characterization of a skeleton. Our algorithm improves on previous solutions by producing a list of coordinates corresponding to the skeleton contour in O(N) time with O(N) processors in an EREW PRAM, where N is the width of the picture.

Parallel Heap Operations on an EREW PRAM

We consider parallel heap operations on the exclusive-read exclusive-write parallel random-access machine. We first present an O(n/p + log p) time parallel algorithm to construct a heap of n elements using p processors, which is optimal for p θ(n/log n). We then propose a parallel root deletion algorithm. In a preparatory step, a data structure for dynamic processor allocation is constructed using O((n/log n)1 − 1/k) processors in O(log k) time for some constant k, 1 ≤ k ≤ ⌈log(n/log n)⌉. A sequence of root deletions can then be performed, each of which takes O((log n)/p + log p + log log n) time using p processors. Finally, we discuss a parallel algorithm running in O((log n)/p + log p) time for inserting an element into a heap, which is optimal for p = θ((log n)/log log n). Both deletion and insertion algorithms run in O(log log n) time when p = θ((log n)/log log n).

AN EFFICIENT EREW ALGORITHM FOR MINIMUM PATH COVER AND HAMILTONICITY ON COGRAPHS

It is shown that the notoriously difficult problem of finding the minimum number of paths that cover the vertices of a graph can be solved efficiently for cographs. The result implies that for this class of graphs finding a Hamiltonian path and a Hamiltonian cycle can be solved efficiently in parallel. Specifically, with an n-vertex cograph G represented by its parse tree as input, the algorithm determines the number of paths in a minimum path cover in O(log n) time using n/log n processors in the exclusive read exclusive write parallel random access machine (EREW-PRAM) model. The authors also exhibit all the paths in a minimum path cover of G in O(log/sup 2/n) time using n/log n processors in the EREW-PRAM. >

Efficient and Scalable PRAM Algorithms for Discrete-Event Simulation of Bounded Degree Networks

We describe two new parallel algorithms, one conservative and another optimistic, for discrete-event simulation on an exclusive-read exclusive-write parallel random-access machine (EREW PRAM). The target physical systems are bounded degree networks which are represented by logic circuits. Employing p processors, our conservative algorithm can simulate up to O(p) independent messages of a system with n logical processes in O(log n) time. The number of processors, p, can be optimally varied in the range 1 ≤ p ≤ n. To identify independent messages, this algorithm also introduces a novel scheme based on a variable size time window. Our optimistic algorithm is designed to reduce the rollback frequency and the memory requirement to save past states and messages. The optimistic algorithm also simulates O(p) earliest messages on a p-processor computer in O(log n) time. To our knowledge, such a theoretical efficiency in parallel simulation algorithms, conservative or optimistic, has been achieved for the first time.

Parallel computation of matchings in trees

We present adaptive parallel algorithms for b-matchings in trees. The algorithms are designed using the exclusive-read exclusive-write parallel random-access machine (EREW PRAM) model of parallel computation. For a tree of n vertices, we present an algorithm that determines a maximum cardinality b-matching in O( n/p + log n) time using p processors, where p ⩽ n. An algorithm that executes in O( n/p′ + log n) time, where 1 < np/( n + p log n) ⩽ p′ < p ⩽ n and p > √ n/log n is also designed for the maximum weight b-matching problem in trees. When p ⩽ n/(log n), the algorithm are cost-optimal.

Time-space optimal parallel merging and sorting

The authors present a parallel merging algorithm that, on an exclusive-read exclusive-write (EREW) parallel random-access machine (PRAM) with k processors merges two sorted lists of total length n in O(n/k+log n) time and constant extra space per processor, and hence is time-space optimal for any value of k<or=n/(log n). The authors also describe how this gives rise to a stable version of the parallel merging algorithm that is similarly time-space optimal on an EREW PRAM. The authors observe that this technique for achieving stability incurs two penalties: a slightly more complicated algorithm and somewhat larger constants of proportionality. These two parallel merges naturally lead to time-space optimal parallel sorting algorithms. Extensions to sorting and open topics for future research are discussed.<<ETX>>

Parallel binary search

Two arrays of numbers sorted in nondecreasing order are given: an array A of size n and an array B of size m, where n<m. It is required to determine, for every element of A, the smallest element of B (if one exists) that is larger than or equal to it. It is shown how to solve this problem on the EREW PRAM (exclusive-read exclusive-write parallel random-access machine) in O(logm logn/log log m) time using n processors. The solution is then extended to the case in which fewer than n processors are available. This yields an EREW PRAM algorithm for the problem whose cost is O(n log m, which is O(m)) for n<or=m/log m. It is shown how the solution obtained leads to an improved parallel merging algorithm.<<ETX>>

Parallel algorithms for contour extraction and coding on an EREW PRAM computer

A parallel approach to contour extraction and coding on an Exclusive Read Exclusive Write (EREW) Parallel Random Access Machine (PRAM) is presented and analyzed. The algorithm is intended for binary images. The labeled contours can be represented by lists of coordinates, and/or chain codes, and/or any other user designed codes. Using O( n 2/log n) processors, the algorithm runs in O(log n) time, where, n by n is the size of the processed binary image.

Scans as primitive parallel operations

A study of the effects of adding two scan primitives as unit-time primitives to PRAM (parallel random access machine) models is presented. It is shown that the primitives improve the asymptotic running time of many algorithms by an O(log n) factor, greatly simplifying the description of many algorithms, and are significantly easier to implement than memory references. It is argued that the algorithm designer should feel free to use these operations as if they were as cheap as a memory reference. The author describes five algorithms that clearly illustrate how the scan primitives can be used in algorithm design: a radix-sort algorithm, a quicksort algorithm, a minimum-spanning-tree algorithm, a line-drawing algorithm, and a merging algorithm. These all run on an EREW (exclusive read, exclusive write) PRAM with the addition of two scan primitives and are either simpler or more efficient than their pure PRAM counterparts. The scan primitives have been implemented in microcode on the Connection Machine system, are available in PARIS (the parallel instruction set of the machine).< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Parallel parsing of programming languages

A new method of specifying the syntax of programming languages, known as hierarchical language specifications (HLS), is proposed. Efficient parallel algorithms for parsing languages generated by HLS are presented. These algorithms run on an exclusive-read exclusive-write parallel random-access machine. They require O( n) processors and O( log 2 n) time, where n is the length of the string to be parsed. The most important feature of these algorithms is that they do not use a stack.