Linear Array With A Reconfigurable Pipelined Bus System Research Articles

An efficient [formula omitted] time 3D all nearest neighbor algorithm from image processing perspective

In this paper, we solve the k-dimensional all nearest neighbor ( kD_ANN) problem, where k = 2 or 3, on a linear array with a reconfigurable pipelined bus system (LARPBS) from image processing perspective. First, for a two-dimensional (2D) binary image of size N × N , we devise an algorithm for solving the 2D_ANN problem using a LARPBS of size N 2 + ϵ , where 0 < ϵ ⪡ 1 . Then, for a three-dimensional (3D) binary image of size N × N × N , we devise an algorithm for solving the 3D_ANN problem using a LARPBS of size N 3 + ɛ , where 0 < ɛ < 1 . To the best of our knowledge, all results derived above are the best O ( 1 ) time 2D_ANN and 3D_ANN algorithms on the LARPBS model known.

Parallel algorithms for robot path planning with simpler VLSI architecture

This paper proposes a parallel algorithm for robot path planning on a linear array with a reconfigurable pipelined bus system (LARPBS) through the construction of a Voronoi diagram on a binary image of the workspace. The algorithm is based on a d4 distance metric, and it does not incur any additional time or processor requirements compared with those of a previously reported proposal (Tzionas et al., 1997). This paper recommends the same model as the simpler VLSI architecture for the problem in question.

Efficient algorithms for the all nearest neighbor and closest pair problems on the linear array with a reconfigurable pipelined bus system

We present two O(1)-time algorithms for solving the 2D all nearest neighbor (2D/spl I.bar/ANN) problem, the 2D closest pair (2D/spl I.bar/CP) problem, the 3D all nearest neighbor (3D/spl I.bar/ANN) problem and the 3D-closest pair (3D/spl I.bar/CP) problem of n points on the linear array with a reconfigurable pipelined bus system (LARPBS) from the computational geometry perspective. The first O(1) time algorithm, which invokes the ANN properties (introduced in this paper) only once, can solve the 2D/spl I.bar/ANN and 2D/spl I.bar/CP problems of n points on an LARPBS of size 1/2n/sup 5/3+c/, and the 3D/spl I.bar/ANN and 3D/spl I.bar/CP problems pf n points on an LARPBS of size 1/2n/sup 7/4+c/, where 0 < /spl epsi/ = 1/2/sup c+1/-1 /spl Lt/ 1, c is a constant and positive integer. The second O(1) time algorithm, which recursively invokes the ANN properties k times, can solve the kD/spl I.bar/ANN, and kD/spl I.bar/CP problems of n points on an LARPBS of size 1/2n/sup 3/2+c/, where k = 2 or 3, 0 < /spl epsi/ = 1/2/sup n+1/-1 /spl Lt/ 1, and c is a constant and positive integer. To the best of our knowledge, all results derived above are the best O(1) time ANN algorithms known.

Constant time fault tolerant algorithms for a linear array with a reconfigurable pipelined bus system

Recently, researchers have proposed many models using reconfigurable optically pipelined buses. Most algorithms developed for these models assume that a healthy system is available. The only previous work in this area considers faulty processors or hardware for an N-processor linear array with a reconfigurable pipelined bus system (LARPBS), resulting in fault tolerant algorithms that run in O ( log N ) time. We extend and improve upon previous results by considering new fault scenarios and slight modifications to the LARPBS model. By modifying the switches on the receiving segment of an LARPBS, a reasonable, low-cost extension to the model, we are able to achieve fault tolerant algorithms that execute in O ( 1 ) time rather than O ( log N ) time. The fault tolerant algorithms that we consider are key basic fundamental algorithms, such as compaction, binary prefix sums, and sorting, that all execute in constant time on a healthy LARPBS. As the algorithms improved are building blocks for more complex algorithms, the results presented in this paper will extend to those more complex algorithms as well.

A Parameterized Linear Array with a Reconfigurable Pipelined Bus System: LARPBS(p)

The linear array with a reconfigurable pipelined bus system (LARPBS) is an optical bus-based theoretical parallel computation model. Many parallel algorithms have been proposed using this model of computation. However, a current limitation of the LARPBS model is that it does not provide for performance prediction of these algorithms running on realistic implementations of the LARPBS model. This paper investigates the parameterization of the LARPBS model so as to overcome this limitation. Specifically, a new parameterized parallel computation model, the LARPBS(p) model, is proposed in this paper. The LARPBS(p) model captures computational costs through six abstract parameters: the number of processors, the communication latency, the communication overhead, the network capacity, the computation time and the synchronization time. The proposed parameters and, subsequently, the cost analysis on the LARPBS(p) model are presented. In addition applications of the cost analysis to some primitive operations and to two matrix multiplication algorithms on the LARPBS(p) are also presented. LARPBS(p) is intended to serve as a basis for a more accurate estimation of execution time of algorithms by providing greater detail of the costs involved on the LARPBS.

