Results 1  10
of
50
Programming Parallel Algorithms
, 1996
"... In the past 20 years there has been treftlendous progress in developing and analyzing parallel algorithftls. Researchers have developed efficient parallel algorithms to solve most problems for which efficient sequential solutions are known. Although some ofthese algorithms are efficient only in a th ..."
Abstract

Cited by 191 (9 self)
 Add to MetaCart
In the past 20 years there has been treftlendous progress in developing and analyzing parallel algorithftls. Researchers have developed efficient parallel algorithms to solve most problems for which efficient sequential solutions are known. Although some ofthese algorithms are efficient only in a theoretical framework, many are quite efficient in practice or have key ideas that have been used in efficient implementations. This research on parallel algorithms has not only improved our general understanding ofparallelism but in several cases has led to improvements in sequential algorithms. Unf:ortunately there has been less success in developing good languages f:or prograftlftling parallel algorithftls, particularly languages that are well suited for teaching and prototyping algorithms. There has been a large gap between languages
Query indexing and velocity constrained indexing: Scalable techniques for continuous queries on moving objects
 IEEE Transaction Computers
, 2002
"... Moving object environments are characterized by large numbers of moving objects and numerous concurrent continuous queries over these objects. Efficient evaluation of these queries in response to the movement of the objects is critical for supporting acceptable response times. In such environments t ..."
Abstract

Cited by 118 (19 self)
 Add to MetaCart
Moving object environments are characterized by large numbers of moving objects and numerous concurrent continuous queries over these objects. Efficient evaluation of these queries in response to the movement of the objects is critical for supporting acceptable response times. In such environments the traditional approach of building an index on the objects (data) suffers from the need for frequent updates and thereby results in poor performance. In fact, a brute force, noindex strategy yields better performance in many cases. Neither the traditional approach, nor the brute force strategy achieve reasonable query processing times. This paper develops novel techniques for the efficient and scalable evaluation of multiple continuous queries on moving objects. Our solution leverages two complimentary techniques: Query Indexing and Velocity Constrained Indexing (VCI). Query Indexing relies on i) incremental evaluation; ii) reversing the role of queries and data; and iii) exploiting the relative locations of objects and queries. VCI takes advantage of the maximum possible speed of objects in order to delay the expensive operation of updating an index to reflect the movement of objects. In contrast to an earlier technique [29] that requires exact knowledge about the movement of the objects, VCI does not rely on such information. While Query Indexing outperforms VCI, it does not efficiently handle the arrival of new queries. Velocity constrained indexing, on the other hand, is unaffected by changes in queries. We demonstrate that a combination of Query Indexing and Velocity Constrained Indexing enables the scalable execution of insertion and deletion of queries in addition
Planar Separators and Parallel Polygon Triangulation
, 1992
"... We show how to construct an O( p n)separator decomposition of a planar graph G in O(n) time. Such a decomposition defines a binary tree where each node corresponds to a subgraph of G and stores an O( p n)separator of that subgraph. We also show how to construct an O(n ffl )way decomposition tree ..."
Abstract

Cited by 51 (7 self)
 Add to MetaCart
We show how to construct an O( p n)separator decomposition of a planar graph G in O(n) time. Such a decomposition defines a binary tree where each node corresponds to a subgraph of G and stores an O( p n)separator of that subgraph. We also show how to construct an O(n ffl )way decomposition tree in parallel in O(log n) time so that each node corresponds to a subgraph of G and stores an O(n 1=2+ffl )separator of that subgraph. We demonstrate the utility of such a separator decomposition by showing how it can be used in the design of a parallel algorithm for triangulating a simple polygon deterministically in O(log n) time using O(n= log n) processors on a CRCW PRAM. Keywords: Computational geometry, algorithmic graph theory, planar graphs, planar separators, polygon triangulation, parallel algorithms, PRAM model. 1 Introduction Let G = (V; E) be an nnode graph. An f(n)separator is an f(n)sized subset of V whose removal disconnects G into two subgraphs G 1 and G 2 each...
Optimal Doubly Logarithmic Parallel Algorithms Based On Finding All Nearest Smaller Values
, 1993
"... The all nearest smaller values problem is defined as follows. Let A = (a 1 ; a 2 ; : : : ; an ) be n elements drawn from a totally ordered domain. For each a i , 1 i n, find the two nearest elements in A that are smaller than a i (if such exist): the left nearest smaller element a j (with j ! i) a ..."
Abstract

