EREW Research Articles

A parallel extended GCD algorithm

A new parallel extended GCD algorithm is proposed. It matches the best existing parallel integer GCD algorithms of Sorenson and Chor and Goldreich, since it can be achieved in O ϵ ( n / log n ) time using at most n 1 + ϵ processors on CRCW PRAM. Sorenson and Chor and Goldreich both use a modular approach which consider the least significant bits. By contrast, our algorithm only deals with the leading bits of the integers u and v, with u ⩾ v . This approach is more suitable for extended GCD algorithms since the coefficients of the extended version a and b, such that a u + b v = gcd ( u , v ) , are deeply linked with the order of magnitude of the rational v / u and its continuants. Consequently, the computation of such coefficients is much easier.

Optimal parallel selection

We present an optimal parallel selection algorithm on the EREW PRAM. This algorithm runs in O (log n ) time with n /log n processors. This complexity matches the known lower bound for parallel selection on the EREW PRAM model. We therefore close this problem which has been open for more than a decade.

A simple optimal parallel algorithm for constructing a spanning tree of a trapezoid graph

Let G be a connected graph with n vertices. A spanning tree of G is an acyclic subgraph of G that has n vertices and n−1 edges. In this paper, we propose a simple optimal parallel algorithm for constructing a spanning tree of a trapezoid graph in O(log n) time with O(n/log n) processors on the EREW PRAM computational model.

Fast and scalable computations of 2D image moments

Image moments are used in image analysis for object modelling and matching. The moment computation of a two-dimensional (2D) image involves a significant amount of multiplication and addition in a direct method. In this paper, we use the suffix sum functions to compute the gray-level image moments instead of using a direct method. This new method can reduce drastically the number of multiplications required. We first derive the mathematical relationships between moment computations and suffix sums. Based on the derived mathematical relationships, four new parallel algorithms for computing image moments are derived on various computational models. By integrating the advantages of both optical transmission and electronic computation, the 2D image moments can be computed in constant time on a 2D array with reconfigurable optical buses. The performance comparison shows that the proposed method is fast and efficient. In addition, three scalable and cost optimal algorithms are derived on the AROB, the hypercube computer and the EREW PRAM model.

Formula dissection: A parallel algorithm for constraint satisfaction

Many well-known problems in Artificial Intelligence can be formulated in terms of systems of constraints. The problem of testing the satisfiability of propositional formulae (SAT) is of special importance due to its numerous applications in theoretical computer science and Artificial Intelligence. A brute-force algorithm for SAT will have exponential time complexity O ( 2 n ) , where n is the number of Boolean variables of the formula. Unfortunately, more sophisticated approaches such as resolution result in similar performances in the worst case. In this paper, we present a simple and relatively efficient parallel divide-and-conquer method to solve various subclasses of SAT. The dissection stage of the parallel algorithm splits the original formula into smaller subformulae with only a bounded number of interacting variables. In particular, we derive a parallel algorithm for the class of formulae whose corresponding graph representation is planar. Our parallel algorithm for planar 3-SAT has the worst-case performance of 2 O ( n ) on a PRAM (parallel random access model) computer. Applications of our method to constraint satisfaction problems are discussed.

Parallel merging with restriction

In this paper, we study the merging of two sorted arrays $A=(a_{1},a_{2},\ldots, a_{n_{1}})$ and $B=(b_{1},b_{2},\ldots,b_{n_{2}})$ on EREW PRAM with two restrictions: (1) The elements of two arrays are taken from the integer range [1,n], where n=Max(n 1,n 2). (2) The elements are taken from either uniform distribution or non-uniform distribution such that $\#\{a\in A\,\mbox{and}\,b\in B\,\mbox{s.t.}\,a,b\in [(i-1)\frac{n}{p}+1,i\,\frac{n}{p}]\}=O(\frac{n}{p})$ , for 1?i?p?(number of processors). We give a new optimal deterministic algorithm runs in $O(\frac{n}{p})$ time using p processors on EREW PRAM. For $p=\frac{n}{\log^{(g)}{n}}$ ; the running time of the algorithm is O(log?(g) n) which is faster than the previous results, where log?(g) n=log?log?(g?1) n for g>1 and log?(1) n=log?n. We also extend the domain of input data to [1,n k ], where k is a constant.

