In this paper we present an experimental evaluation of COMPASSION, a runtime system for irregular applications based on collective I/O techniques. It provides a “Collective I/O” model, enhanced with “Pipelined” operations and compression. All processors participate in the I/O simultaneously, alone or grouped, making scheduling of I/O requests simpler and providing support for contention management. In-memory compression mechanisms reduce the total execution time by diminishing the amount of I/O requested and the I/O contention. Our experiments, executed on an Intel Paragon and on the ASCI/Red teraflops machine, demonstrate that COMPASSION can obtain significantly high-performance for I/O above what has been possible so far.
In this paper we present a parallel run-time system for the efficient implementation of adaptive applications on distributed memory machines. Our approach is application driven; the target applications are characterized by very large variations in time and length scales. Preliminary performance data from parallel unstructured adaptive mesh refinement on an SP machine suggest that the flexibility of our approach does not cause undue overhead.
This paper presents a fast implementation of the recursive spectral bisection method for p-way partitioning. It is known that recursive bisections for p-way partitioning using optimal strategies at each step may not lead to a good overall solution. The relaxed implementation accelerates the partitioning process by relaxing the accuracy requirement of spectral bisection (SB) method. Considering the solution quality of a SB method on a graph is primarily determined by the accuracy of its Fiedler vector, we propose to set a tight iteration number bound and a loose residual tolerance for Lanczos algorithms to compute the Fiedler vector. The relaxed SB was tested on eight representative meshes from different applications. Experimental results show that the relaxed SB on six meshes produces approximately equivalent quality solutions as the Chaco SB while gaining 10% to 35% improvements in execution time. On the other two meshes, the relaxed SB approaches the Chaco SB in quality as p increases and reduces the execution time by 40% to 70%. Coupled with the Kernighan-Lin local refinement algorithm, the relaxed SB is able to yield high quality solutions in all test cases as p goes beyond 32. Multilevel and spectral quadrisection algorithms benefit from relaxed implementations, as well.
We describe the parallelization of a three dimensional, unstructured grid, finite element code which solves hyperbolic conservation laws for mass; momentum, and energy, and diffusion equations modeling heat conduction and radiation transport. Explicit temporal differencing advances the cell-based gasdynamic equations. Diffusion equations use fully implicit differencing of nodal variables which leads to large, sparse; symmetric, and positive definite matrices. Because of the unstructured grid, the off-diagonal non-zero elements appear in unpredictable locations. The linear systems are solved using parallelized conjugate gradients. The code is parallelized by domain decomposition of physical space into disjoint subdomains (SDs). Each processor receives its own SD plus a border of ghost cells. Results are presented on a problem coupling hydrodynamics to non-linear heat conduction.
To achieve scalable parallel performance in Molecular Dynamics Simulation, we have modeled and implemented several dynamic spatial domain decomposition algorithms. The modeling is based upon Valiant's Bulk Synchronous Parallel architecture model (BSP), which describes supersteps of computation, communication, and synchronization. We have developed prototypes that estimate the differing costs of several spatial decomposition algorithms using the BSP model. Our parallel MD implementation is not bound to the limitations of the BSP model, allowing us to extend the spatial decomposition algorithm. For an initial decomposition, we use one of the successful decomposition strategies from the BSP study, and then subsequently use performance data to adjust the decomposition, dynamically improving the load balance. We report our results here.
Adaptive mesh refinement is a key problem in large-scale numerical calculations. The need of adaptive mesh refinement could introduce load imbalance among processors, where the load measures the amount of work required by refinement itself as well as by numerical calculations thereafter. We present a dynamic load balancing algorithm to ensure that the work load are balanced while the communication overhead is minimized. The main ingredient of our method is a technique for the estimation of the size and the element distribution of the refined mesh before we actually generate the refined mesh. Base on this estimation, we can reduce the dynamic load balancing problem to a collection of static partitioning problems, one for each processor. In parallel each processor could then locally apply a static partitioning algorithm to generate the basic units of submeshes for load rebalancing. We then model the communication cost of moving submeshes by a condensed and much smaller subdomain graph, and apply a static partitioning algorithm to generate the final partition.
We introduce short-cutting and overlapping techniques that, separately and in combination show promise of speedup for parallel processing of problems with irregular or asymmetric computation. Methodology is developed and demonstrated on an example problem. Experiments on an IBM SP-2 and a workstation cluster are presented.
Parallelizing dynamic scientific applications involves solving the dynamic load balancing problem. The balancing should take the communication requirements of the application into account. Many problems are dealing with objects in κ-dimensional space with very special communication patterns. We describe a kind of an orthogonal recursive bisection clustering and show that its dynamic adaption involves only small overhead. As a spatial clustering it is well suited to applications with local communication.
A theoretical foundation for latent semantic indexing (LSI) is proposed by adapting a model first used in array signal processing to the context of information retrieval using the concept of subspaces. It is shown that this subspace-based model coupled with minimal description length (MDL) principle leads to a statistical test to determine the dimensions of the latent-concept subspaces in LSI. The effect of weighting on the choice of the optimal dimensions of latent-concept subspaces is illustrated. It is also shown that the model imposes a so-called low-rank-plus-shift structure that is approximately satisfied by the cross-product of the term-document matrices. This structure can be exploited to give a more accurate updating scheme for LSI and to correct some of the misconception about the achievable retrieval accuracy in LSI updating. Variants of Lanczos algorithms are illustrated with numerical test results on Cray T3E using document collections generated from World Wide Web.
We are interested in partitioning sparse rectangular matrices for parallel processing. The partitioning problem has been well-studied in the square symmetric case, but the rectangular problem has received very little attention. We will formalize the rectangular matrix partitioning problem and discuss several methods for solving it. We will extend the spectral partitioning method for symmetric matrices to the rectangular case and compare this method to three new methods | the alternating partitioning method and two hybrid methods. The hybrid methods will be shown to be best.
mpC is a medium-level parallel language for programming heterogeneous networks of computers. It allows to write libraries of parallel routines adaptable to peculiarities of any particular executing multiprocessor system to ensure efficient running. The adaptable routines distribute data and computations in accordance with performances of participating processors. In this case even the problems traditionally considered regular, become irregular. Advantages of mpC for efficient solving of regular problems on heterogeneous networks of computers are demonstrated with an mpC routine implementing Cholesky factorization, with efficiency of the mpC routine being compared with ScaLAPACK one.
We present a new parallel tree contraction scheme which takes O(log n) contraction phases to reduce a tree to its root, and implement this scheme in O(log n log log n) time using O(n/ log log n) processors on an arbitrary CROW PRAM. We then show a data structure to represent a connected distance-hereditary graph G in the form of a rooted tree. Applying our tree contraction scheme on the above data structure together with graph theoretical properties, we solve the problems of finding a minimum connected γ-dominating set and finding a minimum γ-dominating clique on G in O(log n log log n) time using O((n + m) /log log n) processors on an arbitrary CROW PRAM, where n and m are the number of vertices and edges in G, respectively.
Simulation of particles in fluids requires the solution of nonlinear Navier-Stokes equations for fluids coupled with Newton's equations for particle dynamics, in which the most time consuming part is the solution of nonsymmetric and indefinite sparse linear systems. In this paper, we present a comprehensive algorithm for the simulation of particulate flows in two dimensional domains. A backward Euler method is used for time evolution, and a variant of Newton's method is used to solve the nonlinear systems. The linear systems are solved efficiently by a novel multilevel algorithm that generates discrete divergence-free space for the incompressible fluid. Unlike incomplete factorization preconditioners, our technique has the desirable properties of robust and effective preconditioning along with efficient implementation on parallel computers. We present experiments on the SGI Origin2000 that demonstrate the parallel performance of our algorithm, and discuss various aspects of the simulation package and the associated software design.
In this work, we propose a cooperative multi-thread parallel tabu search heuristic for the circuit partitioning problem. This procedure is based on the cooperation of multiple search threads. Each thread implements a different variant of a sequential tabu search algorithm, using a different combination of initial solution algorithm and move attribute definition. These threads communicate by exchanging elite solutions. PVM and Linda are used in the implementation of the parallel tabu search procedure. Numerical results reported for a set of ISCAS benchmark circuits illustrate the effectiveness of the parallel tabu search procedure. Comparative results illustrating the efficiency of the implementations in PVM and Linda are also assessed.
In this paper, we propose a restarted variant of the Lanczos method for symmetric eigenvalue problems named the thick-restart Lanczos method. This new variant is able to retain an arbitrary number of Ritz vectors from the previous iterations with a minimal restarting cost. Since it restarts with Ritz vectors, it is simpler than similar methods, such as the implicitly restarted Lanczos method. We carefully examine the effects of the floating-point round-off errors on stability of the new algorithm and present an implementation of the partial reorthogonalization scheme that guarantees accurate Ritz values with a minimal amount of reorthogonalization. We also show a number of heuristics on deciding which Ritz pairs to save during restart in order to maximize the overall performance of the thick-restart Lanczos method.
We present a sphere-packing technique for Delaunay-based mesh generation, refinement and coarsening. We have previously established that a bounded radius of ratio of circumscribed sphere to smallest tetrahedra edge is sufficient to get optimal rates of convergence for approximate solutions of Poisson's equation constructed using control volume (CVM) techniques. This translates to Delaunay meshes whose dual, the Voronoi cells diagram, is well-shaped. These meshes are easier to generate in 3D than finite element meshes, as they allow for an element called a sliver. We first support our previous results by providing experimental evidence of the robustness of the CVM over a mesh with slivers. We then outline a simple and efficient sphere packing technique to generate a 3D boundary conforming Delaunay-based mesh. We also apply our sphere-packing technique to the problem of automatic mesh coarsening. As an added benefit, we obtain a simple 2D mesh coarsening algorithm that is optimal for finite element meshes as well. This is a joint work with Dafna Talmor (CMU), Shang-Hua Teng (UlUC), Noel Walkington (CMU), and Han Wang (CMU).
A distributed, parallel implementation of the widely used Modular Semi-Automated Forces (ModSAF) Distributed Interactive Simulation (DIS) is presented, using networked high-performance resources to simulate large-scale entity-level exercises. Processing, communication and I/O demands increase dramatically as the simulation grows in terms of size or complexity. A general framework for functional decomposition and scalable communications architecture is presented. An analysis of the communications load within a single computer and between computers is presented. Ongoing activities to address more dynamically communication limitations and processing load using Globus are discussed.
We describe the design and implementation of the Distributed Object-Oriented Threads System (DOTS). This system is a complete redesign of the Distributed Threads System (DTS) using the object-oriented paradigm both in its internal implementation and in the programming paradigm it supports. DOTS extends the support for fork/join parallel programming from shared memory threads to a distributed environment. It is currently implemented on top of the Adaptive Communication Environment (ACE). A heterogeneous network of Windows NT PC's and of UNIX workstations is transformed by DOTS into a homogeneous pool of anonymous compute servers. DOTS has been used recently in applications from computer graphics and computational number theory. We also discuss the performance characteristics of DOTS for a workstation cluster running under Solaris and a PC network using Windows NT, as they were obtained from a prototypical example.
In this paper we describe the parallel implementation of the Vertex-To-Vertex Radiosity method on a cluster of PC hosts with a Distributed Shared Memory interface (DSM). We first explain how we use stochastic rays to compute the Form-Factor. We then proceed to describe the implementation of this method on top of the millipede system, a virtual parallel machine that runs on top of available distributed environments. We discuss a step-by-step process for exploiting millipede's optimization mechanisms. Despite the relatively slow communication medium, the optimization process leads from initial slowdown to high speedups.
A key ingredient in the solution of a large, sparse system of linear equations by an iterative method like conjugate gradients is a preconditioner, which is in a sense an approximation to the matrix of coefficients. Ideally, the iterative method converges much faster on the preconditioned system at the extra cost of one solve against the preconditioner per iteration. We survey a little-known technique for preconditioning sparse linear systems, called support-graph preconditioning, that borrows some combinatorial tools from sparse Gaussian elimination. Support-graph preconditioning was introduced by Vaidya and extended by Gremban, Miller, and Zagha. We extend the technique further and use it to analyze existing preconditioners based on incomplete factorization and on multilevel diagonal scaling. In the end, we argue that support-graph preconditioning is a ripe field for further research.
