Exclusive-write Parallel Random Access Machine Research Articles

A Parallel Algorithm for Scheduling a Two-Machine Robotic Cell in Bicycle Frame Welding Process

Welding frames with differing geometries is one of the most crucial stages in the production of high-end bicycles. This paper proposes a parallel algorithm and a mixed integer linear programming formulation for scheduling a two-machine robotic welding station. The time complexity of the introduced parallel method is O(log2n) on an n3-processor Exclusive Read Exclusive Write Parallel Random-Access Machine (EREW PRAM), where n is the problem size. The algorithm is designed to take advantage of modern graphics cards to significantly accelerate the computations. To present the benefits of the parallelization, the algorithm is compared to the state of art sequential method and a solver-based approach. Experimental results show an impressive speedup for larger problem instances—up to 314 on a single Graphics Processing Unit (GPU), compared to a single-threaded CPU execution of the sequential algorithm.

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.

Greedy Givens algorithms for computing the rank- k updating of the QR decomposition

A Greedy Givens algorithm for computing the rank-1 updating of the QR decomposition is proposed. An exclusive-read exclusive-write parallel random access machine computational model is assumed. The complexity of the algorithms is calculated in two different ways. In the unlimited parallelism case a single time unit is required to apply a compound disjoint Givens rotation of any size. In the limited parallelism case all the disjoint Givens rotations can be applied simultaneously, but one time unit is required to apply a rotation to a two-element vector. The proposed Greedy algorithm requires approximately 5/8 the number of steps performed by the conventional sequential Givens rank-1 algorithm under unlimited parallelism. A parallel implementation of the sequential Givens algorithm outperforms the Greedy one under limited parallelism. An adaptation of the Greedy algorithm to compute the rank- k updating of the QR decomposition has been developed. This algorithm outperforms a recently reported parallel method for small k, but its efficiency decreases as k increases.

Concurrent threads and optimal parallel minimum spanning trees algorithm

