EREW Research Articles

Simulating the CRCW PRAM on reconfigurable networks

This paper addresses the problem of simulating the CRCW PRAM on reconfigurable networks. Let N and M, respectively, be the numbers of processors and memory cells contained in the CRCW PRAM. We firstly show that a two-dimensional N × MN 1 r reconfigurable network can simulate any operation performed on the CRCW PRAM in O(1) time, where r ⩾ 2 and is a constant. Then, if N ⩽ M, we further show that any operation performed on the CRCW PRAM can be simulated as well as O(1) time on a r-dimensional N 1 (r − 1) × N 1 (r − 1) × … × N 1 (r − 1) × ( M N (r − 2) (r − 1) ) reconfigurable network, where r ⩾ 2 and is a constant.

A Parallel Algorithm for Finding a Perfect Matching in a Planar Graph

We present au intuitive and simple O( log 2 n log Φ) time, O(n2 M(n)) processor parallel algorithm for finding a perfect matching in a planar graph, where n is the order, Φ is the number of the distinct perfect matchings of the graph and M(n) is the best sequential complexity of matrix multiplication of size n. The algorithm runs on a CRCW PRAM. Clearly, our algorithm belongs to the class NC if the number of perfect matchings is polynomially bounded in the size of the input graph.

On the complexity of the k-chain subgraph cover problem

The k-chain subgraph cover problem asks if the edge set of a given bipartite graph G is the union of the edge sets of k chain graphs, where each chain graph is a subgraph of G. Although the k-chain subgraph cover problem is known to be NP-complete for the class of bipartite graphs, it is still unknown whether this problem is NP-complete or polynomial-time solvable for subclasses of bipartite graphs. In this paper, we answer this question partially by showing that this problem for an important subclass of bipartite graphs, termed convex bipartite graphs, belongs to not only the class P, but also the class NC. More specifically, we show that the k-chain subgraph cover problem on the convex bipartite graph can be solved in O( m 2) time sequentially or O( log 2 n) time in parallel using O( m 3) processors on the CRCW PRAM, where n and m denote the number of vertices and edges, respectively.

Alphabet-independent optimal parallel search for three-dimensional patterns

We give an alphabet-independent optimal parallel algorithm for the searching phase of three-dimensional pattern matching. All occurrences of a three-dimensional pattern P of shape m × m × m in a text T of shape n × n × n are to be found. Our algorithm works in log m time with O( N/ log( m)) processors on a CREW PRAM, where N = n 3. Some ideas from [3] are used. We explore classification of two-dimensional periodicities of faces of the cubic pattern. Some projection techniques are developed to deal with three dimensions. The nonperiodicity implies some sparseness properties, while periodicity implies other special useful properties (i.e., monotonicity) of the set of occurrences. Both types of properties are used in deriving our algorithm. The advantage of our approach is that it is essentially two-dimensional, no special properties related to three dimensions and no new complicated data structures are considered, the resulting algorithm is rather simple. The search phase is preceded by the preprocessing phase (computation of the witness table). Our main results concern the searching phase, however, we present shortly a new approach to the second phase also. Usefulness of the dictionaries of basic factors ( DBFs, see [9]), in the computation of the three-dimensional witness table is presented. Our algorithms can be easily adjusted to the case of unequally sided patterns.

More general parallel tree contraction: Register allocation and broadcasting in a tree

We extend the classic parallel tree-contraction technique of Miller and Reif to handle the evaluation of a class of expression trees that does not fit their original framework. We discuss applications to the following problems: (1) Register allocation, i.e., computing the number of registers needed to evaluate a given expression if all intermediate results are kept in registers; and (2) broadcasting in a tree, i.e., computing the number of steps needed to transmit a message from the root to all other nodes in a given rooted tree if each node is a processor that can communicate with a single neighbor in each step. We show that on inputs of size n, both problems can be solved with optimal speedup in O(( log n) 2) time on an EREW PRAM, in O( log n log log n) time on a CREW PRAM, and in O( log n) time on a CRCW PRAM.

Shortest paths in digraphs of small treewidth. Part II: Optimal parallel algorithms