FAILURE-SENSITIVE ANALYSIS OF PARALLEL ALGORITHMS WITH CONTROLLED MEMORY ACCESS CONCURRENCY

The abstract problem of using P failure-prone processors to cooperatively update all locations of an N-element shared array is called Write-All. Solutions to Write-All can be used iteratively to construct efficient simulations of PRAM algorithms on failure-prone PRAMS. Such use of Write-All in simulations is abstracted in terms of the iterative Write-All problem. The efficiency of the algorithmic solutions for Write-All and iterative Write-All is measured in terms of work complexity where all processing steps taken by the processors are counted. This paper considers determinitic solutions for the Write-All and iterative Write-All problems in the fail-stop synchronous CRCW PRAM model where memory access concurrency needs to be controlled. A deterministic algorithm of Kanellakis, Michailidis, and Shvartsman [16] efficiently solves the Write-All problem in this model, while controlling read and write memory access concurrency. However it was not shown how the number of processor failures f affects the work efficiency of the algorithm. The results herein give a new analysis of the algorithm [16] that obtain failure-sensitive work bounds, while retaining the known memory access concurrency bounds. Specifically, the new result expresses the work bound as a function of N, Pandf. Another contribution in this paper is the new failure-sensitive analysis for iterative Write-All with controlled memory access concurrency. This result yields tighter bounds on work (vs. [16]) for simulations of PRAM algorithms on fail-stop PRAMS.

Block sensitivity of weakly symmetric functions

Block sensitivity, which was introduced by Nisan [Noam Nisan, CREW PRAMs and decision trees, SIAM Journal on Computing 20 (6) (1991) 999–1007. Earlier version in STOC’89], is one of the most useful measures of Boolean functions. In this paper we investigate the block sensitivity of weakly symmetric functions (functions invariant under some transitive group action). We prove a Ω ( N 1 / 3 ) lower bound for the block sensitivity of weakly symmetric functions. We also construct a weakly symmetric function which has block sensitivity O ̃ ( N 3 / 7 ) .

On coding labeled trees

We consider the problem of coding labeled trees by means of strings of node labels. Different codes have been introduced in the literature by Prüfer, Neville, and Deo and Micikevičius. For all of them, we show that both coding and decoding can be reduced to integer (radix) sorting, closing several open problems within a unified framework that can be applied both in a sequential and in a parallel setting. Our sequential coding and decoding schemes require optimal O ( n ) time when applied to n -node trees, yielding the first linear time decoding algorithm for a code presented by Neville. These schemes can be parallelized on the EREW PRAM model, so as to work in O ( log n ) time with cost O ( n ) , O ( n log n ) , or O ( n log n ) , depending on the code and on the operation: in all cases, they either match or improve the performances of the best ad hoc approaches known so far.

Output-sensitive algorithms for optimally constructing the upper envelope of straight line segments in parallel

The importance of the sensitivity of an algorithm to the output size of a problem is well-known especially if the upper bound on the output size is known to be not too large. In this paper we focus on the problem of designing very fast parallel algorithms for constructing the upper envelope of straight-line segments that achieve the O ( n log H ) work-bound for input size n and output size H. When the output size is small, our algorithms run faster than the algorithms whose running times are sensitive only to the input size. Since the upper bound on the output size of the upper envelop problem is known to be small ( n α ( n ) ), where α ( n ) is a slowly growing inverse-Ackerman's function, the algorithms are no worse in cost than the previous algorithms in the worst case of the output size. Our algorithms are designed for the arbitrary CRCW PRAM model. We first describe an O ( log n · ( log H + log log n ) ) time deterministic algorithm for the problem, that achieves O ( n log H ) work bound for H = Ω ( log n ) . We then present a fast randomized algorithm that runs in expected time O ( log H · log log n ) with high probability and does O ( n log H ) work. For log H = Ω ( log log n ) , we can achieve the running time of O ( log H ) while simultaneously keeping the work optimal. We also present a fast randomized algorithm that runs in O ˜ ( log n / log k ) time with nk processors, k > log Ω ( 1 ) n . The algorithms do not assume any prior input distribution and the running times hold with high probability.

