Nested Dissection Algorithm Research Articles

Second‐order accurate hierarchical approximate factorizations for solving sparse linear systems

AbstractWe describe a second‐order accurate approach to sparsifying the off‐diagonal matrix blocks in the hierarchical approximate factorization methods for solving sparse linear systems. These methods repeatedly sparsify the fill‐in matrix blocks that arise in block Gaussian elimination, to compute an approximate factorization of the given matrix, assuming that the fill‐in blocks are low‐rank. The factorization is then used for preconditioning in a Krylov subspace method, such as the conjugate gradient method (CG), BiCGSTAB or GMRES. However, to achieve fast convergence on ill‐conditioned systems, sparsifications can only introduce a small error, in which case they may inefficiently restore sparsity, and consequently the factorization can take a lot of time to compute. In the novel approach to sparsification, the 2‐norm of the incurred error in the sparsification of a matrix block is squared compared to previous approaches, with no additional computations. We incorporate the new approach into the recent sparsified nested dissection algorithm and test it on a wide range of symmetric positive definite problems. The new approach halves the number of CG iterations needed for convergence, significantly improving the overall performance of the algorithm. Our approach can be incorporated into other solvers that exploit the low‐rank property of matrix blocks.

PMORSy: parallel sparse matrix ordering software for fill-in minimization

In this paper we present PMORSy—a new parallel software package for symmetric sparse matrix ordering on shared memory systems. The NP-complete fill-in minimization problem is solved by means of multilevel nested dissection algorithm with modifications for vertex separators. Parallel processing is done in a task-based fashion with the granularity tuning. We employ threading techniques on shared memory using OpenMP 3.0 technology as opposed to the Message Passing Interface-based approach widely used for parallel sparse matrix ordering. Experimental results on symmetric matrices from the University of Florida Sparse Matrix Collection and matrices from finite-element analysis of three-dimensional strength problems show that our implementation is competitive to the ParMETIS and PT-Scotch libraries both in ordering quality and performance. The PMORSy library is publicly available from the Lobachevsky State University Supercomputing Center web-site.

Volume and neighbors algorithm for finding elimination trees for three dimensional [formula omitted]-adaptive grids

This paper presents an algorithm called “volume & neighbors” for finding elimination trees for multifrontal solver algorithm applied to three dimensional h-adaptive finite element method computations. The algorithm is described in a pseudo-code and explained on exemplary h-refined grids. The algorithm is implemented in three dimensional h-adaptive finite element method code and tested on a sequence of representative grids, namely uniform grid, grid with point singularity, grid with edge singularity and grid with face singularity. The number of floating point operations for the multifrontal solver algorithm working with the elimination trees generated by the volume & neighbors algorithm is compared with the number of floating-point operations resulting from execution of the state-of-the-art multifrontal direct solver MUMPS with state-of-the-art algorithms for constructing elimination trees like nested-dissection from METIS library and approximate minimum degree AMD algorithm as well as PORD algorithm. In all the cases the volume & neighbors algorithm outperforms other state-of-the art algorithms. The only exception is the case of the uniform grid, where the algorithm results in a similar number of FLOPs than nested dissection algorithm.

Dynamic Programming Algorithm for Generation of Optimal Elimination Trees for Multi-frontal Direct Solver Over H-refined Grids

In this paper we present a dynamic programming algorithm for finding optimal elimination trees for computational grids refined towards point or edge singularities. The elimination tree is utilized to guide the multi-frontal direct solver algorithm. Thus, the criterion for the optimization of the elimination tree is the computational cost associated with the multi-frontal solver algorithm executed over such tree. We illustrate the paper with several examples of optimal trees found for grids with point, isotropic edge and anisotropic edge mixed with point singularity. We show the comparison of the execution time of the multi-frontal solver algorithm with results of MUMPS solver with METIS library, implementing the nested dissection algorithm.

On sparse matrix orderings in interior point methods