Multiple Addition and Prefix Sum on a Linear Array with a Reconfigurable Pipelined Bus System

We present several fast algorithms for multiple addition and prefix sum on the Linear Array with a Reconfigurable Pipelined Bus System (LARPBS), a recently proposed architecture based on optical buses. Our algorithm for adding N integers runs on an N log M-processor LARPBS in O(log* N) time, where log* N is the number of times logarithm has to be taken to reduce N below 1 and M is the largest integer in the input. Our addition algorithm improves the time complexity of several matrix multiplication algorithms proposed by Li, Pan and Zheng (IEEE Trans. Parallel and Distributed Systems, 9(8):705–720, 1998). We also present several fast algorithms for computing prefix sums of N integers on the LARPBS. For integers with bounded magnitude, our first algorithm for prefix sum computation runs in O(log log N) time using N processors and in O(1) time using N1+e processors, for \frac{1}{3} ≤ e < 1. For integers with unbounded magnitude, the first algorithm for multiple addition runs in O(log log N log* N) time using N log M processors, when M is the largest integer in the input. Our second algorithm for multiple addition runs in O(log* N) time using N1+e log M processors, for \frac {1}{3} ≤ e < 1. We also show suitable extensions of our algorithm for real numbers.

Fast and scalable algorithms for the Euclidean distance transform on a linear array with a reconfigurable pipelined bus system

The Euclidean distance transform ( EDT) is an operation to convert a binary image consisting of black and white pixels to a representation where each pixel has the Euclidean distance of the nearest black pixel. The EDT has many applications in computer vision and image processing. We present two algorithms for computing the EDT on the linear array with a reconfigurable pipelined bus system (LARPBS), a recently proposed architecture based on optical buses. Our first algorithm runs in O( log log N) time for a binary N× N image on an LARPBS with N 2+ ε processors, for any fixed ε, 0< ε<1. Our second algorithm is highly scalable and runs in O( N 2 p 2 log log p) time if the LARPBS has only p 2+ ε processors for p< N. The previous best deterministic algorithm for computing the EDT on the LARPBS is by Pan et al. Proceedings of IPDPS 2000 Workshop on Parallel and Distributed Computing in Image Processing, Video Processing and Multimedia (PDIVM 2000), Lecture Notes in Computer Science, Vol. 1800, Springer, Berlin, 178). Their algorithm runs either in O( log N log log N) time on an LARPBS with N 2 processors or in O( log log N) time on an LARPBS with O( N 3) processors.

Fault tolerant algorithms for a linear array with a reconfigurable pipelined bus system*

Recently, researchers have proposed many models using reconfigurable optically pipelined buses. All algorithms developed for these models assume that a healthy system is available. We present some fundamental algorithms that are able to tolerate up to N/2 faults on an N-processor, linear array with a reconfigurable pipelined bus system (LARPBS) (one particular optical model). We then extend these results to apply to other algorithms in the areas of image processing and matrix operations.

Sublogarithmic deterministic selection on arrays with a reconfigurable optical bus