Cited by 37 (7 self)
 Add to MetaCart
The all nearest smaller values problem is defined as follows. Let A = (a 1 ; a 2 ; : : : ; an ) be n elements drawn from a totally ordered domain. For each a i , 1 i n, find the two nearest elements in A that are smaller than a i (if such exist): the left nearest smaller element a j (with j ! i) and the right nearest smaller element a k (with k ? i). We give an O(log log n) time optimal parallel algorithm for the problem on a CRCW PRAM. We apply this algorithm to achieve optimal O(log log n) time parallel algorithms for four problems: (i) Triangulating a monotone polygon, (ii) Preprocessing for answering range minimum queries in constant time, (iii) Reconstructing a binary tree from its inorder and either preorder or postorder numberings, (vi) Matching a legal sequence of parentheses. We also show that any optimal CRCW PRAM algorithm for the triangulation problem requires \Omega\Gammauir log n) time. Dept. of Computing, King's College London, The Strand, London WC2R 2LS, England. ...
Design and Implementation of a Practical Parallel Delaunay Algorithm
, 1999
"... This paper describes the design and implementation of a practical parallel algorithm for Delaunay triangulation that works well on general distributions. Although there have been many theoretical parallel algorithms for the problem, and some implementations based on bucketing that work well for unif ..."
Abstract

Cited by 31 (4 self)
 Add to MetaCart
This paper describes the design and implementation of a practical parallel algorithm for Delaunay triangulation that works well on general distributions. Although there have been many theoretical parallel algorithms for the problem, and some implementations based on bucketing that work well for uniform distributions, there has been little work on implementations for general distributions. We use the well known reduction of 2D Delaunay triangulation to find the 3D convex hull of points on a paraboloid. Based on this reduction we developed a variant of the Edelsbrunner and Shi 3D convex hull algorithm, specialized for the case when the point set lies on a paraboloid. This simplification reduces the work required by the algorithm (number of operations) from O(n log^2 n) to O(n log n). The depth (parallel time) is O(log^3 n) on a CREW PRAM. The algorithm is simpler than previous O(n log n) work parallel algorithms leading to smaller constants. Initial experiments using a variety of distributions showed that our parallel algorithm was within a factor of 2 in work from the best sequential algorithm. Based on these promising results, the algorithm was implemented using C and an MPIbased toolkit. Compared with previous work, the resulting implementation achieves significantly better speedups over good sequential code, does not assume a uniform distribution of points, and is widely portable due to its use of MPI as a communication mechanism. Results are presented for the IBM SP2, Cray T3D, SGI Power Challenge, and DEC AlphaCluster.
Probabilistic roadmap methods are embarrassingly parallel
 In Proc. IEEE Int. Conf. Robot. Autom. (ICRA
, 1999
"... In this paper we report on our experience parallelizing probabilistic roadmap motion planning methods (prms). We show that signi cant, scalable speedups can be obtained with relatively little e ort on the part of the developer. Our experience is not limited toprms, however. In particular, we outline ..."
Abstract

Cited by 24 (5 self)
 Add to MetaCart
In this paper we report on our experience parallelizing probabilistic roadmap motion planning methods (prms). We show that signi cant, scalable speedups can be obtained with relatively little e ort on the part of the developer. Our experience is not limited toprms, however. In particular, we outline general techniques for parallelizing types of computations commonly performed in motion planning algorithms, and identify potential di culties that might be faced in other e orts to parallelize sequential motion planning methods. 1
Optimal Randomized Parallel Algorithms For Computational Geometry I
, 1989
"... 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 ! 1). These include planar point location, triangulation and trapezoidal decomposition. We also present optimal ..."
Abstract

Cited by 22 (9 self)
 Add to MetaCart
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 ! 1). These include planar point location, triangulation and trapezoidal decomposition. We also present optimal algorithms for 3D maxima and twoset dominance counting by an application of integer sorting. Most of these algorithms run on CREW PRAM model and have optimal processortime 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 ashsort algorithm to perform divide and conquer in a plane very eciently leading to the improved performance by our approach.
Ultrafast expected time parallel algorithms
 Proc. of the 2nd SODA
