EREW PRAM Model Research Articles

Parallel algorithms for merging and sorting

We present an O(log(min( m, n, j))-time sequential algorithm to select the jth-smallest element of an array resulting from the merging of two sorted arrays A and B of sizes m and n. This algorithm is then used to design two parallel algorithms to partition A and B into p subarrays of size O( (m + n) p ) in O( N p + log N) and O( N p + log p log N) times on crew pram and erew pram models with p processors, where N = m + n. A third parallel algorithm has been presented that partitions A and B in O( N p + log p log N) time into p pairs of subarrays of size O( N p ) on erew pram with p processors without using any selection algorithm. Finally, these partitioning algorithms are used to obtain optimal parallel merging and sorting algorithms on crew prams and erew prams.

Parallel Transitive Closure and Point Location in Planar Structures

Parallel algorithms for several graph and geometric problems are presented, including transitive closure and topological sorting in planar $st$-graphs, preprocessing planar subdivisions for point location queries, and construction of visibility representations and drawings of planar graphs. Most of these algorithms achieve optimal $O(\log n)$ running time using $n / \log n$ processors in the EREW PRAM model, n being the number of vertices.

An optimal parallel adaptive sorting algorithm

We consider the problem of designing optimal parallel algorithms for sorting presorted sequences. To evaluate the existing order in an input sequence, we use the number of the maximal ascending consecutive subsequences, Runs. in the sequence as a measure of presortedness. An adaptive parallel sorting algorithm is presented, which sorts a sequence X of length n inO(log n·log Runs( X)) time by using O( n logn ) processors in the EREW PRAM model of computation. It is the first adaptive parallel sorting algorithm that is cost optimal with respect to Runs.

Parallel cardinality stacks and an application

Goldberg poses the question of whether his MDD (maximum-distance discharge) algorithm for Maximum Flow can run in O(n 2 log n( m p )) time using p = O( m ) processors and a linear amount of memory. Two data structures he considers, the dynamic array and the parallel 2–3 tree, yield slightly superlinear space bounds. We present a simple data structure that supports the required operations, adheres to the required time bounds, and uses an optimal (linear) amount of space in the EREW PRAM model of computation, answering Goldberg's question in the affirmative. We call our structure the Parallel Cardinality Stack (PCS). The operations supported by this structure may have applications in other parallel algorithms.

Merging heaps in parallel

Recently, Sack and Strothotte [8] proposed an efficient algorithm to merge two heaps. We propose to show that the algorithm in Sack and Strothotte [8] can be easily parallelized. More specifically, with heaps H and H′ with n and k elements, respectively, as input, our algorithm constructs a new heap containing all the keys in H and H′ combined in O(log n) time using at most min {[log n] − [log k], [log k]} + 1 processors in the EREW-PRAM model.

Notes on 'divide-and-conquer-based optimal parallel algorithms for some graph problems on EREW PRAM model'

A proof of correctness is presented for the connected-components algorithm. In addition, the authors present a modified implementation of the PARALLELFCS algorithm, which finds a fundamental cycle set of a connected graph. Analyzing the processor-(time)/sup 2/ complexity, it is shown that the modified version has a better performance because it is optimally scalable to a larger number of processors.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A note on adaptive parallel sorting

We present a cost optimal parallel algorithm for sorting presorted sequences. The measure of presortedness we consider is Rem, i.e., the smallest number of elements whose removal leaves a sorted sequence. The algorithm sorts a sequence X of length n, with Rem( X) = r, in O(log n) time, provided O(( n + r log r)/log n) processors are available, in the EREW PRAM model. This is the first PRAM sorting algorithm which is cost optimal with respect to Rem.

An optimal parallel algorithm for the minimum circle-cover problem

Given a set of n circular arcs, the problem of finding a minimum number of circular arcs whose union covers the whole circle has been considered both in sequential and parallel computational models. Here we present a parallel algorithm in the EREW PRAM model that runs in O(log n) time using O( n) processors if the arcs are not given already sorted, and using O( n/log n) processors otherwise. Our algorithm is optimal since the problem has an Ω( n log n) lower bound for the unsorted-arcs case, and an Ω( n) lower bound for the sorted-arcs case. The previous best known parallel algorithm runs in O(log n) time using O( n 2) processors, in the worst case, in the CREW PRAM model.

Constructing a Maximal Independent Set in Parallel

The problem of constructing in parallel a maximal independent set of a given graph is considered. A new deterministic NC-algorithm implemented in the EREW PRAM model is presented. On graphs with n vertices and m edges, it uses $O((n + m)/\log n)$ processors and runs in $O(\log^3 n)$ time. This reduces by a factor of $\log n$ both the running time and the processor count of the previously fastest deterministic algorithm that solves the problem using a linear number of processors.

A fast and simple randomized parallel algorithm for the maximal independent set problem

A simple parallel randomized algorithm to find a maximal independent set in a graph G = ( V, E) on n vertices is presented. Its expected running time on a concurrent-read concurrent-write PRAM with O(| E| d max) processors is O(log n), where d max denotes the maximum degree. On an exclusive-read exclusive-write PRAM with O(| E|) processors the algorithm runs in O(log 2 n). Previously, an O(log 4 n) deterministic algorithm was given by Karp and Wigderson for the EREW-PRAM model. This was recently (independently of our work) improved to O(log 2 n) by M. Luby. In both cases randomized algorithms depending on pairwise independent choices were turned into deterministic algorithms. We comment on how randomized combinatorial algorithms whose analysis only depends on d-wise rather than fully independent random choices (for some constant d) can be converted into deterministic algorithms. We apply a technique due to A. Joffe (1974) and obtain deterministic construction in fast parallel time of various combinatorial objects whose existence follows from probabilistic arguments.