An optimal parallel solution for the path cover problem on [formula omitted]-sparse graphs

Nakano et al. [A time-optimal solution for the path cover problem on cographs, Theoret. Comput. Science 290 (2003) 1541–1556] presented a time- and work-optimal algorithm for finding the smallest number of vertex-disjoint paths that cover the vertices of a cograph and left open the problem of applying their technique into other classes of graphs. Motivated by this issue we generalize their technique and apply it to the class of P 4 -sparse graphs, which forms a proper superclass of cographs. We show that the path cover problem on P 4 -sparse graphs can also be optimally solved. More precisely, given a P 4 -sparse graph G on n vertices and its modular decomposition tree, we describe an optimal parallel algorithm which returns a minimum path cover of G in O ( log n ) time using O ( n / log n ) processors on the EREW PRAM model. Our results generalize previous results and extend the family of perfect graphs admitting optimal solutions for the path cover problem.

Modular exponentiation via the explicit Chinese remainder theorem

Fix pairwise coprime positive integers p 1 ,P 2 ,..., p a . We propose representing integers u modulo m, where m is any positive integer up to roughly p 1 p 2 ... P s , as vectors (u mod p 1 , u mod p 2 ,.., u mod p s ). We use this representation to obtain a new result on the parallel complexity of modular exponentiation: there is an algorithm for the Common CRCW PRAM that, given positive integers x, e, and m in binary, of total bit length n, computes x e mod m in time O(n/lglgn) using n O(1) processors. For comparison, a parallelization of the standard binary algorithm takes superlinear time; Adleman and Kompella gave an O((lg n) 3 ) expected time algorithm using exp(O(n lg n)) processors; von zur Gathen gave an NC algorithm for the highly special case that m is polynomially smooth.

Recognizing and representing proper interval graphs in parallel using merging and sorting

We present a parallel algorithm for recognizing and representing a proper interval graph in O ( log 2 n ) time with O ( m + n ) processors on the CREW PRAM, where m and n are the number of edges and vertices in the graph. The algorithm uses sorting to compute a weak linear ordering of the vertices, from which an interval representation is easily obtained. It is simple, uses no complex data structures, and extends ideas from an optimal sequential algorithm for recognizing and representing a proper interval graph [X. Deng, P. Hell, J. Huang, Linear-time representation algorithms for proper circular-arc graphs and proper interval graphs, SIAM J. Comput. 25 (2) (1996) 390–403].

Formula omitted] query time algorithm for all pairs shortest distances on permutation graphs

We present an algorithm for the all pairs shortest distance problem on permutation graphs. Given a permutation model for the graph on n vertices, after O ( n ) preprocessing the algorithm will deliver answers to distance queries in O ( 1 ) time. In the EREW PRAM model, preprocessing can be accomplished in O ( log n ) time with O ( n ) work. Where the distance between query vertices is k, a path can be delivered in O ( k ) time. The method is based on reduction to bipartite permutation graphs, a further reduction to unit interval graphs, and a coordinatization of unit interval graphs.

A faster parallel connectivity algorithm on cographs

Cographs are a well-known class of graphs arising in a wide spectrum of practical applications. In this note, we show that the connected components of a cograph G can be optimally found in O ( log log log Δ ( G ) ) time using O ( ( n + m ) log log log Δ ( G ) ) processors on a common CRCW PRAM, or in O ( log Δ ( G ) ) time using O ( ( n + m ) log Δ ( G ) ) processors on an EREW PRAM, where Δ ( G ) is the maximum degree of G , and n and m respectively are the numbers of vertices and edges of G . These are faster than the previously best known result on general graphs.

