CRCW Model Research Articles

Geometric Approach for Optimal Routing on a Mesh with Buses

The architecture of “mesh of buses” is an important model in parallel computing. Its main advantage is that the additional broadcast capability can be used to overcome the main disadvantage of the mesh, namely its relatively large diameter. We show that the addition of buses indeed accelerates routing times. Furthermore, unlike in the “store and forward” model, the routing time becomes proportional to the network load, resulting in decreasing in routing time for a smaller number of packets. We consider 1–1 routing ofmpackets in ad-dimensional mesh withndprocessors andd·nd−1buses (one per row and column). The two standard models of accessing the buses are considered and compared: CREW, in which only one processor may transmit at any given time on a given bus, and the CRCW model, in which several processors may attempt to transmit at the same time (getting a noise signal as a result). We design a routing algorithm that routesmpackets in the CREW model inO(m1/d+n1/(d+1)) steps. This result holds form⩽n2d/3ford⩾3 and unconditionally ford=2. A matching lower bound is also proved. In the CRCW case we show an algorithm ofO(m1/dlogn) and a lower bound ofΩ(m1/d). It is shown that the difference between the models is essentially due to the improved capability of estimating threshold functions in the CRCW case.

Parallel integer sorting and simulation amongst CRCW models

In this paper a general technique for reducing processors in simulation without any increase in time is described. This results in an O( log n ) time algorithm for simulating one step of PRIORITY o...

Parallel integer sorting and simulation amongst CRCW models

In this paper a general technique for reducing processors in simulation without any increase in time is described. This results in an O(?logn) time algorithm for simulating one step of PRIORITY on TOLERANT with processor-time product of O(n log logn); the same as that for simulating PRIORITY on ARBITRARY. This is used to obtain anO(logn/log logn + ?logn (log logm ? log logn)) time algorithm for sortingn integers from the set {0,...,m ? 1},m ?n, with a processor-time product ofO(n log logm log logn) on a TOLERANT CRCW PRAM. New upper and lower bounds for ordered chaining problem on an allocated COMMON CRCW model are also obtained. The algorithm for ordered chaining takesO(logn/log logn) time on an allocated PRAM of sizen. It is shown that this result is best possible (upto a constant multiplicative factor) by obtaining a lower bound of Ω(r logn/(logr + log logn)) for finding the first (leftmost one) live processor on an allocated-COMMON PRAM of sizen ofr-slow virtual processors (one processor simulatesr processors of allocated PRAM). As a result, for ordered chaining problem, "processor-time product" has to be at least Ω(n logn/log logn) for any poly-logarithmic time algorithm. Algorithm for ordered-chaining problem results in anO(logN/log logN) time algorithm for (stable) sorting ofn integers from the set {0,...,m ? 1} withn-processors on a COMMON CRCW PRAM; hereN = max(n, m). In particular if,m =n O(1), then sorting takes ?(logn/log logn) time on both TOLERANT and COMMON CRCW PRAMs. Processor-time product for TOLERANT isO(n(log logn)2). Algorithm for COMMON usesn processors.

A time- and cost-optimal algorithm for interlocking sets-with applications

Given a family I of intervals, two intervals in I interlock if they overlap but neither of them strictly contains the other. A set of intervals in which every two are related in the reflexive transitive closure of the interlock relation is referred to as an interlocking set. The task is determining the maximal interlocking sets of I arises in numerous applications, including traffic control, robot arm manipulation, segmentation of range images, routing, automated surveillance systems, recognizing polygonal configurations, and code generation for parallel machines. Our first contribution is to show that any sequential algorithm that computes the maximal interlocking sets of a family of n intervals must take /spl Omega/(n log n) time in the algebraic tree model. Next, we show that any parallel algorithm for this problem must take /spl Omega/(log n) time in the CREW model even if an infinite number of processors and memory cells are available. We then go on to show that both the sequential and the parallel lower bounds are tight by providing matching algorithms running, respectively, in /spl Theta/(n log n) sequential time and in /spl Theta/(log n) time using n processors in the CREW model. At the same time, if the endpoints of the intervals are specified in sorted order, our sequential algorithm runs in O(n) time, improving the best previously known result. It is interesting to note that even if the endpoints are sorted, /spl Omega/(log n) is a time lower bound for solving the problem in the CREW model, regardless of the amount of resources available. As an application of our algorithm for interlocking sets, we obtain a time- and cost-optimal solution to a restricted version of the single row routing problem. The best previously known result for routing a set of n nets without street crossovers runs in O(log n loglog n) time using n processors in the CRCW model. By contrast, our algorithm runs in /spl Theta/(log n) time using n/log n processors in the CREW model, being both time- and cost-optimal.