The major computational task of most interior point implementations is solving systems of equations with symmetric coefficient matrix by direct factorization methods, therefore, the performance of Cholesky-like factorizations is a critical issue. In the case of sparse and large problems the efficiency of the factorizations is closely related to the exploitation of the nonzero structure of the problem. A number of techniques were developed for fill-reducing sparse matrix orderings which make Cholesky factorizations more efficient by reducing the necessary floating point computations. We present a variant of the nested dissection algorithm incorporating special techniques that are beneficial for graph partitioning problems arising in the ordering step of interior point implementations. We illustrate the behavior of our algorithm and provide numerical results and comparisons with other sparse matrix ordering algorithms.

Universality of 3D percolation exponents and first-order corrections to scaling for conductivity exponents

By using a fast, Nested Dissection algorithm we compare the results of finite-size scaling at p c and of “ p ” scaling ( L = const ) on large cubic random resistor networks [up to 500×500×500]. The “ p ” scaling for conductivity of both site and bond networks leads to an exponent t = 2.00 ( 1 ) . The finite-size scaling leads to the ratio of this conductivity exponent to the coherence length exponent ν : t / ν = 2.283 ( 3 ) . Combining these results we estimate ν = 0.876 ( 6 ) , in excellent agreement with a value proposed by Ballesteros et al. The first-order correctional exponent ω is found to be ω = 1.0 ( 2 ) .

Building graph separators with the recursive rotation algorithm for the nested dissection method

A recursive rotation algorithm is built and investigated. The algorithm is a possible version of the nested dissection algorithm. The Liu algorithm builds a matrix graph separator by means of rotation of an elimination tree, which reduces the height of the latter. In this case, the nodes of the matrix graph are previously reordered by one of the well-known Cuthill-McKee algorithms, the reverse Cuthill-McKee algorithm, and the King algorithm. Then this procedure is recursively repeated. The recursive rotation algorithm is compared with the multilevel and spectral methods of graph separation for 2D finite-element grids.

A parallel algorithm for direct solution of large sparse linear systems, well suitable to domain decomposition methods

The goal of this paper is to develop a parallel algorithm for the direct solution of large sparse linear systems and integrate it into domain decomposition methods. The computational effort for these linear systems, often encountered in numerical simulation of structural mechanics problems by finite element codes, is very significant in terms of run-time and memory requirements.In this paper, a two-level parallelism is exploited. The exploitation of the lower level of parallelism is based on the development of a parallel direct solver with a nested dissection algorithm and to introduce it into the FETI methods. This direct solver has the advantage of handling zero-energy modes in floating structures automatically and properly. The upper level of parallelism is a coarse-grain parallelism between substructures of FETI. Some numerical tests are carried out to evaluate the performance of the direct solver.

A parallel algorithm for direct solution of large sparse linear systems, well suitable to domain decomposition methods

The goal of this paper is to develop a parallel algorithm for the direct solution of large sparse linear systems and integrate it into domain decomposition methods. The computational effort for these linear systems, often encountered in numerical simulation of structural mechanics problems by finite element codes, is very significant in terms of run-time and memory requirements.In this paper, a two-level parallelism is exploited. The exploitation of the lower level of parallelism is based on the development of a parallel direct solver with a nested dissection algorithm and to introduce it into the FETI methods. This direct solver has the advantage of handling zero-energy modes in floating structures automatically and properly. The upper level of parallelism is a coarse-grain parallelism between substructures of FETI. Some numerical tests are carried out to evaluate the performance of the direct solver.

PT-S cotch: A tool for efficient parallel graph ordering

The parallel ordering of large graphs is a difficult problem, because on the one hand minimum degree algorithms do not parallelize well, and on the other hand the obtainment of high quality orderings with the nested dissection algorithm requires efficient graph bipartitioning heuristics, the best sequential implementations of which are also hard to parallelize. This paper presents a set of algorithms, implemented in the PT-S cotch software package, which allows one to order large graphs in parallel, yielding orderings the quality of which is only slightly worse than the one of state-of-the-art sequential algorithms. Our implementation uses the classical nested dissection approach but relies on several novel features to solve the parallel graph bipartitioning problem. Thanks to these improvements, PT-S cotch produces consistently better orderings than P arM eT iS on large numbers of processors.