We consider the problem of preprocessing an n-vertex digraph with real edge weights so that subsequent queries for the shortest path or distance between any two vertices can be efficiently answered. We give parallel algorithms for the EREW PRAM model of computation that depend on the treewidth of the input graph. When the treewidth is a constant, our algorithms can answer distance queries in O( α( n)) time using a single processor, after a preprocessing of O( log 2 n) time and O( n) work, where α( n) is the inverse of Ackermann's function. The class of constant treewidth graphs contains outerplanar graphs and series-parallel graphs, among others. To the best of our knowledge, these are the first parallel algorithms which achieve these bounds for any class of graphs except trees. We also give a dynamic algorithm which, after a change in an edge weight, updates our data structures in O( log n) time using O( n β ) work, for any constant 0 < β < 1. Moreover, we give an algorithm of independent interest: computing a shortest path tree, or finding a negative cycle in O( log 2 n) time using O( n) work.

Sorting in Linear Time?

We show that a unit-cost RAM with a word length ofwbits can sortnintegers in the range 0…2w−1 inO(nloglogn) time for arbitraryw⩾logn, a significant improvement over the bound ofO(nlogn) achieved by the fusion trees of Fredman and Willard. Provided thatw⩾(logn)2+εfor some fixedε>0, the sorting can even be accomplished in linear expected time with a randomized algorithm. Both of our algorithms parallelize without loss on a unit-cost PRAM with a word length ofwbits. The first one yields an algorithm that usesO(logn) time andO(nloglogn) operations on a deterministic CRCW PRAM. The second one yields an algorithm that usesO(logn) expected time andO(n) expected operations on a randomized EREW PRAM, provided thatw⩾(logn)2+εfor some fixedε>0. Our deterministic and randomized sequential and parallel algorithms generalize to the lexicographic sorting of multiple-precision integers represented in several words.

An optimal parallel algorithm for sorting multisets

We consider the problem of sorting n numbers that contain only k distinct values. We present a randomized arbitrary CRCW PRAM algorithm that runs in O( log n) time using (n log k) log n processors. The same algorithm runs in O((log n) log log n) time with a total work of O( n ( log k) 1 + ε ) for any fixed ε < 0. All the stated bounds hold with high probability.

Triply-Logarithmic Parallel Upper and Lower Bounds for Minimum and Range Minima over Small Domains

We consider the problem of computing the minimum ofnvalues, and several well-known generalizations [prefix minima, range minima, and all nearest smaller values (ANSV)] for input elements drawn from the integer domain [1···s], wheres≥n. In this article we give simple and efficient algorithms for all of the preceding problems. These algorithms all takeO(logloglogs) time using an optimal number of processors andO(nsϵ) space (for constant ϵ<1) on the COMMON CRCW PRAM. The best known upper bounds for the range minima and ANSV problems were previouslyO(loglogn) (using algorithms for unbounded domains). For the prefix minima and for the minimum problems, the improvement is with regard to the model of computation. We also prove a lower bound of Ω(loglogn) for domain sizes=2Ω(lognloglogn). Since, forsat the lower end of this range, loglogn=Ω(logloglogs), this demonstrates that any algorithm running ino(logloglogs) time must restrict the range ofson which it works.

Optimal Parallel Two Dimensional Text Searching on a CREW PRAM

We present a parallel algorithm for two dimensional text searching over a general alphabet. This algorithm is optimal in two ways. First, the total number of operations on the text is linear. Second, the algorithm takes time O (log m ) on a CREW PRAM (where m is the length of the longest dimension of the pattern), thus matching the lower bound for string matching on a PRAM without concurrent writes. On a CRCW, the algorithm runs in time O (log log m ).

Parallel algorithms for relational coarsest partition problems

