Efficient Parallel Solutions to Some Geometric Problems

Applied Mathematical Modelling, 2006

High performance machines have become available nowadays to an increasing number of researchers. Most of us might have both an access to a supercomputing center and an algorithm that could benefit from these high performance machines. The aim of the present work is to revisit all existing parallelization alternatives, including emerging technologies like software-only speculative parallelization, to solve on different architectures the same representative problem: The computation of the convex hull of a point set.

Computer-Aided Design, 1990

The problem of computing the convex hull of a set of vectors in the two-dimensional plane is considered from the point of view ot parallel implementation on transputer networks. A parallel algorithm is described, timed and evaluated against tunctionally equivalent single processor code. The results of these numerical experiments are presented and discussed.

International Journal of Computational Geometry & Applications, 1996

We present a parallel algorithm for finding the convex hull of a sorted point set. The algorithm runs in O( log log n) (doubly logarithmic) time using n/ log log n processors on a Common CRCW PRAM. To break the Ω( log n/ log log n) time barrier required to output the convex hull in a contiguous array, we introduce a novel data structure for representing the convex hull. The algorithm is optimal in two respects: (1) the time-processor product of the algorithm, which is linear, cannot be improved, and (2) the running time, which is doubly logarithmic, cannot be improved even by using a linear number of processors. The algorithm demonstrates the power of the “the divide-and-conquer doubly logarithmic paradigm” by presenting a non-trivial extension to situations that previously were known to have only slower algorithms.

IEEE Transactions on Computers, 1988

A bstract-In this paper, we present parallel algorithms to identifv (i.e., detect and enumerate) the extreme points of the convex hull of a set of planar points using a hypercube, pyramid, tree, mesh-of-trees, mesh with reconfigurable bus, EREW PRAM, and a modified AKS network. It is known that the problem of identifying the convex hull for a set of planar points given arbitrarily cannot be solved faster than sorting. For the situation where the input set of n planar points is given ordered (by x-coordinate) one per processor on a machine with 8 (n) processors, we introduce a worst case hypercube algorithm that finishes in 80og n) time, a worst case algorithm for the pyramid, tree, and mesh-of-trees that finishes in 8(log3 n/(log log n)*) time, and a worst case algorithm for the mesh with a reconfigurable bus that finishes in 8(log2 n) time. Notice that for ordered data the sorting bound does not apply. We also show that our 80og n) time hypercube algorithm for ordered data extends to yield an optimal time and processor 80og n) worst case time EREW PRAM algorithm for the case where the set of planar points is distributed arbitrarily one point per processor. We also show that this algorithm can be extended to run in worst case 80og n) time on a modified AKS network, giving the first optimal 80og n) time algorithm for solving the convex hull problem for arbitrary planar input on a fixed degree network.

Canadian Conference on Computational Geometry, 2008

We present a framework for multi-core implementations of divide and conquer algorithms and show its efficiency and ease of use by applying it to the fundamental geo- metric problem of computing the convex hull of a point set. We concentrate on the Quickhull algorithm intro- duced in (2). In general the framework can easily be used for any D&C-algorithm. It

Proceedings of the fourth annual ACM symposium on Parallel algorithms and architectures - SPAA '92, 1992

An O(log n) time, n processor randomized algorithm for computing the k-nearest neighbor graph of n points in d dimensions, for fixed d and k is presented. The method is based on the use of sphere separators. Probability bounds are proved using the moment generating function technique.

Computational Geometry, 2007

We develop a number of space-efficient tools including an approach to simulate divide-and-conquer space-efficiently, stably selecting and unselecting a subset from a sorted set, and computing the kth smallest element in one dimension from a multi-dimensional set that is sorted in another dimension. We then apply these tools to solve several geometric problems that have solutions using some form of divideand-conquer. Specifically, we present solutions running in O(n log n) time using O(1) extra memory given inputs of size n for the closest pair problem and the bichromatic closest pair problem. For the orthogonal line segment intersection problem, we solve the problem in O(n log n + k) time using O(1) extra space where n is the number of horizontal and vertical line segments and k is the number of intersections.

IEEE Symposium on Foundations of Computer Science, 1994

We give fast randomized and deterministic parallel methodsfor constructing convex hulls in IRd, for any fixed d.Our methods are for the weakest shared-memory model,the EREW PRAM, and have optimal work bounds (withhigh probability for the randomized methods). In particular,we show that the convex hull of n points in IRdcanbe constructed in O(logn) time using O(n log n + nbd=2c)work, with

Algorithmica, 1992

We present parallel algorithms fcr some fundamental problems in computational geometry which have a running time of O(log n) using n processors, with very high probability (approaching 1 as n ~ oo). These include planar-point location, triangulation, and trapezoidal decomposition. We also present optimal algorithms for three-dimensional maxima and two-set dominance counting by an application of integer sorting. Most of these algorithms run on a CREW PRAM model and have optimal processor-time product which improve on the previously best-known algorithms of Atallah and Goodrich [5] 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 [26] and Reif and Valiant [25] for flashsort algorithm to perform divide and conquer in a plane very efficiently leading to the improved performance by our approach.

2000

This dissertation develops and studies fast algorithms for solving closest point problems. Algorithms for such problems have applications in many areas including statistical classification, crystallography, data compression, and finite element analysis. In addition to a comprehensive empirical study of known sequential methods, I introduce new parallel algorithms for these problems that are both efficient and practical. I present a simple and flexible programming model for designing and analyzing parallel algorithms. Also, I describe fast parallel algorithms for nearest-neighbor searching and constructing Voronoi diagrams. Finally, I demonstrate that my algorithms actually obtain good performance on a wide variety of machine architectures. The key algorithmic ideas that I examine are exploiting spatial locality, and random sampling. Spatial decomposition provides allows many concurrent threads to work independently of one another in local areas of a shared data structure. Random sampling provides a simple way to adaptively decompose irregular problems, and to balance workload among many threads. Used together, these techniques result in effective algorithms for a wide range of geometric problems. The key experimental ideas used in my thesis are simulation and animation. I use algorithm animation to validate algorithms and gain intuition about their behavior. I model the expected performance of algorithms using simulation experiments, and some knowledge as to how much critical primitive operations will cost on a given machine. In addition, I do this without the burden of esoteric computational models that attempt to cover every possible variable in the design of a computer system. An iterative process of design, validation, and simulation delays the actual implementation until as many details as possible are accounted for. Then, further experiments are used to tune implementations for better performance.