Narrow Results

The usual QR algorithm for finding the eigenvalues of a Hessenberg matrix H is based on vector-vector operations, e.g. adding a multiple of one row to another. The opportunities for parallelism in such an algorithm are limited. In this paper, we describe a reorganization of the QR algorithm to permit either matrix-vector or matrix-matrix operations to be performed, both of which yield more efficient implementations on vector and parallel machines. The idea is to chase a k by k bulge rather than a 1 by 1 or 2 by 2 bulge as in the standard QR algorithm. We report our preliminary numerical experiments on the CONVEX C-1 and CYBER 205 vector machines.

The purpose of this paper is to suggest a new parallel algorithm for the knapsack problem. The design of the proposed parallel algorithm is based on a shared memory SIMD machine with a heap tree data structure. It can solve a general n-component knapsack problem in time O(2^n/2) with memory-processor tradeoff M²P = O(2^n/2). The proposed technique can have better performance in terms of cost as the number of processors needed can be offset by increasing memory space. The performance is compared with those of other algorithms to demonstrate its superiority. We believe that the proposed algorithm is pragmatically feasible at the moment when multiprocessor systems are gradually becoming popular.

In this paper we introduce a class of trees, called generalized compressed trees. Generalized compressed trees can be derived from complete binary trees by performing certain ‘contraction’ operations. A generalized compressed tree CT of height h has approximately 25% fewer nodes than a complete binary tree T of height h. We show that these trees have smaller (up to a 74% reduction) 2-dimensional and 3-dimensional VLSI layouts than the complete binary trees. We also show that algorithms initially designed for T can be simulated by CT with at most a constant slow-down. In particular, algorithms having non-pipelined computation structure and originally designed for T can be simulated by CT with no slow-down.

A fully parallel algorithm for updating and downdating the singular value decompositions (SVD’s) of an m-by-n(m≥n) matrix A is described. The algorithm uses similar chasing techniques for modifying the SVD’s described in [3], but requires fewer plane rotations, and can be implemented almost identically for both updating and downdating. Both cyclic and consecutive storage schemes are considered in parallel implementation. We show that the latter scheme outperforms the former on a distributed memory MIMD multiprocessor. We present the experimental results on the 32-node Connection Machine (CM-5).

The knapsack problem is known to be a typical NP-complete problem, which has 2ⁿ possible solutions to search over. Thus a task for solving the knapsack problem can be accomplished in 2ⁿ trials if an exhaustive search is applied. In the past decade, much effort has been devoted in order to reduce the computation time of this problem instead of exhaustive search. In 1984, Karnin proposed a brilliant parallel algorithm, which needs O(2^n/6) processors to solve the knapsack problem in O(2^n/2) time; that is, the cost of Karnin's parallel algorithm is O(2^2n/3). In this paper, we propose a fast search technique to improve Karnin's parallel algorithm by reducing the search time complexity of Karnin's parallel algorithm to be O(2^n/3) under the same O(2^n/6) processors available. Thus, the cost of the proposed parallel algorithm is O(2^n/2). Furthermore, we extend this search technique to the case that the number of available processors is P = O(2^x), where x ≥ 1. From the analytical results, we see that our search technique is indeed superior to the previously proposed methods. We do believe our proposed parallel algorithm is pragmatically feasible at the moment when multiprocessor systems become more and more popular.

This paper presents an algorithm for the Gaussian elimination problem that reduces the length of the critical path compared to the algorithm of Lord et al. This is done by redefining the notion of a task. For all practical purposes, the issues of communication overhead and pivoting cannot be overlooked. We consider these issues for the new algorithm as well. Timing results of this algorithm as executed on the CM-2 model of the Connection Machine are presented. Another contribution of this paper is the use of logical pivoting for stable computation of the Gaussian elimination algorithm. Pivoting is essential in producing stable results. When pivoting occurs, an interchange of two rows is required. A physical interchange of the values can be avoided by providing a permutation vector in a globally accessible location. We show experimental results that substantiate the use of logical pivoting.

In this paper, we propose a new parallel bidirectional algorithm, based on Cholesky factorization, for the solution of sparse symmetric system of linear equations. Unlike the existing algorithms, the numerical factorization phase of our algorithm is carried out in such a manner that the entire back substitution component of the substitution phase is replaced by a single step division. Since there is a substantial reduction in the time taken by the repeated execution of the substitution phase, our algorithm is particularly suited for the solution of systems with multiple b-vectors. The effectiveness of our algorithm is demonstrated by comparing it with the existing parallel algorithm, based on Cholesky factorization, using extensive simulation studies on two-dimensional problems discretized by FEM.

