K-dimensional Mesh Research Articles

The maximum degree and diameter-bounded subgraph in the mesh

The problem of finding the largest connected subgraph of a given undirected host graph, subject to constraints on the maximum degree Δ and the diameter D, was introduced in Dekker et al. (2012) [1], as a generalization of the Degree–Diameter Problem. A case of special interest is when the host graph is a common parallel architecture. Here we discuss the case when the host graph is a k-dimensional mesh. We provide some general bounds for the order of the largest subgraph in arbitrary dimension k, and for the particular cases of k=3,Δ=4 and k=2,Δ=3, we give constructions that result in sharper lower bounds.

Embedding a family of disjoint multi-dimensional meshes into a crossed cube

Crossed cubes are an important class of hypercube variants. This paper addresses how to embed a family of disjoint multi-dimensional meshes into a crossed cube. We prove that for n ⩾ 4 and 1 ⩽ m ⩽ ⌊ n / 2 ⌋ − 1 , a family of 2 m disjoint k-dimensional meshes of size 2 t 1 × 2 t 2 × ⋯ × 2 t k each can be embedded in an n-dimensional crossed cube with unit dilation, where ∑ i = 1 k t i = n − m and max 1 ⩽ i ⩽ k { t i } ⩾ n − 2 m − 1 . This result means that a family of mesh-structured parallel algorithms can be executed on a same crossed cube efficiently and in parallel. Our work extends some recently obtained results.

Improved Methods for Divisible Load Distribution on k-Dimensional Meshes Using Multi-Installment

In the divisible load distribution, the classic methods on linear arrays divide the computation and communication processes into multiple time intervals in a pipelined fashion. Li (2003) has proposed a set of improved algorithms for linear arrays which can be generalized to k-dimensional meshes. In this paper, we first propose the algorithm M (multi-installment) that employs the multi-installment technique to improve the best algorithm Q proposed by Li. Second, we propose the algorithm S (start-up cost) that includes the computation and communication start-up costs in the design. While the asymptotic speedups of our algorithms M and S derived from the closed-form solutions are the same as algorithm Q, our algorithms approach the optimal speedups considerably faster than algorithm Q as the number of processors increases. Finally, we combine algorithms M and S and propose the algorithm MS. While algorithm MS has the same the asymptotic performance as algorithms Q and S, it achieves a better speedup when the load to be processed is very large and the number of processors is fixed or when the load to be processed is fixed and the number of processors is small.

Improved methods for divisible load distribution on k-dimensional meshes using pipelined communications

We give the closed form solutions to the parallel time and speedup of the classic method for processing divisible loads on linear arrays as functions of N, the network size. We propose two methods which employ pipelined communications to distribute divisible loads on linear arrays. We derive the closed form solutions to the parallel time and speedup for both methods and show that the asymptotic speedup of both methods is /spl beta/+1, where /spl beta/ is the ratio of the time for computing a unit toad to the time for communicating a unit load. Such performance is even better than that of the known methods on k-dimensional meshes with k>1. The two new algorithms which use pipelined communications are generalized to distribute divisible loads on k-dimensional meshes, and we show that the asymptotic speedup of both algorithms is k/spl beta/+1, where k/spl ges/1. We also prove that, on k-dimensional meshes where k/spl ges/1, as the network size becomes large, the asymptotic speedup of 2k/spl beta/+1 can be achieved for processing divisible loads by using interior initial processors.

TRIDIAGONAL SOLVERS WITH MULTIPLE RIGHT HAND SIDES ON k-DIMENSIONAL MESH AND TORUS INTERCONNECTION NETWORKS

We consider the problem of designing optimal and efficient algorithms for solving tridiagonal linear systems with multiple right-hand side vectors on k-dimensional mesh and torus interconnection networks. We derive asymptotic upper and lower bounds for these solvers using odd-even cyclic reduction. We present various important bounds on execution time including general lower bounds which are independent of initial data assignment, and lower bounds based on classifying assignments via the proportion of initial data assigned amongst processors. Finally, different algorithms are designed in order to achieve running times that are within a small constant factor of the lower bounds provided.

Speed-up of Parallel Processing of Divisible Loads on k-dimensional Meshes and Tori

Speed-up of Parallel Processing of Divisible Loads on k-dimensional Meshes and Tori

Graph embeddings and simplicial maps