Parallel finite element modeling of earthquake ground response and liquefaction

Parallel computing is a promising approach to alleviate the computational demand in conducting large-scale finite element analyses. This paper presents a numerical modeling approach for earthquake ground response and liquefaction using the parallel nonlinear finite element program, ParCYCLIC, designed for distributed-memory message-passing parallel computer systems. In ParCYCLIC, finite elements are employed within an incremental plasticity, coupled solid-fluid formulation. A constitutive model calibrated by physical tests represents the salient characteristics of sand liquefaction and associated accumulation of shear deformations. Key elements of the computational strategy employed in ParCYCLIC include the development of a parallel sparse direct solver, the deployment of an automatic domain decomposer, and the use of the Multilevel Nested Dissection algorithm for ordering of the finite element nodes. Simulation results of centrifuge test models using ParCYCLIC are presented. Performance results from grid models and geotechnical simulations show that ParCYCLIC is efficiently scalable to a large number of processors.

An incomplete nested dissection algorithm for parallel direct solution of finite element discretizations of partial differential equations

A multilevel algorithm is presented for direct, parallel factorization of the large sparse matrices that arise from finite element and spectral element discretization of elliptic partial differential equations. Incomplete nested dissection and domain decomposition are used to distribute the domain among the processors and to organize the matrix into sections in which pivoting is applied to stabilize the factorization of indefinite equation sets. The algorithm is highly parallel and memory efficient; the efficient use of sparsity in the matrix allows the solution of larger problems as the number of processors is increased, and minimizes computations as well as the number and volume of communications among the processors. The number of messages and the total volume of messages passed during factorization, which are used as measures of algorithm efficiency, are reduced significantly compared to other algorithms. Factorization times are low and speedups high for implementation on an Intel iPSC/860 hypercube computer. Furthermore, the timings for forward and back substitutions are more than an order-of-magnitude smaller than the matrix decomposition times.

Fast and efficient solution of path algebra problems

This paper extends the author's parallel nested dissection algorithm (Pan and Reif, Technical Report 88-18, Computer Science Department, SUNY Albany, 1988) originally devised for solving sparse linear systems. We present a class of new applications of the nested dissection method, this time to path algebra computations (in both cases of the single source path problems and of the all pair path problems), where the path algebra problem is defined by a symmetric matrix A whose associated undirected graph G has a known family of separators of small size s( n) (in many cases of interest, s( n) = O(√ n).) The assumption that G has known separators is reasonable in a large variety of practical dynamic situations, where G is fixed and the entries of the matrix A associated with the edges of G may vary with the input. We substantially improve the known algorithms for path algebra problems of this general class: Previous estimates Path problem Sequential time Parallel time Proccessors Precomputed separators Single source O(n 2) O(n) O(I(n) log n) n n 3/(I(n) log n) No Yes All pairs O(n 3) O(n) O(I(n) log n) n 2 n 3/(I(n) log n) No Yes New Algrithms Path problem Sequential time Parallel time Processors Precomputed separators Single source O(n 1.5) O(( log n) √n) O(I(n) log 2 n) n/ log n n 1.5/(I(n) log n) No Yes All pairs O(n 2 log n) O(( log n) √n) O(I(n) log 2 n) n 1.5 n 2/I(n) log n) No Yes Here we assume that G is given with its O(√ n)-separator family. The latter assumption can be lifted for the sequential time estimates and for O((log n) √ n) parallel time estimates for planar graphs, because the evaluation of an O(√)-separator family can be done in O( n) sequential time (Lipton and Tarjan, SIAM J. Appl. Math. 36, No. 2, (1979), 177–189) or, on PRAM, in O((log n) √ n) parallel time with (√ n)/log n processors (Gazit and Miller, manuscript, Computer Sci. Dept., University of Southern California, 1986), with small overhead constants in both cases. I( n) denotes parallel time of computing the sum of n values, I( n)= O(log n) for any EREW PRAM, I( n) = O(1) on a randomized CRCW PRAM. Furthermore using the randomized algorithm of (Gazit and Miller, in “Proceedings, 28th Annu. IEEE Symp. FOCS, 1987,” pp. 238–248), we may precompute separators of a planar graph using O(log 2 n) time, n + ƒ 1+ϵ processors for a positive ϵ where ƒ is the number of faces; this is less than the cost of the subsequent path computation. Moreover, we preserve the above processor bounds but further decrease the parallel time by a factor of log n (via a modification of our new algorithms based on pipelining) in the important case of computing the minimum cost paths in a planar graph. Further applications lead, in particular, to computing a maxflow and a mincut in an undirected planar network using O( I( n) log 2 n) parallel steps, n 1.5 I(n) log n processors, versus the known bounds, O(log 2 n) and n 4, of (Johnson, J. ACM 34, No. 4 (1987), 950–967).

