Reconfigurable Mesh Of Size Research Articles

Optimal algorithms for the multiple query problem on reconfigurable meshes, with applications

The main contribution of this work is to show that a number of fundamental and seemingly unrelated problems in database design, pattern recognition, robotics, computational geometry, and image processing can be solved simply and elegantly by stating them as instances of a unifying algorithmic framework that we call the multiple query problem. The multiple query problem (MQ, for short) is a 5-tuple (Q, A, D, /spl phi/, /spl oplus/), where Q is a set of queries, A is a set of items, D is a set of solutions, /spl phi/: Q/spl times/A/spl rarr/D is a function, and /spl oplus/ is a commutative and associative binary operator over D. The input to the MQ problem consists of a sequence Q= of m queries from Q and of a sequence A= of n items from A. The goal is to compute, for every query q/sub i/ (1/spl les/i/spl les/m) its solution defined as /spl phi/(q/sub i/,A)=/spl phi/(q/sub i/,a/sub 1/)/spl oplus//spl phi/(q/sub i/,a/sub 2/)/spl oplus//spl middot//spl middot//spl middot//spl oplus//spl phi/(q/sub i/,a/sub n/). We begin by discussing a generic algorithm that solves a large class of MQ problems in O(/spl radic/m+f(n)) time on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n, where f(n) is the time necessary to compute the expression d/sub 1/ /spl oplus/ d/sub 2/ /spl oplus//spl middot//spl middot//spl middot//spl oplus/ d/sub n/ with d/sub i/ /spl isin/ D on such a platform. We then go on to show that the MQ framework affords us an optimal algorithm for the multiple point location problem on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n. Given a set A of n points and a set Q of m (m/spl les/n) points in the plane, our algorithm reports, in O(/spl radic/m+log log n) time, all points of Q that lie inside the convex hull of A. Quite surprisingly, our algorithm solves the multiple point location problem without computing the convex hull of A which, in itself, takes /spl Omega/(/spl radic/n) time on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n. Finally, we prove an /spl Omega/(/spl radic/m+g(n)) time lower bound for nontrivial MQ problems, where g(n) is the lower bound for evaluating the expression d/sub 1/ /spl oplus/ d/sub 2/ /spl oplus//spl middot//spl middot//spl middot//spl oplus/ d/sub n/ with d/sub i/ /spl isin/ D, on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n.

A residue number system on reconfigurable mesh with applications to prefix sums and approximate string matching