An undirected graph is viewed as a simplicial complex. The notion of a graph embedding of a guest graph in a host graph is generalized to the realm of simplicial maps. Dilation is redefined in this more general setting. Lower bounds on dilation for various guest and host graphs are considered. Of particular interest are graphs that have been proposed as communication networks for parallel architectures. Bhatt et al. provide a lower bound on dilation for embedding a planar guest graph in a butterfly host graph. Here, this lower bound is extended in two directions. First, a lower bound that applies to arbitrary guest graphs is derived, using tools from algebraic topology. Second, this lower bound is shown to apply to arbitrary host graphs through a new graph-theoretic measure, called bidecomposability. Bounds on the bidecomposability of the butterfly graph and of the k-dimensional torus are determined. As corollaries to the main lower bound theorem, lower bounds are derived for embedding arbitrary planar graphs, genus g graphs, and k-dimensional meshes in a butterfly host graph.

Parallel Threshold Voting

Voting on large collections of input objects is becoming increasingly important in data fusion, signal and image processing applications, learning algorithms, and distributed computing. To achieve high speed in voting, the multiple processing resources typically available in such applications should be utilized; hence the need for parallel voting algorithms. We develop efficient parallel algorithms for threshold voting which generalize and extend previous work on both sequential threshold voting and parallel majority voting. Our discussion centers on unweighted threshold (m-out-of-n) voting. However, we observe that under certain conditions, the results can be extended to efficient weighted threshold voting. We show how a known O(n)-time sequential algorithm for m-out-of-n voting can be parallelized through a simple divide-and-conquer strategy. When m = θ(n), the resulting algorithm has O(log 2 n) time complexity on n-processor PRAM and hypercubic computers and O(k 2 n 1/k ) time complexity on a k-dimensional mesh with n processors. We also analyze the time complexity of the algorithm for m = o(n) and its special case of m = θ(1).

Selection on k-Dimensional Meshes with Multiple Broadcasting

Randomized selection algorithms on k-dimensional mesh-connected computers with multiple broadcasting are proposed in this paper. We first show that a leader can be elected in O(log N) time on any k-dimensional mesh-connected computers with multiple broadcasting of size N. We then show that we can find the p-th smallest element among a data set of size N in O((log N + k + N 1/(k(k+1)) ) log N) expected time using a regular N 1/k x... x N 1/k k-dimensional mesh and in O((log N + k 2 N 1/(k2k) )log N) expected time using an irregular N (2k-1k+1)/(k2k) x N (2k-2k+1)/(k2k) x... x N (k+1)/(k2k) k-dimensional mesh. This leads to a selection algorithm which runs in O((log N) 2 ) expected time on a regular ((log N/log log N) 1/2 )-dimensional mesh or on an irregular (log log N)-dimensional mesh each with N processors. To our best knowledge, this is the first polylogarithmic selection algorithm on meshes with multiple broadcasting.

On the Power of the Linear Array Architecture for Performing Tree-Structured Computations

We consider the problem of scheduling the execution of programs on the linear array architecture. A program is represented by a directed acyclic graph (dag), whose nodes represent tasks and whose edges represent both precedence constraints and functional dependencies among tasks. We prove that, for binary tree dags with unit execution time tasks, the linear array can simulate with constant slowdown the architecture independent model of C. H. Papadimitriou and M. Yannakakis when the message-to-instruction ratio is assumed to be equal to the diameter of the linear array. (This is the interpretation im plied in their article.) Furthermore, we prove that for binary tree dags with unit execution time tasks the linear array is strictly more powerful than the above interpretation of their model. Using our simulation result, we give polynomial time algorithms to find schedules for binary tree dags with n tasks and height h on linear arrays, when h ≥ n12 log n (achieving makespan O(h)), and when h ≤ n12-ϵ for any fixed ϵ > 0 (achieving makespan O(n12), where the constant inside the O depends on ϵ). The makespan achieved by our schedules is within a constant factor of optimal. The time-processors product achieved is within a constant factor of optimal when h ≤ n12-ϵ , and within an O(log n) factor of optimal when h ≥ n12log n. These schedules improve upon the makespan of the schedules of D. Ghosal and coworkers by an O(log n) factor for those ranges of h, and at the same time also improve upon their time-processors product by an O(log n) factor (for h ≤ n12-ϵ or maintain their same time-processors product up to a constant (for h ≥ n12 log n). Further, for h ≤ n12/log2n, We provide a polynomial time computable schedule on a linear array that achieves makespan O(n12), using O(n12) processors (i.e., both optimal up to a constant), this time under an assumption that links have unlimited bandwidth. Using straightforward arguments as in D. Ghosal and co-workers′, we extend some of our polynomial time scheduling algorithms to deal with the more general case, where the trees have bounded degree d, and the architecture is a k-dimensional mesh.