In Part I of this paper, we proposed a new parallel bidirectional algorithm, based on Cholesky factorization, for the solution of sparse symmetric system of linear equations. In this paper, we propose a new parallel bidirectional algorithm, based on LU factorization, for the solution of general sparse system of linear equations having non symmetric coefficient matrix. As with the sparse symmetric systems, the numerical factorization phase of our algorithm is carried out in such a manner that the entire back substitution component of the substitution phase is replaced by a single step division. However, due to absence of symmetry, important differences arise in the ordering technique, the symbolic factorization phase, and message passing during numerical factorization phase. The bidirectional substitution phase for solving general sparse systems is the same as that for sparse symmetric systems. The effectiveness of our algorithm is demonstrated by comparing it with the existing parallel algorithm, based on LU factorization, using extensive simulation studies.

A large number of optimization problems have been identified as computationally challenging and/or intractable to solve within a reasonable amount of time. Due to the NP-hard nature of these problems, in practice, heuristics account for the majority of existing algorithms. Metaheuristics are one very popular type of heuristics used for many of these optimization problems. In this paper, we present a novel parallel-metaheuristic framework, which effectively enables to devise parallel metaheuristics, particularly with heterogeneous metaheuristics. The core component of the proposed framework is its harmony-search-based coordinator. Harmony search is a recent breed of metaheuristic that mimics the improvisation process of musicians. The coordinator facilitates heterogeneous metaheuristics (forming a parallel metaheuristic) to escape local optima. Specifically, best solutions generated by these worker metaheuristics are maintained in the harmony memory of the coordinator, and they are used to form new-possibly better-harmonies (solutions) before actual solution sharing between workers occurs; hence, their solutions are harmonized with each other. For the applicability validation and the performance evaluation, we have implemented a parallel hybrid metaheuristic using the framework for the task scheduling problem on multiprocessor computing systems (e.g., computer clusters). Experimental results verify that the proposed framework is a compelling approach to parallelize heterogeneous metaheuristics.

Using a directed acyclic graph (dag) model of algorithms, we solve a problem related to precedence-constrained multiprocessor schedules for array computations: Given a sequence of dags and linear schedules parametrized by n, compute a lower bound on the number of processors required by the schedule as a function of n. In our formulation, the number of tasks that are scheduled for execution during any fixed time step is the number of non-negative integer solutions d_n to a set of parametric linear Diophantine equations. We present an algorithm based on generating functions for constructing a formula for these numbers d_n. The algorithm has been implemented as a Mathematica program. Example runs and the symbolic formulas for processor lower bounds automatically produced by the algorithm for Matrix-Vector Product, Triangular Matrix Product, and Gaussian Elimination problems are presented. Our approach actually solves the following more general problem: Given an arbitrary r× s integral matrix A and r-dimensional integral vectors b and c, let d_n(n=0,1,…) be the number of solutions in non-negative integers to the system Az=nb+c. Calculate the (rational) generating function ∑_{n≥ 0}d_ntⁿ and construct a formula for d_n.

Evidence is given to suggest that minimally vertex colouring an interval graph may not be in NC¹. This is done by showing that 3-colouring a linked list is NC¹-reducible to minimally colouring an interval graph. However, it is shown that an interval graph with a known interval representation and an O(1) chromatic number can be minimally coloured in NC¹.

For the CRCW PRAM model, an o(log n) time, polynomial processors algorithm is obtained for minimally colouring an interval graph with o(log n) chromatic number and a known interval representation. In particular, when the chromatic number is O((log n)^1-ε), 0<ε<1, the algorithm runs in O(log n/log log n) time. Also, an O(log n) time, O(n) cost, EREW PRAM algorithm is found for interval graphs of arbitrary chromatic numbers. The following lower bound result is also obtained: even when the left and right endpoints of the interval are separately sorted, minimally colouring an interval graph needs Ω(log n/log log n) time, on a CRCW PRAM, with a polynomial number of processors.

Vehicle routing problems involve the navigation of one or more vehicles through a network of locations. Locations have associated handling times as well as time windows during which they are active. The arcs connecting locations have time costs associated with them. In this paper, we consider two different problems in single vehicle routing. The first is to find least time cost routes between all pairs of nodes in a network for navigating vehicles; we call this the all pairs routing problem. We show that there is an O(log³ n) time parallel algorithm using a polynomial number of processors for this problem on a CREW PRAM.

We next consider the problem in which a vehicle services all locations in a network. Here, locations can be passed through at any time but only serviced during their time window. The general problem is -complete under even fairly stringent restrictions but polynomial algorithms have been developed for some special cases. In particular, when the network is a line, there is no time cost in servicing a location, and all time windows are unbounded at either their lower or upper end, O(n²) algorithms have been developed. We show that under the same conditions, we can reduce this problem to the all pairs routing problem and therefore obtain an O(log³ n) time parallel algorithm on a CREW PRAM.

A parenthesis string is a string of left and right parentheses. The string is well-formed when it consists of balanced pairs of left and right parentheses. This study presents a novel systolic algorithm for generating all the well-formed parenthesis strings in lexicographical order. The algorithm is cost-optimal and is run on a linear array of processors such that each well-formed parenthesis string can be generated in three time steps. The processor array is appropriate for VLSI implementation, since it has the features of modularity, regularity, and local connection.

