Embed Size (px)
Citation preview
Purdue University Purdue University
Purdue e-Pubs Purdue e-Pubs
Department of Computer Science Technical Reports Department of Computer Science
1990
Parallel Techniques for Computational Geometry Parallel Techniques for Computational Geometry
Mikhail J. Atallah Purdue University, [email protected]
Report Number: 90-1020
Atallah, Mikhail J., "Parallel Techniques for Computational Geometry" (1990). Department of Computer Science Technical Reports. Paper 22. https://docs.lib.purdue.edu/cstech/22
This document has been made available through Purdue e-Pubs, a service of the Purdue University Libraries. Please contact [email protected] for additional information.
PARALLEL TECHNIQUES FOR COMPUTATIONAL GEOMETRY
Mikhail J. Atallah
Department of Computer Sciences Purdue University
West Lafayette, IN 47907
CSD TR #I020
PARALLEL TECHNIQUES FORCOMPUTATIONAL GEOMETRY
Mikhail J. Atallah
Department of Computer SciencesPurdue University
West Lafayette, IN 47907
CSD TR #1020
Parallel Techniques for Computational Geometry
Mikbail J. Atallah*
Department of Computer Science Purdue University
?Vest Lafayette, I N 47907.
Abstract
A survey of techniques for solving geometric problems in parallel is given, both for shared memory parallel machines and for networks of processors. Open problems are also discussed, as well a s directions for future research.
'This work was supported by the office oi Naval Research under Contracts N00014-84-K-0502 and N00014-86-K-0689, the Air Force Office of Scientific Research under Grant AFOSR-90-0107, the National Science Foundation under Grant DCR-8451393, and the National Library oi Medicine under Grant R01- LMO5118.
Parallel Techniques for Computational Geometry
Mikhail J. Atallah'"
Department of Computer SciencePurdue University
'West Lafayette, IN 47907.
Abstract
A survey of techniques for solving geometric problems in parallel is given, both forshared memory parallel machines and for networks of processors. Open problems arealso discussed, &:l well as directions for future research.
"This work was supported by the Office or Naval Research under Contracts NOOOl4-84-K-0502 andNOOOl4--SG-K-0689, the Air Force Oflke or Scientific Research under Grant AFOSR-90-0107, the Na.tionalScience Foundation under Grant DCR-8451393, and the National Library of Medicine under Gra.nt ROlLMOSI18.
1
1 Introduction
Many of the problems in compu tationd geometry come from applications in pattern recog-
nition, computer graphics, statistics, operations research, computer-aided design, robotics,
etc. The problems which arise in these areas can come from real-time applications, and
hence need to be solved as fast as possible. For many of these problems, however, we are
already a t the Limits of what can be achieved through sequential computation. Such se-
quential methods can be inadequate for situations in which the input consists of a large
number of geometric objects. Thus, it is natural to study what khds of speed-ups can be
achieved through parallel computing. As an indication of the importance of this research
direction, wenote that four of the eleven problems used as benchmark problems to evaluate
parallel architectures for the DARPA Architecture Workshop Benchmark Study of 1986
were computational geometry problems.
Unfortunately, many of the techniques used to find efficient sequential algorithms for
computational geometry problems do not translate we1 into a parallel setting. That is,
while providing elegant paradigms for designing sequential algorithms, these techniques use
methods which seem to be inherently sequential. Therefore, one needs to develop new
paradigms for computational geometry, paradigms better suited for a pa~a,llel processing
environment. This article is a survey of the main known algorithmic techniques for solving
computational geometry problems efficiently in pardel. Since the focus is on general algo-
rithmic techniques rather than on specific problems, no attempt is made to list all of the
known parallel complexity bounds for geometric problems (there are too many of them).
The rest of the paper is organized as follows. Section 2 briefly reviews parallel models,
Section 3 discusses basic subproblems that tend to arise in the solution of geometric problems
on any parallel model, Section 4 discusses PRAM techniques, Section 5 discusses techniques
for mesh-connected arrays of processors, Section 6 deals with the hybrid RAM/ARRAY
model and its connection to 1/0 complexity, Section 7 mentions some experimental work,
and Section 8 concludes.
2 Parallel Models
This section briefly ~eviews the modeIs of pardel computation for which parallel geometric
dgori thms have been designed.
1 Introduction
Many of the problems in computational geometry come from applications in pattern recog
nition, computer graphics, statistics, operations research, computer-aided design, robotics,
etc. The problems which arise in these areas can come from real-time applications, and
hence need to be solved as fast as possible. For many of these problems, however, we are
already at the limits of what ca.n be achieved through sequential computation. Such se·
quential methods can be inadequate for situations in which the input consists of a large
number of geometric objects. Thus, it is natural to study what kinds of speed-ups can be
achieved through parallel computing. As an indication of the importance of tills research
direction, wanote that four of the eleven problems used as benchma.rk problems to evaluate
parallel architectures for the DARPA Architecture Workshop Benchmark Study of 1986
were computational geometry problems.
Unfortunately, many of the techniques used to find efficient sequential algorithms for
computational geometry problems do not translate well into a parallel setting. That is,
while providing elegant paradigms for designing sequential algorithms, these techniques use
methods which seem to be inherently sequential. Therefore, one needs to develop new
paradigms for computational geometry, paradigms better suited for a parallel processing
environment. This article is a survey of the main known algorithmic techniques for solving
computational geometry problems efficiently in parallel. Since the focus is on general algo.
rithmic techniques rather than on specific problems, no a.ttempt is made to list aJ1 of the
known parallel complexity bounds for geometric problems (there are too many of them).
The rest of the paper is organized as follows. Section 2 briefly reviews paraJlel models,
Section 3 discusses basic subproblems tha.t tend to adse in the solution ofgeometric problems
on any parallel model, Section 4 discusses PRAM techniques, Section 5 discusses techniques
for mesh-connected arrays of processors, Section 6 deals with the hybrid RAM/ARRAY
model and its connection to I/O complexity, Section 1 mentions some experimental work,
and Section 8 concludes.
2 Parallel Models
This section briefly reviews the models of parallel computa.tion for which parallel geometric
algorithms have been designed.
2
2.1 PRAM Models
The PRAM (Parallel Random Access Machine) model of parallel computation is the shared-
memory model where the processors operate synchronously. A step in a PRAM consists of
each processor reading the content of a cell in the shared memory, writing something in a
cell of the shared memory, or performing a computation within i ts own registers. Thus all
communication is done via the shared memory. The PRAM comes in many flavors. The
CREW (Concurrent Read Exclusive Write) version of this model allows many processors
to simultaneously read the content of a memory location, but forbids any two processors
from simultaneously attempting to write in the same memory location (even if they are
trying to write the same thing). The CRCW (Concurrent Read Concurrent Write) version
of the PRAM differs from the CREW one in that it also allows many processors to write
simultaneously in the same memory location: in any such common-write contest, only one
processor succeeds, but it is not known in advance which one. (There are other versions oi
the CRCW-PRAM but we shall not concern ou~selves with these here.) The EREW-PRAM
is the weakest version of the PRAM: it forbids both concurrent reading and concurrent
writing.
The PRAM has so far been the main vehicle used to study the parallel algorithmics of
geometric problems, and much of this survey (Section 4) will deal with PRAM techniques.
2.2 Networks of Processors
A network of processors is modeled as a graph where the nodes represent processors and the
edges represent communication lines. AU the network models we consider are synchronous,
and a step of such a network of processors consists either of each processor communicating
with a neighbor by sending/receiving the contents of a register (a data movement step), or
of each processor performing a computation within its own registers (a computation step).
We next briefly review some network models.
2.2.1 The Mesh
In a d-dimensional mesh of processoTs, the ptocessors operate synchronously and are po-
sitioned on an hl x . . . x hd grid, one processor per grid point. A processor is denoted
by its position in the grid, a typical one being denoted by (il,. . ., id) where 1 5 i k < hk
for every k E (1,. . . , d}. Processors (il, . . . , i d ) and ( j l , . . . , jd ) are neighbors if and only
2.1 PRAM Models
The PRAM (Parallel Ra.ndom Access Machine) model of parallel computation is the shared
memory model where the processors operate synchronously. A step in a PRAM consists of
each processor reading the content of a cell in the shared memory, writing something in a.
cell of the shared memory, or performing a. computation within its own registers. Thus all
communication is done via the shared memory. The PRAM comes in many flavors. The
CREW (Concurrent Read Exclusive Write) ve:sion of this model allows ma.ny processors
to simultaneously read the content of it. memory location, but forbids any two processors
from simultaneously attempting to write in the same memory location (even if they are
trying to write the same thing). The CReW (Concnrrent Read Concurrent Write) version
of the PRAM differs from the CREW one in tha.t it also allows many processors to write
simultaneously in the same memory location: in any such common-write contest, only one
processor succeeds, but it is not known in advance which one. (There are other versions of
the CRCW-PRAM but we shall not concern ourselves with these here.) The EREW-PRAM
is the weakest version of the PRAM: it forbids both concurrent reading and concurrent
writing.
The PRAM has so far been the main vehicle used to study the parallel algorithmics of
geometric problems, and much of this survey (Section 4) will deal with PRAM techniques.
2.2 Networks of Processors
A network of processors is modeled as a. graph where the nodes represent processors and the
edges represent communica.tion lines. All the network models we consider are syncllIonous,
and a step of such a. network of processors consists either of ea.ch processor communicating
with a. neighbor by sending/receiving the contents of a register (a data movement step), or
of each processor performing a computation within its own registers (a. computation step).
We next briefly review some network models.
2.2.1 The Mesh
In a d-dlmensional mesh of processors, the processors operate synchronously and are po
sitioned on an hI X •.. X hd grid, one processor per grid point. A processor is denoted
by its position in the grid, a typical one being denoted by (il, ... , id) where 1 $ i" ::; h"
for every k E {l, •.. ,d}. Processors (il, .. . ,id) and (il, ... ,jrl) are neighbors if and only
3
if lil - jll + liz - jzl + - - - + lid - jd ( = 1 . Note that a processor cannot have more than
2d neighbors (processors at the boundary have fewer). A processor has a fixed (i.e., O(1))
number of storage registe~s. Some researchers assume that a register can store up to log n
bits, while others limit the size of a register to O(1) bits: here we assume the former model.
2.2.2 The Hypercube
Every processor in the h-dimensional hypercube H is labeled as b o b r . . . be-1, where 6; E
(0, I} for 0 5 i 5 k - 1. A processor with label bobl . . . bk-l is connected to k processors, -
having labels bobl . . . bS . . . bk-, , for 0 5 s 5 k - 1 (where is denotes the complement of b,).
An edge (vl, v 2 ) of H is said to be of dimension s, if vl and vz differ in bit position s, i-e.,
vl = bob1 ... 6 ,... bk-l and 9 2 = bob l . . . b ,... bA.-l .
2.2.3 Other Network Models
Some geometric algorithms were designed for a number of other networks, which we shall
not cover in any detail. These include the tree of processors, the pyramid, and the mesh of
trees. Although the general algorithmic techniques for solving geometric problems on these
models can be quite similar to the techniques used for other models (like the mesh), there
are significant differences in the way processors communicate (these networks have smaller
diameter than the mesh). Generally speaking, the tree of processors has been used more for
parallel information storage and retrieval than for solving geometric problems. The pyramid
has been used mostly for image processing applications. For the reader interested in learning
more about these and other network models, see the forthcoming books by Leighton [94]
and by Miller and Stout [98].
2.3 Hybrid Models
These are models consisting of more than one type of machine, and the main one for which
geometric problems have been considered consists of a sequential computer to which a mesh
is attached. We postpone the description of this model until Section 6.
Although geometric algorithms have been designed for all of the network models men-
tioned above, there are far fewer geometric algorithms for network models than for PRAMS.
Furthermore, among the nctwork models, Inore geometric algorithms have been designed
for the mesh than for any of the other network models, perhaps because the pardel com-
plexity of such basic operations as sorting and list ranking is well understood for the mesh.
if Ii] - itl + li2 - hi + ... + lid - jell = l. Note that a processor cannot have more than
2d neighbors (processors at the boundary have fewer). A processor has a ftxed (i.e., 0(1))
number of storage registers. Some researchers assume that a register can store up to log n
bits, while others limit the size of a register to O( 1) bits: here we assume the former model.
2.2.2 The Hypercube
Every processor in the k-dimensional hypercube H is labeled as bobt ••• bk-l, where Vi E
{O, 1} for 0 .$ i .$ k - 1. A processor with label bob l .. . bk-l is connected to k processors,
having labels bob l .•• ii, ... bk-I, for 0 .$ s .$ k - 1 (where btl denotes the complement of b,,).
An edge (v}, 112) of H is said to be of dimension s, if 111 and V2 differ in bit position 5, i.e.,
111 = bob1 .• .b, ... bk-1 and 1)2 = bob1 •• • boO ., .bk-l.
2.2.3 Other Network Models
Some geometric algorithms were designed for a number of other networks, which we shall
not coveT in any detail. These include the tree of processors, the pyramid, and the mesh of
trees. Although the general algorithmic techniques for solving geometric problems on these
models can be quite similar to the techniques used for other models (like the mesh), there
are significant differences in the way processors communicate (these networks have smaller
diameter than the mesh). Generally speaking, the tree of processors has been used more for
parallel information storage and retrieval than for solving geometric problems. The pyramid
has been used mostly for image processing applications. For the reader interested in learning
more about these and other network models, see the forthcoming books by Leighton [94]
and by Miller and Stout [98].
2.3 Hybrid Models
These are models consisting of more than one type of machine, a.nd the main one for which
geometric problems have been considered consists of a. sequential computer to which a mesh
is attached. We postpone the description of this model until Section 6.
Although geometric algorithms have been designed for all of the network models men
tioned above, there are far fewer geometric algorithms for network models than for PRAMs.
Furthermore, among the network models, mOTe geometric. algorithms have been designed
for the mesh than for any of the other network models, perhaps because the parallel com·
plexity of such basic operations as sorting and list ra.nking is well understood for the mesh.
4
Other models like the hypercube are just as important, but the complexity o i the most
basic operations on them is still open. For this reason, among all the network models, we
shall focus on the mesh (in Section 5) and on hybrid variants of the mesh (in Section 6).
We also briefly discuss the connections between these and the I/O complexity of geometric
problems (in Section 6).
3 Basic Subproblems .
This section reviews some basic subproblems that are ubiquitous in the design of parallel
geometric algorithms, no matter what parallel model is used. In many models the complex-
ity of these basic subproblems is well understood, but for some models (like the hypercube)
the complexity of some of these (like sorting and list-ranking) is still open, and in such sit-
uations no final statement about the complexity of the mast common geometric problems
can be made until these issues are resolved (especially since many geometric problems are
related to sorting). These basic operations are reviewed below.
3.1 Sorting, Merging
Sorting is probably the most frequently used subroutine in parallel geometric algorithms.
Fortunately, for PRAM models and for the mesh, we know how to sort optimally: O(1og n)
time and n processors on the EREW-PRAM [41, 81, O(& time on a fi x 6 mesh
[95, 105,87]. The parallel complexity of sorting on the hypercube is not known (the current
best kypercube bound is O ( l ~ ~ n ( l o ~ l o g n ) ~ ) with n processors [49]). On the mesh, the
complexity of merging is the same as that of sorting, but on the hypercube and PRAM it is
easier than sorting [117, 127, 29, 791; it is O(1og n) time on an n-processor hypercube, and
on the PRAM it is O(log log n) time with n processors or, alternatively, O(1og n) time with
n/ log n processors.
3.2 Parallel Prefix
Given an array A of n elements and an associative operation +, the paralIel prefix problem
is that of computing the array 3 of n elements such that B(i ) = G=, A(k). Parallel
prefix can be solved in O(logn) time and n/ logn processors on an EREW-PRAM [go],
O(logn/ log log n) time and n log log n/ log n processors on a CRCW-PRAM [45], O(&
time on the mesh (trivial), and in O(1ogn) time on an n-processor hypercube (trivial).
Computing the smallest element in the A array is a special case of parallel prefix; for the
Other models like the hypercube a.re just as important, but the complexity of the most
basic operations on them is still open. For this reason, among all the network models, we
shall focus on the mesh (in Section 5) and on hybrid variants of the mesh (in Section 6).
We also briefly discuss the connections between these and the I/O complexity of geometric
problems (in Section 6).
3 Basic Subproblems
This section reviews some basic subproblems that are ubiquitous in the design of parallel
geometric algorithms, no matter what para.llel model is used. In many models the complex
ity of these basic subproblems is well understood, but for some models (like the hypercube)
the complexity of some of these (like sorting and list-ranking) is still open, and in such sit
uations no final statement about the complexity of the most common geometric problems
can be made until these issues are resolved (especially since many geometric problems are
related to sorting). These basic operations are reviewed below.
3.1 Sorting, Merging
Sorting is probably the most frequently used subroutine in pa.rallel geometric algorithms.
Fortuna.tely, for PRAM models and for the mesh, we know how to sort optimally: O(logn)
time a.nd n processors on the EREW-PRAM [41, 8J, O(Ji) time on a. ..;n x .JTi mesh
[95, 105,87]. The parallel complexity of sorting on the hypercube is not known (the current
best hypercube bound is O(logn(loglogn)2) with n processors [49]). On the mesh, the
complexity of merging is the sa.me as tha.t of sorting, but on the hypercube a.nd PRAM it is
easier than sorting [117, 127, 29, 79J; it is o(log n) time on an n-processor hypercube, and
on the PRAM it is O(log log n) time with n processors or, alterna.tively, O(logn) time with
n/ log n processors.
3.2 Parallel Prefix
Given an array A of n elements and an associative operation +, the parallel prefix problem
is that of computing the a.rra.y B of n elements such that B(i) :::: [:1=1 A(k). Pa.rallel
prefix can be solved in O(logn) time and n/logn processors on an EREW-PRAM [90],
O(lognlloglogn) time and nloglognjlogn processors on a CReW-PRAM [45]. O(J1i)
time on the mesh (trivial), and in O(logn) time on an n-processor hypercube (trivial).
Computing the smallest element in the A array is a special case of pa.rallel prefix; for the
5
CRCW model it can be done faster than general parallel prefix-in O(E-l) time with nl+'
processors for any positive constant c or, alternatively, in O(1oglog n) time with nlloglog n
processors [117].
3.3 List Ranking
List ranking is a more general version of the pardel prefix problem: the elements are given
as a linked list, i.e., we are given an array A each entry of which contains an element as well
as a pointer to the entry of A containing the predecessor of that element in the linked list.
The problem is to compute an array B such that B(i ) is the "sum" of the first i elements
in the linked list. This problem is considerably harder than the previous one, and most
tree computations as well as Inany graph computations reduce, via the Euler tour technique
[122j, to solving that problem. EREW-PRAM algorithms that run in O(1ogn) time and
n/ logn processors are known [44, 101. An O ( 6 ) time mesh dgorithm is also known [22}.
Its complexity on the hypercube is still an open problem.
3.4 Tree Contraction
Given a (not necessarily balanced) rooted tree, the problem is to reduce it to a single node
by a sequence of node removals, where a node v can be removed if it is not the root and
either (i) it is aleaf, or (ii) it has only one child. In case (ii) the removal of v is accomplished
by "bypassing it", i.e., making v's child the child of v's parent. In a parallel setting, many
nodes can be removed simultaneously so long as they are independent, in the sense that the
parent of a node being removed cannot be removed at the same time. This problem is an
abstraction of many other problems, including that of evaluating an arithmetic expression
tree [102]. Many elegant optimal EREW-PRAM algorithms for it are known [I, 44, 71,841,
running in O(1ogn) time with n/ log n processors. It is easy to implement these in O(&
time on a fi x JSi mesh by using the techniques in [22].
The above list of basic subproblems is not exhaustive in that (i) many techniques that
are basic for general combinatorid problems were omitted (we have focused only on those
most relevant to geometric problems rather than to general combinatorid p~oblems), and
(ii) among the techniques applicable to geometric problems we have postponed covering the
more specidzed ones (they tend to be model-dependent).
CRew model it can be done faster than general parallel prefix-in D(E-1) time with nI+(
processors for any positive constant E or, alternatively, in D(loglogn) time with nfloglogn
processors [117).
3.3 List Ranking
List ranking is a. more general version of the parallel prefix. problem: the elements are given
as a linked list, i.e., we are given an array A each entry of which contains an element as well
as a pointer to the entry of A containing the predecessor of that element in the linked list.
The problem is to compute an array B such that B(i) is the "sum" of the first i elements
in the linked list. This problem is considerably harder than the previous one. and most
tree computations as well as many graph computations reduce, via the Euler tour technique
[122]. to solving that problem. EREW~PRAM algorithms that run in O(logn) time a.nd
n/logn processors are known [44, to]. An O(..fii) time mesh algorithm is also known [22}.
Its complexi ty on the hypercube is still an open problem.
3.4 Tree Contraction
Given a (not necessarily balanced) rooted tree, the problem is to reduce it to a single node
by a sequence of node removals, where a node 1] can be removed if it is not the root and
either (i) it is a leaf, or (ii) it has only one child. In case (ll) the removal of v is accomplished
by "bypassing it", i.e., making v's child the child of 1]'S parent. In a. parallel setting, many
nodes can be removed simultaneously so long as they aTe independent, in the sense that the
parent of a node being removed cannot be removed at the same time. This problem is an
abstraction of many other problems, including that of evaluating an arithmetic expression
tree [102]. Many elegant optimal EREW-PRAM algorithms for it are known [1,44,71,84],
running in O(logn) time with nflogn processors. It is easy to implement these in O(Ji)
time on a. Vii X Vii mesh by using the techniques in [22].
The above list of basic subproblems is not exha.ustive in that (i) many techniques that
aTe basic for general combinatorial problems were omitted (we have focused only on those
most relevant to geometric problems rather than to general combinatorial problems), and
(ii) among the techniques applicable to geometric problems we have postponed covering the
more specialized ones (they tend to be model.dependent).
6
4 PRAM Techniques
The PRAM has been extensively used in theoretical studies as a uniform vehicle for design-
ing parallel algorithms. The PRAM is generally considered to be a rather unrealistic model
of parallel computation. However, although there are no PRAMs commercially available,
algorithms designed for PRAMs can often be efficiently simulated on some of the more
realistic parallel models. The PRAM enables the algorithm designer to focus on the struc-
ture of the problem itself, without being distracted by architecture-specific issues. Another
advantage of the PRAM is that, if one can give strong evidence (in the sense explained in
the next subsection) that a problem has no fast parallel solution on the PRAM, then there
is no point in looking for a fast solution to it on more realistic parallel models (since these
are weaker than the PRAM).
4.1 Inherently Sequential Geometric Problems
A parallel algorithm is said to run in polylognrithrnic time if its time complexity is O(log%),
where n is the problem size and t is a constant independent of n (i.e., k = O(1)). A
problem solvable in polylogarithmic time using a polynomial number of processors is said
to be in the class NC. It is strongly believed (but not proved) that not all problems solvable
in polynomial time sequentially are solvable in polylogarithmic time using a polynomial
number of processors (i.e., it is believed that P + NC). As in the theory of NP-completeness,
there is an analogous method for showing that a particular problem is probably not in
NC: by showing that the membership of that problem in NC would imply that P = NC.
Such a proof consists of showing that each problem in P admits an NC reduction to the
problem at hand (an NC reduction is a reduction that takes polylogarithmic time and uses
a polynomial number of processors). Such a problem is said to be P-complete. For a more
detailed discussion of the class NC and pardel complexity theory, see (for example) [lo81
or [83]. A proof establishing P-completeness of a problem is viewed as strong evidence that
the problem is "inherently sequential". Most of the problems shown to be P-complete to
date are not geometric (most are graph or algebra problems). This is no accident: geometric
problems in the plane tend to have enough structure to enable membership in NC. Even
the otherwise P-complete problem of linear programming [65, 661 is in NC when restricted
to the plane. In the rest of this subsection we mention the (very few) planar geometric
problems that are known to be P-complete, and also a problem that is conjectured to be
4 PRAM Techniques
The PRAM has been extensively used in theoretical studies as a uniform vehicle for design
ing parallel algorithms. The PRAM is generally considered to be a rather unrealistic model
of parallel computation. However I although there are no PRAMs commercially available,
algorithms designed for PRAMs can often be efficiently simula.ted on some of the more
realistic parallel models. The PRAM enables the algorithm designer to focus on the struc
ture of the problem itself, without being distrac~ed by architecture-specific issues. Another
advantage of the PRAM is that, if one can give strong evidence (in the sense explained in
the next subsection) that a. problem has no fast parallel solution on the PRAM, then there
is no point in looking for a fast solution to it on more realistic parallel models (since these
a.re weaker than the PRAM).
4.1 Inherently Sequential Geometric Problems
A parallel algorithm is said to run in pQlylogarithmic time if its time complexity is o(logk n),
where n is the problem size and k is a constant independent of n (i.e" k = 0(1)). A
problem solvable in polylogarithmic time using a polynomial number of processors is said
to be in the class NC. It is strongly believed (but not pToved) that not all problems solvable
in polynomial time sequentially are solvable in polylogarithmic time using a polynomial
number of processors (Le., it is believed that P ;:fi NC). As in the theory of NP-completeness,
there is an analogous method for showing that a particular problem is proba.bly not in
NC: by showing that the membership of that problem in NC would imply tha.t P = NC.
Such a. proof consists of showing tha.t each problem in P admits an NC reduction to the
problem at hand (an NC reduction is a reduction that takes polylogarithmic time and uses
a polynomial numberof processors). Such a problem is said to be P-complete. For a more
detailed discussion of the class NC and parallel complexity theory, see (for example) [108]
or (831. A proof establishing P-completeness of a problem is viewed as strong evidence that
the problem is "inherently sequential". Most of the problems shown to be P-complete to
date are not geometric (most are graph OT algebra problems). This is no accident: geometric
problems in the plane tend to have enough structure to enable membership in NC. Even
the otherwise P-complete problem of linear programming [65, 66] is in NC when restricted
to the plane. In the rest of this subsection we mention the (very few) planar geometric
problems that are known to be P·complete, and also a problem that is conjectured to be
7
P-complete. Each oi the problems known to be P-complete involves a collection of line
segments in the plane.
Plane-sweep Iriangulalion. One is given a simple n-vertex polygon P (which may
contain holes) and asked to produce the triangulation that would be constructed by
the following sequential algorithm: sweep the plane from left to right with a vertical
line L, such that each time L encounters a vertex v of P one draws all diagonals of P
from v that do not cross previously drawn diagonals. This problem is a special case
of the well-known polygon triangulation problem (see [67, 110]), and it clearly has a
polynomial time sequential solution.
Weighted planar partitioning. One is given a collection of n non-intersecting segments
in the plane, such that each segment s is given a distinct weight w(s), and asked to
construct the partitioning of the plane produced by extending the segments in order
of their weights. The extension of a segment "stops" at the first segment (or segment
extension) that is "hit" by the extension. This problem has applications to "art gallery
problems" [48, 1061, and is P-complete even if there are only 3 possible orientations
for the line segments. It is straightforward to solve it sequentially in O(nlog2 n) time
(using the dynamic point-location data structure of [Ill]), and in O(nlog1ogn) time
. by a more sophisticated method [48].
Visibility layers. One is give a collection of n non-intersecting segments in the plane,
and asked to label each segment by its "depth" in terms of the following layering
process (which starts with i = 0): find the segments that are (partially) visible from
(O,+cm), label each such segment as being at depth i , remove each such segment,
increment i, and repeat until no segments are left. This is an example of a class
of problems in computational geometry known as layering problems or onion peeling
problems [35,92, 1071, and is P-complete even if al l the segments are horizontal.
The P-completeness proois of the above problems were given in (131; for the third prob-
lem see also [78]. The proofs consist of giving NC reductions from the monotone circuit value
problem and planar circuit value problem, which are known to be P-complete [70, 88, 1031.
These reductions typically involve the use of geometry to simulate a circuit, by using the
relative positions of objects in the plane.
P-complete. Each of the problems known to be P-complete involves a collection of line
segments in the pla.ne.
• Plane-sweep triangulation. One IS given a simple n-vertex polygon P (which may
contain holes) and asked to produce the triangula.tion that would be constructed by
the following sequentia.l algorithm: sweep the plane from left to right with it. vertical
line L, such that each time L encounters a vert~x v of P one draws all diagonals of P
from v that do not cross previously drawn diagonals. This problem is a special case
of the well-known polygon triangula.tion problem (see [67, Hal). a.nd i~ clearly has a
polynomial time sequential solution.
• Weighted planar partitioning. One is given a collection of n non-intersecting segments
in the pla.ne, such that each segment s is given a distinct weight w(s). and asked to
construct the partitioning of the plane produced by extending the segments in order
of their weights. The extension of a segment "stops" at the first segment (or segment
extension) that is "hit" by the extension. This problem has applications to "art gallery
problems" [48, 106]. and is P-complete even if there are only 3 possible orientations
for the line segments. It is straightforward to solve it sequentially in O(nlog2 n) time
(using the dynamic point-location data structure of [111]), and in 0(71. loglogn) time
by a more sophisticated method {48].
• Visibility layers. One is give a collection of n non-intersecting segments in the pla.ne,
and asked to la.bel each segment by its "depth" in terms of the following layering
process (which starts with i ; 0); find the segments that a.re (partia.Ily) visible from
(0, +00), label each such segment as being at depth i, remove each such segment,
increment i, and repeat until no segments are left. This is· an example of a. class
of problems in computational geometry known as layering problems or onion peeling
problems [35,92, 107], and is P-complete even if all the segments are horizontal.
The P-completeness proofs of the above problems were given in [13]; for the third prob
lem see also [78]. The proofs consist ofgiving NC reductions from the monotone circuit value
problem and planar circuit value problem, which are known to be P-complete [70, 88, 103].
These reductions typically involve the use of geometry to simulate a. circuit, by using the
relative positions of objects in the plane.
8
Perhaps the most famous open pr~blem in the area of geometric P-completeness is that
of the convex layers problem [35]: given n points in the plane, mark the points on their
convex hull as being layer zero, then remove layer zero and repeat the process, generating
layers 1,2, . . . , etc. In view of the P-completeness of the above-mentioned visibility layers
problem, it is reasonable to conjecture that the convex layers problem is also P-complete.
4.2 "Fast" and "Efficient"
Once one has established that a geometric problem is in NC, the next step is to design a
PRAM algorithm for it that runs as fast as possible, while being efficient in the sense that
it uses as few processors as possible. Ideally, the parallel time complexity should match the
lower bound (assuming such a lower bound is known), and the time x processors product
should match the sequential time complexity or the problem. A parallel lower bound for
a geometric problem is usually established by sh~wing that it can be used to solve some
other (perhaps nongeometric) problem having that lower bound. For example, it is well
known [47] that computing the logical OR of n bits has an R(1ogn) time lower bound on a
CREW-PRAM. This can easily be used to show that detecting whether the boundaries of
two convex polygons intersect also has an R(1og n) time lower bound on that same model,
by encoding the n bits whose OR we wish to compute in two concentric regular n-gons
such that the ith bit governs the relative positions of the ith vertices of the two n-gons.
Interestingly, if the word "boundaries" is removed from the previous sentence then the lower
bound argument falls apart and it becomes possible to solve the problem in constant time
on a CREW-PRAM, even using a sublinear number of processors [20,128].
Before reviewing the techniques that have resulted in many PRAM geometric algorithms
that are fast and efficient in the above sense, a word of caution is in order. nom a theoretical
point of view, the class NC and the requirement that a "fast" parallel algorithm should run
in polylogarithmic time, are eminently reasonable. But from a more practical point of view,
not having a polylogarithmic time algorithm does not enti~ely doom a problem to being
"non-parallelizable". One can indeed argue [126] that a p~oblem of sequential complexity
O(n) and lthat is solvable in O(fi) time by using fi processors is "parallelizable" in a
very real sense, even if no polylogarithmic time dgori thm is known for it.
Perhaps the most famous open problem in the area of geometric P-completeness is that
of the convex layers problem (35]: given n points in the plane, mark the points on their
convex hull as being layer zero, then remove layer zero and repeat the process, generating
layers 1,2, ... , etc. In view of the P-completeness of the above-mentioned visibility layers
problem, it is reasonable to conjecture that the convex layers problem is also P-complete.
4.2 "FastU and "Efficient"
Once one has established that a. geometric problem is in NC, the next step is to design a
PRAM algorithm for it that runs as fast as possible, while being efficient in the sense tha.t
it uses as few processors as possible. Ideally, the parallel time complexity should match the
lower bound (assuming such a lower bound is known), and the time x processors product
should match the sequential time complexity of the problem. A parallel lower bound for
a geometric problem is usually established by showing that it can be used to solve some
other (perhaps nongeometric) problem having that lower bound. For example, it is well
known [47] that computing the logical OR of n bits has an n(log n) time lower bound on a
CREW-PRAM. This can easily be used to show that detecting whether the boundaries of
two convex polygons intersect also has an .Q(log n) time lower bound on that same model,
by encoding the n bits whose OR we wish to compute in two concentric regular n-gons
such that the ith bit governs the relative positions of the ith vertices of the two n-gons.
Interestingly, if the word "boundaries" is removed from the previous sentence then the lower
bound argument falls a.part and it becomes possible to solve the problem in constant time
on a CREW-PRAM, even using a sublinear number of processors [20, 128].
Before reviewing the techniques that have resulted in many PRAM geometric a.lgorithms
that are fast and efficient in the above sense, a. word of caution is in order. From a theoretical
point of view, the class NC and the requirement that a "fast'l parallel algorithm should run
in polylogarithmlc time, are eminently reasonable. But from a more practical point of view I
not having a. polylogarithmic time algorithm does not entirely doom a problem to being
"non-parallelizable". One can indeed argue [126] that a problem of sequential complexity
0(n) and that is solvable in O(v'ii) time by using Vii processors is "parallelizable" in a
very real sense, even if no polylogarithmic time algorithm is known for it.
9
4.3 Divide and Conquer
The sequential divide and conquer algorithms that have efficient PRAM implementations
are those for which the "conquer" step can be done extremely fast (e.g., in constant time).
Take, for example, an O(n1og n) time sequentid algorithm that works by recursively solving
two p~oblems of size n / 2 each, and then combining the answers they return in linear time.
In order for a PRAM implementation of such an algorithm to run in O(1ogn) time with n
processors, the n processors must be capable of performing the "combine" stage in constant
time. For some geometric problems this is indeed possible (these include the convex hull
problem E20, 1281). The time and processor complexities then obey the recurrences
with boundary conditions T(1) 5 c2 and P(l) = 1 , where cl and cl are constants. These
imply that T(n) = O(1ogn) and P(n) = n.
But for many problems, such an attempt at implementing a sequential algorithm fdrls
because of the impossibility of performing the "conquer" stage in constant time. For these,
the next two approaches often work.
4.4 "Rootish" Divide and Conquer
By "rootish" we mean partitioning the problem into n'Ik subproblems to be solved recur-
sively in parallel, lor some constant integer k (usually, k = 2). For example, instead of
dividing the problem into two subproblems of size n/2 each, we divide it into (say) f i subproblems of size fi each, which we recursively solve in parallel. That the conquer stage
takes O(1ogn) time (assuming it does) causes no harm with this subdivision scheme, since
the time and processor recurrences in that case would be
with boundary conditions T(1) < c;! and P(1) = 1, where cl and cz are constants. These
imply that T(n) = O(1og n) and P(n) = n.
The problems that can be solved using rootish divide and conquer include the convex
hull [2, 191, the visibility of nonintersecting planar segments from a point [28], and the
4.3 Divide and Conquer
The sequential divide and conquer algorithms that have efficient PRAM implementations
are those for which the "conquer" step can be done extremely fast (e.g., in constant time).
Take, for example, an O(n log n) time sequential algorithm that works by recursively solving
two problems of size n/2 each, and then combining the answers they return in linear time.
In order for a PRAM implementation of such an algorithm to run in O{logn) time with n
processors, the n processors must be capable of performing the "combine" stage in constant
time. For some geometric problems this is indeed possible (these include the convex hull
problem {20, 128]). The time and processor complexities then obey the recurrences
T(n) S T(n/2) +Ct.
Pen) s max{n,2P(n/2)},
with boundary conditions T(l) ~ C2 and pel) = 1, where Cl and C2 are constants. These
imply that T(n) =O(1ogn) and Pen) =n.
But for many problems, such an attempt at implementing a sequential algorithm fails
because of the impossibility of performing the "conquer" stage in constant time. For these,
the next two approaches often work.
4.4 "Rootish" Divide and Conquer
By "roatish" we mea.n partitioning the problem into n 1/k subproblems to be solved recur
sively in parallel, for some constant integer k (usually, k = 2). For example, instead of
dividing the problem into two subproblems of size n/2 each, we divide it into (say) Viisubproblems of size ,;n each, which we recursively solve in parallel. That the conquer stage
takes O(logn) time (assuming it does) causes no harm with this subdivision scheme, since
the time and processor recurrences in that case would be
T(n) ~ T(v'1i) + Cl10g n,
Pen) $ max{n,0iP(vn)}.
with boundary conditions T(l) S C2 and pel) = 1, where Cl and C2 are constants. These
imply that T(n) = O(Iog n) and pen) = n.
The problems that can be solved using rootish divide and conquer include the convex
hull [2, 19], the visibility of nonintersecting pla.nar segments from a. point [28), and the
10
visibility of a polygonal chain from a point [15]. The scheme is useful in various ways and
forms, and sometimes with recurrences very different from the above-mentioned ones. For
example, it was used in the form of a fourth-root divide and conquer to obtain (in a rather
involved way) an optimal EREW algorithm for the visibility of a simple polygon from a
point [15] (that is, O(logn) time with n/logn processors).
There are instances where one has to use a hybrid of two-way divide and conquer and
rootish divide and conquer, in order to obtain the desired complexity bounds. For example,
in 1151, the recursive procedure takes two parameters (one of which is problem size) and
uses either fourth-root divide and conquer or two-way divide and conquer, depending on
the relative sizes of these two input parameters.
4.5 Cascading
This sampling and iterative refinement method was introduced by Cole [41] for the sorting
problem, and was iurther developed in [16, 721 for the solution of geometric problems. It
has proved to be a fundamental technique, one that enables optimal solutions when most
other techniques fail. Its details are intricate even for sorting, but the gist of it can easily
be described. Since the technique works best for problems that are solved sequentially by
divide and conquer, we use such a hypothetical problem to illustrate the discussion: consider
an O(n logn) time sequen tial algorithm that works by recursively solving two subproblems
of size n/2 each, followed by an O(n) time conquer stage. Let T be the tree of recursive
calls for this algorithm, i.e., a node 01 this recursion tree at height h corresponds to a
subproblem of size equal to the number of leaves in its subtree (= 2h) . A Lbnatural'l way
of pardelizing such an algorithm would be to mimic it by using n processors to process
T in a bottom up fashion, one level a t a time, completing level h before moving to level
h + 1 of T (where by "level h" we mean the set of nodes of T whose height is h). Such
a pardelization will yield an O(1ogn) time algorithm only if processing each level can be
done in constant time. It can be quite nontrivial to process one level in constant time,
so this natural parallelization can be challenging. However, it is frequently the ckse that
processing one level cannot be done in constant time, and it is precisely in these situations
that the cascading idea can be useful. In order to be more specific when sketching this idea,
we assume that the hypothetical problem being solved is about a set S of n points, with
the points stored in the leaves of T.
In a nutshell, the general idea of cascading is as follows. The computation proceeds
visibility of a polygonal chain from a point [15]. The scheme is useful in various ways and
forms, and sometimes with recurrences very different from the above-mentioned ones. For
exa.mple, it was used in the form of a fourth-root divide and conquer to obtain (in a rather
involved way) an optimal EREW algorithm for the visibility of a. simple polygon from a
point [15] (that is, O(logn) time with n/logn processors).
There are instances where one has to use a hybrid of two-way divide and conquer and
footish divide and conquer, in order to obtain the desired complexity bounds. For example,
in [15], the recursive procedure takes two parameters (one of which is problem size) and
uses either fourth-root divide and conquer or two-way divide and conquer, depending on
the relative sizes of these two input parameters.
4.5 Cascading
This sampling a.nd iterative refinement method was introduced by Cole [41] for the sorting
problem, and was further developed in [16, 72] for the solution of geometric problems. It
has proved to be a fundamental technlque, one that enables optimal solutions when most
other techniques fail. Its details are intricate even for sorting, but the gist of it can easily
be described. Since the technique works best for problems that are solved sequentially by
divide and conquer I we use such a. hypothetical. problem to illustra.te the discussion: consider
an O(nlogn) time sequential algorithm that works by recursively solving two subproblems
of size n/2 each, followed by an D(n) time conquer stage. Let T be the tree of recursive
calls for this algorithm l i.e., a node of this recursion tree at height h corresponds to a
subproblem of size equal to the number of leaves in its subtree (= 211 ). A I'naturaln way
of parallelizing such an algorithm would be to mimic it by using n processors to process
T in a bottom up fashion, one level at a time, completing level h before moving to level
h + 1 of T (where by Illevel hn we mean the set of nodes of T whose height is h). Such
a parallelization will yield an O(1ogn) time algorithm only if processing each level can be
done in constant time. It can be quite nontrivial to process one level in constant time,
so this natural parallelization can be challenging. However, it is frequently the case that
processing one level cannot be done in constant time, and it is precisely in these situations
that the cascading idea can be useful. In order to be more specific when sketching this idea,
we assume that the hypothetical problem being solved is about a set S of n points, with
the points stored in the leaves of T.
In a nutshell, the general idea. of cascading is as follows. The computation proceeds
11
in a logarithmic number of stages, each of which takes constant time. Each stage involves
activity by the n processors at more than one level, so the computation diffuses up the tree
T, rather than working on only one level at a time. For each node v E T, let h(v) be the
height of v in T, L(v) be the points stored in the leaves of the subtree of v in T, and let
I (L(v ) ) be the iniormation we seek to compute for node v (the precise definition of I ( - )
varies from problem to problem). The ultimate goal is for every v E T to compute the
I(L(v)) array. Each v E T lies "dormant" and does nothing until the stage number exceeds
a certain value (usually h(v) ) , a t which time node u "wakes up" and starts computing, from
stage to stage, I (L t ) for a progressively larger subset L' of L(v), a subset L' that (roughly)
doubles in size irom one stage to the next of the computation. I(Lf) can be thought of as an
approximation of the desired I(L(v)), an approximation that starts out being very rough
(when L' consists of, say, a single point) but gets repeatedly refined from one stage to the
next. When L' eventually becomes equal to L(v), node v becomes inactive for all future
stages (i.e., i t is done with its computation, since it now has I(L(u))). There are many
(often intricate) implementation details that vary irom one problem to the next, and many
times the scheme substantially deviates irom the above rough sketch, but our purpose was
only to give the general idea of cascading.
The cascading technique has been used to solve many problems (not just geometric
ones). Some of the geometric problems for which i t has been used are:
Fractional cascading. Given a directed graph G in which every node v contains a
sorted list C(v), construct a linear space data structure (that is, one whose size is
at most a constant factor larger than the space taken by the input) that enables one
processor to quickly locate any x in all the sorted lists stored along a given path
( V I , vz, . . . , vk) in G (by "quickly" we mean in O(1og (C(vl ) ( + k) time). This problem
was introduced by Chazelle and Guibas [37] who gave an elegant optimal sequential
algorithm. An optimal O (log n) time and 7 ~ / log n processor parallel algorithm for this
problem was given in [16].
Trapezoidal decomposition. Given a set S of n planar line segments, determine for
each segment endpoint p the first segment encountered by starting a t p and walking
vertically upward (or downward). An O(log n) time and n processor CREW-PRAM
algorithm is known 1161. This implies similar bounds for the polygon triangulation
problem [72, 74, 1301.
in a logarlthmic number of stages, each of which takes constant time. Each stage involves
activity by the n processors at more than one level, so the computation diffuses up the tree
T, rather than working on only one level at a time. For each node vET, let h(v) be the
height of 1J in T, L(v) be the points stored in the leaves of the subtree of v in T, and let
I(L(v)) be the information we seek to compute for node v (the precise definition of 1(·)
varies from problem to problem). The ultimate goal is for every vET to compute the
I(L(v» array. Each vET lies "dormant" and does nothing until the stage number exceeds
a certain value (usually h(v», at which time node v "wakes up" and starts computing, from
stage to stage, I(L') for a progressively larger subset £' of L(v), a subset £' that (roughly)
doubles in size from one stage to the next of the computation. I( L') can be thought of as an
approximation of the desired 1( L(1))), a.n approximation that starts out being very rough.
(when L' consists of, say, a single point) but gets repeatedly refined from one stage to the
next. When L' eventually becomes equal to £(v), node v becomes inactive for all future
stages (Le., it is done with its computation, since it now has I(L(l1»). There are many
(often intricate) implementation details tha.t vary from one problem to the next, and many
times the scheme substantially deviates from the above rough sketch, but our purpose was
only to give the general idea of cascadil'lg.
The cascading technique has been used to solve many problems (not just geometric
ones). Some of the geometric problems for which it has been used are;
• Fractional cascading. Given a. directed graph G in which every node v contains a
sorted list C(v), construct a. linear space data structure (that is, one whose size is
at most a constant factor larger than the space taken by the input) that enables one
processor to quickly locate any :I: in all the sorted lists stored along a given path
(Vt,V21" .,Vk) in G (by "quickly" we mean in O{logIC(vdl +k) time). This problem
was introduced by Chazelle and Guibas [37] who gave an elegant optimal sequential
algorithm. An optimal o (log n) time and nflogn processor parallel algorithm for this
problem was given in [16].
• Trapezoidal decomposition. Given a set S of n pla.nar line segments, determine for
each segment endpoint p the first segment encountered by staTting at p and walking
vertically upward (or downward). An O(logn) time and n processor CREW·PRAM
algorithm is known [16]. Th.is implies similar bounds for the polygon triangulation
problem [72, 74, 130].
12
a Topological sorting of n nonintersecting line segments. This is the problem of ordering
the segments so that, if a vertical line 1 intersect segments s; and sj and i < j, then the
intersection between 1 and s; is above the intersection between I and s j . An O(1ogn)
time, n-processor CREW-PRAM algorithm is easily obtained by implementing the
main idea of the mesh agorithm of [23] (which reduces the problem to a trapezoidal
decomposition computation followed by a tree computation).
r Planar point location. Given a subdivision of the plane into polygons, build a data
structure that enables one processor to quickly locate, for any query point, the face
containing it. Using n processors, cascading can be used to achieve O(1ogn) time for
both construction and query 116, 121, 461. The planar point location problem itself
tends to arise rather frequently, even in geometric problems apparently unrelated to
it.
Intersection detection, three-dimensional maxima, two-set dominance counting, visi-
bility from a point, aU nea~est neighbors. For all of these problems, cascading can be
used to achieve O(logn) time with n processors [16, 421.
Alternative approaches to cascading have been proposed for some of the above problems;
for example, see [28, 113, 1291 and also the elegant parallel hiererchical approach of Dadoun
and Kirkpatrick, which is tliscussed nest.
4.6 Geometric Hierarchies
This paradigm has proved extremely useful and general in computational geometry, both
sequential [85,62, 63, 641 and parallel 151, 521. Generally speaking, the method consists of
building a sequence of descriptions of the geometric object under consideration, where an
element of the sequence js simpler and s m d e r (by a constant factor) than its predecessor,
and yet "close" enough that information about it can be used to obtain in constant time
information about the predecessor. This "information" could be, for example, the location
of a query point in the subdivision, assuming the elements of the sequence are progressively
simpler subdivisions of the plane (in that case pointers exist between faces of a subdivision
and those of its predecessor - these pointers are part of the data structure representing
the sequence of subdivisions). The technique turns out to be useful for other models than
the PRAM (see Subsection 5.2).
• Topological sorting of n nonintersecting line segments. This is the problem of ordering
the segments so that, if a vertical line 1intersect segments Sj and Sj and i < j, then the
intersection between land Si is above the intersection between land Sj. An O(logn)
time, n-processor CREW-PRAM algorithm is easily obtained by implementing the
main idea of the mesh agorithm of [23] (which reduces the problem to a trapezoidal
decomposition computation followed by a tree computation).
• Planar point location. Given a subdivision of the plane into polygons, build a data
structure tha.t enables one processor to quickly locate, for any query point, the face
containing it. Using n processors, cascading can be used to achieve O(logn) time for
both construction and query [16, 121, 46]. The planar point location problem itself
tends to arise rather frequently, even in geometric problems apparently unrelated to
it.
• Intersection detection, three-dimensional maxima, two-set dominance counting. visi
bility from a point, all nearest neighbors. For all of these problems, cascading can be
used to achieve O(logn) time with n processors [16, 42J.
Alternative approaches to cascading have been proposed for some of the above problems;
for example, see [28, 113, 129] and also the elega.nt parallel hiererchical approach of Dadoun
and Kirkpatrick, which is discussed nest.
4.6 Geometric Hierarchies
This paradigm has proved extremely useful and general in computational geometry. both
sequential [85,62, 63, 64J and parallel [51, 52]. Generally speaking, the method consists of
building a sequence of descriptions of the geometric object under consideration, where an
element of the sequence is simpler and smaller (by a constant factor) than its predecessor,
and yet "close" enough that information about it can be used to obtain in constant time
information about the predecessor. This "information" could be, for example, the location
of a query point in the subdivision, assuming the elements of the sequence are progressively
simpler subdivisions of the plane (in that case pointers exist between faces of a subdivision
and those of its predecessor - these pointers are part of the data structure representing
the sequence of subdivisions). The technlque turns out to be useful for other models than
the PRAM (see Subsection 5.2).
13
4.7 Brent% Theorem
This technique is irequently used to reduce the processor complexity without any increase
in the time complexity.
Theorem 1 (Brent) Any synchronous parallel algorithm taking time T that consists of a
total oJ W operations can be simulated by P processors in time O((W/P) + 2').
There are actually two qualifications to the above Brent's theorem [34] before one can
apply it to a PRAM: (i) at the beginning of the i-th parallel step, we must be able to compute
the amount of work W; done by that step, in time O(Wi/P) and with P processors, and
(ii) we must know how to assign each processor to its task. Both (i) and (ii) are generally
(but not always) easily satisfied in parallel geometric algorithms, so that the hard part is
usually achieving W operations in time T .
4.8 FkomCREW t o EREW
In order to turn a CREW dgori thm into an EREW one, one needs to get rid of the read
conflicts, the simultaneous reading irom the same memory cell by many processors. Such
read conflicts orten occur in the conquer stage, and can take the form of concurrent searching
of a data structure by many processors (see, e.g., [15]). To avoid read conflicts during such
concurrent searching, the scheme of [log] can be helpful:
Lemma 4.1 (Paul, Vishkin, Wagener [log]) Suppose T is a 2-3 tree with m leaves, suppose
a,, al, . . . , ak are data items that may or may not be stored in (the leaves of ) T , and suppose
each processor Pi wants to search for aj in T, j = 1, 2, . . . , k. Then in O(log m + log k)
time, the k processors can perIom their respective searches without read conpicts.
Many types of searches can be accommodated by the above lemma. The following tend to
occur in geometric applications:
Type 1: Searching for a particular item in the tree, and
+ Type 2: Searches of the type "find the t-th item starting from item p".
The search tree need not be a 2-3 tree: the requirements for the concurrent searching scheme
of [log] to be applicable are that (i) each node of the tree has O(1) children, and (ii) the
k searches should be "sortable" according to their ranks in the sorted order of the leaves
4.7 Brent's Theorem
This technique is frequently used to reduce the processor complexity without any increase
in the time complexity.
Theorem 1 (Brent) Any synchronous parallel algorithm taking time T that consists of a
total oJ W operations can be simulated by P processors in time 0 ((WIP) +T).
There are actually two qualifications to the a.bove Brent's theorem (34] before one can
ap-ply it to a PRAM; (i) at the beginning of the i-th pa.rallel stept we must be able to compute
the amount of work Wi done by that step, in time o(WilP) and with P processors, and
(li) we must know how to assign each processor to its task. Both (i) and (ll) are generally
(but not always) easily satisfied in parallel geometric algorithms, so that the hard part is
usually achieving W operations in time T.
4.8 From CREW to EREW
In order to tUID a. CREW aJgorithm into a.n EREW one, one needs to get rid of the read
conflicts, the simultaneous reading from the sa.me memory cell by many processors. Such
read conflicts often occur in the conquer stage, and can take the form of concurrent searching
of a data structure by many processors (see, e.g., [15]). To avoid read conflicts during such
concurrent searching, the scheme of [109] can be helpful:
Lemma 4.1 (Paul, Vishkin, Wagener (109]) Suppose T is a 2-3 tree with m leaves, suppose
aI, a2, .. 01 ak are data items that mayor may not be stored in (the leaves of) T, and suppose
each processor Pj wants to search for aj in T, j = I} 2, .0., k. Then in O(log m +log k)
time, the k processors can perform their respective searches without read conflicts.
Many types of searches can be accommodated by the above lemma. The following tend to
occur in geometric applications:
• Type I; Searching for a particular item in the tree, and
• Type 2: Searches of the type "find the t-th item starting from item p".
The sea.rch tree need not be a. 2-3 tree: the requirements for the concurrent searching scheme
of [109] to be applicable are that (i) each node of the tree has 0(1) children, and (ii) the
k searches should be Hsortable" according to their ranks in the sorted order of the lea.ves
14
of the tree. (The scheme of [I091 has other requirements, but they are needed only for the
concurrent insertions and deletions that it can also handle, not for searching.) Requirement
(i) is usually satisfied in geometric applications. Requirement (ii) is also clearly satisfied
for the sea~ches of Type 1. It can be made to be satisfied for searches of Type 2 by sorting
the queries according to the leaf orders of their targets (this requires first doing a search of
Type 1 to determine the leaf order of p).
4.9 Matrix Searching Techniques -
A significant contribution to computational geometry (both sequential and parallel) is the
formulation of many of its problems as searching problems in monotone matrices [5, 31.
Geometric problems amenable to such a formulation include the largest empty rectangle
[GI, various area minimization problems [5] (such as finding a minimum area circumscribing
d-gon of a polygon), perimeter minimization [5] (finding a minimum perimeter triangle
circumscribing a polygon), the layers of maxima problem [5], and rectilinear shortest paths
in the presence of rectangular obstacles [14]. Many more problems are likely to be formdated
as such matrix searching problems in the iuture. We briefly review these matrix searching
formulations next.
4.9.1 Row Minima
An important matrix searching technique for solving geometric problems was introduced by
Aggarwd et al. in [3], where a linear time sequentid solution was also given. The technique,
which we review next, has myriads of applications to geometric and combinatorial problems
[5,31-
Suppose we have an m x n matrix A and we wish to compute the array d A such that,
for every row index T ('I 5 r m), OA(r) is the smallest column index c that minimizes
A(r, c) (that is, among all c's that minimize A(r, c), BA ( T ) is the smallest).' If OA satisfies
the following sorted property:
~ A ( T ) I ~ A ( T + 'I), and if for every submatrix A' of A, BA, also satisfies the sorted property, then matrix A is
said to be totally monotone [5, 31.
Given a t o t d y monotone matrix A, the problem of computing the eA array is known as
that of "computing the row minima" of that matrix [5]. The best EREW-PRAM algorithm
of the tree. (The scheme of [109] has other requirements, but they are needed only for the
concurrent insertions and deletions that it can also handle, not for searching.) ReQ.uirement
(i) is usually satisfied in geometric applications. Requirement (ii) is also clearly satisfied
for the searches of Type 1. It can be made to be satisfied for searches of Type 2 by sorting
the queries according to the leaf orders of their ta.rgets (this requires first doing a search of
Type 1 to determine the lea.f order of pl.
4.9 Matrix Searching Techniques
A significant contribution to computational geometry (both sequential and parallel) is the
formulation of many of its problems as searching problems in monotone matrices [5, 3].
Geometric problems amenable to such a formulation include the largest empty rectangle
[6J, various area minimization problems (5] (such as finding a minimum area circumscribing
d-gon of a polygon), perimeter minimization [5] (finding a minimum. perimeter triangle
circumscribing a polygon), the layers of maxima problem [5], and rectilinear shortest paths
in the presence of rectangular obstades [14]. Many more problems are likely to be formulated
as such matrix searching problems in the future. We briefly review these matrix searching
formulations next.
4.9.1 Row Minima
An important matrix searching technique for solving geometric problems was introduced by
Aggarwal et al. in [3]' where a linear time sequential solution was also given. The technique,
which we review next, has myriads of applications to geometric and combinatorial problems
[5, 3J.
Suppose we have an m x n matrix A and we wish to compute the array (JA such that,
for every row index T (1 ~ r :s m), 8ACr) is the smallest column index c that minimizes
A(r, c) (that is, among all c's that minimize A(r, c), BA(T) is the smallest).. If 8A satisfies
the following sorted property:
and if for every submatrix. A' of A, 9A, also satisfies the sorted property, then matrix A is
said to be totally monotone [5, 3].
Given a totally monotone matrix A, the problem of computing the 8A array is known as
that of "computing the roW minima" of that matrix [5]. The best EREW-PRAM algorithm
15
for this problem runs in O(logn) time and n processors [24] (where m = n). Any improve-
men t in this parallel complexity bound wiU also imply corresponding improvements on the
parallel complexities of the many geometric applications of this problem.
4.9.2 Tube Minima
In what can be viewed as the three-dimensional version of the above row minima problem
[5 ] , one is given an nl x ns x n3 matrix A and one wishes to compute, for every 1 5 i 5 nl
and 1 < j 5 n3, the nl x n3 matrix BA such that OA(i, j) is the smallest index k that
minimizes A(i, k, j ) (that is, among all k's that minimize A(;, k, j ) , BA ( i , j ) is the smallest).
The matrix A is such that BA satisfies the following sorted property:
Furthermore, for any submatrix A' of A, flAt also satisfies the sorted property.
Given such a matrix A, the problem of computing the OA array is called by Aggarwd
and Park [5] "computing the tube minima" of that matrix. Many geometric aplications
of this problem are mentioned in [5]. There are many nongeometric applications to this
pmblem as well. These include parallel string editing Il:I.], constructing Huffmann codes in
parallel [25], and other tree-construction problems. (In [25] the problem was given the name
''multiplying two concave matrices".) The best CREW-PRAM algorithms for this problem
run in O(1ogn) time and n" logn processors [S, 111, and the best CRCW-PRAM algorithm
runs in 0 (Iog log n) time and n2/ log log n processors [I21 (where n = nl = nz = ns). Both
the CREW and the CRCW bounds are easily seen to be optimal.
4.1 0 Randomization
Reif and Sen [113,114,115] have modified and applied to parallel geometric computation the
randomization techniques that had proved their worth in sequential geometric computing
(cf. the work of K. Clarkson, and also Haussler and Welzl, Mulmuley) as well as in areas other
than computational geometry. Recall that a randomized algorithm is one which bases some
of its decisions on the outcomes of coin fiips. Thus for a particular input, there are many
possible executions of a randomized algorithm (which one actually happens depends on the
outcomes of the coin flips). A good randomized algorithm must ensure that the number of
"bad" possible executions (e.g., those that take too long to terminate) is a small fraction of
for this problem runs in O(logn) time and n processors {24] (where m = n). Any improve
ment in this parallel complexity bound will also imply corresponiling improvements on the
parallel complexities of the many geometric applications of this problem.
4.9.2 Tube Minima
In wha.t can be viewed as the three-dimensional version of the above row mlnima problem
[5], one is given an nt X n2 X ns matrix A and one wishes to compute, for every 1 $" i $" nl
and 1 $" j :5 na, the nl X n3 matrix SA such that (}A(i,i) is the sma.l1est index k that
minimizes A(i, k,j) (that is, among all k's that minimize A(i, k,j), 8A(i 1 j) is the smallest).
The matrix A is such that (JA satisfies the following sorted property:
(JA(i,i) 5 (JA(i,j + 1),
8A(i,i) 5 lJA(i + 1,j).
Furthermore, for any submatrix AI of A, 0A' also satisfies the sorted property.
Given such a matrix A, the problem of computing the (}A arra.y is called by Aggarwal
and Park [5] "computing the tube minima.lI of that matrix. Many geometric aplications
of this problem are mentioned in [5]. There are many nongeometrlc applications to this
problem as well. These include parallel string editing [11], constructing Huffmann codes in
parallel [25], and other tree-construction problems. (In [25] the problem was given the name
"multiplying two concave matrices".) The best CREW-PRAM algorithms for this problem
run in O(logn) time and n2/logn processors [5, ill, and the best CRCW-PRAM algorithm
runs in O(loglogn) time and n2/loglogn processors [12] (where n =nt =n2 =n3)' Both
the CREW and the CR.eW bounds are easily seen to be optimal.
4.10 Randomization
Reif and Sen [113, 114,115] have modified and a.pplied to parallel geometric computation the
randomization techniques that had proved their worth in sequential geometric computing
(cf. the work of K. Clarkson, and also Haussler and Welzl, Muhnuley) as well as in areas other
than computational geometry. Recall that a randomized algorithm is one which bases some
of its decisions on the outcomes of coin flips. Thus for a particula.r input, there are many
possible executions of a randomized algorithm (which one actually happens depends on the
outcomes of the coin flips). A good ra.ndomized algorithm must ensure tha.t the number of
"bad" possible executions (e.g., those that take too long to terminate) is a small fraction of
16
all the possible executions. Algorithms that are not randomized are deterministic (although
this adjective is usually omitted when the context does not leave room for confusion). Some
deterministic algorithms (such as the 2-dimension a1 parallel Voronoi diagram algorithm
given in 1911) have efficient expected time behavior for a randomly chosen set of input
points, whereas randomized algorithms make no assumption about the input distribution.
Randomized algorithms have the disadvantage that they might iail, but if the probabil-
ity of failure is made small enough then they can have advantages over deterministic ones:
they are typically very simple (which makes them easy to program and to comprehend),
and the multiplicative constant in their time complexity is usually small. For example, the
algorithms given by Reif and Sen in I1131 have a running time of O(logn) with n proces-
sors, wit18 high probability (i.e., a probability that approaches one for very large n). The
problems they deal with include planar point location and trapezoidal decomposition. The
techniques they use there (and also in [115]) are somewhat reminiscent o i the Flashsort
algorithm of Reif and Valiant [116]. The polling technique of Reif and Sen [114] has yielded
optimal randomized parallel bounds for two problems that continue to frustrate determin-
is tic approaches, namely, the problems of computing the 3-dimensional convex hull and
2-dimensional Voronoi diagram.
4.11 Other PRAM Techniques
There are other techniques that me did not describe in detail because of their somewhat
specializetl nature. One such technique is the "array of trees" parallel data structure,
originally designed in a non-geometric framework [21] but later used in [76] to establish
geometric parallel bounds for such problems as hidden-line elimination, CSG evaluation,
and computing the contour of a collection of rectangles. Another technique is the "stratified
decomposition tree" used in [77] in the parallel solution of visibility and path problems in
polygons.
5 Mesh Techniques
In this section, for convenience, we limit the discussion to 2-dimensional (i.e., 6 x fl meshes, but most of the results and techniques mentioned are known to easily generalize to
higher dimensional meshes as weU. The geometric objects under consideration (e.g., points)
are initially stored in the mesh, one object per processor. Therefore we are implicitly
assuming that the mesh has enough processors to store the problem description - the
aU the possible executions. Algorithms that are not randomized are deterministic (although
this adjective is usually omitted when the context does not leave room for confusion). Some
deterministic algorithms (such as the 2-dimensional parallel Voronoi diagram algorithm
given in (91]) have efficient expected time behavior for a randomly chosen set of input
points, whereas randomized algorithms make no assumption about the input distribution.
Randomized algorithms have the disadvantage that they might fail, but if the probabil
ity of failure is made small enough then they can have advantages over deterministic ones:
they are typically very simple (which makes them easy to program and to comprehend),
and the multiplicative constant in their time complexity is usually small. For example, the
algorithms given by Reif and Sen in {113] have a running time of O(logn) with n proces
sors, with high probability (Le., a probability that approaches one for very large n). The
problems they deal with include planar point location and trapezoidal decomposition. The
techniques they use there (and also in [115]) are somewhat reminiscent of the Flashsort
algorithm of Reif and Valiant (116]. The polling technique of Reif and Sen [114] has yielded
optimal randomized parallel bounds for two problems that continue to frustrate determin·
istic approaches, namely, the problems of computing the 3-dimensional convex hull and
2-dimensional Voronoi diagram.
4.11 Other PRAM Techniques
There are other techniques that we did not describe in detail because of their somewhat
specialized nature. One such technique is the "array of trees" parallel da.ta structure,
originally designed in a non-geometric framework [21] but later used in [76] to establish
geometric pa.rallel bounds for such problems as hidden-line elimination, CSG evaluation,
and computing the contour of a. collection of rectangles. Another technique is the "stratified
decomposition tree" used in [77) in the pataUel solution of visibility and path problems in
polygons.
5 Mesh Techniques
In this section, for convenience, we limit the discussion to 2-dimensional. (i.e., ...rn x J1i)
meshes, but most of the results and techniques mentioned are known to easily generalize to
higher dimensional meshes as well. The geometric objects under consideration (e.g., points)
are initially stored in the mesh, one object per processor. Therefore we are implicitly
assuming that the mesh has enough processors to store the problem description - the
17
important case where the problem size is too large to fit in the mesh, is discussed in the
next section.
Since it is known how to sort n items optimally (i.e., in O ( 4 ) time) on a & x f i mesh, sorting is not a bottleneck when trying to design O(+) time solutions to geometric
p~oblems on the mesh (contrast this with the situation for the hypercube, a network in
which the complexity of sorting is still unknown). In fact many of the classicdl problems
of computational geometry have been shown to be solvable on the mesh within the opti-
mal O(& time bound (we mention some of these later). Most of these problems have
an O(n logn) sequential time complexity, and since the mesh time x processoTs product
is proportional to nfi, one might think that the word "optimal" is being abused here.
However, this is not the case: any nontrivial problem on a fi x fi mesh requires R(&
time (since it can take that long for two processors to communicate), and there is usually
no hope of using o(n) processors because of the already mentioned 0 ( 1 ) storage limitation
per processor (it takes Sl(n) space, and hence a(n) processors, just to store the input).
5.1 Mesh Divide and Conquer
Many geometric algorithms on the mesh use some form of divide-and-conquer: the problem
gets partitioned into (e-g.) four pieces of size n/4 each, then each piece is moved into one
of the four quadrants of the mesh where it is solved recursively by the (fi/2) x (,/5/2)
quadrant, after which the answers returned by the four recursive calls are combined to
obtain the overall solution. The "conquer" stage as well as the various bookkeeping steps
usually involve sorting and take O ( f i time. Thus the time recurrence of this scheme
generally ends up being of the form
where c is a constant, which implies T(n) = O(&. An example of this is the convex hull
algorithm of [loo] :
1. If n is small (say, n _< 4) then solve the problem directly by brute force, otherwise
proceed to Step 2 below.
2. Sort the n points whose convex hull we seek by x coordinates. Put those with the
smallest n/4 x-coordinates in one of the four quadrants, those with the next n/4
smallest x-coordinates into another quadrant, etc. In fact the sorting itself can be
important case where the problem size is too large to fit in the mesh, is discussed in the
next section.
Since it is known how to sort n items optimally (Le., in O(y'n) time) on a -Iii. X .;nmesh, sorting is not a bottleneck when trying to design D(..;n) time solutions to geometric
problems on the mesh (contrast this with the situation fOT the hypercube, a network in
which the complexity of sorting is still unknown). In fact many of the classical problems
of computa.tional geometry have been shown to be solvable on the mesh within the opti
mal O(Jn) time bound (we mention some of these later). Most of these problems have
an O(n 10gn) sequential time complexity, and since the mesh time X processors product
is proportional to n..,fii, one might think that the word lloptimaP' is being abused here.
However, this is not the case: any nontrivial problem on a ...;n X ..;n mesh requires fi(y'n)
time (since it can take that long for two processors to communicate), and there is usually
no hope of using o(n) processors because of the already mentioned 0(1) storage limitation
per processor (it takes n(n) space, and hence n(n) processors, just to store the input).
5.1 Mesh Divide and Conquer
Many geometric algorithms on the mesh use some fonn of divide-and-conquer: the problem
gets partitioned into (e.g.) four pieces of size n/4 each, then each piece is moved into one
of the fOUT quadrants of the mesh where it is solved recursively by the (1ii/2) X (..j'ii/2)
quadrant, after which the answers returned by the four recursive calls are combined to
obtain the overall solution. The "conquer~1 sta.ge as well as the various bookkeeping steps
usually involve sorting and take O(y'n) time. Thus the time recurrence of this scheme
generally ends up being of the form
T(n) = T(n/4) + cvn,where c is a constant, which implies T(n) =O(Vi). An example of this is the convex hull
algorithm of [100]:
1. If n is small (say, n 5 4) then solve the problem directly by brute force, otherwise
proceed to Step 2 below.
2. Sort the n points whose convex hull we seek by x coordinates. Put those with the
smallest n/4 x-coordinates in one of the four quadrants, those with the next n/4
smallest ::t:-coordinates into another quadrant, etc. In fact the sorting itself can be
18
done so that each quadrant automatically contains the appropriate n/4 points, i.e.,
no separate data movement is needed other than sorting (see [I001 for details).
3. Recursively solve the problem for each of the four quadrants.
4. Combine the solutions returned by the four recursive calls into the hull of the whole
point set. This involves finding the common tangents betweens pairs of disjoint convex
polygons in O(m time.
The nontrivial part is usually the L'combine" part (i-e., Step 4 in the above example).
The data movement techniques of [I057 often play a roIe in that stage, and sometimes the
tree computation technique of [22] is needed (e.g., in [82] and [23]).
5.2 Multisearching
The lollowing problem is oiten the bottleneck in the parallel solution of geometric problems
on a network of processors. It is a generalization of the problem described in Subsection
4.8: given a search strkcture modeled as a graph G with n constant-degree nodes, and given
O(n) search processes on that structure, the muftisearch problem is that of performing as
fast as possible all of the search processes on that structme. The searches need not be
processed in any particular order, and can simultaneously be processed in parallel by using,
for example, one processor for each. However, the path that a search query wiU trace in G
is not known ahead of time, and must instead be determined "on-line": only when a search
query is a t (say) node u o i G can it determine which node of G it should visit next (it does
so by comparing its own search key to the information stored a t v - the nature of tbis
information and of the comparison performed depend on the specific problem being solved).
The multisearch problem is a usefd abstraction that can be used to solve many prob-
lems (more on this later). It is a challenging problem both for EREW-PRAMS and for
networks of processors, since many searches might want to visit a single node of G, creating
a 'Lcongestion" problem (with the added complication that one cannot even tally ahead of
time how much congestion will occur at a node, since one does not know ahead of time the
iull search paths, only the nodes of G at which they start). When the parallel model used to
solve the problem is a network of processors, the graph G is initially stored in the network
in the natural way, with each processor containing one node of G and that node's adjacency
list. I t is important to keep in mind that the computational network's topology is not the
same as the search structure G, so that a neighbour of node v in G need not be stored in a
done so that each quadrant automatically contains the appropriate n/4 points , i.e.,
no separate data movement is needed other than sorting (see [100) for details).
3. Recursively solve the problem for each of the four quadrants.
4. Combine the solutions returned by the four recursive calls into the hull of the whole
point set. This involves finding the common tangents betweens pairs of disjoint convex
polygons in O(J1i) time.
The nontrivial part is usually the "combine" part (Le., Step 4 in the above example).
The data movement techniques of [105J often playa role in that stage, and sometimes the
tree computation technique of [22] is needed (e.g., in [82] and [23]).
5.2 Multisearching
The following problem is often the bottleneck in the parallel solution of geometric problems
on a network of processors. It is a. generalization of the problem described in Subsection
4.8: given a search structure modeled as a graph G with n constant-degree nodes, and given
O(n) search processes on that structure, the multisearch problem is that of performing as
fast as possible all of the search processes on that structure. The searches need not be
processed in any particular order, and Can simultaneously be processed in parallel by using,
for example, one processor for each. However, the path that a search query wiD trace in G
is not known ahead of time, and must instead be determined "on-line": only when a search
query is at (say) node 11 of G can it determine which node of G it should visit next (it does
so by comparing its own search key to the information stored at 11 - the nature of this
informa.tion and of the comparison performed depend on the specific problem being solved).
The multisearch problem is a useful abstraction that can be used tosolvemanyprob
lems (more on this later). It is a challenging problem both for EREW·PRAMs and for
networks of processors, since many sea.rches might want to visit a single node of G, creating
a "congestion" problem (with the added complication that one cannot even tally ahead of
time how much congestion will occur at a. node, since one does not know ahead of time the
full search paths, only the nodes of G at which they start). When the parallel model used to
solve the problem is a network of processors, the graph G is initially stored in the network
in the natural way, with each processor containing one node of G a.nd that node's adjacency
list. It is important to keep in mind that the computational network's topology is not the
same as the search structure G, 50 that a neighbour of node v in G need not be stored in a.
19
processor adjacent to the one containing v . Each processor also contains initially (at most)
one of the search queries to be processed (in which case that search does not necessarily
start at the node of G stored in that processor).
In the EREW-PRAM, the difficulty comes from the "exclusive read" restriction of the
model: if k processes were to simultaneously access node v's information, the k processors
assigned to these k search processes are apparently unable to simultaneously access v's in-
formation. We have already mentioned, in Lemma 4.1, an elegant way around this problem,
designed by Paul, Vishkin and Wagener [log] for the case where G is a 2-3 tree (although
they assume a linear ordering on the search keys, something whi& usually does not hold in
a geometric framework involving mu1 tidimensional search keys).
The rnultisearch problem is even more challenging for networks of processors. In such
models, data is not stored in a shared memory, but is distributed over a network and requires
considerable time to be permuted to allow different processors access t o different dataitems.
Furthermore, each tnemory location can be accessed by only O(1) query processes a t a time,
since a processor containing (say) node v's information would be unable to simultaneously
store more than a constant number of search queries.
In [125] the rnultisearch problem is solved O ( f i f r&) time on a. f i x Jii mesh-
connected computer, where r is the length of the longest search path associated with a
query. For most geometric data structures, the search path traversed when answering a
query has length T = O(logn), and hence the time complexity is O ( 6 ) time, which is
asymptotically optimal. The classes of graphs for which this result holds contain most of
the important cases of G that arise in practice, ranging from simple trees to the powerful
Kirkpatrick hierarchical search DAG [85] that is so important in both sequential and par-
allel computational geometry (see Subsection 4.6). Applications include interval trees and
the retated mu1 tiple interval in torsection search, as well as hierarchical representations of
polyhedra and i ts many applications including lines-polyhedron intersection queries, mul-
tiple tangent plane determination, threedimensional convex hull and intersecting convex
polyhedra.
A special case of the multisearching problem for hypercube multiprocessors was studied
processor adjacent to the one containing v. Each processor also contains initially (at most)
one of the search queries to be processed (in which case that search does not necessarily
start at the node of G stored in that processor).
In the EREW-PRAM, the difficulty comes from the "exclusive read" restriction of the
model: if k processes were to simultaneously access node l1'S information, the k processors
assigned to these k search processes are appa.rently unable to simultaneously access v's in
formation. We have already mentioned, in Lemma 4.1, an elega.nt way around this problem,
designed by Paul, Vishkin and Wagener [109] for the case where G is a 2-3 tree (although
they assume a linear ordering on the search keys, something which usually does not hold in
a geometric framework involving multidimensional search keys).
The multisearch problem is even mOTe challenging for networks of processors. [n such
models, data is not stored in a shared memory, but is distributed over a network and requires
considerable time to be permuted to allow different processors access to different data items.
Furthermore, each memory location can be accessed by only 0(1) query processes at a time,
since a. processor containing (say) node v's information would be unable to simultaneously
store more than a. constant number of search queries.
In [125] the multisearch problem is solved O(..fii + T 1&) time on a .;n x Vii mesh
connected computer, where T is the length of the longest search path associated with a
query. For most geometric data structures, the search path traversed when answering a.
query has length T = O(1ogn), and hence the time complexity is O(vn) time, which is
asymptotically optimal. The classes of graphs for which this result holds contain most of
the important cases of G that arise in practice, ranging from simple trees to the powerful
Kirkpatrick hierarchical search DAG [85] that is so important in both sequential. and par·
allel computational geometry (see Subsection 4.6). Applications include interval trees and
the related multiple interval intersection search, as well as hierarchical representations of
polyhedra and its many applications including lines-polyhedron intersection queries, mul
tiple tangent plane determination, three-dimensional convex hull and intersecting convex
polyhedra.
A special case of the multisearching problem for hypercube multiprocessors was studied
in [59].
20
5.3 Mesh Prune and Search
Some mesh algorithms use the parallel equivdent of what has been called, in sequential
computation, the "prune and search" paradigm [92]. This paradigm consists of throwing
away a subset of the input (after determining that it does not contribute to the answer)
and then recursively searching the surviving portion of the input. The portion of the
input thrown away is a fixed fraction of the input (i.e., a subset of size cn of an input
of size n, where c is a positive constant). Mesh implementations of this idea have the
intriguing feature of advantageously keeping many of the processors idle during much of
the computation. This is because, after doing the "pruning" {= decreasing problem size by
a constant factor), the resulting (smder) problem is compressed into a s m d e r submesh
of the original mesh, where it is recursively solved while the processors not in this smaller
submesh remain idle.
Mesh algorithms might involve a sequence of many recursive calls (occurring after one
another rather than in parallel) and still run in O(&) time. So long as these successive
recursive calls are on problems of sizes cln,czn,. . ., ckn where k a s well as the c;'s are
constauts and 6 f + . . . + 6 < 1, the time complexity is O(&) (assuming that
setting up each recursive call is done in O(m time, and that the other bookkeeping and
combining of subsolutions also takes O ( f i time). As an example, see the algorithm in
[loo] for computing the closest pair among a set of n planar points.
The parallel version of the prune and search technique has been far more useful for the
mesh than ior the PRAM, because in the mesh we can afford to prune in O(&) time and
still end up with an optimal algorithm, whereas in the PRAM model the technique typically
yields superlogarithmic time bounds ([61] is one of the few instances where it was used for
a PRAM geometric algorithm, and that was for the CRCW madel).
5.4 Some Known Bounds and Open Problems for the Mesh
We now mention some problems for which O(& time mesh algorithms are known, as well
as some open problems lor the mesh.
The following problems have known O ( f i time solutions on the mesh (the list is not
exhaustive).
Convex hull and all nearest neighbour problems for planar point; sets [100].
Voronoi diagram of a planar set of n points [82]. This remained an open problem for
5.3 Mesh Prune and Search
Some mesh algorithms use the parallel equivalent of what has been called, in sequential
computation, the "prune and search" paradigm [92]. This paradigm consists of throwing
away a subset of the input (after determining that it does not contribute to the answer)
and then recursively searching the surviving portion of the input. The portion of the
input thrown away is a fixed fraction of the input (i.e., a subset of size cn of an input
of size n, where c is a positive constant). Mesh implementations of this idea have the
intriguing feature of advantageously keeping ma.ny of the processors idle during much of
the computation. This is because, after doing the "pruninglJ (= decreasing problem size by
a. constant factor), the resulting (smaller) problem is compressed into a smaller submesh
of the original mesh, where it is recursively solved while the processors not in this smaller
submesh remain idle.
Mesh algorithms might involve a sequence of ma.ny recursive calls (occurring after one
another rather than in parallel) and still run in O( J7i) time. So long as these successive
recursive calls ate on problems of sizes cln,c2n•••. , Ckn where k as well as the Ci'S a.Te
constants and VC1 + VC2 +... + ...jCk < 1, the time complexity is O(.Jii') (assuming that
setting up each recursive call is done in D(-In) time, and that the other bookkeeping and
combining of subsolutions also takes D(.fii) time). As an example, see the algorithm in
[100] for computing the closest pair among a set of n planar points.
The parallel version of the prune and search technique has been far more useful for the
mesb tha.n for the PRAM, because in the mesh we can afford to prune in O(J7i) time and
still end up with an optimal algorithm, whereas in the PRAM model the technique typically
yields superlogarithmic time bounds ([61] is one of the few instances where it was used for
a PRAM geometric algorithm, and that was for the CReW model).
5.4 Some Known Bounds and Open Problems for the Mesh
We now mention some problems for which O(Vfi) time mesh algorithms are known, as well
as some open problems for the mesh.
The following problems have known O(Vii) time solutions on the mesh (the list is not
exhaustive).
• Convex hull and all nearest neighbour problems for pla.nar point sets [l00].
• Voronoi diagram of a planar set of n points [82]. This remained a.n open problem for
21
a while, until Jeong and Lee gave their elegant algorithm achieving an optimal time
bound.
Minimum distance spanning tree for planar point sets. This follows irom the above-
mentioned Voronoi diagram result of Jeong and Lee, and the fact that a minimum
spanning tree 01 an e-edge undirected graph can be computed in O(&) time on a
fi x & mesh [112].
Trapezoidal decomposition oi a set of n (possibly intersecting) segments [82]. Note
that visibility is a special case of trapezoidal decomposition.
Polygon triangulation. This follows irom the above-mentioned trapezoidal decompo-
sition result of Jeong and Lee, and the fact that polygon triangulation can be solved
by two c d s to the trapezoidal decomposition procedure [130].
Topologica~ sorting of nonintersecting line segments. This follolvs from [23] and the
above-men tioned trapezoidal decomposition result.
The area of the union of iso-oriented rectangles [loo].
r Intersection detection between n planar line segments [82, 1001.
r Computing the largest empty rectangle [53]. This is the problem of computing the
largest-area iso-oriented rectangle that is constrained to lie in a given iso-oriented
rectangular region and not to contain any of n given points.
3-dimensional convex hull, computing the intersection of two 3-dimensional convex
polyhedra [125, 80, 931.
0 t her geometric problems considered in the literature include the computation of robot
configuration space (551, visibility and separability [54], ECDF searching [60], multipoint
and planar point location [82], and others.
The following problems remain open on the mesh, in the sense that no 0(m time
algorithm on a f i x f i mesh is known for them.
Convex layers in the plane. (See the end of Subsection 4.1 for a definition of this
problem.)
a. while, until Jeong and Lee gave their elegant algorithm achieving an optimal time
bound.
• Minimum distance spanning tree for plana.r point sets. This follows from the above
mentioned VOTonoi diagram result of Jeong and Lee, and the fa.ct that a minimum
spanning tree of a.n e-edge undirected graph can be computed in O(..;e) time on a
ve x ..;e mesh [112J.
• Trapezoidal decomposition of a set of n (possibly intersecting) segments [82]. Note
that visibility is a special case of trapezoidal decomposition.
• Polygon triangulation. This follows from the above-mentioned trapezoidal decompo.
sition result of Jeong and Lee, and the fact that polygon triangulation can be solved
by two calls to the trapezoidal decomposition procedure [130].
• Topological sorting of nonintersecting line segments. This follows from [23] and the
above-mentioned trapezoidal decomposition result.
• The area of the union of iso-oriented rectangles [100].
• Intersection detection between n planar line segments [82, 100].
• Computing the largest empty rectangle [53]. This is the problem of computing the
largest-area iso-oriented recta.ngle that is constrained to lie in a given iso-oriented
rectangular region and not to contain any of n given points.
• 3-dimensional convex hull. computing the intersection of two 3-dimensional convex
polyhedra [125, SOt 93].
Other geometric problems considered in the literature include the computation of robot
configuration space [55), visibility and separability [54], ECDF searching [60]t multipoint
a.nd planar point location [82), and others.
The following problems remain open on the mesh t in the sense that no O(J1i) time
algorithm on a Vii x Vii mesh is known for them.
• Convex layers in the plane. (See the end of Subsection 4.1 for a definition of this
problem.)
22
The layers of maxima in the plane. This is defined in a similar way to convex layers,
I~ut with the words "convex hull" replaced by "maximal elements".
The mast interesting open geometric problems on the mesh are in the hybrid model
described in the next section, and will be mentioned there.
Another framework in which geometric problems have been considered on the mesh is
that in which the input geometric figure is a bina~y image stored in the mesh in the natural
way (the (i, j)th pixel is stored in the processor at row i and column j). The techniques
needed in this image processing framework can be quite different from those we mentioned
above and are not within the scope of this survey (see, for example, [101, 56)).
6 A Hybrid Model: The RAM/ARRAY
The main justification for the hybrid model that is the subject of this section, is that many
existing parallel machines have a "front end" that is a conventional sequential computer,
and that the number of processors in the parde l machine itself is typically the fixed number
purchased rather than a function of the problem size n.
Suppose we have a parallel machine (like a d-dimensional mesh-connected array of p
processors) that can solve a problem of size p in time ~ ( ~ ' l ~ ) (this includes the time to
input the data to the array as well as the actual computation time, a standard assump-
tion in the literature of mesh-connected arrays, and certainly a reasonable one for the case
d = 1). Suppose such a mesh-connected array of processors is attached to a conventional
random access machine (RAM) that wishes to solve a problem of size n > p. We cad such
a machine a RGM/ARRAY(d). It is important to realize that the mesh alone cannot even
store the description of the geometricr problem, because of the limitation that each proces-
sor has 0 (1) storage registers, and hence the sequentid "front end" must play a role in the
solution process. If the problem's sequential time complexity is, say, O(nlogn), then the
mesh gives a factor of s ( p ) = pl-lldlogp speedup lor a problem of size p. However, if the
RAM/ARRAY(d) is trying to solve a problem of size n, n > p, then it is not clear how
it should use the mesh to achieve the factor of s(p) speedup and obtain O(nlogn/s(p))
time performance. Actually, it is not even clear whether maintaining the s ( p ) speedup is
at aU possible. Identifying the problems for which this optimal O(nlog n/s(p)) t' ime can
be achieved is an interesting question that was originally posed, for sorting in the case
d = 1, by Mueller [I041 who also gave a partial solution. The question has been answered
• The la.yers of maxima in the plane. This is defined in a. similar way to convex layers t
but with the words "convex hullu replaced by uma.ximal elements".
The most interesting open geometric problems on the mesh are in the hybrid model
described in the next section, and will be mentioned tnere.
Another framework in which geometric problems have been considered on the mesh is
that in which the input geometric figure is a binary image stored in the mesh in the natural
way (the (i, j)th pixel is stored in the processor at row i and column j). The techniques
needed in this image processing framework can be quite different from those we mentioned
above and are not within the scope of this survey (see, for example, [101,56)).
6 A Hybrid Model: The RAM/ARRAY
The main justification for the hybrid model that is the subject of this section, is that many
existing parallel machines have a tlfrant end" that is a conventional sequential computer t
and that the number of processors in the parallel machine itself is typically the fixed number
purchased rather than a function of the problem size n.
Suppose we have a pa.rallel machine (like a. d-wmensional mesh-connected array of p
processors) that ca.n solve a problem of size p in time O(pl/d) (this includes the time to
input the data to the arra.y as well as the actual computation time, a standard assump
tion in the literature of mesh-connected arra.ys, and certainly a reasonable one for the case
d = 1). Suppose such a mesh-connected array of processors is attached to a conventional
random access machine (RAM) that wishes to solve a problem of size n > p. We call such
a machine a RAM/ARRAY(d). It is important to realize that the mesh alone cannot even
store the description of the geometrio problem, because of the limitation that each proces
sor has 0(1) storage registers, and hence the sequential "front end" must playa role in the
solution process. IT the problem's sequential time complexity is, say, 8(nlogn), then the
mesh gives a. factor of s(p) = pl-l/dlogp speedup for a problem of size p. However, if the
RAMIARRAY(d) is trying to soJve a problem of size n, n > p, then it is not clear how
it should use the mesh to achieve the factor of s(p) speedup and obtain O(nlognjs(p))
time performance. Actually, It is not even clear whether maintaining the s(p) speedup is
a.t all possible. Identifying the problems for which this optimal. O(nlognjs(p» time can
be achieved js an interesting question tha.t was originally posed, for sorting in the case
d = 1, by Mueller [1041 who also gave a partial solution. The question has been aDswered
23
in the affirmative in [17, 271. This result immediately implies an affirmative answer on a
RAM/ARRAY(l) for the geometric problems that can be solved in Linear time after a pre-
processing sorting step, like the planar convex hull and maximal elements problems. The
O(n log n/s(p)) time bound can also be achieved on a RAM/ARRAY(l) for the foUowing
geometric problems [26]: all nearest neighbors of a planar set of points, the measure and
perimeter of a union of rectangles, the visibility of a set of non-intersecting line segments
from a point. 3-dimensional maxima, dominance counting between two sets of points (and
hence the related problem of counting intersections bet ween rectilinear rectangles). Essen-
t i d y the same method as for the RAM/ARRAY(l) establishes that all these problems can
be solved in O(n logn/s(p)) on a RAM/ARRAY(d), with s ( p ) = pl-lldlogp [26].
We illustrate the technique for the case d = 1 and for geometric problems whose se-
quential time complexity is O(?r log n), i-e., when the task is to design O(n log n/ logp) time
algorithms on a RAM/ARRAY(l). In that case the algorithm usually follows the pway
divide-and-conquer paradigm (there is an alternative method, using a 'lazy B-tree" ap-
proach [17], which we do not discuss). That is, the algorithm divides the problem into p
subproblems. Then it recursively solves each of the p subproblems, one after the other.
After the p recursive calls return, it combines the subsolutions to form the final solution.
The main difficulty is how to perform the combining step in O ( n ) time. If the combining
step can be performed in O(n) time, then the overall time complexity T(n) satisfies the
recurrence T(n) = p . T(n/p) + O(n) , which implies that T(n) is O(nlogn/ logp). In the
case of a RAM/ARRAY(d) where d > 1, instead of pdrtitioning the problem into p sub.
problems, the problem gets partitioned into pllfd+') subproblems. In that case the p'l(d+l)
subsolutions must be "combined" in ~ ( n / ~ ' - l l ~ ) time.
The following result from sequential computation, due to F'rederickson and Johnson [69],
is often useful in the RAM/ARRAY(d) framework. Given an a x b matrix (b 5 a) whose
columns are sorted, the kth smallest element can be selected in time O(b f nzlog(k/m)),
where m = min{k, b), if the matrix is already in the memory, or if any element of the matrix
can be produced in constant time. This implies that the bth element can be selected from
the matrix in O(b) time. This selection algorithm has been used in one of the two schemes
given in (171 to establish the optimal sorting algorithm for this model, and it turned out to
be a crucial tool for many geometric problems [26].
The question of whether the speedup of s ( p ) , that the d-dimensional array makes possible
for a problem of size p, can be carried over to larger problems is really dealing with the
in the affirmative in [17, 27]. Tills resul~ immediately implies an affirmative answer on a
RAM/ ARRAY( 1) for the geometric problems that can be solved in linear time after a pre
processing sorting step, like the planar convex hull and maximal elements problems. The
O(nlogn/s(p)) time bound can also be achieved on a RAM/ARRAY(I) for the following
geometric problems [26]; all nearest neighbors of a planar set of points, the measure and
perimeter of a union of rectangles, the visibility of a set of non-intersecting tine segments
from a. point. 3-dimensional maxima, dominance counting between two sets of points (and
hence the related problem of counting intersections between rectilinear rectangles). Essen
tially the same method as for the RAM/ARRAY(l) establishes that all these problems can
be solved in O(nlogn/s(p») on a RAM/ARRAY(d), with s(p) = pl-l/dlogp [26].
We illustrate the technique for the case d = 1 and for geometric problems whose se
quential time complexity is e(nlogn), i.e., when the task is to design O(nlogn/logp) time
algorithms on a RAM/ARRAY(!). In that case the algorithm usually follows the p-way
divide-and-conquer paradigm (there is an alternative method, using a "lazy B-tree" ap
proach [17], which we do not discuss). That iS l the algorithm divides the problem into p
subproblems. Then it recursively solves each of the p subproblems, one after the other.
After the p recursive calls return, it combines the subsolutions to form the final solution.
The main difficulty is how to perform the combining step in O(n) time. If the combining
step can be performed in O(n) time, then the overall time complexity T(n) satisfies the
recurrence T(n) = p. T(n/p) +O(n), which implies that T(n) is O(nlogn/logp). In the
case of a. RAM/ARRAY(d) where d > 1, instead of partitioning the problem into p sub·
problems, the problem gets partitioned into pl/(d+I) subproblems. In that case the p1/(d+I)
subsolutions must be "combined" in O(n/pl-I/d) time.
The following result from sequential computation, due to Frederickson and Johnson [69],
is often useful in the RAM/ARRAY(d) framework. Given an a x b matrix (b ~ a) whose
columns are sorted, the kth smallest element can be selected in time O(b +mlog(k/m»,
where m =min{k, b}, if the matrix is already in the memory, or if any element of the ma.trix
ca.n be produced in constant time. This implies that the 6th element can be selected from
the matrix in O(b) time. This selection algorithm has been used in one of the two schemes
given in [17] to establish the optimal sorting algorithm for this model, and it turned out to
be a crucial tool for many geometric problems [26].
The question of whether the speedup of s(p), that the d-dimensional arra.y makes possible
for a. problem of size p, can be carried over to larger problems is really dealing with the
24
fundamental issue of the parallel-decomposability of the problem at hand: given that a
problem of size p can be solved on a parallel machine faster by a factor 'of (say) s(p) than
on a RAM alone, then that problem i s fully parallel-decomposable if a RAM to which the
parallel machine is attached can solve arbitrarily large instances of that problem with a
speedup of s(p) when compared to a RAM done. Although it is known that for some
geometric problems the speedup of s(p) for a problem of size p can indeed be translated
into a speedup of also s(p) for problems of size n, n > p, this question remains open for
many other classical geometric problems, such as:
Topolagical sorting of nonintersecting line segments.
r Trapezoidal decomposition. However, if the nonintersecting line segments sl, s2,. . . , s, are given in topologically sorted order, then it is known how to solve it in O(n1og n/s(p))
time on a RAM/ARRAY(d) [26]. What makes the problem easier in that case is the
fact that, if one partitions the problem into p equal-sized subproblems according to
their topologicaI order, then the "interaction" between subproblems is encapsulated
by their visibilities from a point at infinity. In particular, it is known for the case
when the line segments are horizontal because sorting them by y coordinates is like
sorting them topologically.
r Voronoi diagram of a planar point set.
a 3-dimensional convex hull, computing the intersection of two 3-dimensional convex
polyhedra.
Negative results would also be interesting: which problems are inherently such that it
is impossible to maintain the same speedup for n > p as for n = p ?
The techniques developed for RAM/ARRAY(d)s have also been used in [I241 to achieve
linear speedups on several hypercube-related computers which consist of p processors each
containing O(n/p) local memory, provided that n > for some constant 6 > 0. The
same speedup is known for sorting [4, 501.
Finally, there are close connections between the work on parallel-decomposability and
the work on 1/0 complexity (7, 811. In the study of 1/0 complexity, one is given a sequen-
tial computer which has a srnaU main memory and a large secondary storage, and one is
interested in solving problems of arbitrarily Iarge size. Tlie input of the problem is initially
stored in the secondary storage and the output has to be written to the secondary storage.
fundamental issue of the parallel-decomposability of the problem at hand: given that a
problem of size p can be solved on a parallel machine faster by a factor 'of (sa.y) s(p) than
on a RAM alone, then that problem is fully parallel-decomposable if a RAM to which the
parallel machine is attached can solve arbitrarily large instances of that problem with a.
speedup of s(p) when compared to a RAM alone. Although it is known that for some
geometric problems the speedup of s(p) for a problem of size p can indeed be translated
into a speedup of also s(p) for problems of size n, n > P, this question remains open for
many other classical geometric problems, such as:
• Topological sorting of nonintersecting line segments.
• Trapezoidal decomposition. However, if the nonintersecting line segments 81,52, •.• I Sn
are given in topologically sorted order, then it is known how to solve itin O(nlogn/s(p»
time on a RAM/ARRAY(d) [26]. What makes the problem easier in that case is the
fa.ct that, if one partitions the problem into p equal-sized subproblems according to
their topological order, then the "interaction" between subproblems is encapsulated
by their visibilities from a point at infinity. In particular, it is known for the case
when the line segments are horizontal because sorting them by y coordinates is like
sorting them topologically.
• Voronoi diagram of a planar point set.
• 3-dimensional convex hull, computing the intersection of two 3-dimensional convex
polyhedra.
Negative results would also be interesting: which problems are inherently such tha.t it
is impossible to maintain the same speedup for n > p as for n = p ?
The techniques developed for RAM/ARRAY(d)s have also been used in [124] to achieve
linear speedups on several hypercube-related computers which consist of p processors each
containing Oen/p) local memory, provided that n > pl+e: for some constant E > O. The
same speedup is known for sorting [4, 5ll].
Finally, there are close connections between the work on parallel-decomposability and
the work on I/O complexity [7, 81]. In the study of I/O complexity, one is given a sequen
tial computer which has a small main memory and a large secondary storage, and one is
interested in solving problems of arbitrarily large size. The input of the problem is initially
stored in the seconda,y storage and the output has to be written to the secondary storage.
25
The limitation that the size of the main memory is small, is similar to the limitation that
the size of the attached parallel machine is small. The major concern in the study of I/O
complexity is to minimize the amount ofI/O between the main memory and the secondary
storage. To achieve the best I/O performance, the algorithm is allowed arbitrarily long
computation times for scheduling the 110s (i.e., only the amount of 110 matters). On the
other hand, the time to decompose the computation into subcomputations and to schedule
the sub compu t ations must be counted in the study of parallel-decomposability. The tech-
niques developed for the study of geometric parallel-decomposability can be used to obtain
I/ O complexity bounds for the geometric problem considered [124].
7 Experimental Work
Much of the work in parallel computational geometry has been theoretical in nature, but
some researchers have implemented geometric algorithms on various parallel architectures
and reported interesting results.
Guy Blelloch [30, 3 11 has implemented parallel geometric algorithms on the Connection
Machine (Chill, including convex hull (the 6-divide-and-conquer method we mentioned
earlier). BleUoch argued that in the CM architecture, scan operations (essentially, parallel
prefix) are implemented so efficiently that one should solve problems on the CM architecture
by using, whenever possible, calls to these built-in routines. In fact he went as far as
assuming the cost of a parallel prefix to be 0(1), and gave a detailed study of the implications
of such an assumption on solving various problems. The experimental data obtained by
Blelloch and by other researchers seems to confirm that Blelloch's assumption is quite
reasonable.
Cohen, Miller, Sarraf and Stout have implemented parallel geometric algorithms on
hypercube architectures like the iPSC, including convex hulls and domination [40], and
convex hulls of digitized pictures [97].
The above-mentioned experimental work demonstrates, among other things, that algo-
rithmic ideas developed for abstract parallel models can be usefuI when programming "real"
parallel machines.
Generally speaking, work in parallel computational geometry continues to be mostly
theoretical, with experimental work being the exception rather than the rule. Perhaps this
'"Connection Machine" and 'CMn are registered trademarks of Thinking Machines Corporation.
The limitation that the size of the main memory is small, is similar to the limitation that
the size of the attached paraliel machine is smaU. The major concern in the study of I/O
complexity is to minimize the amount of I/O between the main memory and the secondary
storage. To achieve the best I/O performance, the algorithm is allowed arbitrarily long
computation times for scheduling the l/Os (Le., only the amount of I/O matters). On the
other hand t the time to decompose the computation into subcomputations and to schedule
the subcomputations must be counted in the study of parallel-decomposability. The tech
niques developed for the study of geometric parallel-decomposability can be used to obtain
I/O complexity bounds for the geometric problem considered [124].
7 Experimental Work
Much of the work in parallel computational geometry has been theoretical in nature, but
some researchers have implemented geometric algorithms on various parallel architectures
and reported interesting results.
Guy Blelloch [30,31] has implemented parallel geometric algorithms on the Connection
Machine (CM?, including convex hull (the y'n-divide-and-conquer method we mentioned
earlier). Blelloch argued that in the eM architecture, scan operations (essentially, pa.ra.Ilel
prefix) are implemented so efficiently that one should solve problems on the eM architecture
by using. whenever possible, calls to these built-in routines. In fact he went as far as
assuming the cost of a parallel prefix to be 0(1), and gave a. detailed study of the implications
of such a.n assumption on solving various problems. The experimental data obtained by
BleUoch and by other researchers seems to confirm that Blelloch's assumption is quite
reasona.ble.
Cohen, Miller, Sarra.f and Stout have implemented parallel geometric algorithms on
hypercube architectures like the iPSC. including convex hulls and domination [40], and
convex hulls of digitized pictures [97].
The above-mentioned experimental work demonstrates, a.mong other things, that algo
rithmic. ideas developed for a.bstract parallel models can be useful when programming "real"
parallel machines.
Generally speaking, work in parallel computational geometry continues to be mostly
theoretical, with experimental work being the exception rather than the rule. Perhaps this
I "Connection Machine" and "eM" are registered trademarks of Thinking Ma.chines Corporation.
26
will change as researchers gain increased access to parallel machines.
8 Further Remarks
In view of the importance of the hypercube, surprisingly few geomet~ic algorithms have
been designed for this parallel model (see [33, 58, 59, 97, 99, 1191 for some of these). We
believe that, once the complexity of such basic operations as sorting and list ranking is
settled for the hypercube model, algorithm design for geometric problems on that model
will probably receive increased attention. An important step in this direction has recently
been taken in the new sorting algorithm of Cypher and Plaxton [49]. One way around the
"sorting bottleneck" for the hypercube would be to take the randomization approach, the
way Reif and Sen did [113] (sorting is then no longer a bottleneck, since there is an optimal
randomized sorting algorithm for the hypercube [116]).
In addition to the open problems in parallel computational geometry that we already
mentioned earlier, the following open problems are likely to receive considerable attention
in the future:
Optimal deterministic PRAM construction of Voronoi diagrams in the plane. The
current best bounds are, in the CREW-PRAM model, O(1og n log log n) time and
n log n/ log log n processors or, alternatively, 0 (Iog2 n) time and n/ log n processors
(see [43]).
Optimal deterministic PRAM construction of 3-dimensional convex hull.
. Optimal EREW-PRAM solution to linear programming in the plane (an algorithm
exists in the CRCW model [61]).
The following are additional promising directions for future research:
a Output-sensitive PRAM algorithms - where the complexity depends on the size of
the output (for example, in [75], the number of processors needed depends on the
number of intersections). Most geometric problems remain open when looked at from
this perspective (even the planar convex hull problem).
a Robust parallel algorithms. Recall that robust algorithms are such that their correct-
ness is not destroyed by roundoff error. Most existing parallel geometric algorithms
misbehave if implemented with rounded arithmetic. There has been recently a flurry
will change as researchers gain increased access to parallel machines.
8 Further Remarks
In view of the importance of the hypercube, surprisingly few geometric algorithms have
been designed for this parallel model (see [33, 58, 59, 97, 99, 119] for some of these). We
believe that, once the complexity of such basic operations as sorting and list ranking is
settled for the hypercube model, algorithm design for geometric problems on that model
will probably receive increased attention. An important step in this direction has recently
been taken in the new sorting algorithm of Cypher and Plaxton [49]. One way around the
"sorting bottleneck" for the hypercube would be to take the randomization approach, the
way Reif and Sen did [113] (sorting is then no longer a bottleneck, since there is an optimal
randomized sorting algorithm for the hypercube [116]).
In addition to the open problems in parallel computational geometry that we already
mentioned earlier, the following open problems are likely to receive considerable attention
in the future:
• Optimal deterministic PRAM construction of Voronoi diagrams in the plane. The
current best bounds are, in the CREW·PRAM model, O(lognloglogn) time and
n log n/log log n processors or, alternatively, 0 (log2 n) time and n/log n processors
(see [43]).
• Optimal deterministic PRAM construction of 3-wmensional convex hull.
• Optimal EREW·PRAM solution to linear progra.mming in the plane (an algorithm
exists in the CReW model [61]).
The following are additional promising directions for future research:
• Output-sensitive PRAM algorithms - where the complexity depends on the size of
the output (for example, in [75], the number of processors needed depends on the
number ofintersections). Most geometric problems remain open when looked at from
this perspective (even the planar convex hull problem).
• Robust parallel algorithms. Recall that robust algorithms are such that their correct·
ness is not destroyed by ro~ndoff error. Most existing parallel geometric algorithms
misbehave if implemented with rounded arithmetic. There has been recently a. flurry
27
of activity in designing efficient and robust sequentid algorithms for geometric prob-
lems (see [96] for a list of references), and we expect this important activity to spread
to the design of parallel geometric algorithms as well.
Acknowledgement. It is a pleasure to acknowledge the helpful comments of Danny Chen
on a earlier draft of this survey.
References
[I] K. Abrahamson, N. Dadoun, D. A. Kirpatrick, and T. Przytycka, L'A Simple Parallel Tree Contraction Algorithm," J . o j Algorilhrns, Vol. 10, 1989, pp. 287-302.
[2] A. Aggarwal, B. Chaaelle, L. Guitas, C. ~ ' ~ l i n l a i n ~ , and C. Yap, "Parallel Computational Geometry," Algo~thmica, Vol. 3, 1988, pp. 293-328.
131 A . Aggarwal, M. M. Klawe, S. Moran, P. Shor and R. Wilber, "Geometric Applications of a Matrix Searching Algorithm," Algoriihrnica, Vol. 2, 1987, pp. 209-233.
[4] A. Aggarwal and M.-D. Huang, "Network Complexity of Sorting and Graph Problems and Simulating CRCW PRAMS by Interconnection Networks," Lecture Notes in Computer Science, 319: VLSI Algoriihrns and Architeclures, 3rd Aegean Workshop on Computing, A WOC 88, Springer Verlag, 1988, pp. 339-350.
[5] A. Aggarwal and 3. Park, "ParalleL Searching in Multidimensional Monotone Arrays," Proc. 29th Annual IEEE Symposium on Foundalions o l Computer Science, 1988, pp. 497-512. (To appear in J. of Algoriihrns.)
[6] A. Aggarwal and S. Suri, "Fast Algorithms for Computing the Largest Empty Rectangle," Prac. 3rd ACM Symp. on Cornpuiniional Geometry, 1987, pp. 278-290.
[7] A. Aggarwal and 3 .S. Vitter, "The Input/Ou tput Complexity of Sorting and Related Problems," Communications of ihe ACM, Vol. 3 1, 1988, pp. 1116-1127.
[8] M. Aj tai, 3. Komlos, and E. Szemeredi, "Sorting in c log n Parallel Steps," Combinatorica, Vol. 3, 1983, pp. 1-19.
[9] S.G. Akl, "A Constant-Time Parallel Algorithm for Computing Convex Hulls," BIT, Vol. 22, 1982, pp. 130-134.
[lo] R. Anderson and G.L. Miller, "Deterministic Parallel List Ranking," Lecture Noles in C.S. 319: 3rd AWOC, Springer Verlag, 1988, pp. 81-90.
Ell.] A. Apostolico, M. J. Atallah, L. Larmore, and R. S. McFaddin, "Efticient ParalleI Algorithms for String Editing and Related Problems," SIAM J. Cornput., Vol. 19, 1990, pp. 968-988.
[12] M.J. Atallah, "A Faster Parallel Algorithm for a Matrix Searching Problem," Pmc. 2d Scan- dinavian Workshop on Algorithm Theory, Springer Verlag, 1990, pp. 192-200. (To appear in Algorifhmica.)
[13] h1.J. Atallah, P. Callahan and M.T. Goodrich, "P-Complete Geometric Problems," Pmc. 2d Annual ACM Symp. on Parallel Algoriiirms and Architectures, Springer Verlag, 1990, pp. 317- 326.
[I41 M. J. Atallah and D. Z. Chen, "Parallel Rectilinear Shortest Paths with Rectangular Obstacles," Proc. 2d Annual ACM Symp. on Parallel Algorithms and Architeclures, Springer Verlag,1990, pp. 270-279.
of activity in designing efficient and robust sequential algorithms for geometric prob
lems (see [96] for a list of references), and we expect this important activity to spread
to the design of parallel geometric algorithms as well.
Acknowledgement. It is a pleasure to acknowledge the helpful comments of Danny Chen
on a earlier draft of Utis survey.
References
[1] K. Abrahamson, N. Dadoun, D. A. Kirpatrick, and T. Przytycka, "A Simple Parallel TreeContraction Algorithm," J. of Algorithms, Vol. 10, 1989, pp. 287-302.
[2] A. Aggarwal, B. Chazelle, L. Guibas, C. 6'Dunlaing, and C. Yap, "Parallel ComputationalGeometry," Algorithmica, Vol. 3, 1988, pp. 293-328.
[3] A. Aggarwal, M. M. Klawe, S. Moran, P. Shor and R. Wilber, "Geometric Applications of aMatrix Searching Algorithm," Algorilhmica, Vol. 2, 1987, pp. 209-233.
[4] A. Aggarwal and M.-D. Huang, "Network Complexity of Sorting and Graph Problems andSimulating CReW PRAMS by Interconnection Networks," Lecture Notes in Computer Science,:J19; VLSI Algorithms and Architetlures, 3rd Aegean Workshop on Computing, AWOC 88,Springer Verlag, 1988, pp. 339-350.
[5] A. Aggarwal and J. Park, "Parallel Searching in Multidimensional Monotone Arrays," Proc.29th Annual IEEE Symposium on Foundations of Computer Science, 1988, pp. 497-512. (Toappear in J. of Algorithms.)
[6] A. Aggarwal and S. Suri, "Fast Algorithms for Computing the Largest Empty Rectangle,"Proc. 9rd ACM Symp. on Computational Geometry, 1987, pp. 278-290.
[7J A. Aggarwal and J.S. Vitter, "The Input/Output Complexity ofSorting and Related Problems,"Communications of the ACM, VoL 31, 1988, pp. 1116-1127.
[8] M. Ajtai, J. Komlos, and E. Szemeredi, "Sorting in clogn Parallel Steps," Com6inatonca, Vol.3, 1983, pp. 1-19.
[9] S.G. Akl, "A Constant-Time Parallel Algorithm for Computing Convex Hulls/' BIT, Vol. 22,1982, pp. 130-134.
[10] R. Anderson and G.L. Miller, "Deterministic Parallel List Ranking," Lecture Notes in C.S. 319:3rd AWOC, Springer Verlag, 1988, pp. 81-90.
[Il] A. Apostolico, M. J. Atallah, L. Larmore, and H. S. McFaddin, "Efficient Parallel Algorithmsfor String Editing and Related Problems," SIAM J. Comput., Vol. 19, 1990, pp. 968-988.
[12] M.J. AtaIlah, "A Faster Parallel Algorithm for a Matrix Searching Problem," Proc. !d Scandinavian Workshop on Algorithm Theory, Springer Verlag, 1990, pp. 192-200. (To appear inAlgonthmica.)
[13] M.J. Atallah, P. Callaha.n and M.T. Goodrich, uP-Complete Geometric Problems." Proc. edAnnual ACM Symp. on Parallel Algoriilims and Architechlres, Springer Verlag, 1990, pp. 317326.
[14] M. J. Atallah and D. Z. Chen, "Parallel Rectilinear Shortest Paths with Rectangular Obstacles,"Proc. £d Annual ACM Symp. on Para.llel Algorithms and Architectures, Springer Verlag,1990,pp. 270-279.
28
[15] M. J. Atallah, D. Z. Cllen and H. Wagener, "An Optimal Parallel Algorithm for the Visibility of a Simple Polygon from a Point," To appear in J A C e a preliminary version appeared in Pmc. 5th Aanuai A CM Symp. orr Compuiaiional Geomelry, Saarbrucken, Federal Republic of Germany, 1989, pp. 114-123.
(161 M. J. Atallah, R. Cole, and M. T. Goodrich, "Cascading Divideand-Conquer: A Technique for Designing Parallel Algorithms," SIAM J. Cornput., \'ol. 18, 1989, pp. 499-532.
(17) M. J . Atallah, G . N. Frederickson, and S. R. Kosaraju. Sorting with Efficient Use of Special- Purpose Sorters. IrrJonnalion Processing Letters, 1988, Vol. 27, pp. 13-15.
[18] M. J. Atallah and M. T. Goodrich, "Efficient Plane Sweeping in Parallel," Prac. 2nd Annual ACM Symp. on Compulalional Geometry, Yorktown Heights, New York, 1986, pp. 216-225.
[19] M. J. Atallah and M. T. Goodrich, "Eficient Parallel Solutions to Some Geometric Problems," J. of Parallel and Distributed Computing, Vol. 3, 1986, pp. 492-507.
[20] M. J. Atallah and M. T. Goodrich, "Parallel Algorithms for Some F'unctions of Two Convex Polygons," Algorifhmica, Vol. 3, 1988, pp. 535-548.
[21] M. J. Atallall, S.R. Kosaraju and M.T. Goodrich, "On the Parallel Complexity of Evaluating Some Sequences of Set Manipulation Operations," Lccture Notes in Cornpuler Science, 319: VLSI Algorithms and Archilectures, 3rd Aegean Workshop on Compuling, A woc 88, Springer- Verlag, 1988, pp. 1-10.
[22] M. J. Atallah and S. E. Hambrusch, "Solving n e e Problems on a Mesh-Connected Processor Array," Injo. and Coalrol, Vol. 69, 1986, pp. 168-187.
[23] M. J. A tallah, S. E. Hambrusch and L. E. TeWinkel, "Parallel Topological Sorting of Fea- tures in a Binary Image," Proc. 26th Annual Allerlon Con! on Communicaiion, Control, and Cotnpuiing, Monlicello, Illinois, 1988, pp. 11 14-1 115. (To appear in Algon'ihmica.)
[24] M. J . Atallah and S. R. Kosaraju, "An Efficient Parallel Algorithm for the Row Minima of a Totally Monotone Matrix." Pmc. 2d ACM-SIAM Symp. on Discrete A[gon'thms, 1991, pp. 394- 403.
[25] M. J. Atallah, S. R. Kosaraju, L. Larmore, G. L. Miller and S. Teng, "Constructing Trees in Parallel? Proc. IsL Annual ACM Symp. on Parallef Algorithms arrd Archiieciures, Santa Fe, Nerv Mexico, 1089, pp. 421-431.
[2G] M. J. Atallah and J-J. Tsay, "On the ParalletDecornposibility of Geometric Problems, Pmc. 5th Annuoi ACM Symp. on Computafional Geomeiq, 1989, pp. 104-113.
(271 R. Beige1 and J . Gill, "Sorting n Objects with a k-Sorter," to appear in IEEE Tkansaciions on Computers.
(281 P. Bertolazzi, C. Guerra and S. Satza, "A Parallel Algorithm lor the Visibility Problem From a Point", J. of Parallel and Dislributed Computing, Vol. 9, 1990, pp. 11-14,
[29] G. Bilardi and A. Nicolau, "Adaptive Bitonic Sorting: An Optimal Parallel Algorithm for Shared Memory Machines," SIA M J. Compur., Vol. 18,1989, pp. 216-228.
[30] G. E. Blelloch, "Scan Primitives and Parallel Vector Models," Ph.D. Thesis, Massacbuseiis Insltfule o j Technology, 1988.
[31] C. E. Blelloch, "Scans as Primitive Parallel Operations," Proc. of the Int. Conj on Parallel Processing, 1987, pp. 355-362.
(321 A. Eorodin and J. E. Hopcroft, "Routing, Merging, and Sorting on Parallel Models of Compu- tation," J . of Compuier and Sysiem Sciences, Vol. 30, 1985, pp. 130-145.
(331 L. Boxer and R. Miller, "Dynamic Computational Geometry on Meshes and Hypercubes," J. ojSupercompuiing, Vol. 3, 1989, pp. 161-191.
[15] M. J. Atal\ah, D. Z. Chen and H. Wagener, "An Optimal Parallel Algorithm for the Visibilityof a Simple Polygon from a Point," To a.ppear in JACM; a preliminary version appeared inProe. 5th Annual ACM Symp. 071 Computational Geometry, Saarbrucken, Federal Republic ofGermany, 1989, pp. 114-123.
[16] M. J. Atallah, R. Cole, and M. T. Goodrich, "Cascading Divide-and-Conquer: A Technique forDesigning Parallel Algorithms," SIAM J. Compul., Vol. 18, 1989, pp. 499-532.
[17] M. J. Atallah, G. N. Frederickson, and S. R. Kosaraju. Sorting with Efficient Use of SpecialPurpose Sorters. Infonnation Processing Letters, 1988, Vol. 27, pp. 13-15.
[18] M. J. Atallah and M. T. Goodrich, "Efficient Plane Sweeping in Parallel," Proc. 2nd AnnualACM Symp. on Computational Geometry, Yorktown Heights, New York, 1986, pp. 216-225.
[19] M. J. Atallah and M. T. Goodrich, "Efficient Parallel Solutions to Some Geometric Problems,"J. of Parallel and Distributed Computing, Vol. 3, 1986, pp. 492-507.
[20) M. J. MaHan and M. T. Goodrich, "Parallel Algorithms for Some Functions of Two ConvexPolygons," Algorithmica, Vol. 3, 1988, pp. 535-548.
[21] M. J. AtaUah, S.R. Kosaraju and M.T. Goodrich, "On the Parallel Complexity of EvaluatingSome Sequences of Set Manipulation Operations," Lecture NrJtes in Computer:- Science, 319:VLSI Algorithms and Architectures, 9rd Aegean Workshop on Computing, A woe 88, SpringerVerlag, 19S8, pp. 1-10.
[22] M. J. Atallah and S. E. Hambrusch, "Solving Tree Problems on a Mesh-Connected ProcessorArray," Info. and Control, Vol. 69, 1986, pp. 168-187.
[23] M. J. Atallah, S. E. Hambrusch and L. E. TeWinkel, "Parallel Topological Sorting of Features in a Binary Image," Proe. ~6th Annual Allenon Con/. on Communication, Control, andComputing, MonLicello, lllinois, 1988, pp. 1114-1115. (To appear in Algoriihmica.)
[24] M. J. ALallah and S. R. Kosaraju, "An Efficient Parallel Algorithm for the Row Minima of aTotally Monotone Matrix." Proc. !!d ACM-SIAM Symp. on Discrete A/gorithmst 1991, pp. 394403.
[25] M. J. Atallah t S. R. Kosaraju, L. Larmore, G. L. Millet and S. Teng, "Constructing Trees inParallel," Proe. 1st Annual ACM Symp. on Parallel Algorithms and Architectures, Santa Fe,New Mexico. 1989, pp. 421-431.
[26] M. J. Atallah and J-J. Tsay, "On the Parallel-Decomposibility of Geometric Problems, Proc.5th Annual ACM Symp. on Computational Geometry, 1989, pp. 104-113.
[27] R. Beigel and J. Gill, "Sorting n Objects with a. k-Sorter," to appear in IEEE 7Tansactions onComputers.
[28] P. Bertolazzi, C. Guerra and S. Sa[za, "A Parallel Algorithm for the Visibility Problem Froma Point", J. of Parallel and Distributed Computing, Vol. 9, 1990, pp. 11-14.
[29] G. Bilardi and A. Nicolau, "Adaptive Bitonic Sorting: An Optimal Parallel Algorithm forShared Memory Machines," SIAM J. Comput., Vol. 18,1989, pp. 216-228.
[30] G. E. Blelloch, "Scan Primitives and Parallel Vector Models," Ph.D. Thesis, MassachusettsInstitute of TechnologYl 1988.
[31] G. E. Blelloch, "Scans as Primitive Para.llel Operations," Proc. of the Int. ConI. on ParallelProcessing, 1987, pp. 355-362.
[32] A. Borodin and J. E. Hopcroft, "Routing, Merging, and Sorting on Parallel Models of CompuLation," J. of Computer and System Science!, Vol. 3D, 1985, pp. 130-145.
[33] L. Boxer and R. Miller, "Dynamic Computational Geometry on Meshes and Hypercubes." J.of Supercomputing, Vol. 3, 1989, pp. 161-191.
29
1341 R. P. Brent, "The Parallel Evaluation of General Arithmetic Expressions," J. ACM, Vol. 21, 1974, pp. 201-206.
[35] B. M. Chazelle, "Optimal Algorithms for Computing Depths and Layers," Proc. oJ the 20ih Allerlon Conference on Cornmunicalions, Conirol and Computing, 1983, pp. 427-436.
[36] 8 . M. Chazelle, "Computational Geometry on a Systolic Chip," IEEE Ifans. on Computers, Vol. (2-33, 1984, pp. 774-785.
[37] B. Chazelle and L. J. Guibas, "Fractional Cascading: I. A Data Structuring Technique," Algo- rithmic~, Vol. l , pp. 133-162.
[38] D. Z. Chen, "Efficient Geometric Algorithms in the EREW-PRAM," Proc. 28th Annual Allertor ConJ on Communication, Conirol, and Compuling, Monticello, Illinois, 1990, pp- 818-827.
[39] A. Chow, "Parallel Algorithms for Geometric Problems," Ph-D. thesis, Computer Science Dep t., Univ. of Illinois at Urbana-Champaign, 1980.
[40] E. Cohen, R. Miller, E.M. Sarraf and Q.F. Stout, "Eficient Convexity and Domination Algo- rithms for Fine and Medium-Grain Hypercube Computers", to appear in Algorilhmica.
[41] R. Cole, "Parallel Merge Sort," SIAM J. Compul., Vol. 17, 1988, 770-785.
[42] R. Cole and M.T. Goodrich, "Optimal Parallel Algorithms for Point-Set and Polygon Prob- lems", Proc. 4ih Annual ACM Symp. on Cornpulalional Ceomely, 1988, pp. 201-210.
(431 R. Cole, M. T. Goodrich and C. O1Dunlaing1 "Merging Free Trees in Parallel for Efficient Voronoi Diagram Construction," Proc. 171h Inlernalionnl Colloq. on Aulomafo, Long., and Programming, Springer Verlag, 1990, pp. 432-445.
[44] R. Cole and U. Vishkin, "Approximate and Exact Parallel Scheduling with Applications to List, n e e and Graph Problems," Proc. 27th Annual IEEE Symp. on Foundaiions of Comp. Sci., 1986, pp. 487-491.
1451 R. Cole and U. Vishkin, "Faster Optimal Parallel Prefix Sums and List Ranking," Info. and Conlmi, Vol. 81, 1989, pp. 334-352.
[46] R. Cole and 0. Zahicek, "An Optimal Parallel Algorithm for Building a Data Structure for Planar Point Location", Courant Inst. Tech Rept 316, 1987. (To appear in J. of Pamllel and Disiribuled Compuling.)
1471 S. Cook and C. Dwork, "Bounds on the Time for ParallelRAM's lo Computesimple Functions," Proc. 14th ACM Annual Symp. on Theory of Computing, 1982, pp. 231-233.
[48] J. Czyzowicz, I. Rival and J. Urrutia, "Galleries, Light Matchings, and Visibility Graphs," Lecture Noles in CS: 382, Pmc. WADS 89, Spdnger Verlag, 1989, p. 316-324.
[49] R. Cypher and C. G. Plaxton, "Deterministic Sorting in Nearly Logarithmic Time on the Hypercube and Related Computers," Proc. 22d Annual ACM Symp. on Theory of Compuiing, 1990, pp. 193-203.
(501 R. Cypher and J. L. C. Sanz, "Optimal Sorting on Feasible Parallel Computers," Iniernaiional Conference on Parallel Processing, 1988, pp. 339-350.
(5 11 N. Dadoun and D. Kirkpatrick, "Parallel Processing for Efficient Subdivision Search," 3rd ACM Symp. Cornpulalional Geom., 1987, pp. 205-214.
[52] N. Dadoun, "Geometric Hierarchies and Parallel Subdivision Search," Ph.D. Thesis, U. of British Columhia, 1990.
[53] F. Dehne, "Computing the Largest Empty Rectangle on One and Two Dimensional Processor Arrays," to appear in J. Parallel Disl. Compul.
[54] F. Dehne, "Solving Visibility and Separability Problems on a Mesh of Processors," Visual Computer, Vol. 3,1988, pp. 356-370.
[34] R. P. Brent, "The Parallel Evaluation of General Arithmetic Expressions," J. ACM, Vol. 21,1974, pp. 201-206.
[35] B. M. Chazelle, "Optimal Algorithms for Computing Depths and Layers," Proc. oJ the ~Oth
Allerton Conference on Communications, Control and Computing, 1983, pp. 427-436.
[36] B. M. Chazelle, "Computational Geometry on a Systolic Chip," IEEE 'lTans. on Computers,Vol. C-33, 1984, pp. 774-785.
[37] B. Chazelle and L. J. Guibas, "Fractional Cascading: I. A Data Structuring Technique," AlgorithmicQ, Vol. I. pp. 133-162.
[38] D. Z. Chen, "Efficient Geometric Algorithms in the EREW-PRAM." Proc. 28th Annual AllertonCon! on Communicat.ion, Control, and Computing, Monticello, Illinois, 1990, pp. 818-821.
[39] A. Chow, "Parallel Algorithms for Geometric Problems," Ph.D. thesis. Computer Science Dept.)Univ. of Illinois at Urbana-Champaign) 1980.
[40] E. Cohen. R. Miller, E.M. Sarraf and Q.F. Stout, "Efficient Convexity and Domination Algorithms for Fine- and Medium-Grain Hypercube Computers", to appear in Algorithmica.
[41] R. Cole, "Parallel Merge Sort," SIAM J. Comput., VoL 17, 1988.770-785.
[42] R. Cole and M.T. Goodrich, "Optimal Parallel Algorithms for Point-Set and Polygon Problems", Proc. 4th Annual ACM Symp. on Computational Geometry, 1988, pp. 201-210.
[43] a. Cole. M. T. Goodrich and C. O'Dunlaing, "Merging Free Trees in Parallel for EfficientVoronoi Diagram Construction," Proc. 17th International Colloq. on Automata, Lang., andProgramming) Springer Verlag, 1990, pp. 432-445.
(44] R. Cole and U. Vishkin, "Approximate and Exact Parallel Scheduling with Applications toList) Tree and Graph Problems," Proc. ~71h Annual IEEE Symp. on Foundations of CompoSci., 1986, pp. 487-491.
[45) R. Cole and U. Vishkin, "Faster Optimal Parallel Prefix Sums and List Ranking," Tnfo. andControl, Vol. 81, 1989, pp. 334-352.
[46J R. Cole and O. Zahicek, "An Optimal Parallel Algorithm for Building a Data Structure forPlanar Point Location)), Courant Inst. Tech Rept 316, 1987. (To appear in J. of Parallel andDistributed Computing.)
[47] S. Cook and C. Dwork, "Bounds on the Time for Parallel RAM's to Compute Simple Functions,"Proc. 14th ACM Annual Symp. on Theory of Computing, 1982, pp. 231-233.
[48] J. Czyzowiez, 1. Rival and J. Urrutia, "Galleries, Light Matchings. and Visibility Graphs,))Lecture Notes In CS: 982, Proc. WADS 89, Springer Verlag, 1989, p. 316-324.
[49) R. Cypher and C. G. Plaxton, "Deterministic Sorting in Nearly Logarithmic Time on theHypercube and Related Computers," Proc. B2d Annual ACM Symp. on Theory oJ Computing,1990J pp. 193-203.
[50] R. Cypher and J. L. C. Sanz, nOptimal Sorting on Feasible Parallel Computers/' InternationalConference on Parallel Processing, 1988, pp. 339·350.
(51] N. Dadoun and D. Kirkpatrick, "Parallel Processing for Efficient Subdivision Search," 9rd ACMSymp. Computational Geom.) 1987, pp. 205-214.
[52] N. Dadoun. "Geometric Hierarchies and Parallel Subdivision Search." Ph.D. Thesis, U. ofBritish Columbia, 1990.
[53] F. Dehne, "Computing the Largest Empty Rectangle on One and Two Dimensional ProcessorArrays," to appear in J. Parallel Dist. Comput.
[54) F. Dehne, "Solving Visibility and Separability Problems on a Mesh of Processors," VisualComputer, Vol. 3,1988, pp. 356-370.
30
[55] F. Dehne, A.-L. Hassenklover, and J .-R. Sack, "Computing the Configuration Space for a Robot on a Mesh of Processors," to appear in Parnilel Compuiing.
[56] F. Dehne, A.-L. Hassenklover, J .-R. Sack, and N. Santoro, "Computational Geometry Algo- rithms for the Systolic Screen," to appear in Algorilhmica.
[57] F. Dehne, J.-R. Sack and I. Stojmenovic, "A Note On Determining The 3-Dimensional Convex Hull of a Set of Points On a Mesh of Processors," Proc. 1988 Scandinavian Workshop on Algon'ihms and Theory, pp. 154-162.
[58] F. Dehne, A. Ferreira and A. Rau-Chaplin, "Parallel Fractional Cascadingon a Hypercube Mul- tiprocessor," Proc. 27ih Annual Alierion Conf. on Communication, Control, and Computing, Monticello, Illinois, 1989, pp. 1084-1093.
[59] F. Dehne and A. Rau-ChapIin, "Implementing Datastructures on a Hypercube Multiprocessor, with Applications in Parallel Computational Geometry." J. Parallel Distrib. Compuiing, Vol. 8, 1990, pp. 367-375.
[60] F. Dehne and I. Stojmenovic, "An O(fi) Time Algorithm for the ECDP Searching Problem for Arbitrary Dimensions on a Mesh of Processors," Info. Proc. Leli., Vol. 28, 1988, pp. 67-70.
[G LJ X. Deng, "An Optimal Parallel Algorithm for Linear Programming in the Plane," Injo. Proc. Leliers, Vol. 35, 1990, pp. 213-217.
[62] D. P. Dobkin and D. G. Kirkpatrick, "Fast Detection of Polyhedral Intersections," Theor. Comp. Sci. Vol. 27, 1983, pp. 241-253.
[63] D. P. Dobkin and D. G. Kirkpatrick, "A Linear Time Algorithm for Determining the Separation of Convex Polyhedra," J. o j Algoriihms, Vol. 6, 1985, pp. 381-392.
[64] D. P. Dobkin and D. G. Kirkpatrick, "Determining the Separation of Prepprocessed Polyhedra - A Unified Approach," Proc. ojihe Inl. Colloq. on Automata, Lung., and Programming, 1990, pp. 154-165.
[65] D. Dobkin, R. J. Lipton and S. Reiss, "Linear Programming is Log-space Hard for P" Injo. Proc. Lell., Vol. 9, 1979, pp. 96-97.
[66] D. Dobkin and S. Reiss, 'The Complexity oFLinear Programming," Theor. Comp. Sci., Vol. 11, 1980, pp. 1-18.
[67] H. Edelsbrunner, Algorilhms in Corrtbinatoriai Geomelry, Springer-Verlag, NY, 1987.
(681 R. ElGindy and M. T. Goodrich, "Parallel Algorithmsfor Shortest Path Problems in Polygons," The Visual Computer: Inlernaiional J. o j Compuier Graphics, Vol. 3, 1988, pp. 371-378.
(691 G. N. Prederickson and D. B. Johnson, 'The Complexity of Selection and Ranking in X+Y and Matrices with Sorted Columns," J. o j Computer and System Sciences, Vol. 24, 1982, pp. 197- 208.
(701 L. M. Goldschlager, 'The Monotone and Planar Circuit Value Problems are Log Space Complete for P," SIGACT News, Vol. 9, 1977, pp. 25-29.
(711 A. Gibbons and W. Rytter , "An Optimal Parallel Algorithm for Dynamic Expression Evaluation and its AppIications," Proc. ofSymp. on Found. of Soflware Technology and Theoretical Comp. Sci., Springer Verlag, 1986, pp. 453-469.
[72] M. T. Goodrich, "Efficient Parallel Techniques for Computational Geometry," Ph.D. thesis, Department of Computer Science, Purdue University, 1987.
[73] M. T. Goodrich, "Finding the Convex Hull of a Sorted Point Set in Parallel," Information Processing Letters, Vol. 26, 2987, pp. 173-179.
(741 M. T. Goodrich, '"lkiangulating a Polygon in Parallel," J. Algorilbms, in press.
[55J F. Dehne, A.-L. Hassenklover, and J .-R. Sack, "Computing the Configuration Space for a Roboton a Mesh of Processors." to appear in Parallel Computing.
[56] F. Dehne, A.-L. Hassenklover, J.-R. Sack, and N. Santoro, "Computational Geometry Alge>rithms for the Systolic Screen," to appear in Algr>rithmica.
[57] F. Dehne, J .-R. Sack and I. Stojmenovic, teA Note On Determining The 3-Dimensional ConvexHull of a Set of Points On a Mesh of Processors," Proc. 1988 Scandinavian Workshop onAlgorithms and Theoryl pp. 154-162.
[58] F. Dehne, A. Ferreira and A. Rau-Chaplin, "Parallel Fractional Cascading on a Hypercube Multiprocessor," Proe. 27th Annual Allerton Conf. on Communication, Control, and Computing,Monticello, Illinois, 1989, pp. 1084-1093. -
[59] F. Dehne and A. Rau-Chaplin, "Implementing Data Structures on a Hypercube Multiprocessor,with Applications in Parallel Computational Geometry." J. Paraliel.Distrib. Computing, Vol. 8,1990, pp. 367-375.
[60] F. Dehne and I. Stojmenovic, "An O(.jn) Time Algorithm for the ECDF Searching Problemfor Arbitrary Dimensions on a Mesh of Processors," Info. Proe. Lett., VoL 28, 1988, pp. 67-70.
[6 tJ X. Deng, "An Optimal Parallel Algorithm for Linear Programming in the Plane," Info. Proc.Letters, Vol. 35, 1990, pp. 213-217.
[62] D. P. Dobkin and D. G. Kirkpatrick, "Fast Detection of Polyhedral Intersections," Theor.Compo Sci. Vol. 27, 1983, pp. 241-253.
[63] D. P. Dobkin and D. G. Kirkpatrick, "A Linear Time Algorithm for Determining the Separationof Convex Polyhedra," J. of Algorithms, Vol. 6, 1985, pp. 381-392.
[64] D. P. Dobkin and D. G. Kirkpatrick, "Determining the Separation of Prepprocessed Polyhedra- A Unified Approach," Proc. o/the lnt Colloq. on Automata, Lang' l and Programming, 1990,pp. 154-165.
[65J D. Dobkin, R. J. Lipton and S. Reiss, "Linear Programming is Log-space Hard for P" Info.Proc. LeU., Vol. 9, 1979, pp. 96-97.
[66] D. Dobkin and S. Reiss, "The Complexity of Linear Programming," Ther>r. Compo Sci., Vol. 11,1980, pp. 1-18.
(67] H. Edelsbrllnner, Algr>rilhms in Combinatorial Geometry, Springer-Verlag, NY, 1987.
[68] H. EIGindy and M. T. Goodrich, "Parallel Algorithms for Shortest Path Problems in Polygons,"The Visual Computer: In~ernational J. of Computer Graphics, Vol. 3, 1988J pp. 371-378.
[69J G. N. Frederickson and D. B. Johnson, ''The Complexity of Selection and Ranking in X +Y andMatrices with Sorted Columns," J. of Computer and System Sciences, Vol. 24, 1982, pp. 197208.
[701 L. M. Goldschlager, ''The Monotone and Planar Cit'cuit Value Problems are Log Spa.ce Completefor P," SIGACT News, Vol. 9, 1977, pp. 25-29.
[71] A. Gibbons and W. Rytter, "An Optimal Parallel Algorithm for Dynamic Expression Evaluationand its Applications," Proc. ofSymp. on Found. of Sr>ftware Technology and TheQretical Cornp.Sci., Springer Verlag, 1986, pp. 453-469.
[72] M. T. Goodrich, "Efficient Parallel Techniques for Computational Geometry," Ph.D. thesis,Department of Computer Science, Purdue University, 1981.
[73] M. T. Goodrich, "Finding the Convex Hull oC a Sorted Point Set in Parallel," InformationProcessing Letters, VoL 26, 1987, pp. 173-179.
[74] M. T. Goodrich, ''Triangulating a. Polygon in Parallel,>! J. Algorithms, in press.
31
[75] M. T. Goodrich, "Intersecting Line Segments in Parallel with an Output-Sensitive Number of Processors," Johns Hopkins Univ Tech b p t 88-27, 1988.
[76] M. T. Goodrich, M. Ghouse and J. Bright, "Generalized Sweep Methods for Parallel Compu- tational Geometry," Proe. 2d Annual ACM Symp. on ParaIlel Algon'ihms and Architectures, 1990, pp. 280-289.
[773 M. T. Goodrich, S. B. Shauck and S. Guha, "Parallel Method for Visibility and Shortest Path Problems in Simple Polygons," Pmc. 6th Annual ACM Symp. on Compulational Geometry, 1990, pp. 73-82.
[78] J. Hershberger, "Upper Envelope Onion Peeling," Proc. 2d Scandinavian Workshop on Algo- rithm Theory, Springer Verlag, 1990, pp. 368-379.
(791 T. TIagerup, and C. Rub. "Optimal Merging and Sorting on the EREW PRAM." Inform. Process. Lett., Vol. 33, 1989, 181-185.
(803 J. A. Holey and 0. H. lbarra, "Triangulation in a Plane and 3-D convex hull on Mesh-Connected Arrays and Hypercubes." Tech. Rep., Univ. of Minnesota, Dept. of Computer Science, 1990.
[81) J.-W. Hong and H. T. Kung, "I/O Complexity: The Red-Blue Pebble Game," Pmc. 131h Annual ACM Symposium on Theory oj Computing, 1981, pp. 326-333.
[82] C. S. Jeong and D. T. Lee, Parallel Geometric Algorithms on a Mesh Connected Computer, Technical Report 87-02-FC-01, Dept. EE/CS, Northwestern Univ., 1987. To appear in Algo- n'ihmica.
[83] R.M. Karp and V. Ramachandran, "A Survey of Parallel Algorithms for Shared-Memory Ma- chines," U.C. Berkeley Tech Rept. CSD-TR 88/408, March 1988.
[84] S. R. Kosaraju and A. Dslcher , "Optimal Parallel Evaluation oFTreeS tructured Computations by Raking", Leclure Noles in CS 519: A WOC 88, Springer Verlag, 1988, pp. 101-110.
[85] D. G. Kirkpatrick. "Optimal search in planar subdivisions." SIAM J. of Computing, Vol. 12, 1983, 28-35.
[86] M. Kunde, "Optimal Sorting on Multidimensional Mesh-Connected Computers," Proc. o j STACS 1987, Lecture Notes in Computer Science, Springer, 1987, pp. 408-419.
[87] H. T. K u n g and C. D. Tliompson. "Sorting on a Mesh-Connected Parallel Computer," Comm. ACM, Vol. 20, 1977, yp. 263-27.
($81 C. P. Kruskal, L. Rudolph, and M. Snir, "A Complexity Theory of Efficient Parallel Algorithms" Lecture Noles in CS:SI Proc. 15th ICALP, Springer Verlag, 1988, pp. 333-346.
(891 C. P. Kruskal, L. Rudolph, and M. Snir, "The Power of Parallel Prefix," Proc. 1985 IEEE hi. ConJ on ParalleI Processing, St. Charles, IL., pp. 180-185.
[go] R. E. Ladner and M. J. Fischer, "Parallel Prefix Computation ," J. ACM, 1980, pp. 83 1-838.
[91] C. Levcopoulos, J. Katajainen and A. Lingas, "An Optimal Expected Time Algorithm for Voronoi Diagrams," Proc. 1st Scandinavian Workshop on Aigorilhm Theoy, Springer Verlag, 1988.
[92] D. T. Lee and F. P. Preparata, "Computational Geometry-A Survey," fEEE Trans. on Coin- pulers, Vol. C-33, 1984, pp. 872-1101.
[93] D. T. Lee, F. P. Preparata, C.S. Jeang and A. L. Chow, "SIMD Parallel Convex Hull Algo- rithms." Tech. Rep. AC-91-02, Nort hmestern Univ., Dept. of Electrical Eng. and Computer Science, 1991.
[94] F. T. Leighton, An Iniroduclion lo Parallel Algorithms and Ar~hilectures~ Morgan Kaufmann, California, to appear in 1991.
[75J M. T. Goodrich, "Intersecting Line Segments in Parallel with an Output-Sensitive Number ofProcessors," Johns Hopkins Univ Tech Rept 88-27, 1988.
[76J M. T. Goodrich, M. Ghouse and J. Bright, "Generalized Sweep Methods for Parallel Computational Geometry," Proc. ~d Annual ACM Symp. on Parallel Algorithms and Architectllres,1990, pp. 280-289.
[77] M. T. Goodrich, S. B. Shauck and S. Guha, <IParallel Method for Visibility and Shortest PathProblems in Simple Polygons," Proc. 6th Annual ACM Symp. on Computational Geometry,1990, pp. 73-82.
[78J J. Hershberger] "Upper Envelope Onion Peeling," Proc. 2d Scandinavian Workshop on Algorithm Theory] Springer Verlag, 1990, pp. 3G8-379.
[79] T. IIagerup] and C. Rub. "Optimal Merging and Sorting on the EREW PRAM." Inform.Process. Lett., Vol. 33, 1989, 181-185.
[80] J. A. Holey and O. H. Ibarra, "Triangulation in a. Plane and 3-D convex hull on Mesh-ConnectedArrays and Hypercubes." Tech. Rep., Univ. of Minnesota, Dept. of Computer Science, 1990.
[81} J.-W. Hong and H. T. Kung, "I/O Complexil;y: The Red-Blue Pebble Game," Proc. 13thAnnual ACM Symposium on Theory of Computing, 1981, pp. 326-333.
[82] C. S. Jeong and D. T. Lee, Parallel Geometric Algorithms on a Mesh Connected Computer,Technical Report J 87-02-FC-01] Dept. EE/CS, Northwestern Univ., 1987. To appear in A/gorithmica.
[83] R.M. Karp and V. Ramachandran, "A Survey of Parallel Algorithms for Shared-Memory Machines," D.C. Berkeley Tech Rept. CSD-TR 88/408, March 1988.
[84] S. R. Kosaraju and A. Deicher, "Optimal Parallel Evaluation ofTree-Structured Computationsby Raking"] Lecture Notes in CS 319: Awoe 88, Springer Verlag, 1988, pp. 101-110.
[85] D. G. Kirkpatrick. "Optimal search in planar subdivisions." SIAM J. of Computing, Vol. 12,1983, 28-35.
[86] M. Kunde, "Optimal Sorting on Multidimensiona.l Mesh-Connected Computers," Proc. ojSTAGS 1987, Lecture Notes in Computer Science, Springer, 1987, pp. 408-419,
[87] H. T. Kung and C. D. Thompson. IISorting on a. Mesh-Connected Parallel Computer," Comm.ACM, Vol. 20, 1977, pp. 263-27.
[88] C. P. Kruskal, L. Rudolph, and M. Snir, "A Complexity Theory of Efficient Parallel Algorithms"Lec!ure Notes in CS:317, Proc. 15th ICALP, Springer Verlag, 1988, pp. 333-346.
[89] C. P. Kruskal, L. Rudolph, and M. Snir, "The Power of Parallel Prefix," Prot. 1985 IEEE Int.ConI on Parallel Processing, St. Charles, IL., pp. 180-185.
[90] R. E. Ladner and M. J. Fischer, llParallel Prefix Computation," J. ACM. 1980, pp. 831-838.
[91] C. Levcopoulos, J. Katajainen and A. Lingas. "An Optimal Expected Time Algorithm forVoronoi Diagrams," Proc. 1st Scandinavian Workshop on Algorithm Theory, Springer Verlag,1988.
[92] D. T. Lee and F. P. Preparata, "Computational Geometry-A Survey]" IEEE Trans. on CompUlers, Vol. G-33, 1984, pp. 872-1101.
[93] D. T. Lee, F. P. Preparata, C.S. Jeong and A. L. Chow, "SIMD Parallel Convex Hull Algorithms." Tech. Rep. AG-91-02, Northwestern Univ., Dept. of Electrical Eng. and ComputerSc:ienee, 1991.
[94] F. T. Leighton, An Introrludion to Parallel Algorithms and Architectures, Morgan Kaufmann,California, to appear in 1991.
32
1051 J. M. Marberg and E. Gafni, "Sorting in Constant Number of Row and Column Phases on a Mesh." Proc. 24th Annual Allerioa ConJ on Communicalion, Control, and Computing, Mon- ticello, Iltinois, 1986, pp. 603-612.
[96] Z. Ci and V. Milenkovic, "Constructing Strongly Convex Hulls Using Exact or Rounded Arith- metic." Proc. Sixth Annual ACM Symp. on Comp. Ceom., 1990, pp. 235-243. (To appear in Algorilhmica.)
[97] R.. Miller, 'cConvexity Algorithms for Digitized PicLures on ah lntel iPSC Hypercube," Super- computer 31, Vl-3, pp. 45-53.
[98] R. Miller and Q.F. Stout, Parallel Algoriihms for Regular Archileciures, The MIT Press, Cam- bridge, Massachusetts, to appear in 1991.
[99] R. Miller and Q.F. Stout, "Efficient parallel convex hull algorithms," IEEE Trans. Compuiers C-37 (1988), pp. 1605-1618.
[loo] R. Miller and Q.F. Stout, "Mesh Computer Algorithms for Computational Geometry," IEEE Trans. Cornpulers C-38 (1989)) pp. 321-340.
[loll R. Miller and Q.F. Stout, "Geometric Algorithms for Digitized Pictures on a Mesh Connected Computer," IEEE Trans. PAMI, Vol. 7 1985, pp. 216-228.
[I021 G. L. Miller and 3. H. Reif, "Parallel 3 e e Contraction and its Applications," Proc. 261h ACM Symp. on Foundations oJ Comp. Sci., 1985, pp. 478489.
[103] S. Miyano,S. Shiraishi and T. Shoudai, "A List of P-Complete Problems," Tech Rept RIFIS- TR-CS-17, 1989, Kyushu Univ.
[104] H. Mueller, "Sorting numbers using limited systolic coprocessors," Infomation Processing Leiiers, Vol. 24, 1987, pp. 351-354.
[I051 D. Nassimi and S. Sahni, "Data Broadcasting in SIMD Computers," IEEE n u n s . on Com- puters, Vol, 30, 1981, pp. 101-106.
[lo61 J . O'Rourke, Art Gallery Theorems and Algorifhms, Oxford Univ. Press, 1987.
[lo71 J. O'Rourke, "Computational Geometry," Ann. Reu. Comp. Sci., Vol. 3, 1988, pp. 389-4.11.
[108] 1. Parberry, "Parallel Complexity Theory," Pitman, London, 1987.
[lo91 W. Paul, U. Vishkin and H. Wagener, "Parallel dictionaries on 2-3 trees." Pmc. 1Dih Coil. on Aulom., Lung., and Prog. (ICALP), LNCS 154, Springer, Berlin, 1983, pp. 597-609.
[I101 F. P. Preparata and M. I. Shamos, Compuiaiional Geometry: An Iniroduclion , Springer- Verlag, 1985.
[111] F. P. Preparata and R. Tamassia, "Fully Dynamic Techniques for Point Location and 'ban- sitive Closure in Planar Structures," Proc. 29th ACM Symp. on Theory 01 Compuling, 1988, pp. 558-567.
11121 J . H. Reif and Q. F. Stout, manuscript.
[113] J. H. Reif and S. Sen, "Optimal randomized Parallel Algorithmsfor ComputationaI Geometry," Proc. 1987 IEEE Inl. Conk on Parallel Processing, pp. 270-277. (To appear in Algon'thmica.)
[I141 J . H. Reif and S. Sen, "Polling: A New Random Sampling Technique for Computational Geometry," Proc. 21sL Annual ACM Symp. on Theoy o j Compulling, 1989, pp. 394-404.
[115] J. H. Reif and S. Sen, "Randomized Algorithms for Binary Search and Load Balancing on Fixed Connection Networks with Geometric Applications (Preliminary Version)," Proc. 2nd Annual ACM Symp. ParalIel Algotiitims and Anhilectures 1990, pp. 327-337.
[116] J. H. Reif and L. Valiant, "A Logarithmic Time Sort for Linear Size Networks," Proc. 15th ACM Symp. on Theoy of Cornp., 1981.
(951 J. M. Marberg and E. Gafni, "Sorting in Constant Number of Rowand Column Phases on aMesh," Proc. 24th Annual Allerion Con! on Communication, Control, and Computing, Monticello, lHinois, 1986, pp. 603-612.
[96] Z. Li and V. Milenkovic, "Const.ructing Strongly Convex Hulls Using Exact. or Rounded Arithmetic." Proc. Sixth Annual ACM Symp. on Compo Geom., 1990, pp. 235-243. (To appear inAlgorithmica.)
[97] R.. Miller, ('Convexity Algorithms for Digitized Pictures on an Intel iPSe Hypercube," Supe.rcomputer 31, VI-3, Pll. 45-53.
[98J R. Miller and Q.F. Stout, Parallel Algorithms/or Regular Architectures, The MIT Press, Cambridge, Massachusetts, to appear in 1991.
[99] R. Miller and Q.F. Stout, "Efficient parallel conveX hull algorithms," IEEE Trans. ComputersC·37 (1988), pp. 1605-1618.
[100] R. MHler and Q.F. Stout, "Mesh Computer Algorithms for Computational Geometry," IEEETrans. Computers C-38 (1989), pp. 321-340.
[101] R. Miller and Q.F. Stout, "Geometric Algorithms for Digitized Pictures on a Mesh ConnectedComputer," IEEE Trans. PAMI, Vol. 7 1985, pp. 216--228.
[102] G. L. Miller and J. H. Reif, "Parallel Tree Contraction and its Applications," Fmc. 26th. ACMSymp. on Foundations of Compo Sci., 1985, pp. 478-489.
[103] S. Miyano,S. Shiraishi and T. Shoudai, "A List of P-Complete Problems," Tech Rept RIFISTR-CS-17. 1989, Kyushu Univ.
[104] H. Mueller, "Sorting numbers using limited systolic coprocessors," Information. ProcessingLetters, Vol. 24, 1987, pp. 351-354.
[105] D. Nassimi and S. Sahni, "Data Broadcasting in SIMD Computers," IEEE Trans. on Com-pllters, Vol, 30, 1981, pp. 101-106.
[106] J. O'Rourke, Art Gallery Th.eorems and Algorithms, Oxford Univ. Press, 1987.
[107] J. O'Rourke, "Computational Geometry," Ann. Rev. Compo Sci., Vol. 3, 1988, pp. 389-411.
[108] 1. Parherry, "Parallel Complexity Theory," Pit.man, London, 1987.
[109] 'IN. Paul, U. Vishkin and H. Wagener, "Parallel dictionaries on 2-3 trees." Proc. 10th Coli. onAutom., Lang., and Prog. (lCALF), LNCS 154, Springer, Berlin, 1983, pp. 597-609.
[HO) F. P. Preparata. and M. 1. Shamos, Computational Geometry: An Introduction, SpringerVerlag, 1985.
[111] F. P. Preparata and R. Tamassia, "Fully Dynamic Techniques for Point Location and Transitive Closure in Planar Structures," Proc. 29th A CM Symp. On Theory of Computing, 1988,pp. 558-567.
[112] J. H. Reifand Q. F. Stout, manuscript.
[113] J. H. Reifand S. Sen, "Optimal randomized Parallel Algorithms for Computational Geometry,"Proe. 1987 IEEE Int. ConI. on Parallel Processing, pp. 270-277. (To appear in Algorithmica.)
[114] J. H. Reif and S. Sen, "Polling: A New Random Sampling Technique for ComputationalGeometry," Proc. ~lsl Annual ACM Symp. on Theory of Computing, 1989, pp. 394-404.
[115] J. H. Reif and S. Sen, "Randomized Algorithms for Binary Search and Load Balancing onFixed Connection Networks with Geometric Applications (Preliminary Version)," Proc. 2ndAnnual ACM Symp. Parallel Algorithms and Architectures 1990, pp. 327-337.
[116] J. H. Reif and L. Valiant, "A Logarithmic Time Sort for Linear Size Networks," Proc. 15thACM Symp. on Theory 0/ Comp., 1981.
33
[I171 Y. Shiloach and U. Vishkin, "Finding the MaKimurn, Merging, and Sorting in a Parallel Computation Model," J. Algorifh~rrs, Vol. 2, 1981, pp. 88-102.
[118] C. P. Schnorr and A. Shamir, "An Optimal Sorting Algorithm for Mesh Connected Comput- ers," Proc. 18th ACM Symp. on Theory on Computing, 1986, pp. 255-261.
[I191 I. Stojmenovic, manuscript, 1988.
[120] Q. F. Stout, "Constant-time geometry on PRAMS", Proc. 1988 Ini 'I . Con,. on Parallel Corn- puling, Vol. 111, IEEE, pp. 104-107.
[I211 R. Tamassia and J. S. Vitter, "Parallel Transitive Closure and Point Location in Planar Struc- tures," Proc. 1st Annual ACM Symp. on Parallel Algoriihms and Archileclures, 1989, pp. 399- 408.
[ I 221 R. E. Tarjan and U. Vishkin, "Finding Biconnected Components and Computing Tree Func- tions in Logarithmic Parallel Time," SIAM J, Cornput., Vol. 14, 1985, pp. 862-874.
[123] G. T. Toussaint, "Solving Geometric Problems with Rotating Calipers," Proc. IEEE MEL E- CON '83, Athens, Greece, May 1983.
[I241 J . -J . Tsay, "Optimal Medium-Grained Parallel Algorithms Tor Geometric Problems," Purdue CS Dept Tech Rept 942, 1990.
[I251 M. J. Atallah, F. Dehne, R. Miller, A. Rau-Chaplin, J-J. Tsay, "Multisearch Techniques lor Implementing Data Structures on a Mesh-Connected Computer," Purdue CS Dept Tech Rept 91-012, 1991. (To appear in Proc. Zd Annual ACM Symp. on ParaIleI Algon'lhms and Anhilectures, Hilton Head, South Carolina, 1991.)
11261 P. Vaidya, personal communication.
(1271 L. Valiant, "Parallelism in Comparison Problems," SIAM J. on Compuiing, Vol. 4, 1975, pp. 348-355.
[128] H. Wagener , "Optimally Parallel Algorithms for Convex Hull Determination," manuscript , 1985.
[I291 D. E. Willard and Y. C. Wee, "Quasi-Valid Range Querying and its Implications for Nearest Neighbor Problems," Proc. 4Lh Annual ACM Symp. on Computalional Geometry, 1988, pp. 34- 43.
(1301 C. K. Yap, "Parallel Triangulation of a Polygon in Two Calls to the Trapezoidal Map," Algo- n'thmiea, Vol. 3, 1988, pp. 279-288.
[117] Y. Shiloach and U. Vishkin, "Finding the Maximum, Merging, and Sorting in a ParallelComputation Model," J. Algorithms, Vol. 2, 1981, pp. 88-102.
[118] C. P. Schnorr and A. Shamir, "An Optimal Sorting Algorithm for Mesh Connected Computers," Proc. 18th ACM Symp. on Theory on Computing, 1986, pp. 255-261.
[U9] 1. Stojmenovic, manuscript, 1988.
[120] Q. F. Stout, "Constant-time geometry on PRAMs", Proc. 1988 IntJI. Conf. on Parallel Computing, VoL III, IEEE, pp. 104-107.
[121] R. Tamassiaand J. S. Vitter, "Parallel Transitive Closure and Point Location in Planar Structures," Proc. 1st Annual ACM Symp. on Parallel Algorithms and Architectures, 1989, pp. 399408.
[122] R. E. Tarjan and U. Vishkin, "Finding Biconnected Components and Computing Tree Functions in Logarithmic Parallel Time," SIAM J. Compllt., Vol. 14, 1985, pp. 862-874.
[123] G. T. Toussaint, "Solving Geometric Problems with Rotating Calipers," Proc. IEEE MELECON '83, Athens, Greece, May 1983.
[124] J.•J. Tsay, "Optimal Medium-Grained Parallel Algorithms for Geometric Problems," PurdueCS Dept Tech Rept 942, 1990.
[[25] M. J. Atallah, F. Dehne, R. Miller, A. Rau-Chaplin, J-J. Tsay, "Multisearch Techniquesror Implementing Data Structures on a Mesh-Connected Computer," Purdue CS Dept TechRept 91-012, 1991. (To appear in Proc. £d Annual ACM Symp. on Parallel Algorithms andArchitectures, Hilton Head, South Carolina, 1991.)
(126) P. Vaidya, personal communication.
(127} L. Valiant, "Parallelism in Comparison Problems," SIAM J. on Computing, Vol. 4, 1975,pp. 348-355.
[128] H. Wagener, "Optimally Parallel Algorithms for Convex. Hull Determination," manuscript,1985.
(l29] D. E. Willard and Y. C. Wee, "Quasi-Valid Range Querying and its Implications for NearestNeighbor Problems," Proc. 4th Annual ACM Symp. on Computat1onat Geometry, 1988, pp. 3443.
(l30) C. K. Yap, "Parallel Triangulation of a Polygon in Two Calls to the Trapezoidal Map," Algorithmica, Vol. 3, 19881 pp. 279-288.
34
