CREW PRAM Model Research Articles

Optimal randomized parallel algorithms for computational geometry

We present parallel algorithms for some fundamental problems in computational geometry which have running time of $O(logn)$ using $n$ processors, with very high probability (approaching 1 as $n~ \rightarrow~ \infty$). These include planar point location, triangulation and trapezoidal decomposition. We also present optimal algorithms for 3-D maxima and two-set dominance counting by an application of integer sorting. Most of these algorithms run on CREW PRAM model and have optimal processor-time product which improve on the previously best known algorithms of Atallah and Goodrich [3] for these problems. The crux of these algorithms is a useful data structure which emulates the plane sweeping paradigm used for sequential algorithms. We extend some of the techniques used by Reischuk [22] Reif and Valiant [21] for flashsort algorithm to perform divide and conquer in a plane very efficiently leading to the improved performance by our approach.

Efficient parallel algorithms for shortest paths in planar digraphs

Efficient parallel algorithms are presented, on the CREW PRAM model, for generating a succinct encoding of all pairs shortest path information in a directed planar graphG with real-valued edge costs but no negative cycles. We assume that a planar embedding ofG is given, together with a set ofq faces that cover all the vertices. Then our algorithm runs inO(log2 n) time and employsO(nq+M(q)) processors (whereM(t) is the number of processors required to multiply twot×t matrices inO(logt) time). Let us note here that wheneverq<n then our processor bound is better than the best previous one (M(n)).O(log2 n) time,n-processor algorithms are presented for various subproblems, including that of generating all pairs shortest path information in a directedouterplanar graph. Our work is based on the fundamental hammock-decomposition technique of G. Frederickson. We achieve this decomposition inO(logn log*n) parallel time by usingO(n) processors. The hammock-decomposition seems to be a fundamental operation that may help in improving efficiency of many parallel (and sequential) graph algorithms.

Optimal Parallel Randomized Algorithms for Three-Dimensional Convex Hulls and Related Problems

Further applications of random sampling techniques which have been used for deriving efficient parallel algorithms are presented by J. H. Reif and S. Sen [Proc. 16th International Conference on Parallel Processing, 1987]. This paper presents an optimal parallel randomized algorithm for computing intersection of half spaces in three dimensions. Because of well-known reductions, these methods also yield equally efficient algorithms for fundamental problems like the convex hull in three dimensions, Voronoi diagram of point sites on a plane, and Euclidean minimal spanning tree. The algorithms run in time $T = O(\log n)$ for worst-case inputs and use $P = O(n)$ processors in a CREW PRAM model where n is the input size. They are randomized in the sense that they use a total of only polylogarithmic number of random bits and terminate in the claimed time bound with probability $1 - n^{ - \alpha } $ for any fixed $\alpha > 0$. They are also optimal in $P\cdot T$ product since the sequential time bound for all these problems is $\Omega (n\log n)$. The best known deterministic parallel algorithms for two-dimensional Voronoi-diagram and three-dimensional convex hull run in $O(\log ^2 n)$ and $O(\log ^2 n\log ^ * n)$ time, respectively, while using $O(n/\log n)$ and $O(n)$ processors, respectively.

A faster optimal algorithm for the measure problem

The measure problem involves computing the area of the union of a set of n iso-oriented rectangles in the plane. Recently, it has been shown that for a set of n such rectangles, the measure problem can be solved in O(log n log log n) time, using O( n/log log n) processors in the CREW PRAM model of computation. In this note we show that the measure problem can be solved optimally in O(log n) time using O( n) processors in the same model of computation, thus settling an open problem posed in [8].

Intersecting Line Segments in Parallel with an Output-Sensitive Number of Processors

An efficient parallel algorithm is given for constructing the arrangement of n line segments in the plane, i.e., the planar graph determined by the segment endpoints and intersections. This algorithm is efficient relative to three efficiency measures—it is an NC algorithm, it has a small time-processor product, and it is output-size sensitive. In particular, it runs in $O(\log n)$ time using $O(n\log n + k)$ processors, where k is the size of the output (which is $\Omega (n^2 )$ in the worst case). The algorithm does not receive the value of k as input, it determines it on-line. A method or solving an important special case of the segment arrangement problem is also shown, namely, when each input segment is parallel to one of the coordinate axes (i.e., iso-oriented). The algorithm for this problem runs in $O(\log n)$ time using an optimal $O(n + k / \log n)$ processors. The model of computation is the CREW PRAM model, where processor allocation must be explicit and global.

Parallel Algorithms for Channel Routing in the Knock-Knee Model

The channel routing problem of a set of two-terminal nets in the knock-knee model is considered. A new approach to route all the nets within d tracks, where d is the density, such that the corresponding layout can be realized with three layers is developed. The routing and the layer assignment algorithms run in $O(\log n)$ time with $n / \log n$ processors on the CREW PRAM model under the reasonable assumption that all terminals lie in the range $[1,N]$, where $N = O(n)$.

A parallel algorithm for finding a maximum clique of a set of circular arcs of a circle

This paper gives a parallel algorithm for the problem of finding a maximum clique of a circular-arc graph when a circular-arc model is given. Our parallel algorithm runs in O(log 2 n) time using O( n 3/log n) processors in the CREW PRAM model.

Parallel general prefix computations with geometric, algebraic, and other applications

We introduce a generic problem component that captures the most common, difficult “kernel” of many problems. This kernel involves general prefix computations (GPC). GPC's lower bound complexity of Ω(n logn) time is established, and we give optimal solutions on the sequential model inO(n logn) time, on the CREW PRAM model inO(logn) time, on the BSR (broadcasting with selective reduction) model in constant time, and on mesh-connected computers inO(√n) time, all withn processors, plus anO(log2 n) time solution on the hypercube model. We show that GPC techniques can be applied to a wide variety of geometric (point set and tree) problems, including triangulation of point sets, two-set dominance counting, ECDF searching, finding two-and three-dimensional maximal points, the reconstruction of trees from their traversals, counting inversions in a permutation, and matching parentheses.

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.

An optimal parallel circle-cover algorithm

Given a set of n circular arcs, we provide an optimal parallel algorithm (on the CREW PRAM model of computation) for finding a minimum number of circular arcs whose union covers the circle. The algorithm runs in O(log n) time with O( n) processors and uses O( n) space. This is a significant improvement over the recent algorithm by Bertossi that runs in O(log n) time with O( n 2) processors and uses O( n 2) space.

Cascading Divide-and-Conquer: A Technique for Designing Parallel Algorithms

Techniques for parallel divide-and-conquer are presented, resulting in improved parallel algorithms for a number of problems. The problems for which improved algorithms are given include segment intersection detection, trapezoidal decomposition, and planar point location. Efficient parallel algorithms are algo given for fractional cascading, three-dimensional maxima, two-set dominance counting, and visibility from a point. All of the algorithms presented run in $O(\log n)$ time with either a linear or a sublinear number of processors in the CREW PRAM model.

Parallel processing of regions represented by linear quadtrees

We show how computation of geometric properties of a region represented by a linear quadtree can be speeded up by about a factor of p by using a p -processor CREW PRAM model of parallel computation. Similar speedups are obtained for computing the union and intersection of two regions, and the complement of a region, using linear quadtree representations.

Parallel algorithms for planar graph isomorphism and related problems

Parallel algorithms for planar graph isomorphism and several related problems are presented. Two models of parallel computation are considered: the CREW-PRAM model and the two-dimensional array of processors. The results include O( square root n)-time mesh algorithms for finding a good separating cycle and the triconnected components of a planar graph, and for solving the single-function coarsest partitioning problem.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>