We prove algorithmic characterizations of weakly chordal graphs, which lead to efficient parallel algorithms for recognizing P₅-free and -free weakly chordal graphs. For an input graph on n vertices and m edges, our algorithms run in O(log²n) time and require O(m²/log n) processors on the EREW PRAM model of computation. The proposed recognition algorithms efficiently detect P₅s and in weakly chordal graphs in O(log n) time with O(m²/logn) processors on the EREW PRAM. Additionally, we show how the algorithms can be augmented to provide a certificate for the existence of a P₅ (or a ) in case the input graph is not P₅-free (respectively, -free) weakly chordal.

Dimension-adaptive sparse grid interpolation is a powerful tool to obtain surrogate functions of smooth, medium to high-dimensional objective models. In case of expensive models, the efficiency of the sparse grid algorithm is governed by the time required for the function evaluations. In this paper, we first briefly analyze the inherent parallelism of the standard dimension-adaptive algorithm. Then, we present an enhanced version of the standard algorithm that permits, in each step of the algorithm, a specified number (equal to the number of desired processes) of function evaluations to be executed in parallel, thereby increasing the parallel efficiency.

Wang and Sahni [4] reported two parallel algorithms for N-point prefix computation on an N-processor OTIS-Mesh optoelectronic computer. The overall time complexity for both SIMS and MIMD models of their first algorithm was shown to be (8 N^1/4 - 1) electronic moves and 2 OTIS moves. This was further reduced to (7 N^1/4 - 1) electronic moves and 2 OTIS moves in their second algorithm. We present here an improved parallel algorithm for N-point prefix computation on an N-processor OTIS-Mesh, which needs (5.5 N^1/4 + 3) electronic moves and 2 OTIS moves. Our algorithm is based on the general theme of parallel prefix algorithm proposed in [4] but following the data distribution and local prefix computation similar to that of [1].

The neighbourhood broadcasting problem in an interconnection network is defined as sending a fixed sized message from the source node to all its neighbours in a single-port model. Previously, this problem has been studied for several interconnection networks including the hypercube and the star. The objective of such works has been to minimize the total number of steps required for the neighbourhood broadcasting algorithms. Here, we first use a general neighbourhood broadcasting scheme to develop a neighbourhood broadcasting algorithm for the star interconnection network that is asymptotically optimal, conceptually simple, and easy to implement since routing for all nodes involved is uniform. It uses the cycle structures of the star graph as well as the standard technique of recursive doubling. We then show that the scheme for the star network is general enough to be applied to a broader family of interconnection networks such as the pancake interconnection network for which no previous neighbourhood broadcasting algorithm is known, resulting in asymptotically optimal algorithms. Finally, we use this scheme to develop neighbourhood broadcasting algorithms for multiple messages for several interconnection networks.

OTIS (optical transpose interconnection system) is a popular model of optoelectronic parallel computers that has gained enormous attention in the recent years. Several parallel algorithms have been published for many fundamental problems on this architecture. In this paper, first we propose a parallel algorithm for sparse enumeration sort on OTIS-Mesh of Trees (OTIS-MOT). For N (= n²) data elements, our sorting algorithm requires 4 log N electronic moves + 3 OTIS moves. We next present a shortest path routing algorithm that runs also in logarithmic time.

In this paper we evaluate the potential for using an NVIDIA graphics processing unit (GPU) to accelerate high precision integer multiplication, addition, and subtraction. The reported peak vector performance for a typical GPU appears to offer good potential for accelerating such a computation. Because of limitations in the on-chip memory, the high cost of kernel launches, and the nature of the architecture's support for parallelism, we used a hybrid algorithmic approach to obtain good performance on multiplication. On the GPU itself we adapt the Strassen FFT algorithm to multiply 32KB chunks, while on the CPU we adapt the Karatsuba divide-and-conquer approach to optimize application of the GPU's partial multiplies, which are viewed as "digits" by our implementation of Karatsuba. Even with this approach, the result is at best a factor of three increase in performance, compared with using the GMP package on a 64-bit CPU at a comparable technology node. Our implementations of addition and subtraction achieve up to a factor of eight improvement. We identify the issues that limit performance and discuss the likely impact of planned advances in GPU architecture.

In this paper, by the novel idea of integrating multiple-proposal algorithm and multiple-chain algorithm by parallel computing, we develop a highly efficient sampler for approximating statistical distributions: parallel Multi-proposal and Multi-chain Markov Chain Monte Carlo (pMPMC3), and we illustrate the high performance of this sampler by calculating P-value (odds ratio significance) for Genome Wide Association Study (GWAS). Computational results show that, by setting the convergence condition as the standard deviation of P-value is less than 10⁻³, pMPMC3 with 4 proposals and 4 chains obtains a convergent P-value within 10⁶ iterations, while the conventional method Monte Carlo simulation does not obtain convergent P-values even in 10⁷ iterations. We also test pMPMC3 by changing the number of chains, the number of proposals and the size of the dataset on a cluster with maximum 600 processes, the algorithm scales well.