This paper resolves a long-standing open problem on whether the concurrent write capability of parallel random access machine (PRAM) is essential for solving fundamental graph problems like connected components and minimum spanning trees in O (log n ) time. Specifically, we present a new algorithm to solve these problems in O (log n ) time using a linear number of processors on the exclusive-read exclusive-write PRAM. The logarithmic time bound is actually optimal since it is well known that even computing the “OR” of n bit requires Ω(log n time on the exclusive-write PRAM. The efficiency achieved by the new algorithm is based on a new schedule which can exploit a high degree of parallelism.

The CREW PRAM Complexity of Modular Inversion

One of the long-standing open questions in the theory of parallel computation is the parallel complexity of the integer gcd and related problems, such as modular inversion. We present a lower bound $\Omega (\log n)$ for the parallel time on a concurrent-read exclusive-write parallel random access machine (CREW PRAM) computing the inverse modulo certain n-bit integers, including all such primes. For infinitely many moduli, our lower bound matches asymptotically the known upper bound. We obtain a similar lower bound for computing a specified bit in a large power of an integer. Our main tools are certain estimates for exponential sums in finite fields.

Parallelism Always Helps

It is shown that every unit-cost random-access machine (RAM) that runs in time T can be simulated by a concurrent-read exclusive-write parallel random-access machine (CREW PRAM) in time $O(\rt{T} \log T)$. The proof is constructive; thus it gives a mechanical way to translate any sequential algorithm designed to run on a unit-cost RAM into a parallel algorithm that runs on a CREW PRAM and obtain a nearly quadratic speedup. One implication is that there does not exist any recursive function that is "inherently not parallelizable."

An Efficient Parallel Algorithm for the Matrix-Chain-Product Problem

We consider the problem of finding an optimal order of computing a matrix-chain product. This problem can be solved using dynamic programming in $O(n^3 )$ sequential time, but the best sequential algorithm known for this problem runs in $O(n\log n)$ time. A general technique for parallelizing a class of dynamic-programming algorithms leads to an algorithm that runs in $O(\log ^2 n)$ time on a concurrent-read exclusive-write parallel random-access machine (CREW PRAM) with $O({{n^6 } / {\log n}})$ processors. The best parallel algorithm previously known runs in $O(\log ^3 n)$ time using $O({{n^2 } / {\log ^3 n}})$ processors. We present an algorithm that runs in $O(\log ^4 n)$ time on a CREW PRAM with n processors.

Tree-Adjoining Language Parsing in $O(n^6 )$ Time

In this paper, we present algorithms for parsing general tree-adjoining languages (TALs). Tree-adjoining grammars (TAGs) have been proposed as an elegant formalism for natural languages. It was an open question for the past ten years as to whether TAL parsing can be done in time $O(n^6 )$. We settle this question affirmatively by presenting an $O(n^3 M(n))$-time algorithm, where $M(k)$ is the time needed for multiplying two Boolean matrices of size $k \times k$ each. Since $O(k^{2.376} )$ is the current best-known value for $M(k)$, the time bound of our algorithm is $O(n^{5.376} )$. On an exclusive-read exclusive-write parallel random-access machine (EREW PRAM), our algorithm runs in time $O(n\log n)$ using ${{(n^2 M(n))} / {\log n}}$ processors. In comparison, the best-known previous parallel algorithm had a run time of $O(n)$ using $n^5 $ processors (on a systolic-array machine). We also present algorithms for parsing context-free languages (CFLs) and TALs whose worst-case run times are $O(n^3 )$ and $O(n^6 )$, respectively, but whose average run times are better. Therefore, these algorithms may be of practical interest.

The Subtree Max Gap Problem with Application to Parallel String Covering

We introduce the subtree max gap problem. Consider a rooted tree T with n leaves whose internal nodes have at least two children. Each leaf is associated with a real number. For each internal node v, let Av be the set of numbers associated with the leaves in the subtree rooted at v which are regarded as points on the x-axis. The subtree max gap problem is to compute the maximum distance (gap) between any two consecutive points of Av for every internal node v of T. Our algorithm for the subtree max gap problem follows a series of reductions to other combinatorial problems which are interesting on their own merit. The algorithm runs in O(log n) time using n processors on the concurrent-read exclusive-write parallel random access machine. The subtree max gap problem plays a central role in the parallel solution of the string covering problem. Recently, lliopoulos, et al. (1993, in "Proc. 26th Symposium in Theory of Computing," pp. 290-299) gave an O(n log n) time sequential algorithm for the string covering problem. Neither parallelizing the above sequential algorithm nor using known techniques from algorithms on strings seems to yield an efficient parallel algorithm for string covering. Our parallel algorithm thus follows a new approach, suing suffix trees and reducing the string covering problem to the subtree max gap problem. The algorithm runs in O(log n) time using n processors on the concurrent-read concurrent-write parallel random access machine, thereby matching the number of operations in lliopoulos, et al.

Parallel Heap Operations on an EREW PRAM

We consider parallel heap operations on the exclusive-read exclusive-write parallel random-access machine. We first present an O(n/p + log p) time parallel algorithm to construct a heap of n elements using p processors, which is optimal for p θ(n/log n). We then propose a parallel root deletion algorithm. In a preparatory step, a data structure for dynamic processor allocation is constructed using O((n/log n)1 − 1/k) processors in O(log k) time for some constant k, 1 ≤ k ≤ ⌈log(n/log n)⌉. A sequence of root deletions can then be performed, each of which takes O((log n)/p + log p + log log n) time using p processors. Finally, we discuss a parallel algorithm running in O((log n)/p + log p) time for inserting an element into a heap, which is optimal for p = θ((log n)/log log n). Both deletion and insertion algorithms run in O(log log n) time when p = θ((log n)/log log n).

Efficient EREW PRAM algorithms for parentheses-matching

We present four polylog-time parallel algorithms for matching parentheses on an exclusive-read and exclusive-write (EREW) parallel random-access machine (PRAM) model. These algorithms provide new insights into the parentheses-matching problem. The first algorithm has a time complexity of O(log/sup 2/ n) employing O(n/(log n)) processors for an input string containing n parentheses. Although this algorithm is not cost-optimal, it is extremely simple to implement. The remaining three algorithms, which are based on a different approach, achieve O(log n) time complexity in each case, and represent successive improvements. The second algorithm requires O(n) processors and working space, and it is comparable to the first algorithm in its ease of implementation. The third algorithm uses O(n/(log n)) processors and O(n log n) space. Thus, it is cost-optimal, but uses extra space compared to the standard stack-based sequential algorithm. The last algorithm reduces the space complexity to O(n) while maintaining the same processor and time complexities. Compared to other existing time-optimal algorithms for the parentheses-matching problem that either employ extensive pipelining or use linked lists and comparable data structures, and employ sorting or a linked list ranking algorithm as subroutines, the last two algorithms have two distinct advantages. First, these algorithms employ arrays as their basic data structures, and second, they do not use any pipelining, sorting, or linked list ranking algorithms. >

A fast algorithm for scalar Nevanlinna-Pick interpolation

In this paper, we derive a fast algorithm for the scalar Nevanlinna-Pick interpolation. Givenn distinct pointsz i in the unit disk |z|<1 andn complex numbersw i satisfying the Pick condition for 1?i?n, the new Nevanlinna-Pick interpolation algorithm requires onlyO(n) arithmetic operations to evaluate the interpolatory rational function at a particular value ofz, in contrast to the classical algorithm which requiresO(n 2) arithmetic operations to compute the so-called Fenyves array (which is inherent in the classical algorithm). The new algorithm bypasses the generation of the Fenyves array to speed up the computation, and also yields a parallel scheme requiring onlyO(logn) arithmetic operations on a concurrent-read, exclusive-write parallel random access machine withn processors. We must remark that the rational functionf(z) computed by the new algorithm is one degree higher than the function computed by the classical algorithm.

Fast parallel constraint satisfaction

We describe a class of constraint satisfaction problems (CSPs) for which a global solution can be found by a fast parallel algorithm. No relaxation preprocessing is needed for the parallel algorithm to work on this class of CSPs. The result is motivated from the problem of labelling a 2-D line drawing of a 3-D object by the Clowes-Huffman-Malik labelling scheme—an important application of CSP in computer vision. For such a CSP, the constraint graph can be general, but the constraint relations are usually of the type we call implicational. It is shown here that a CSP with this type of constraint relations (and no restrictions on its graph) can be solved by an efficient (i.e., with polynomial time complexity) sequential algorithm. Also, it is shown that it can be solved by a fast parallel algorithm that executes in time O(log 3 n) with O( (m + n 3) logn ) processors on an exclusive-read exclusive-write parallel random access machine ( n is the number of variables and m is the number of constraint relations—the constraint relations may have arity more than two).

Efficient and Scalable PRAM Algorithms for Discrete-Event Simulation of Bounded Degree Networks

We describe two new parallel algorithms, one conservative and another optimistic, for discrete-event simulation on an exclusive-read exclusive-write parallel random-access machine (EREW PRAM). The target physical systems are bounded degree networks which are represented by logic circuits. Employing p processors, our conservative algorithm can simulate up to O(p) independent messages of a system with n logical processes in O(log n) time. The number of processors, p, can be optimally varied in the range 1 ≤ p ≤ n. To identify independent messages, this algorithm also introduces a novel scheme based on a variable size time window. Our optimistic algorithm is designed to reduce the rollback frequency and the memory requirement to save past states and messages. The optimistic algorithm also simulates O(p) earliest messages on a p-processor computer in O(log n) time. To our knowledge, such a theoretical efficiency in parallel simulation algorithms, conservative or optimistic, has been achieved for the first time.

Improved processor bounds for parallel algorithms for weighted directed graphs

We present a parallel algorithm that solves the single-source shortest path problem (SSSP) for a weighted digraph G=( V, E) in time O(log 2 n) using M( n) processors on an exclusive-read exclusive-write parallel random access machine (EREW PRAM), where n=\ | V\ |, edge weights are drawn from the set \\s{0, 1,…, k\\s} for some constant k, and M( n) is the number of processors necessary to multiply two n× n integer matrices over a ring in O(log n) time (currently, M( n)= n 2.376 ). This algorithm is a generalization of the O(log 2 n) time, M( n) processor EREW PRAM algorithm due to Gazit and Miller for the SSSP problem in an unweighted digraph. We also briefly explain how our solution of the SSSP problem for a weighted digraph can be used to reduce the previous known processor bounds for a number of digraph problems to M( n) from Θ( n 3) (within a polylog factor) without increasing the running time.

An efficient procedure for theorem proving in propositional logic on vector computers

In this paper, we present an efficient procedure for solving the theorem proving problem in propositional logic. To take advantage of vector processing, we develop a vectorized representation of the problem and the deductions are performed implicitly by simple AND and OR operations on vectors. The approach is simpler than those using explicit inference rules. Vectorized procedures based on the representation are then proposed. The computational bound of the approach on a concurrent-read exclusive-write parallel random access machine is of O( mlog 2 n), where m is the number of clauses and n is the number of distinct Boolean variables in the given formula. A divide-and-conquer strategy is used to partition the problem so that it can be solved by the existing vector computers. Experiments are conducted on vector computers. The result confirms the effectiveness of vectorization techniques and applicability of vector processing to theorem proving in propositional logic.

Parallel computation of matchings in trees

We present adaptive parallel algorithms for b-matchings in trees. The algorithms are designed using the exclusive-read exclusive-write parallel random-access machine (EREW PRAM) model of parallel computation. For a tree of n vertices, we present an algorithm that determines a maximum cardinality b-matching in O( n/p + log n) time using p processors, where p ⩽ n. An algorithm that executes in O( n/p′ + log n) time, where 1 < np/( n + p log n) ⩽ p′ < p ⩽ n and p > √ n/log n is also designed for the maximum weight b-matching problem in trees. When p ⩽ n/(log n), the algorithm are cost-optimal.

Time-space optimal parallel merging and sorting

The authors present a parallel merging algorithm that, on an exclusive-read exclusive-write (EREW) parallel random-access machine (PRAM) with k processors merges two sorted lists of total length n in O(n/k+log n) time and constant extra space per processor, and hence is time-space optimal for any value of k<or=n/(log n). The authors also describe how this gives rise to a stable version of the parallel merging algorithm that is similarly time-space optimal on an EREW PRAM. The authors observe that this technique for achieving stability incurs two penalties: a slightly more complicated algorithm and somewhat larger constants of proportionality. These two parallel merges naturally lead to time-space optimal parallel sorting algorithms. Extensions to sorting and open topics for future research are discussed.<<ETX>>

Parallel binary search

Two arrays of numbers sorted in nondecreasing order are given: an array A of size n and an array B of size m, where n<m. It is required to determine, for every element of A, the smallest element of B (if one exists) that is larger than or equal to it. It is shown how to solve this problem on the EREW PRAM (exclusive-read exclusive-write parallel random-access machine) in O(logm logn/log log m) time using n processors. The solution is then extended to the case in which fewer than n processors are available. This yields an EREW PRAM algorithm for the problem whose cost is O(n log m, which is O(m)) for n<or=m/log m. It is shown how the solution obtained leads to an improved parallel merging algorithm.<<ETX>>

PARALLEL BINARY SEARCH WITH DELAYED READ CONFLICTS

Given two sorted arrays, A (of size n) and B (of size m) where n≤m, it is required to determine for every element of A its position within B. A parallel algorithm is presented to solve this problem on the exclusive-read exclusive-write parallel random access machine (EREW PRAM). The algorithm uses p processors and runs in time. When and n≤mα, with 0<α<1, the cost of the algorithm, i.e. its running time multiplied by the number of processors it uses, matches the running time of the fastest known sequential algorithm for this problem.