A Parallel Reduction of Hamiltonian Cycle to Hamiltonian Path in Tournaments

We propose a parallel algorithm which reduces the problem of computing Hamiltonian cycles in tournaments to the problem of computing Hamiltonian paths. The running time of our algorithm is O(log n) using O( n 2/log n) processors on a CRCW PRAM, and O(log n log log n) on an EREW PRAM using O( n 2/log n log log n) processors. As a corollary, we obtain a new parallel algorithm for computing Hamiltonian cycles in tournaments. This algorithm can be implemented in time O(log n) using O( n 2/log n) processors in the CRCW model and in time O(log 2 n) with O( n 2/log n log log n) processors in the EREW model.

An efficient parallel algorithm for shortest paths in planar layered digraphs

Computing shortest paths in a directed graph has received considerable attention in the sequential RAM model of computation. However, developing a polylog-time parallel algorithm that is close to the sequential optimal in terms of the total work done remains an elusive goal. We present a first step in this direction by giving efficient parallel algorithms for shortest paths in planar layered digraphs. We show that these graphs admit special kinds of separators called {\em one-way} separators which allow the paths in the graph to cross it only once. We use these separators to give divide and conquer solutions to the problem of finding the shortest paths between any two vertices. We first give a simple algorithm that works in the CREW model and computes the shortest path between any two vertices in an $n$-node planar layered digraph in time $O(\log^3 n)$ using $n/ \log n$ processors. A CRCW version of this algorithm runs in time $O(\log^2 n \log \log n)$ and uses $n/ \log \log n$ processors. We then use results of Aggarwal and Park [1] and Atallah [4] to improve the time bound to $O(\log^2 n)$ in the CREW model and $O(\log n \log \log n)$ in the CRCW model. The processor bounds still remain as $n/ \log n$ for the CREW model and $n/ \log \log n$ for the CRCW model.

The Minimum Weight Dominating Set Problem for Permutation Graphs Is in NC

In this paper, we show that the problem of finding a minimum weight dominating set in a permutation graph, where a positive weight is assigned to each vertex, is in NC by presenting an O(log n) parallel algorithm with polynomially many processors on the CRCW model.

Fast and Efficient Simulations among CRCW PRAMs

We study the problem of fast leaders election on TOLERANT, a CRCW PRAM model which tolerates concurrent write but does not support symmetry breaking. The leaders election problem is related to the problem of simulating stronger CRCW models, which support leaders election by predefined conflict resolution rules. We give a randomized simulation of MAXIMUM-a very strong CRCW PRAM-on TOLERANT. The simulation is optimal, is reliable, and runs in nearly doubly logarithmic time and linear space. This is the first simulation which is fast, optimal, and space-efficient, and therefore grants true comparison of algorithms running on different CRCW PRAMs. Moreover, it implies that the memory to which concurrent read or concurrent write is allowed should never be more than linear-the rest of the memory can always be addressed under the EREW convention. The techniques presented in this paper tackle fundamental difficulties in the design of fast parallel algorithms.

A new class of parallel algorithms for finding connected components on machines with bit-vector operations

The problem of developing serial and parallel algorithms for finding connected components of an undirected graph G = ( V, E) has received considerable attention in the literature. If ¦V¦ = n and ¦E¦ = m, the well-known serial algorithm takes O( n + m) steps. The first parallel algorithm for this problem was reported by Arjomandi and Corneil and takes T k + L[log k] + 2n steps using k processors, where T is the complexity of optimal sequential breadth first search and L is bounded by the diameter of the graph. Using a CREW (concurrent read and exclusive write) model, Chandra proposed a parallel algorithm that takes O( log 2 n) steps using O( n log7 logn ) processors. Following this lead, a number of parallel algorithms requiring the same time bound but different processor bounds have been reported by many authors. In this paper we use a machine model that performs (componentwise) bit vector operations (such as conjunction, comparison, etc.) in parallel. Using this model we show that the connected components of a graph G can be found in O B ( n log n) steps serially, where O B refers to the number of bit vector operations. Thus, for dense graphs this serial algorithm performs better than the algorithm that is based on the depth first search. We also show that finding connected components on a CREW model takes O B ( log 2 n) steps using only n log n processors, and on a CRCW model, it takes O B (( log n)· ( log log n)) steps using only n processors. These algorithms have larger processor efficiency compared to all the known algorithms and are particularly attractive for the dense graphs when a small number of processors are available.

Finding Concurrencies in Three Layer Channel Routing Algorithm for its Parallel Operation in SIMD CRCW Model