, 1991
"... It has been shown previously that sorting n items into n locations with a polynomial number of processors requires Ω(log n/log log n) time. We sidestep this lower bound with the idea of Padded Sorting, or sorting n items into n + o(n) locations. Since many problems do not rely on the exact rank of s ..."
Abstract

Cited by 20 (3 self)
 Add to MetaCart
It has been shown previously that sorting n items into n locations with a polynomial number of processors requires Ω(log n/log log n) time. We sidestep this lower bound with the idea of Padded Sorting, or sorting n items into n + o(n) locations. Since many problems do not rely on the exact rank of sorted items, a Padded Sort is often just as useful as an unpadded sort. Our algorithm for Padded Sort runs on the Tolerant CRCW PRAM and takes Θ(log log n/log log log n) expected time using n log log log n/log log n processors, assuming the items are taken from a uniform distribution. Using similar techniques we solve some computational geometry problems, including Voronoi Diagram, with the same processor and time bounds, assuming points are taken from a uniform distribution in the unit square. Further, we present an Arbitrary CRCW PRAM algorithm to solve the Closest Pair problem in constant expected time with n processors regardless of the distribution of points. All of these algorithms achieve linear speedup in expected time over their optimal serial counterparts. 1 Research done while at the University of Michigan and supported by an AT&T Fellowship.
Extremal Polygon Containment Problems
, 1991
"... Given a convex polygonal object P and an environment consisting of polygonal obstacles, we seek a placement for the largest copy of P that does not intersect any of the obstacles, allowing translation, rotation and scaling. We employ the parametric search technique of Megiddo [Me], and the fixed siz ..."
Abstract

Cited by 19 (13 self)
 Add to MetaCart
Given a convex polygonal object P and an environment consisting of polygonal obstacles, we seek a placement for the largest copy of P that does not intersect any of the obstacles, allowing translation, rotation and scaling. We employ the parametric search technique of Megiddo [Me], and the fixed size polygon placement algorithms developed by Leven and Sharir [LS, LS1], to obtain an algorithm that runs in time O(k 2 n# 4 (kn) log 3 (kn) log log(kn)). We also present several other e#cient algorithms for restricted variants of the extremal polygon containment problem, using the same ideas. These variants include: placement of the largest homothetic copies of one or two convex polygons in another convex polygon and placement of the largest similar copy of a triangle in a convex polygon. 1 Introduction Let P be a convex polygon having k vertices and edges, and let Q be a closed two dimensional space bounded by a collection of polygonal obstacles (the "environment") having altogether n...
Randomized Algorithms for Binary Search and Load Balancing on Fixed Connection Networks With Geometric Applications
, 1990
"... There are now a number of fundamental problems in computational geometry that have optimal algorithms on PRAM models. We present randomized parallel algorithms which execute on an nprocessor buttery interconnection network in O(log n) time for the following problems of input size n: trapezoidal ..."
Abstract

Cited by 18 (2 self)
 Add to MetaCart
There are now a number of fundamental problems in computational geometry that have optimal algorithms on PRAM models. We present randomized parallel algorithms which execute on an nprocessor buttery interconnection network in O(log n) time for the following problems of input size n: trapezoidal decomposition, visibility, triangulation and 2D convex hull. These algorithms involve tackling some of the very basic problems like binary search and loadbalancing that we take for granted in PRAM models. Apart from a 2D convex hull algorithm, these are the rst nontrivial geometric algorithms which attain this performance on xed connection networks. Our techniques use a number of ideas from Flashsort which have to be modied to handle more dicult situations; it seems likely that they will have wider applications. 1 Introduction 1.1 Motivation and overview In the past decade, we have witnessed a systematic growth in the stateofart of parallelizing algorithms in the PRAM envi...