Several new number representations based on a residue number system are presented which use the smallest prime numbers as moduli and are suited for parallel computations on a reconfigurable mesh architecture. The bit model of linear reconfigurable mesh with exclusive write and unit-time delay for broadcasting on a subbus is assumed. It is shown how to convert in O(1) time any integer, ranging between 0 and n-1, from any commonly used representation to any new representation proposed in this paper (and vice versa) using an n/spl times/O(log/sup 2/ n/log log n) reconfigurable mesh. In particular, some of the previously known conversion techniques are improved. Moreover, as a byproduct, it is shown how to compute in O(1) time the Prefix Sums of n bits by a reconfigurable mesh having the above mentioned size, thus improving previously known results. Applications to the Prefix Sums of n h-bit integers and to Approximate String Matching with /spl alpha/ mismatches are also considered. The Summation and the Prefix Sums can be computed in O(1) time using O(h log N+log/sup 2/ N/log log N)/spl times/Nh and O(h/sup 2/+log/sup 2/ N/log(h+log N))/spl times/O(N(h+log N)) reconfigurable meshes, respectively. Moreover, it is shown for the first time how to find in O(1) time all the occurrences of a pattern of length m in a text of length n, allowing less than /spl alpha/ mismatches, using a reconfigurable mesh of size O(m log|/spl Sigma/|)/spl times/O (n(log|/spl Sigma/|+log/sup 2/ /spl alpha//log log /spl alpha/)), where the pattern and the text are strings over a finite alphabet /spl Sigma/ and /spl alpha/<m/spl les/n.

Computing the Maximum Overlap of Two Convex Polygons under Translations

Finding a vast array of applications, the list-ranking problem has emerged as one of the fundamental techniques in parallel algorithm design. Surprisingly, the best previously known algorithm to rank a list of n items on a reconfigurable mesh of size $n \times n$ was running in O(log n ) time. It was open for more than 8 years to obtain a faster algorithm for this important problem. Our main contribution is to provide the first breakthrough: we propose a deterministic list-ranking algorithm that runs in O(log* n ) time as well as a randomized one running in O(1) expected time, both on a reconfigurable mesh of size $n \times n$ . Our results open the door to a large number of efficient list-ranking-based algorithms on reconfigurable meshes.

Efficient List Ranking on the Reconfigurable Mesh, with Applications

Finding a vast array of applications, the list-ranking problem has emerged as one of the fundamental techniques in parallel algorithm design. Surprisingly, the best previously known algorithm to rank a list of n items on a reconfigurable mesh of size $n \times n$ was running in O(log n ) time. It was open for more than 8 years to obtain a faster algorithm for this important problem. Our main contribution is to provide the first breakthrough: we propose a deterministic list-ranking algorithm that runs in O(log* n ) time as well as a randomized one running in O(1) expected time, both on a reconfigurable mesh of size $n \times n$ . Our results open the door to a large number of efficient list-ranking-based algorithms on reconfigurable meshes.

Constant Time Algorithms for Computing the Contour of Maximal Elements on a Reconfigurable Mesh

There has recently been an interest in the introduction of reconfigurable buses to existing parallel architectures. Among them the Reconfigurable Mesh (RM) draws much attention because of its simplicity. This paper presents three constant time algorithms to compute the contour of the maximal elements of N planar points on the RM. The first algorithm employs an RM of size N × N while the second one uses a 3-D RM of size [Formula: see text]. We further extend the result to k-D RM of size N1/(k - 1) × N1/(k - 1) × … × N1/(k - 1).

An O((log log n)/sup 2/) time algorithm to compute the convex hull of sorted points on reconfigurable meshes

The problem of computing the convex hull of a set of n sorted points in the plane is one of the fundamental tasks in image processing, pattern recognition, cellular network design, and robotics, among many others. Somewhat surprisingly, in spite of a great deal of effort, the best previously known algorithm to solve this problem on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n was running in O(log2 n) time. It was open for more than ten years to obtain an algorithm for this important problem running in sublogarithmic time. Our main contribution is to provide the first breakthrough: we propose an almost optimal convex hull algorithm running in O((log log n)/sup 2/) time on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n. With slight modifications, this algorithm can be implemented to run in O((log log n)/sup 2/) time on a reconfigurable mesh of size /spl radic/n/loglogn/spl times//spl radic/n/loglogn. Clearly, the latter algorithm is work-optimal. We also show that any algorithm that computes the convex hull of a set of n sorted points on an n-processor reconfigurable mesh must take /spl Omega/(log log n) time. Our result opens the door to an entire slew of efficient convex-hull-based algorithms on reconfigurable meshes.

Constant-time algorithms for constrained triangulations on reconfigurable meshes

A number of applications in computer-aided manufacturing, CAD, and computer-aided geometric design ask for triangulating pieces of material with defects. These tasks are known collectively as constrained triangulations. Recently, a powerful architecture called the reconfigurable mesh has been proposed: In essence, a reconfigurable mesh consists of a mesh-connected architecture augmented by a dynamically reconfigurable bus system. The main contribution of this paper is to show that the flexibility of the reconfigurable mesh can be exploited for the purpose of obtaining constant-time algorithms for a number of constrained triangulation problems. These include triangulating a convex planar region containing any constant number of convex holes, triangulating a convex planar region in the presence of a collection of rectangular holes, and triangulating a set of ordered line segments. Specifically with a collection of O(n) such objects as input, our algorithms run in O(1) time on a reconfigurable mesh of size n/spl times/n. To the best of our knowledge, this is the first time constant time solutions to constrained triangulations are reported on this architecture.

An optimal algorithm for the angle-restricted all nearest neighbor problem on the reconfigurable mesh, with applications

Given a set S of n points in the plane and two directions r/sub 1/ and r/sub 2/, the Angle-Restricted All Nearest Neighbor problem (ARANN, for short) asks to compute, for every point p in S, the nearest point in S lying in the planar region bounded by two rays in the directions r/sub 1/ and r/sub 2/ emanating from p. The ARANN problem generalizes the well-known ANN problem and finds applications to pattern recognition, image processing, and computational morphology. Our main contribution is to present an algorithm that solves an instance of size n of the ARANN problem in O(1) time on a reconfigurable mesh of size n/spl times/n. Our algorithm is optimal in the sense that /spl Omega/(n/sup 2/) processors are necessary to solve the ARANN problem in O(1) time. By using our ARANN algorithm, we can provide O(1) time solutions to the tasks of constructing the Geographic Neighborhood Graph and the Relative Neighborhood Graph of n points in the plane on a reconfigurable mesh of size n/spl times/n. We also show that, on a somewhat stronger reconfigurable mesh of size n/spl times/n/sup 2/, the Euclidean Minimum Spanning Tree of n points can be computed in O(1) time.

A simple Voronoi diagram algorithm for a reconfigurable mesh

In this paper, we introduce a simple and efficient algorithm for computing the Voronoi Diagram for n planar points on a reconfigurable mesh of size O(n)/spl times/O(n). The algorithm has a worst case running of O(log n log log n) time. The algorithm exploits the O(1) communication diameter of the reconfigurable mesh model to implement efficient load balancing.

A CONSTANT TIME SORTING ALGORITHM FOR A THREE DIMENSIONAL RECONFIGURABLE MESH AND RECONFIGURABLE NETWORK

Sorting techniques have numerous applications in computer science. Current real number and integer sorting techniques for the reconfigurable mesh operate in constant time using a reconfigurable mesh of size n × n to sort n numbers. This paper presents a constant time algorithm to sort n items on a reconfigurable network with [Formula: see text] switches and [Formula: see text] processors. Also, new constant time selection and compression algorithms are given. All results may also be implemented on the 3-D reconfigurable mesh.

Interval Graph Problems on Reconfigurable Meshes

A graph G is an interval graph if there is a one-one correspondence between its vertices and a family I of intervals, such that two vertices in G are adjacent if and only if their corresponding intervals overlap. In this context, the family I of intervals is referred to as an interval model of G. Recently, a powerful architecture called the reconfigurable mesh has been proposed: in essence, a reconfigurable mesh consists of a mesh-connected architecture augmented by a dynamically reconfigurable bus system. In this paper, we exploit the reconfigurable mesh architecture for the purpose of obtaining constant-time algorithms for a number of computational problems on interval graphs. These problems include finding a maximum size independent set, a minimum clique cover, a minimum size dominating set, a shortest path between any two vertices in G, the diameter and the center of G, as well as Breadth-First Search and Depth-First Search trees for G. Specifically, with an n-vertex interval graph specified by its interval model as input, all our algorithms run in constant time on a reconfigurable mesh of size n × n. INFORMS Journal on Computing, ISSN 1091-9856, was published as ORSA Journal on Computing from 1989 to 1995 under ISSN 0899-1499.

Constant-Time Convexity Problems on Reconfigurable Meshes

The purpose of this paper is to demonstrate that the versatility of the reconfigurable mesh can be exploited to devise constant-time algorithms for a number of important computational tasks relevant to robotics, computer graphics, image processing, and computer vision. In all our algorithms, we assume that one or two n-vertex (convex) polygons are pretiled, one vertex per processor, onto a reconfigurable mesh of size √ n × √ n. In this setup, we propose constant-time solutions for testing an arbitrary polygon for convexity, solving the point location problem, solving the supporting lines problem, solving the stabbing problem, determining the minimum area/perimeter corner triangle for a convex polygon, determining the k-maximal vertices of a restricted class of convex polygons, constructing the common tangents of two separable convex polygons, deciding whether two convex polygons intersect, answering queries concerning two convex polygons, and computing the smallest distance between the boundaries of two convex polygons. To the best of our knowledge, this is the first time that O(1) time algorithms to solve dense instances of these problems are proposed on reconfigurable meshes.

Constant-Time Tree Algorithms on Reconfigurable Meshes on Size n × n

Recently, an elegant and powerful architecture called the reconfigurable mesh has been proposed in the literature. In essence, a reconfigurable mesh consists of a mesh-connected architecture enhanced by the addition of a dynamic bus system whose configuration changes in response to computational and communication needs. In this paper we show that the reconfigurable mesh architecture can be exploited to yield very simple constant-time algorithms to solve a number of important computational problems involving trees. Specifically, we address the problem of generating the computation tree form of an arithmetic expression, the problem of reconstructing a binary tree from its preorder and inorder traversals, and the problem of reconstructing an ordered forest from its preorder and postorder traversals. We show that with an input of size n, all these problems find constant-time solutions on a reconfigurable mesh of size n × n.

A CONSTANT TIME ALGORITHM FOR THE CHANNEL ASSIGNMENT PROBLEM USING THE RECONFIGURABLE MESH

A constant lime algorithm is given for the reconfigurable mesh which uses a re-configurable mesh to solve the channel assignment problem involving n intervals. To accomplish this, an algorithm is given which creates a linked list of nitems in a reconfigurable mesh of size .

COMPUTING ON RECONFIGURABLE BUSES—A NEW COMPUTATIONAL PARADIGM

Up to now, buses have been used exclusively to ferry data around. The contribution of this work is to show that buses can be used both as topological descriptors and as powerful computational devices. We illustrate the power of this paradigm by designing two fast algorithms for image segmentation and parallel visibility. Our algorithm for image segmentation uses a novel technique invol ving building a bus around every region of interest in the image. With a binary image pretiled in the natural way on a reconfigurable mesh of size N×N our segmentation algorithm runs in O( log N) time, improving by a factor of O( log N) over the state of the art. Next, we exhibit a very simple algorithm to solve the parallel visibility problem on an image of size N×N. Our algorithm runs in O( log N) time. The only previously-known algorithm for this problem runs in O( log N) time on a hypercube with N processors. To support these algorithms, a set of basic building blocks are developed which are of independent interest. These include solutions to the following problems on a bus on length N: (1) computing the prefix maxima of items stored by the processors on the bus, even if none of the processors knows its rank on the bus; (2) computing the rank of every processor on the bus; (3) electing a leader on a closed bus.

Constant time sorting on reconfigurable meshes

We present a constant time sorting algorithm by adopting a 3D reconfigurable mesh with only O(n/sup 3/2/) processors. Our algorithm is developed on an n/sup 1/2//spl times/n/sup 1/2//spl times/n/sup 1/2/ 3-D reconfigurable mesh. Moreover, we further extend the result to k-dimensional reconfigurable meshes for k/spl ges/3. Consequently, an O(4/sup k+1/) time sorting algorithm is obtained by adopting an n/sup 1/(k-1)//spl times/n/sup 1/(k-1)//spl times/.../spl times/n/sup 1/(k-1)/k-D reconfigurable mesh of size O(n/sup 1+1/(k-1)/). Hence, constant time sorting using O(n/sup 1+/spl epsiv//) processors, where O>

Computing the Hough transform on reconfigurable meshes

Until now, buses have been used exclusively to support fast communication and data transfer needs within a parallel machine. Recently, the authors have demonstrated novel uses of buses in a multiprocessor reconfigurable architecture. Specifically, we have argued that buses can be successfully used both as topological descriptors and as powerful computational devices. The purpose of this note is to show that this new paradigm can be used for computing the Hough transform—the most widely used technique for detecting lines and curves in binary or grey level images. Specifically, for an N × N digitized image stored in a reconfigurable mesh of size N × N, one pixel per processor, we present an O ( n × log( N/ n)) time algorithm to compute the Hough transform with n standing for the number of angles in the quantization of the θ-space.

Fast component labelling and convex hull computation on reconfigurable meshes

Traditionally, buses have been used exclusively to support fast communication and data transfer needs within a parallel machine. We demonstrate novel uses for buses in a multiprocessor reconfigurable architecture. Specifically, we show that buses can be successfully used both as topological descriptors and as powerful computational devices. This new paradigm affords us fast algorithms to solve a number of fundamental image processing and computer vision tasks, including connected component labelling and computing the convex hull of every object in a given image. On a binary image of size √ n × √ n stored one pixel per processor, both our component labelling and convex hull algorithms run in O(log n) time and O(itlog su2 n)it time, respectively. In fact, our convex hull algorithm applies to ordered points in the plane as well: with an ordered set S of n such points stored one per processor in a reconfigurable mesh of size √ × √ n, our algorithm computes the convex hull of S in O( log 2 n ).

A SIMPLE SELECTION ALGORITHM FOR RECONFIGURABLE MESHES

One of the fundamental algorithmic problems in computer science involves selecting the κth smallest element in a collection A of n elements. We propose a simple selection algorithm running in O(log2 n) time on a reconfigurable mesh of size √n × -√n.