This paper explores the inherent parallelism in different steps of three layer channel routing algorithm based on merging method in Shared Memory SIMD computer using CRCW model. Overall algorithm is structured as set of sequential steps, implemented by calling several procedures, namely finding longest path of a directed graph, finding minimum or maximum value among a set, merging two nodes in a directed graph, searching a graph for a particular node. Studying the inherent parallelism, each procedure is restructured for parallel operation on SIMD model. The speed-up and complexity analysis is performed at each step considering unbounded parallelism. The overall complexity of this algorithm reduces from O(n2) to O(n* log n) using O(n) processors for n nets.

Parallel recognition of series-parallel graphs

Recently, He and Yesha gave an algorithm for recognizing directed series-parallel graphs in time O (log 2 n ) with linearly many EREW processors. We give a new algorithm for this problem, based on a structural characterization of series-parallel graphs in terms of their ear decompositions. Our algorithm can recognize undirected as well as directed series-parallel graphs. It can be implemented in the CRCW model of parallel computation to take time O (log n ). In the EREW model the time is O (log 2 n ) but the number of processors required improves the bounds of the previous algorithm.

An optimal parallel algorithm to construct a deap

Recently, Carlsson [3] proposed a variation of the heap data structure as an efficient implementation of a double-ended priority queue. This new data structure is referred to as the deap. We show that constructing a deap with special properties can be done very easily, both sequentially and in parallel, by reducing the problem to selection and heap construction. Our parallel algorithm can be implemented to run in O(log n log ∗ n) time using an optimal number of processors in the EREW-PRAM model or in O(log n) time using an optimal number of processors in the CRCW model.

Two-dimensional processor array with a reconfigurable bus system is at least as powerful as CRCW as CRCW model

The power of a computation model usually indicates how fast a problem can be solved under that model. The CRCW shared-memory computer has been considered the most powerful computation model. Recently, the two-dimensional processor array with a reconfigurable bus system (such as the reconfigurable mesh and the polymorphic-torus network) has been proposed for solving many problems efficiently. Since the structure of the two-dimensional processor array with a reconfigurable bus system is regular, it is suitable for VLSI implementation. In this paper, we show that the two-dimensional processor array with a reconfigurable bus system is at least as powerful as the CRCW shared-memory computer. To say more concretely, we show that if a problem can be solved in O( f( n)) time on the CRCW shared-memory computer, it can also be solved in O( f( n)) time on the two-dimensional processor array with a reconfigurable bus system. Also, the proof suggests a general method to convert algorithms designed on the former into algorithms on the latter.

An improved parallel algorithm for integer GCD

We present a simple parallel algorithm for computing the greatest common divisor (gcd) of twon-bit integers in the Common version of the CRCW model of computation. The run-time of the algorithm in terms of bit operations isO(n/logn), usingn 1+ɛ processors, where ɛ is any positive constant. This improves on the algorithm of Kannan, Miller, and Rudolph, the only sublinear algorithm known previously, both in run time and in number of processors; they requireO(n log logn/logn),n 2 log2 n, respectively, in the same CRCW model. We give an alternative implementation of our algorithm in the CREW model. Its run-time isO(n log logn/logn), usingn 1+ɛ processors. Both implementations can be modified to yield the extended gcd, within the same complexity bounds.

An efficient reconstruction of a graph from its line graph in parallel

Let G = ( V, E) denote a line graph. An O(log∥ V∥) parallel reconstruction of root graphs from line graphs is presented that uses O(∥ E∥) processors in the CRCW model. It is based on a divide-and-conquer scheme that partitions the line graph into two sets, such that each set induces a connected subgraph. Previously known algorithms of the same complexity used a large (though polynomial) number of processors. The algorithm is optimal up to a logarithmic factor.

Sorting, Minimal Feedback Sets, and Hamilton Paths in Tournaments

A general method is presented for translating sorting by comparisons algorithms to algorithms that compute a Hamilton path in a tournament. The translation is based on the relation between minimal feedback sets and Hamilton paths in tournaments. It is proven that there is a one to one correspondence between the set of minimal feedback sets and the set of Hamilton paths. In the comparison model, all the tradeoffs for sorting between the number of processors and the number of rounds hold as well for computing Hamilton paths. For the CRCW model, with $O( n )$ processors, we show the following: (i) Two paths in a tournament can be merged in $O(\log \log n)$ time (Valiant’s algorithm [SIAM J. Comput., 4 (1975), pp. 348–355], (ii) a Hamilton path can be computed in $O(\log n)$ time (Cole’s algorithm). This improves a previous algorithm for computing a Hamilton path whose running time was $O(\log^2 n)$ using $O(n^2 )$ processors.