The linear array with a reconfigurable pipelined bus system (LARPBS) is a newly introduced parallel computational model, where processors are connected by a reconfigurable optical bus. In this paper, we show that the selection problem can be solved on the LARPBS model deterministically in O((loglogN)/sup 2// log log log N) time. To our best knowledge, this is the best deterministic selection algorithm on any model with a reconfigurable optical bus.

Efficient parallel algorithms for distance maps of 2D binary images using an optical bus

Computing a distance map (distance transform) is an operation that converts a 2D image consisting of black and white pixels to an image where each pixel has a value or a pair of coordinates that represents the distance to or location of the nearest black pixel. It is a basic operation in image processing and computer vision fields, and is used for expanding, shrinking, thinning, segmentation, clustering, computing shape, object reconstruction, etc. This paper examines the possibility of implementing the problem of finding a distance map for an image efficiently using an optical bus. The computational model considered is the linear array with a reconfigurable pipelined bus system (LARPBS), which has been introduced recently based on current electronic and optical technologies. It is shown that the problem for an n /spl times/ n image can be implemented in O(log n log log n) bus cycles deterministically or in O(log n) bus cycles with high probability on an LARPBS with n/sup 2/ processors. We also show that the problem can be solved in O(log log n) bus cycles deterministically or in O(l) bus cycles with high probability on an LARPBS with n/sup 3/ processors. Scalability of the algorithms is also discussed briefly. The algorithm compares favorably to the best known parallel algorithms for the same problem in the literature.

Fast sorting algorithms on a linear array with a reconfigurable pipelined bus system

We present two fast algorithms for sorting on a linear array with a reconfigurable pipelined bus system (LARPBS), one of the recently proposed parallel architectures based on optical buses. In our first algorithm, we sort N numbers in O(log N log log N) worst-case time using N processors. In our second algorithm, we sort N numbers in O((log log N)/sup 2/) worst-case time using N/sup 1+/spl epsi// processors, for any fixed /spl epsi/ such that 0 < /spl epsi/ < 1. Our algorithms are based on a novel deterministic sampling scheme for merging two sorted arrays of length N each in O(log log N) time on an LARPBS with N processors. To our knowledge, the previous best sorting algorithm on this architecture has a running time of O((log N)/sup 2/) using N processors.

Efficient Graph-Theoretic Algorithms on a Linear Array with a Reconfigurable Pipelined Bus System

We present efficient algorithms for solving several fundamental graph-theoretic problems on a Linear Array with a Reconfigurable Pipelined Bus System (LARPBS), one of the recently proposed models of computation based on optical buses. Our algorithms include finding connected components, minimum spanning forest, biconnected components, bridges and articulation points for an undirected graph. We compute the connected components and minimum spanning forest of a graph in O(log n) time using O(m+n) processors where m and n are the number of edges and vertices in the graph and m=O(n2) for a dense graph. Both the processor and time complexities of these two algorithms match the complexities of algorithms on the Arbitrary and Priority CRCW PRAM models which are two of the strongest PRAM models. The algorithms for these two problems published by Li et al. l7r have been considered to be the most efficient on the LARPBS model till now. Their algorithm l7r for these two problems require O(log n) time and O(n3/log n) processors. Hence, our algorithms have the same time complexity but require less processors. Our algorithms for computing biconnected components, bridges and articulation points of a graph run in O(log n) time on an LARPBS with O(n2) processors. No previous algorithm was known for these latter problems on the LARPBS.

Parallel matrix multiplication on a linear array with a reconfigurable pipelined bus system

The known fast sequential algorithms for multiplying two N/spl times/N matrices (over an arbitrary ring) have time complexity O(N/sup /spl alpha//), where 2</spl alpha/<3. The current best value of /spl alpha/ is less than 2.3755. We show that, for all 1/spl les/p/spl les/N/sup /spl alpha//, multiplying two N/spl times/N matrices can be performed on a p-processor linear array with a reconfigurable pipelined bus system (LARPBS) in O(N/sub m//P+(N/sup 2//p/sup 2//spl alpha//)log p) time. This is currently the fastest parallelization of the best known sequential matrix multiplication algorithm on a distributed memory parallel system. In particular, for all 1/spl les/p/spl les/N/sup 2.3755/, multiplying two N/spl times/N matrices can be performed on a p-processor LARPBS in O(N/sup 2.3755//p+(N/sup 2/)/p/sup 0.8419/log p) time and linear speedup can be achieved for p as large as O(N/sup 2.3755//(log N)/sup 6.3262/). Furthermore, multiplying two N/spl times/N matrices can be performed on an LARPBS with O(N/sup /spl alpha//) processors in O(log N) time. This compares favorably with the performance on a PRAM.

Linear array with a reconfigurable pipelined bus system — Concepts and applications

A new computational model, called a linear array with a reconfigurable pipelined bus system (LARPBS), has been proposed as a feasible and efficient parallel computational model based on current optical technologies. In this paper, we further study this model by proposing several basic data movement operations on the model. These operations include broadcast, multicast, compression, split, binary prefix sum, maximum finding. Using these basic operations, several image processing algorithms are also presented for the model. We show that all algorithms can be executed efficiently on the LARPBS model. It is our hope that the LARPBS model can be used as a new and practical parallel computational model for designing parallel algorithms.

FAST NEAREST NEIGHBOR ALGORITHMS ON A LINEAR ARRAY WITH A RECONFIGURABLE PIPELINED BUS SYSTEM

We present efficient algorithms for the nearest neighbor problem defined in an n × n binary image. We show that using a linear array with a reconfigurable pipelined bus system (LARPBS) of n2 processors, the nearest neighbor problem can be solved in O(loglogn) time, and using an LARPBS of n2+ε processors, for any fixed constant ε>0. the nearest neighbor problem can be solved in O(l) time. We also show that the nearest neighbor problem can be solved on an LARPBS of n2 processors in O(1) time with high probability.