Relational Coarsest Partition Problems (RCPPs) play a vital role in verifying concurrent systems. It is known that RCPPs are P-complete and hence it may not be possible to design polylog time parallel algorithms for these problems. In this paper, we present two efficient parallel algorithms for RCPP in which its associated label transition system is assumed to have m transitions and n states. The first algorithm runs in O(n/sup 1+/spl epsiv//) time using m/n/sup /spl epsiv// CREW PRAM processors, for any fixed /spl epsiv/<1. This algorithm is analogous to and optimal with respect to the sequential algorithm of P.C. Kanellakis and S.A. Smolka (1990). The second algorithm runs in O(n log n) time using m/n CREW PRAM processors. This algorithm is analogous to and nearly optimal with respect to the sequential algorithm of R. Paige and R.E. Tarjan (1987).

Solving the all-pair shortest path query problem on interval and circular-arc graphs

In this paper, we study the following all-pair shortest path query problem: Given the interval model of an unweighted interval graph of n vertices, build a data structure such that each query on the shortest path (or its length) between any pair of vertices of the graph can be processed efficiently (both sequentially and in parallel). We show that, after sorting the input intervals by their endpoints, a data structure can be constructed sequentially in O(n) time and O(n) space; using this data structure, each query on the length of the shortest path between any two intervals can be answered in O(1) time, and each query on the actual shortest path can be answered in O(k) time, where k is the number of intervals on that path. Furthermore, this data structure can be constructed optimally in parallel, in O(log n) time using O(n/log n) CREW PRAM processors; each query on the actual shortest path can be answered in O(1) time using k processors. Our techniques can be extended to solving the all-pair shortest path query problem on circular-arc graphs, both sequentially and in parallel, in the same complexity bounds. As an immediate consequence of our results, we improve by a factor of n the space complexity of the previously best-known sequential all-pair shortest path algorithm for unweighted interval graphs. © 1998 John Wiley & Sons, Inc. Networks 31: 249–258, 1998

An Efficient Parallel Strategy for ComputingK-Terminal Reliability and Finding Most Vital Edges in 2-Trees and Partial 2-Trees

In this paper, we first develop a parallel algorithm for computingK-terminal reliability, denoted byR(GK), in 2-trees. Based on this result, we can also computeR(GK) in partial 2-trees using a method that transforms, in parallel, a given partial 2-tree into a 2-tree. Finally, we solve the problem of finding most vital edges with respect toK-terminal reliability in partial 2-trees. Our algorithms takeO(logn) time withC(m,n) processors on a CRCW PRAM, whereC(m,n) is the number of processors required to find the connected components of a graph withmedges andnvertices in logarithmic time.

Optimal Circular Arc Representations: Properties, Recognition, and Construction

We investigate some properties of minimal interval and circular arc representations and give several optimal sequential and parallel recognition and construction algorithms. We show that, among other things, given ans×tinterval or circular arc representation matrix, •deciding if the representation is minimal can be done inO(logs) time withO(st/logs) EREW PRAM processors, or inO(1) time withO(st) common CRCW PRAM processors; •constructing an equivalent minimum interval representation can be done inO(log(st)) time withO(st/log(st)) EREW PRAM processors, or inO(logt/loglogt) time withO(stloglogt/logt) common CRCW PRAM processors, or inO(1) time withO(st) BSR processors; •constructing an equivalent minimal circular arc representation can be done inO(st) time.

Finding the Convex Hull of Discs in Parallel

We present a parallel method for finding the convex hull of planar discs in the EREW PRAM model. We show that the convex hull of n discs in the plane can be computed in O( log 1+ε n) time using O(n/ log ε n) processors or in O( log n log log n) time using O(n log 1+ε n) processors for any positive constant ε. The first result achieves cost optimal and the second one runs faster. We also show that the convex hull of planar discs can be constructed in O( log n) time using O(n) processors when the number of different kinds of radii is restricted to 2O( log α n) for any positive constant α with 0 &lt; α &lt; 1. Finally, we show that our method can be generalized to computing the convex hull of a large class of planar curves. We use a technique called multi-level divide-and-conquer in our algorithm.

Determining Weak Visibility of a Polygon from an Edge in Parallel

The problem of determining the weak visibility of an n-vertex simple polygon P from an edge e of P is that of deciding whether every point in P is weakly visible from e. In this paper we present an optimal parallel algorithm for solving this problem. Our algorithm runs in O( log n) time using O(n/ log n) processors in the CREW PRAM computational model, and is very different from the sequential algorithms for this problem. We also show how to solve optimally, in parallel, several other problems that are related to the weak visibility of simple polygons.

Fast Generation of Random Permutations Via Networks Simulation

We consider the problem of generating random permutations with uniform distribution. That is, we require that for an arbitrary permutation π of n elements, with probability 1/n! the machine halts with the i th output cell containing π(i) , for 1 ≤ i ≤ n . We study this problem on two models of parallel computations: the CREW PRAM and the EREW PRAM. The main result of the paper is an algorithm for generating random permutations that runs in O(log log n) time and uses O(n 1+o(1) ) processors on the CREW PRAM. This is the first o(log n) -time CREW PRAM algorithm for this problem. On the EREW PRAM we present a simple algorithm that generates a random permutation in time O(log n) using n processors and O(n) space. This algorithm outperforms each of the previously known algorithms for the exclusive write PRAMs. The common and novel feature of both our algorithms is first to design a suitable random switching network generating a permutation and then to simulate this network on the PRAM model in a fast way.

A new parallel algorithm for rooting a tree

When an undirected tree,T, and a vertex,r, in the tree are given, the problem to transformT into a rooted tree withr as its root is considered. Using Euler tour and prefix sum, an optimal algorithm has been developed [2, 3]. We will present another parallel algorithm which is optimal also on EREW PRAM. Our approach reduces the given tree step by step by pruning and pointer jumping. That is, the tree structure is retained during algorithm processing such that another tree computations can be carried out in parallel.

The queue-read queue-write asynchronous PRAM model

This paper presents results for the queue-read, queue-write asynchronous parallel random access machine ( qrqw asynchronous pram) model, which is the asynchronous variant of the qrqw pram model. The qrqw pram family of models, which was introduced earlier by the authors, permit concurrent reading and writing to shared memory locations, but each memory location is viewed as having a queue which can service at most one request at a time. In the basic qrqw pram model each processor executes a series of reads to shared memory locations, a series of local computation steps, and a series of writes to shared memory locations, and then synchronizes with all other processors; thus this can be viewed as a bulk-synchronous model. In contrast, in the qrqw asynchronous pram model discussed in this paper, there is no imposed bulk-synchronization between processors, and each processor proceeds at its own pace. Thus, the qrqw asynchronous pram serves as a better model for designing and analyzing truly asynchronous parallel algorithms than the original qrqw pram. In this paper we elaborate on the qrqw asynchronous pram model, and we demonstrate the power of asynchrony over bulk-synchrony by presenting a work and time optimal deterministic algorithm on the qrqw asynchronous pram for the leader election problem and a simple randomized work and time optimal algorithm on the qrqw asynchronous pram for sorting. In contrast, no tight bounds are known on the qrqw pram for either deterministic or randomized parallel algorithms for leader election and the only work and time optimal algorithms for sorting known on the qrqw pram are those inherited from the erew pram, which are considerably more complicated. Our sorting algorithm is an asynchronous version of an earlier sorting algorithm we developed for the qrqw pram, for which we use an interesting analysis to bound the running time to be O( log n). We also present a randomized algorithm to simulate one step of a crcw pram on a qrqw asynchronous pram in sublogarithmic time if the maximum contention in the step is relatively small. © 1998—Elsevier Science B.V. All rights reserved

Efficient Matrix Chain Ordering in Polylog Time

The matrix chain ordering problem is to find the cheapest way to multiply a chain of n matrices, where the matrices are pairwise compatible but of varying dimensions. Here we give several new parallel algorithms including $O(\lg^3 n)$-time and $n/\!\lg n$-processor algorithms for solving the matrix chain ordering problem and for solving an optimal triangulation problem of convex polygons on the common CRCW PRAM model. Next, by using efficient algorithms for computing row minima of totally monotone matrices, this complexity is improved to $O(\lg^2 n)$ time with $n$ processors on the EREW PRAM and to $O(\lg^2 n \lg \lg n)$ time with $n/ \! \lg \lg n$ processors on a common CRCW PRAM\@. A new algorithm for computing the row minima of totally monotone matrices improves our parallel MCOP algorithm to $O(n \lg^{1.5} n)$ work and polylog time on a CREW PRAM\@. Optimal log-time algorithms for computing row minima of totally monotone matrices will improve our algorithm and enable it to have the same work as the sequential algorithm of Hu and Shing [SIAM J. Comput., 11 (1982), pp. 362--373; SIAM J. Comput., 13 (1984), pp. 228--251].