Parallel nested dissection for path algebra computations

This paper extends the authors' parallel nested dissection algorithm of [13] originally devised for solving sparse linear systems. We present a class of new applications of the nested dissection method, this time to path algebra computations (in both cases of single source and all pair paths), where the path algebra problem is defined by a symmetric matrix A whose associated graph G with n vertices is planar. We substantially improve the known algorithms for path algebra problems of that general class; this has further applications to maximum flow and minimum cut problems in an undirected planar network and to the feasibility testing of a multicommodity flow in a planar network.

The analysis of a nested dissection algorithm

Nested dissection is an algorithm invented by Alan George for preserving sparsity in Gaussian elimination on symmetric positive definite matrices. Nested dissection can be viewed as a recursive divide-and-conquer algorithm on an undirected graph; it usesseparators in the graph, which are small sets of vertices whose removal divides the graph approximately in half. George and Liu gave an implementation of nested dissection that used a heuristic to find separators. Lipton and Tarjan gave an algorithm to findn 1/2-separators in planar graphs and two-dimensional finite element graphs, and Lipton, Rose, and Tarjan used these separators in a modified version of nested dissection, guaranteeing bounds ofO (n logn) on fill andO(n 3/2) on operation count. We analyze the combination of the original George-Liu nested dissection algorithm and the Lipton-Tarjan planar separator algorithm. This combination is interesting because it is easier to implement than the Lipton-Rose-Tarjan version, especially in the framework of existing sparse matrix software. Using some topological graph theory, we proveO(n logn) fill andO(n 3/2) operation count bounds for planar graphs, twodimensional finite element graphs, graphs of bounded genus, and graphs of bounded degree withn 1/2-separators. For planar and finite element graphs, the leading constant factor is smaller than that in the Lipton-Rose-Tarjan analysis. We also construct a class of graphs withn 1/2-separators for which our algorithm does not achieve anO(n logn) bound on fill.

On Row and Column Orderings for Sparse Least Squares Problems

Let $P_1 $ and $P_2 $ be respectively $m \times m$ and $n \times n$ permutation matrices, with $m \geqq n$. Suppose the $m \times n$ sparse matrix $\bar A = P_1 AP_2 $ is reduced to upper trapezoidal form $\left[ {\begin{array}{*{20}c} R \\ 0 \\ \end{array} } \right]$ through the application of Givens rotations sequentially to the rows of $\bar A$. It is well known that the sparsity of R depends only on the choice of $P_2 $, but the choice of $P_1 $ can drastically affect the arithmetic required to compute R. In this paper we provide a mechanism for studying the connection between good row and good column orderings, along with a modified nested dissection algorithm for finding a good $P_2 $ which automatically induces a good $P_1 $. An analysis for a model problem is given, along with some experimental results.