The interval-merging problem

A closed interval is an ordered pair of real numbers [ x, y], with x ⩽ y. The interval [ x, y] represents the set { i ∈ R∣ x ⩽ i ⩽ y}. Given a set of closed intervals I = { [ a 1 , b 1 ] , [ a 2 , b 2 ] , … , [ a k , b k ] } , the Interval-Merging Problem is to find a minimum-cardinality set of intervals M ( I ) = { [ x 1 , y 1 ] , [ x 2 , y 2 ] , … , [ x j , y j ] } , j ⩽ k, such that the real numbers represented by I = ⋃ i = 1 k [ a i , b i ] equal those represented by M ( I ) = ⋃ i = 1 j [ x i , y i ] . In this paper, we show the problem can be solved in O( d log d) sequential time, and in O(log d) parallel time using O( d) processors on an EREW PRAM, where d is the number of the endpoints of I . Moreover, if the input is given as a set of sorted endpoints, then the problem can be solved in O( d) sequential time, and in O(log d) parallel time using O( d/log d) processors on an EREW PRAM.

A Cost Optimal Parallel Algorithm for Patience Sorting

In this paper, we consider a parallel algorithm for the patience sorting. The problem is not known to be in the class NC or P-complete. We propose two algorithms for the patience sorting of n distinct integers. The first algorithm runs in [Formula: see text] time using p processors on the EREW PRAM, where m is the number of decreasing subsequences in a solution of the patience sorting. The second algorithm runs in [Formula: see text] time using p processors on the EREW PRAM. If [Formula: see text] is satisfied, the second algorithm becomes cost optimal.

Pipeline Givens sequences for computing the QR decomposition on a EREW PRAM

Parallel Givens sequences for computing the QR decomposition of an m × n ( m > n) matrix are considered. The Givens rotations operate on adjacent planes. A pipeline strategy for updating the pair of elements in the affected rows of the matrix is employed. This allows a Givens rotation to use rows that have been partially updated by previous rotations. Two new Givens schemes, based on this pipeline approach, and requiring respectively n 2/2 and n processors, are developed. Within this context a performance analysis on an exclusive-read, exclusive-write (EREW) parallel random access machine (PRAM) computational model establishes that the proposed schemes are twice as efficient as existing Givens sequences.

PARALLEL IMPLEMENTATION OF DOMAIN DECOMPOSITION BASED IMAGE COMPRESSION ALGORITHM

AbstractThis paper presents algorithms for parallel implementation of the recently reported binary tree triangular coding (BTTC ) method for lossy image compression. We present parallel BTTC algorithms for four models: (1) parallel random access machine (PRAM), (2) hypercube, (3) 2-D mesh, and (4) sparse mesh, with their respective time complexities as O((n/p) log(n/p)), O((n/p) (log(n/p) +log p)), O((n/p) (log(n/p)+log p)), and O((n/p) (log(n/p)+log p)) for encoding and θ(n/p), θ ((n/p) (1+log p)), θ((n/p) (1+log p)), and θ((n/p) (1+log p)) for decoding, wheren is total number of pixels in the image and p is number of processors.

Parallel Implementation of Domain Decomposition Based Image Compression Algorithm

This paper presents algorithms for parallel implementation of the recently reported binary tree triangular coding (BTTC ) method for lossy image compression. We present parallel BTTC algorithms for four models: (1) parallel random access machine (PRAM), (2) hypercube, (3) 2-D mesh, and (4) sparse mesh, with their respective time complexities as O((n/p) log(n/p)), O((n/p) (log(n/p) +log p)), O((n/p) (log(n/p)+log p)), and O((n/p) (log(n/p)+log p)) for encoding and θ(n/p), θ ((n/p) (1+log p)), θ((n/p) (1+log p)), and θ((n/p) (1+log p)) for decoding, wheren is total number of pixels in the image and p is number of processors.