Combinatorial preconditioners for sparse, symmetric, diagonally dominant linear systems, KD Gremban

Tags: coefficient matrix, STCG, preconditioner, iterative method, conductance, preconditioners, support trees, Laplacian matrices, sparse linear systems, Ai, internal node, support, iterations, ICCG, DSCG, diagonally dominant, Cholesky factorization, nodes, subgraph, coefficient matrices, parallel implementation, linear systems, iterative methods, preconditioned conjugate gradient method, sparse matrices, finite difference methods, Resistive Networks, undirected graphs, Ki, Laplacian matrix, DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG, current flow, nxn matrix, iterative solution, preconditioned system, vector space, vector spaces, CG, solution method, boundary edges, Jacobi method, internal nodes, iteration matrix
Content: Combinatorial Preconditioners for Sparse, Symmetric, Diagonally Dominant Linear Systems Keith D. Gremban October 1996 CMU-CS-96-123 School of computer science Carnegie Mellon University Pittsburgh, PA 15213 Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy Thesis Committee: Gary Miller, Chair Guy Blelloch Paul Heckbert Bruce Maggs Omar Ghattas Mike Heroux, Cray Research This research is sponsored in part by the Wright Laboratory, Aeronautical Systems Center, Air Force Material Command, USAF, and the Defense Advanced research projects Agency (DARPA) under grant number F33615-931-1330, and in part by NSF Grant CCR-9016641. Cray C-90 computing time was provided by the Pittsburgh Supercomputing Center under Grant ASC890018P. The U.S. government is authorized to reproduce and distribute reprints for government purposes, notwithstanding any copyright notation thereon. The views and conclusions contained in this document are those of the author and should not be interpreted as representing the official policies or endorsements, either expressed or implied, of DARPA, NSF, or the U.S. government.
Keywords: linear systems, iterative methods, preconditioners, sparse and very large systems, parallel algorithms
iii Abstract Solution of large, sparse linear systems is an important problem in science and engineering. Such systems arise in many applications, such as electrical networks, stress analysis, and more generally, in the numerical solution of partial differential equations. When the coefficient matrices associated with these linear systems are symmetric and positive definite, the systems are often solved iteratively using the preconditioned conjugate gradient method. We have developed a new class of preconditioners, which we call support tree preconditioners, that are based on the combinatorial properties of the graphs corresponding to the coefficient matrices of the linear systems. We call the resulting iterative method support tree conjugate gradient, or STCG. These new preconditioners are applicable to the class of symmetric and diagonally dominant matrices, and have the advantage of being well-structured for parallel implementation, both in construction and in evaluation. In this thesis, we present the intuition, construction, implementation, and analysis of STCG. STCG is based upon an interesting isomorphism between a certain class of matrices (which we call Laplacian matrices), edge-weighted undirected graphs, and resistive networks. Using this isomorphism, we show that an iterative method can be interpreted in terms of these discrete structures. Based on this interpretation, the STCG method for accelerating convergence is developed, which involves constructing other, more efficient discrete structures called support trees, and using their interpretation as matrices to apply them as preconditioners. Interestingly, the matrix preconditioners used in STCG are larger, but sparser than conventional preconditioners. Additionally, the construction of support trees is basically an application of recursive divide-and-conquer. Support trees have very regular structures and are very well-suited for parallel implementation. Through theoretical analysis and numerical experiments, we show that STCG is practical and efficient for the parallel solution of large sparse linear systems with Laplacian coefficient matrices. STCG is an interesting example of combinatorial techniques being applied to solve an algebraic problem. These techniques have wider applicability than the acceleration of iterative techniques. We also demonstrate an application of these techniques to the more general problem of bounding eigenvalues.
iv
v Acknowledgments My graduate work at CMU was a long process involving a number of cycles of elation, excitement, and frustration. I entered the program after several years of working in a robotics research group at an aerospace company and expected to find a thesis topic and graduate in record time. Was I in for a shock, or rather a series of shocks! Without going into detail, suffice it to say that I encountered a number of setbacks. Fortunately, though, the structure of the Computer Science Ph.D. program at CMU is such that I was given time to overcome these difficulties. I am grateful to Chuck Thorpe, Takeo Kanade, Katsushi Ikeuchi, and Gary Miller for having the patience and the confidence in me to help me through this period. I am also grateful to Roger Schappell for creating a work environment that enabled me to finish this thesis after having physically left CMU. It would not have been possible for me to have finished the program without lots of help from friends. The list is far too long to detail here, but I would especially like to thank Doug Reece for all the time spent listening to my troubles on long runs through Schenley Park. Tracy Ann Lewis was a wonderful listener over coffee throughout my years at CMU. I couldn't have made it through my last several years there without the help of the Carnegie Mellon Shotokan Karate Club. Karate is an amazingly effective way to focus one's mind and relieve stress! I need to specifically acknowledge my immediate seniors, Mark Ciancutti and Bruce Schmidt, as well as the many junior members who helped me out, especially the Wednesday afternoon sparring club, which included Rahul Sukthankar, Ruth Chabay, Yoichi Sato, Sanjay Sachdev, and Tony Lattanze. Of course, I have to thank my parents, Joe and June Gremban, who are responsible for my scientific curiousity. Special thanks go to my family, who put up with me for all this time: my wife Kathy, and my two daughters, Stephanie and Kelly. My final thanks are to my late dachshund, Random Variable, who gave his life for this thesis, and again to my wife, Kathy, who gave up having a life because of this thesis.
vi
vii
Table of Contents
1 Introduction
1
2 Background
5
2.1 Definitions and Notation
5
2.2 Graph Theory
7
2.3 direct Methods for the Solution of Sparse Linear Systems
15
2.4 Iterative Methods for the Solution of Sparse Linear Systems
20
2.5 Domain decomposition methods
30
2.5 Multilevel Methods
33
3 Support Trees: Construction and Application
37
3.1 Communication and Mixing
38
3.2 Support Tree Construction
40
3.3 Implementation of Support Tree Conjugate Gradient
44
3.4 Computational Properties of Support Trees
48
3.5 Summary
52
4 Support Trees: Theory
53
4.1 Matrices and Graphs
53
4.2 Matrices and Resistive Networks
54
4.3 Support Trees and Resistive Networks
57
4.4 Generalized Eigenvalues and Support Numbers
58
4.5 Condition Number Bounds for Support Trees: Preliminary Lemmas
66
4.6 Condition Numbers for Regular Meshes
69
4.7 Summary
78
5 Extended Analysis
79
5.1 Irregular Graphs and Implicit Embedding
80
5.2 Dealing with Unequal Partitions
83
6 Support Trees: Evaluation
91
6.1 Empirical Evaluation of STCG
92
6.2 Tabulated Experimental Results
103
6.3 Summary and Discussion
107
7 Extensions and Applications of Combinatorial Analysis
109
7.1 Symmetric and Diagonally Dominant Matrices
109
7.2 Bounding the Largest Eigenvalue
111
7.3 Summary
120
8 Discussion and Recommendations
123
8.1 Support Tree Conjugate Gradients
123
8.2 STCG is not Multigrid
125
8.3 Recommendations for Future Work
127
9 References
129
viii
1
1 Introduction
Consider the solution of linear systems of the form
Ax = b
(1.1)
where A is an nxn matrix, and both x and b are nx1 vectors. Of special interest is the case where A is large and sparse. Systems of this sort arise frequently in many applications such as electrical networks, tomography, diffusion, and structural mechanics [Axelsson (1994)]. We are especially interested in linear systems that arise from the solution of elliptic boundary value problems by either the finite element or finite difference methods.
The term sparse above refers to the relative number of non-zeros in the matrix A. An nxn matrix A is considered to be sparse if A has only O(n) non-zero entries. In this case, the majority of the entries in the matrix are zeros, which do not have to be explicitly stored. An nxn dense matrix has (n2) non-zeros. One of the goals of dealing with sparse matrices is to make efficient use of the sparsity in order to minimize storage throughout the computations, as well as to minimize the required number of operations. Sparse linear systems are often solved using different computational techniques than those employed to solve dense systems.
The term large varies with respect to the current generation of computers, and with the sparsity of the system. A dense nxn system requires (n2) storage vs. O(n) for a sparse matrix of the same order. Nonetheless, some generalizations can be made with respect to the size of feasible linear systems. Where at one time (1960's) dense linear systems with n > 100 were considered large, such systems can be solved easily on the current (1995) generation of scientific workstations. In 1995, dense linear systems with n > 10,000, and sparse linear systems with n > 100,000 are considered large by most computational scientists, and n will continue to grow. As systems with n = 10,000 become the norm, the desire for more resolution and more accurate simulations will push n to become larger and larger.
Since large linear systems may require intensive computational resources to solve, it is important to take advantage of any special information about the coefficient matrices that is available. Consequently, a host of techniques exist that are applicable to specific kinds of matrices. The techniques presented in this thesis are no different: they are applica- ble to a specific class of matrices which we call Laplacian matrices. These matrices are characterized by being symmetric, diagonally dominant1, and containing non-positive off-diagonals. Laplacian matrices frequently arise in the
1. An nxn matrix A = [aij] is diagonally dominant if, for all i {1, 2, ..., n} , aii aij . ji
2 solution of elliptic boundary value problems. For example, elliptic problems that are discretized with the finite element method using linear, triangular elements yield coefficient matrices that are Laplacian provided that all the angles of the elements are less than 90°. There are two broad categories of methods for solving linear systems: direct and iterative. A direct method for solving the system of equations (1.1) is any method that produces the solution x after a finite number of operations [Axelsson and Barker (1984)]. An example of a direct method is using Gaussian elimination to factor A into matrices L and U where L is lower triangular and U is upper triangular, then solving the triangular systems by forward and back substitution. Direct methods are typically preferred for dense linear systems. The problem with direct methods for sparse systems is that the amount of computational effort and storage required can be prohibitive. For example, consider the case of a nxn finite element mesh defined for Laplace's equation on the unit square. The coefficient matrix A in this case is n2xn2, and will have O(n2) non-zero elements. A naive direct solution may lead to storage of O(n4) and computational effort of O(n6) [Axelsson and Barker (1984), Golub and Ortega (1993)]. Nested dissection is a technique for reducing storage requirements that has been shown to be asymptotically optimal. However, even an efficient direct solution method utilizing nested dissection may require O(nlogn) storage and O(n3) computations [Axelsson and Barker (1984), Hoffman, Martin, and Rose (1973)]. An alternative to direct methods of solution are iterative methods, which involve the construction of a sequence {x(i)} of approximations to the solution x, for which x(i) x. Many different iterative methods have been developed. Possibly the most basic iterative method is the Jacobi method, defined by x(n + 1) = x(n) ­ D­1( A x(n) + b) , where D is the matrix containing only the main diagonal of A. The basic first-order linear stationary iterative method involves repeating a predict-test-correct cycle until the result produced with the approximate solution is sufficiently accurate [Hageman and Young (1981)]. Every test step requires the computation of Ax(i). Iterative methods are storage efficient -- the basic iterative method requires only O(n2) storage for an nxn coefficient matrix. Moreover, each step of an iterative method requires only O(n2) operations, as well. An iterative method is more efficient than the best direct method if the number of iterations required can be held to less than O(n). The conjugate gradients (CG) method is a popular and efficient iterative method that can be used whenever the coefficient matrix is symmetric and positive definite.1 Applied in its basic form to an n2xn2 coefficient matrix, CG may require O(n2) iterations, which is not an improvement over the best direct method. However, through the use of a technique known as preconditioning, the convergence of CG can be accelerated. The resulting method is known as the method of preconditioned conjugate gradients (PCG). The method presented in this thesis is a variant of PCG that we call support tree conjugate gradient, or STCG. Parallel performance of a solution method is an important issue. The size of the linear systems that are being solved has continued to grow over recent years. Linear systems can easily be formulated that exceed the capability of current serial computers to solve. Consequently, the use of parallel computers is required and it is necessary to design new algorithms that can simultaneously take advantage of the sparsity and parallel potential of a linear system. Direct methods for sparse matrices have proven difficult to parallelize. The most common direct methods involve using Gaussian elimination to factor the coefficient matrix into two triangular matrices, and then performing two successive triangular solves. Some progress has been made in parallel factorization, but triangular solution is recognized as the major bottleneck to effective parallelization [Heath, et al (1990)]. In contrast, the primary operation in iterative methods for sparse matrices is matrix-vector multiplication, which can be fairly efficiently parallelized for dense matrices, as well as for sparse matrices with regular structure [Blelloch, et al (1993)]. Therefore, iterative methods are attractive for parallel implementation if the number of iterations can be kept small by accelerating the rate of convergence. Convergence acceleration requires the use of preconditioners, however, and these form a bottleneck to parallel implementation. This is because every iteration of a preconditioned iterative method requires the solution of a linear system involving the preconditioner. Typically, this is done using a direct method: the preconditioner is factored into triangular matrices, and two triangular solves must be performed. 1. Recall that A is symmetric if At = A. A is positive definite if, for any vector x 0 , xt Ax > 0 .
3 The factorization is performed only once, and the factors are stored for use in every iteration. However, the two triangular solves must be performed at every iteration, and, as noted above, sparse triangular solves are difficult to parallelize efficiently. Several studies have shown that the use of preconditioners can actually decrease the parallel performance of iterative methods [Greenbaum, et al (1989), Heroux, et al (1991)]. A variant of iterative methods are the multigrid methods, which are primarily applicable to the solution of linear systems resulting from the discretization of partial differential equations. Multigrid methods can be efficiently parallelized, and require very few iterations to converge. However, in addition to being somewhat limited in applicability, multigrid methods typically require extensive knowledge of the meshing and discretization processes. Such information is often unavailable, and so multigrid methods lack generality. We can briefly summarize the state-of-the-art in solving linear systems as follows: · the size of the linear systems to be solved can be expected to increase indefinitely; · parallel machines are required to solve the largest linear systems; · iterative methods are promising for parallel implementation, if convergence is sufficiently rapid; · convergence can be accelerated through the use of preconditioners, but the use of preconditioners can adversely affect the parallel performance of the iterative method. On the basis of the summary above, we can conclude that the development of an efficient parallel preconditioner would be a significant advance in the state-of-the-art for solving sparse linear systems on parallel machines. In this thesis, we present the design and analysis of a new parallel iterative method for the solution of certain types of large, sparse linear systems. The systems that we shall consider are large, sparse, symmetric, and diagonally dominant with non-positive off-diagonals. The new method is an extension of the PCG method, and is characterized by the form of the preconditioner. We call the new method support tree conjugate gradients, or STCG. STCG is unusual in that the preconditioner is derived from an analysis of the combinatorial properties of the linear system, rather than the algebraic properties. We shall show, both analytically and empirically, that STCG has the following characteristics: · the rate of convergence of STCG is superior to most variants of PCG; · the support tree preconditioners are straightforward to construct, given the coefficient matrix; · support tree preconditioners are large, but very sparse, therefore requiring · relatively little storage (usually less than the original coefficient matrix); · relatively little processing per iteration (usually less than that required by a matrix-vector multiplication involving the original coefficient matrix); · STCG is efficient to implement on parallel machines; · STCG is nearly as efficient on serial machines as many standard variants of PCG. In addition, a major contribution of this thesis is a new method for analyzing matrices. The new analytic method relies on the combinatorial properties of the graphs that are associated with matrices, and enables proofs of various matrix properties without explicitly referring to the underlying vector spaces. Instead, the proofs involve determining bounds on flows in networks, and bounds on various properties of network embeddings. Using this new method, we obtain bounds on the largest eigenvalues of matrices, and prove theoretical bounds on the convergence rate of STCG. The format of this thesis is as follows. In the next chapter, we review the current state of the art in direct and iterative
4 methods and show in more detail why a new method is necessary. Following the review, we present the implementation of STCG. This is followed by a theoretical analysis of the properties of STCG which is divided into two chapters. Next, numerical experiments are presented that compare the performance of STCG with that of other common variants of PCG. Finally, STCG is extended to a larger class of problems, and some interesting extensions and applications of the theory developed for the analysis of STCG are presented.
5
2 Background
This thesis involves the design and analysis of a new method for solving linear systems. A basic understanding of linear algebra and the techniques and tools used to analyze and solve linear systems is therefore necessary. In addition, the method developed in this thesis is based on graph theory, so a basic understanding of this topic is necessary as well. Below, we first establish some basic definitions and notation. Following that, we review some basic results in graph theory, direct methods for the solution of linear systems, and iterative methods for the solution of linear systems.The reader already familiar with this material is encouraged to skip this chapter.
2.1 Definitions and Notation
will be used to denote the set of real numbers. + will denote positive real numbers, while - will denote negative real numbers.
A column vector x is an nx1 array of numbers indexed by row. xi denotes the element in row i of vector x. An nx1 vector will sometimes be referred to as a n-vector. We will denote vectors with boldface italic lower-case letters. In general, a vector may have complex elements, but in this thesis, we shall only be concerned with vectors having real elements.
A collection of vectors {x1,...,xn} is called linearly independent if, for any collection of scalars {1,...,n} not all
n
n
equal to zero, i xi 0 . Conversely, if there exists a collection {1,...,n} with some i 0 and i xi = 0 ,
i=1
i=1
then the collection {x1,...,xn} is said to be linearly dependent.
A matrix A is an mxn array of numbers indexed by row and column. Thus, A(i,j) is the element in row i and column j of the matrix A. An n-vector is a special case of a matrix with a single column. In this thesis, we will be considering square matrices in which m = n. An nxn matrix A is said to be of order n. We will denote matrices with italic capital letters. The element A(i,j) will often be denoted by aij. In general, the elements of a matrix may be complex numbers, although in this thesis, we will only be concerned with matrices having real elements.
6
The rank of an mxn matrix A, rank(A), is the number of linearly independent rows/columns of A. An nxn matrix A is said to be of full rank if rank(A) = n .
The main diagonal of an nxn matrix A is the set of elements indexed by aii for i = 1,...,n, and is denoted by diag(A). A matrix D is said to be diagonal if all elements off the main diagonal are zero.
A nxn matrix A is lower (upper) triangular if all elements above (below) the main diagonal are zero. A is unit lower (upper) triangular if A is lower (upper) triangular and all the elements on the main diagonal are 1. A is strictly lower (upper) triangular if A is lower (upper) triangular and all elements of the main diagonal are zero.
The transpose of an mxn matrix A is denoted by At, and is the nxm matrix defined by At(i, j) = A( j, i) . The trans-
pose of a column vector is a row vector.
n
The inner product of two n-vectors x and y is denoted (x,y), and is defined by ( x, y) = xiyi . Note that
( x, y) = ( y, x) .
i=1
The magnitude of a vector x is denoted x , and is given by x = ( x, x)1 / 2 . A vector with magnitude 1 is called a unit vector.
A matrix is sparse if the ratio of zero to non-zero elements is large. An nxn matrix A is sparse if A contains only O(n) non-zeros. The location of the non-zeros in a sparse matrix A is called the sparsity pattern of A. The scalar product of a matrix/vector with a scalar is the component-wise product of with the elements of the matrix/vector: (*A)(i,j)=A(i,j), and (x)i = *xi. The matrix-vector product of an mxn matrix A with a p-vector x is only defined for n=p. The result is an m-vector n y=Ax given by yi = aijx j. j=1 The matrix-matrix product of an mxn matrix A with a pxq matrix B is only defined for n=p. The result is an mxq n matrix C=AB given by cij = aikbkj . k=1 The identity matrix of order n is the nxn matrix I for which aii=1, i=1,...,n, and aij=0 for ij. The identity matrix I has the property that for any vector x, Ix=x.
A permutation matrix is an identity matrix with rows (columns) reordered. Thus, a permutation matrix P has exactly one 1 in each row and column, and is zero elsewhere. Left multiplication by a permutation matrix interchanges rows, while right multiplication interchanges columns. The inverse of an nxn matrix A is denoted by A-1, and is the unique nxn matrix defined by A A­1 = A­1 A = I. The inverse of a matrix only exists when there is a unique solution to the equation Ax = b . When A has an inverse, A is said to be non-singular. Conversely, a matrix without an inverse is singular. An nxn matrix A is non-singular if and only if A is of full rank. An nxn matrix A is symmetric if At = A.
n An nxn matrix A is diagonally dominant if, i = 1...n , aii aij ; that is, A is diagonally dominant if, for j = 1, j i each row, the sum of the absolute values of the off-diagonal elements is less than or equal to the value of the diagonal
7 n element. A is strictly diagonally dominant if i such that aii > aij ; that is, A is strictly diagonally dominant j = 1, j i if A is diagonally dominant and at least one of the diagonal elements is strictly larger than the corresponding off-diagonal absolute sum. Let A be an nxn matrix. A scalar is an eigenvalue of A if there exists an n-vector x, with x 0, such that Ax = x . The vector x is said to be the eigenvector corresponding to the eigenvalue . The collection of eigenvalues of A is called the spectrum of A, and is denoted (A). The spectral radius of A is denoted (A), and is given by the largest magnitude of any eigenvalue of A. That is, (A) = max{ : (A)} . In general, an eigenvalue may be real or complex. However, in this thesis, we are only concerned with real symmetric matrices, and these matrices have only real eigenvalues. Let A and B be nxn matrices. A scalar is a generalized eigenvalue of the ordered pair of matrices (A, B) if there exists an n-vector x, with x 0, such that Ax = Bx . The vector x is said to be the generalized eigenvector corresponding to the generalized eigenvalue . We denote the collection of generalized eigenvalues of (A,B) by (A,B). An nxn matrix A is positive (negative) definite if, x , xt Ax > 0 (< 0). Equivalently, A is positive (negative) definite if, ( A) , > 0 ( < 0 ). An nxn matrix A is positive (negative) semi-definite if, x , xt Ax 0 ( 0). Equivalently, A is positive (negative) semi-definite if, ( A) , 0 ( 0 ). Let A be an nxn positive definite matrix. The spectral condition number of A is denoted by (A), and is given by the ratio of the largest to smallest eigenvalues of A. That is, let (A) = {1 ... n} . Then (A) = n / 1 . Let B also be nxn and positive definite. The generalized condition number of (A,B) is denoted by (A,B), and is given by the ratio of the largest to smallest generalized eigenvalues of (A,B). Note that (A,B) = (B-1A). An nxn matrix L is a Laplacian matrix, or Laplacian, if L is real, symmetric, and diagonally dominant with non-positive off-diagonals. An nxn matrix L is a generalized Laplacian matrix (generalized Laplacian) if L is real, symmetric, and diagonally dominant. 2.2 Graph Theory In this section, we will review some basic, relevant results in graph theory. Further details can be obtained from books on graph theory, such as the texts by Chartrand (1977) or Harary (1969). First, we start with the following basic definitions. An undirected graph G = (V,E) is a collection V of nodes or vertices, together with a set E of edges or arcs where each edge in E is an unordered pair of nodes. A self-loop is an edge in which the vertices are identical. We denote the cardinality of a set of vertices S by |S|, and the cardinality of a set of edges E by |E|. An undirected graph is depicted as a set of points connected by lines. A graph G = (V,E) is said to be ordered if each of the n vertices in V is assigned a unique number in the range 1,...,n; such an assignment is called an ordering. Given an ordered graph G, we will denote vertices by V = {v1,...,vn}, and edges by E = {e1,...,em}, where ei = (vj,vk) = (vk,vj) for some j,k.We will assume that all graphs are ordered. Let G = (V,E) be a graph. If ei = (vj,vk) E, then vertices vj and vk are called adjacent, denoted vj adj vk. Let v V; the degree of v, deg(v), is the number of distinct vertices adjacent to v.
8 A complete graph is a graph in which all vertices are pairwise adjacent. We denote by Kn the complete graph on n vertices. A walk is an alternating sequence of vertices and edges that begins and ends with a vertex, such that any edge in the sequence connects the vertex preceding it to the vertex following it. A path is a walk in which all the vertices are distinct. A cycle is a walk in which the first and last vertex are the same. A graph is connected if there exists a path between every pair of vertices. Let G1,...,Gm be subgraphs of G such that each Gj is connected and there exist no edges between Gj and Gk for j k; then the Gj are called the connected components of G. A tree is a connected graph with no cycles. A forest is a graph with no cycles, and is therefore a collection of trees. A directed graph G is a graph in which the edges are ordered pairs; that is, (vj,vk) (vk,vj). For an edge e = (vj,vk), vj is termed the tail of the edge, and vk is the head. A directed graph G is depicted as a set of points connected by lines with arrowheads denoting the orientation from tail to head. A weighted graph G (directed or undirected) is a graph together with a function w:E , which assigns weights to edges. Let G = (V(G),E(G)) and H = (V(H),E(H)) be graphs. H is a subgraph of G if V(H) V(G) , and E(H) E(G) . G is then a supergraph of H. Let S V (G) . Let H be the subgraph of G given by V (H ) = S , and (vi,v j) E(H ) iff vi S and v j S . Then H is the subgraph of G induced by the set S. Let G = (V,E) be a graph and S V . Let H be the subgraph of G induced by S. Then the frontier, or boundary, of H is the set of edges (vi, vj) such that either vi S and v j S , or vi S and v j S . Let G and H be graphs. An embedding of H into G is a mapping of vertices of H onto vertices of G, and edges of H onto paths in G. The dilation of the embedding is the length of the longest path in G onto which an edge of H is mapped; we denote the dilation of the embedding by (G,H). The congestion of an edge e in G is the number of paths of the embedding that contain e. The congestion of the embedding is the maximum congestion of the edges in G. We denote the congestion of the embedding by (G,H). 2.2.1 Graphs and matrices Graphs and matrices are related in a variety of interesting ways. In this section, we present an overview of the relationships that are important to understanding this thesis. Further details can be found in the books by Varga (1962) and George and Liu (1981). In the succeeding chapters of this thesis, we will use some of the relationships between graphs and matrices to develop a new approach to accelerating the convergence of the preconditioned conjugate gradient method. The preconditioned conjugate gradient method was derived in terms of the algebraic properties of vectors and matrices; in contrast, the approach developed in this thesis is derived in terms of the combinatorial, or graphtheoretic properties of the matrices. In this section, we review some of the basic properties that relate graphs and matrices. Let G = (V,E) be an ordered, undirected graph with n vertices and no self-loops. Then the adjacency matrix A corresponding to G can be constructed as follows: · aij = aji = 1 if e = (vi,vj) E;
9
· aij = 0 otherwise. Figure 2.1 illustrates an undirected graph and its corresponding adjacency matrix. Note that the adjacency matrix is symmetric, but has all zeros on the diagonal.
v1
v2
v4
v3
0101 1011 0101 1110
Figure 2.1: An Undirected Graph and Corresponding Adjacency Matrix.
Let p be an ordering of the numbers 1,...,n. Then p is a list of length n, p(i) {1,...,n}, and p(i) p(j) for i j. p can be used to construct a permutation matrix P = P(p) by setting P(i,p(i)) = 1, for i = 1,...,n, and P(i,j) = 0 elsewhere. p defines a new labeling of the vertices of G. The corresponding adjacency matrix B that reflects the new ordering is given by B = PAPt . The topology of the graph underlying A and B is the same, only the labeling of the vertices has changed. It is easy to show that if a graph G consists of exactly m connected components G1,...,Gm, then there exists an ordering of G such that the adjacency matrix of G is block diagonal with exactly m diagonal blocks [see George and Liu (1981)]. Equivalently, let A be the adjacency matrix of G. Then there exists a permutation matrix P such that B = PAPt is block diagonal with m diagonal blocks. A generalization of the adjacency matrix is the unit Laplacian matrix. Given an undirected graph G = (V,E), the unit Laplacian, L, is defined as follows: · lij = lji = -1 if e = (vi,vj) E; · lii = deg(vi); · lij = 0 otherwise. (Some authors refer to the unit Laplacian as simply the Laplacian of a graph [for example, see Pothen, Simon, and Liou (1990)]. We prefer to reserve the term Laplacian for a generalization to weighted undirected graphs that will be presented in Chapter 4.) Figure 2.2 illustrates the graph from Figure 2.1, and the corresponding unit Laplacian matrix. Note the differences between the adjacency matrix and the unit Laplacian: the Laplacian has a non-zero diagonal and non-positive off-diagonals. The sparsity pattern of the off-diagonal elements is the same for the Laplacian and the adjacency matrix.
v1
v2
v4
v3
2 ­1 0 ­1 ­1 3 ­1 ­1 0 ­1 2 ­1 ­1 ­1 ­1 3
Figure 2.2: An Undirected Graph and Corresponding Unit Laplacian Matrix.
The unit Laplacian has some interesting properties related to the structure of the graph. Let G be a graph and L the
10
corresponding unit Laplacian. It is easy to show that all the rows and columns of L sum to zero. Therefore, the vector 1, which consists of all ones, is an eigenvector of L with eigenvalue 0; that is, L1 = 0 . Moreover, if G consists of exactly m connected components G1,...,Gm, then there are m linearly independent eigenvectors x1,...,xm corresponding to the eigenvalue 0, and xi(j) = 1 if vj Gi, and xi(j) = 0 otherwise. Any symmetric matrix defines an unweighted undirected graph. (Symmetric matrices can also define weighted undirected graphs, but the details of this are postponed until Chapter 4.) Let A be an nxn symmetric matrix. We define G corresponding to A as follows:
· G has vertex set V = {v1,...,vn}. That is, G has a vertex for every row/column in A. · G has edge set E = {(vi,vj): A(i,j) = A(j,i) 0}. In section 2.3 on direct methods for solving linear systems, we will show that analysis of the graph corresponding to a symmetric matrix can reduce the amount of storage required to factor the matrix.
Just as undirected graphs correspond to symmetric matrices, directed graphs correspond to nonsymmetric matrices. Let G = (V,E) be a directed graph. Then the adjacency matrix A corresponding to G can be constructed as follows:
· aij = 1 if e = (vj,vi) E;
· aij = 0 otherwise.
v1
v2
a)
v4
v3
0000 1001 0101 1000
v1
v2
v3
b)
v4
v5
01100 00011 00000 00000 00000
Figure 2.3: Directed Graphs and Adjacency Matrices. a) A directed graph similar to Figure 2.1, and corresponding adjacency matrix. b) A directed tree and corresponding adjacency matrix.
Clearly, a directed graph in which every directed edge is paired with an edge oriented in the opposite direction defines a symmetric matrix. Figure 2.3 illustrates two directed graphs and corresponding adjacency matrices. Figure 2.3a presents a graph similar to that of Figure 2.1, but directed. Note the difference between the adjacency matrix of Figure 2.1 and that of Figure 2.3a. The directed graph has a much sparser adjacency matrix, and is not symmetric. Figure 2.3b illustrates a directed tree which is ordered from root to leaves and directed from leaves to root. Note that the adjacency matrix is upper triangular. This fact will be used in the implementation of support tree conjugate gradient in Chapter 3. Given any arbitrary nxn matrix A, symmetric or nonsymmetric, we can also define an unweighted directed graph G =
11 (V,E): · G has vertex set V = {v1,...,vn}. That is, G has a vertex for every row/column in A. · G has edge set E = {(vi,vj): A(i,j) 0}. 2.2.2 Network flow and multicommodity flow Network flow problems constitute an important area of research in graph theory and combinatorial optimization. Results from the area of multicommodity flow will be used in Chapter 5 to analyze the theoretical properties of the support tree conjugate gradient method. The most basic network flow problem is that of maximum flow. Following Tarjan (1983), the single-commodity maximum flow problem can be described as follows: 2.1 Definition: (single commodity maximum flow) Let G = (V,E) be a directed graph with two distinguished vertices, a source s and a sink t, and a positive capacity c(v,w) on every edge (v,w) E. (c(v,w) = 0 if (v,w) E.) A flow on G is a function f: E having the following three properties: 1. f(v,w) = -f(w,v). 2. f(v,w) c(v,w) 3. If v V, v s,t, then f (v, w) = 0 . w The value |f| of a flow f is the net flow out of the source s. The maximum flow problem is that of finding a flow of maximum value. 2.2 Definition: A cut (S,S ) is a partition of the vertex set V into two sets S and S =V-S such that s S, and t S . The capacity of a cut, c(S,S ), is defined by c(S, S) = c(x, y). A minimum cut is a cut for x S, y S which the capacity of the cut is a minimum over all cuts. The maximum flow problem has been studied extensively. The main result of interest to us is Ford and Fulkerson's Max-Flow Min-Cut Theorem [Ford and Fulkerson (1956), (1962)]. 2.3 Theorem (Max-Flow Min-Cut): Let G = (V,E) be a directed graph, and let c: E + be a capacity function. A flow f is a maximum flow iff there exists a cut (S,S ) such that |f| = c(S,S ). That is, the value of the maximum flow can be determined without explicitly determining the flow itself simply by finding the value of a minimum cut. The multicommodity flow problem generalizes the single commodity problem. Following Leighton and Rao (1988): 2.4 Definition: A multicommodity flow problem consists of · a graph G = (V,E); · a set of commodities, ; · a capacity function on the edges c: E +;
12 · a supply function for vertices s: VЧ +; · a demand function for vertices d: VЧ +; The objective of a multicommodity flow problem is to construct flows for each commodity that satisfy the demands without violating the constraints of supply and capacity. In contrast to single-commodity flow, there is no Max-Flow Min-Cut Theorem for multicommodity flow. Shahrokhi and Matula (1990) define the ratio of flow supplied between pairs to the demand as the throughput, and studied multicommodity flow for the case in which the throughput must be the same for all pairs. They called this the maximum concurrent flow problem (MCFP). They showed that the dual of MCFP is the problem of assigning distances to the edges to maximize the minimum cost of routing the flow. They developed a polynomial time approximation algorithm for the MCFP for the case of arbitrary demands but uniform capacity. Leighton and Rao (1988) considered a special case of multicommodity flow called the uniform multicommodity flow problem (UMFP). In a UMFP, every ordered pair of vertices defines a commodity, and the demands are the same for each commodity. While it is clear that the flow in a UMFP cannot exceed the capacity of a minimum cut, Leighton and Rao first showed that the converse is not true. That is, there are cases of UMFP where the value of a maximum flow is less than the value of a minimum cut. Let (S,S ) be a cut. For a UMFP with unit demands, the demand across (S,S ) is given by S S . Define the ratio cost of a cut to be
c(x, y)
(S, S) = -x--------S--,---y--------S-----------------
(2.1)
SS
Leighton-Rao define a minimum cut to be a cut (S,S ) for which the ratio cost is the minimum over all cuts. That is, for
a minimum cut,
c(x, y)
(S, S)
=
minS

V
-x--------S--,---y--------S----------------SS
If the edge capacities are all unity, then the minimum cut corresponds to the concept of a sparsest cut from graph theory. Finding a sparsest cut is NP-hard [Garey, Johnson, and Stockmeyer (1976)].
A concept related to that of ratio cost is the flux, or minimum edge expansion, defined by
c(x, y)

=
minS

V
-x--------S--,---y--------S----------------min( S S )
(2.2)
A flux cut is a cut for which the value of flux is the minimum over all cuts. The flux is an important concept because it is a measure of the connectedness of a graph. Any component S of a graph G such that |S| |G|/2 is connected to the rest of the graph with at least |S| edges.
The key theorem that Leighton and Rao proved is the relationship between throughput and minimum cuts for the UMFP. In particular, they proved the following theorem for a graph with n vertices:
2.5 Theorem: There is a feasible flow with |f| = (/logn).
Theorem 2.5, coupled with the fact that the value of a maximum flow cannot exceed the value of a minimum cut yields the following:
13
l--o---g----n- f
(2.3)
Another interesting result from Leighton and Rao deals with the area of graph embedding. In Chapters 4 and 5, we will show that the theoretical properties of the support tree conjugate gradients method are related to the congestion and dilation of certain graph embeddings. In particular, it will be important to minimize the congestion and dilation of the embeddings.
Leighton and Rao proved the following theorem which yields bounds on the congestion and dilation of embeddings without explicitly constructing the embeddings. This result will be used extensively in Chapter 5:
2.6 Theorem: Consider any n-node bounded degree graph H, and any 1-1 embedding of the nodes of H onto the nodes of an n-node bounded degree graph G with flux . The edges of H can be routed as paths in G with congestion and dilation O(l--o---g----n-) .
2.2.3 Graph partitioning
We have discussed above the basic relationship between symmetric matrices and undirected graphs. The linear systems that arise in many applications have interesting interpretations in terms of graphs. In addition, many application problems in computational science and engineering are based on meshes, which are special cases of graphs. Graph partitioning is a process which is fundamental to the generation of support trees in Chapter 3. Graph partitioning is the process of decomposing a graph into two or more pieces of roughly equal size by removing a collection of either edges or vertices called a separator (an edge or vertex separator, respectively). Graph partitioning has a number of applications. For example, finding good partitions is useful in determining orderings for linear systems that minimize the fill that occurs as a result of factorization [George and Liu (1981), Gilbert (1980), Lipton, Rose, and Tarjan (1979)]. Optimization of the physical layout of a VLSI circuit can be performed by using graph partitioning [Donath (1988), Leighton (1983), Leiserson (1983)]. Finally, solving a finite element problem on a distributed processor requires partitioning the finite element mesh and distributing the pieces among the processor elements [Blelloch, et al (1992), Farhat and Lesoinne (1993), Nour-Omid, et al (1987),Williams (1991)]. In each of the applications above, it is desirable to have the pieces (subgraphs) contain roughly the same number of nodes, with as few edges as possible connecting the pieces (since edges imply communication). This observation motivates the following definition: 2.7 Definition (edge separator): An f(n) edge separator that -splits is a subset of edges, F, of a graph G with n vertices if F f (n) and the vertices of G-F can be partitioned into two sets S and S such that there are no edges from S to S , and S , S n , where f is a function and 0 1 .
A similar definition can be formulated for vertex separators. With respect to the previous discussion of network and multicommodity flow, an edge separator defines a cut, and the capacity of a cut is the sum of the weights of the edges in the separator. Similarly, a cut defines a partition of the graph into two sets. The goal of graph partitioning is to find small separators. Not all graphs have small separators. Consider, for example, Kn, the complete graph on n vertices, where n = 2k. If (S,S ) is a cut of Kn such that |S| = |S | = k, then the separator contains k2 edges. Compare this with a nx n rectangular mesh, which has the same number of nodes as Kn, but fewer edges; partitioning the mesh into two pieces of equal size can be done with a separator having only n < k edges.
14 An interesting and important research problem is characterizing families of graphs by separator size. For example, an early result is that every tree has a single vertex separator that 2/3-splits [Jordan (1869)]. More recently, Lipton and Tarjan (1979) proved that every planar graph has an O( n) -separator that 2/3-splits; the constant they obtained for the asymptotic bound was 8 . Djidjev (1982) improved their result by reducing the constant to 6 . Other extensions have been made as well [Gazit and Miller (1987), Miller (1986)]. Gilbert, Hutchinson, and Tarjan (1984) proved that all graphs with genus bounded by g have O( gn) separators. Alon, Seymour, and Thomas (1990) proved an O( h3 / 2n) bound on the separator size for graphs with an excluded minor isomorphic to the complete graph on h vertices. (Roughly speaking, a minor is a subgraph that can be obtained by shrinking edges to identify vertices; an excluded minor is one which cannot be obtained by such reduction operations.) Many different approaches to graph partitioning have been taken. In general, graph partitioning algorithms can be classified as being either combinatorial or geometric. Combinatorial algorithms only make use of graph connectivity information. Combinatorial algorithms include: · iterative improvement algorithms The first iterative improvement algorithm was proposed by Kernighan and Lin (1970). Roughly speaking, this algorithm is implemented by starting with an initial cut, and then iteratively swapping pairs of vertices across the cut if doing so improves the size of the separator. The algorithm continues iterating until no further improvements are possible. Because of the dependence on starting condition, this algorithm is not guaranteed to achieve the best cut. Fiduccia and Mattheyses (1982) improved on the Kernighan and Lin algorithm. In their extension, only one vertex is moved at a time, and the method extends to unbalanced cuts, as well as graphs for which the vertex weights may vary. · simulated annealing [Nour-Omid, et al (1987), Williams (1991)] Simulated annealing is a general purpose optimization method that is modeled on the process of slow cooling that allows liquids to crystallized. The idea, by analogy to liquid crystallization, is that the energy of a physical system is distributed among its components, the distribution is a probabilistic function of the temperature, and crystallization is a minimum energy state. By cooling the system, there is less freedom in the energy distribution, and the system will tend towards an energy minimum. Local minima are avoided by cooling slowly enough that there is enough energy in the system for components to "bounce" out of local minima. [Press, et al (1988)]. Simulated annealing often produces good results, but the only guarantee of optimality is the following: if the temperature decreases sufficiently slowly, then the probability of ending in a global optimum tends to certainty [Hajek (1988)]. · spectral partitioning [Donath and Hoffman (1972), Pothen, Simon, and Liou (1990), Hendrickson and Leland (1992)] Let L be the unit Laplacian matrix of a graph. Then the smallest eigenvalue of L is zero, and the second smallest eigenvalue, 2, is related to the connectivity of the graph. Fiedler (1973) was among the first to make this observation, and called 2 the algebraic connectivity of the graph. 2, the eigenvector corresponding to 2, contains information about the relative distances between vertices. Spectral partitioning is implemented by determining 2, sorting the entries, and partitioning the corresponding vertices about the median value. Higher order eigenvectors can be used to obtain cuts resulting in more than two subgraphs. While this method seems to perform well in practice, there are no guarantees of the quality of the cut. Recently, Guattery and Miller (1994, 1995) have shown examples where the spectral algorithm performs poorly.
15 · greedy method [Dagum (1993), Farhat and Lesoinne (1993)] The greedy method is a region growing procedure. The best way to think about the greedy method is as wave propagation. Wavefronts propagate outward from two or more starting nodes, traveling at the same speed in terms of number of edges per step. The places where wavefronts collide define the separator. This method has the advantage that partitioned pieces are connected. However, there are no performance guarantees. · multicommodity flow [Leighton and Rao (1988), Lang and Rao (1994)]. Multicommodity flow was discussed in §2.2.2. One side effect of the proof relating the value of a maximum uniform multicommodity flow to the value of a minimum cut, was an algorithm guaranteed to find the minimum ratio cut to within a factor of O(log n) [Leighton and Rao (1988)]. The multicommodity flow method is one of the few graph partitioning methods to provide a performance guarantee. In contrast to combinatorial methods, geometric methods require the spatial coordinates of the nodes of the graph. For many finite element and finite difference problems, this geometric information is a by-product of mesh construction. Geometric methods include: · coordinate bisection [Simon (1991), Williams (1991)] This method is the simplest of the geometric methods. The method is implemented by sorting the nodes according to their coordinates, then bisecting with a hyperplane orthogonal to one the coordinate axes. The coordinate axis that yields the smallest separator is chosen. Again, there are no performance guarantees with this method, and the performance can vary with the orientation of the graph. Pathological cases exist for which the separator obtained with coordinate bisection is among the worst possible. · inertia-based slicing [Farhat and Lesoinne (1993)] Inertia-based slicing is a generalization of coordinate bisection. Instead of bisecting orthogonal to one of the coordinate axes, the inertia matrix of the mesh is computed, and the principal axes of the mesh are determined. Bisection is then performed with respect to the principal axes, rather than the coordinate axes. Again, there are no performance guarantees, and pathological cases exist for which inertia-based slicing yields very large separators. · sphere separators [Miller, et al (1992)]. It can be shown that there exist pathological cases for which the planar cuts used in coordinate bisection and inertia-based slicing cannot yield good separators. In contrast, sphere separators do not suffer these inadequacies [Teng (1991)]. The idea behind sphere separators is to conformally map the mesh points onto a sphere, rotate the points on the surface so that the mass of the mesh is more or less evenly spread out over the sphere surface, then partition using a plane through the center of the sphere (which yields a great circle on the sphere surface). Biasing the cut using the inertia matrix of the mesh improves the quality of the separators [Gremban, Miller, and Teng (1994)]. The sphere separator algorithm is also one of the few separator algorithms for which there are bounds on the expected performance. 2.3 Direct Methods for the Solution of Sparse Linear Systems This subsection is not intended to be a thorough review of the state-of-the-art in direct methods for the solution of sparse linear systems. Rather, it is intended to be an overview that presents the problems and the solutions that have relevance to STCG. For more detailed information, the reader is referred to Dongarra, et al (1991), Duff, Erisman, and Reid (1986)], and Heath, et al (1990).
16
Consider the solution of linear systems of the form
Ax = b
(2.4)
where A is nxn large, sparse, symmetric, and positive definite. Direct methods for solution usually involve some variation of computing the Cholesky factorization of A:
A = C Ct
(2.5)
where C is lower triangular. The solution x is then obtained by the successive solution of the two constituent triangular systems Cy = b , and Ct x = y by forward and backward substitution, respectively.
2.3.1 Cholesky factorization and the problem of fill
Cholesky factorization is most easily explained by the use of Gaussian elimination to obtain the root-free Cholesky factorization:
A = LDLt
(2.6)
where L is unit lower triangular, and D is diagonal. Following Khaira, Miller, and Sheffler (1992), the process of factoring A can be described as a recursive series of steps. Let A0 = A, and let In denote the nxn identity matrix. Then,
A0 = d1 v1t v1 B1
(2.7)
=1
0 d1
0t
1 v1t / d1
v1 / d1 In ­ 1 0 B1­(v1v1t ) / d1 0 In ­ 1
= L1 A1L1t
A1 =
d1 0 0t 0 d2 v2t 0 v2 B2
(2.8) (2.9) (2.10)
1 0 0t d1 0
0t
1 0 0t
= 0 1 0t 0 d2
0t
0 1 v2t / d2
0 v2 / d2 In ­ 2 0 0 B2­(v2v2t ) / d2 0 0 In ­ 2
This process proceeds recursively until An-1 = D, where D is diagonal. The final result is
(2.11)
A = L1...Ln ­ 1DLnt ­ 1 ...L1t
(2.12)
Since L = L1...Ln ­ 1 is unit lower triangular, we have the result sought. For A positive definite, all the elements of D are positive, so the Cholesky factorization can be easily obtained from the root-free form:
17
A = LDLt = (LD1/2)(D1/2Lt) = CCt
(2.13)
Each step in the sequence of factorizations shown above is a single step of Gaussian elimination. We will occasionally refer to such a step as a reduction step. For A non-singular, we also have
D = L­1AL­t,
(2.14)
which shows that Gaussian elimination can be performed as a pair of matrix multiplications: a pre-multiplication by a lower triangular matrix, and a post-multiplication by an upper triangular matrix.
For A positive definite, Cholesky factorization, as implemented above, is a stable numerical process. When sparse matrices are involved, however, the problem of fill becomes critical. Fill occurs when a zero entry of A become non- zero in one of the Cholesky factors. It is possible for the Cholesky factors of an nxn sparse matrix to be dense (with (n2) non-zero entries, instead of O(n)). Figure 2.4 illustrates an example for which two-thirds of the zero positions in the original matrix became non-zero in the Cholesky factors.
3 ­1 ­1 0 0
1.73 0 0 0 0 1.73 ­0.58 ­0.58 0 0
­1 3 0 ­1 ­1 ­0.58 1.63 0 ­1 0 1 0 0 = ­0.58 ­0.20 0.79
00 00
0 1.63 ­0.20 ­0.61 ­0.61 0 0 0.79 ­0.16 ­0.16
0 ­1 0 1 0
0 ­0.61 ­0.16 0.77 0 0 0 0 0.77 ­0.52
0 ­1 0 0 1
0 ­0.61 ­0.16 ­0.52 0.58 0 0 0 0 0.58
Figure 2.4: Cholesky Factorization with Fill. The sparse matrix was factored, with 2/3 of the zeros becoming nonzero. Filled values are in bold font.
Fill is easiest to understand from a graph-theoretic point of view. As explained in §2.2.1, a correspondence exists between symmetric matrices and undirected graphs. Let A be an nxn symmetric matrix, and let G = (V,E) be the graph defined by · V = {v1,...,vn} · E = {(vi,vj): A(i,j) 0} As explained above, Gaussian elimination proceeds in a matrix by selecting a diagonal element, and then zeroing out all the off-diagonal elements in the same row and column. Graph theoretically, the ith step of Gaussian elimination corresponds to selecting a vertex vi, deleting all the edges between vi and its neighbors, then adding edges between all the former neighbors of vi. Figure 2.5 illustrates an example step of Gaussian elimination. The original matrix A = A0 corresponds to the graph below it in the figure. The matrix A1 that results from the first step of Gaussian elimination is shown with the corresponding graph below it. Note that node v1 has been disconnected, and an edge has been added between nodes v2 and v3, corresponding to the fill in positions (2,3) and (3,2) of A1. Each step of Gaussian elimination removes all the edges from one node; we call each such step a node reduction. Fill is a property of the order in which nodes are eliminated. Fill can often be reduced by reordering the matrix; graph theoretically, this is equivalent to renumbering the nodes of the graph. Reordering is implemented by pre- and postmultiplication of A by a permutation matrix P and its transpose, respectively: B = PAPt . The permutation matrix Pij used to interchange row/column i and j of A has the form: · Pij(i, j) = Pij( j, i) = 1 · Pij(k, l) = 0 , for k l; · Pij(k, k) = 1 , for k i, j;
18
3 ­1 ­1 0 0
1 0 0 0 0 3 0 0 0 0 1 ­1 / 3 ­1 / 3 0 0
­1 3 0 ­1 ­1 ­1 / 3 1 0 0 0 0 8 / 3 ­1 / 3 ­1 ­1 0 1 0 0 0 ­1 0 1 0 0 = ­1 / 3 0 1 0 0 0 ­1 / 3 2 / 3 0 0 0 0 1 0 0
0 ­1 0 1 0
0 0 0 1 0 0 ­1 0 1 0 0 0 0 1 0
0 ­1 0 0 1
0 0 0 0 1 0 ­1 0 0 1 0 0 0 0 1
1
3
2
1
3
2
45
45
Figure 2.5: Graph Theoretic Interpretation of Gaussian Elimination. The original matrix A = A0 corresponds to the graph at the left. The first step of Gaussian elimination yields A0 = L1 A1L1t . A1 corresponds to the graph at the right, in which all edges to node v1 have been eliminated, and all the neighbors of v1 have been connected. Filled values are in bold font.
1 0 0 0 ­1
100 0 0
0 1 0 ­1 0
010
0 0 1 ­1 0 = 0 0 1
00 00
0 ­1 ­1 3 ­1
0 ­1 ­1 1 / 3 0
­1 0 0 ­1 3 ­1 0 0 ­1 / 3 1 / 3
10000 01000 00100 00030 00003
1 0 0 0 ­1 0 1 0 ­1 0 0 0 1 ­1 0 0 0 0 1 / 3 ­1 / 3 0 0 0 0 1/3
5
1
4
5
1
4
2
3
2
3
Figure 2.6: Gaussian Elimination with Zero Fill. The matrix/graph from Figure 2.5 has been reordered so that factorization does not lead to any fill.
Figure 2.6 illustrates an ordering of the matrix/graph from Figure 2.5 that leads to zero fill. Figure 2.6 is an example of a useful fact that will be exploited later in this thesis: real symmetric matrices that correspond to trees have orderings that permit Cholesky factorization with zero fill.
For most matrices encountered in real applications, factorization will result in fill. The problem, then, is to minimize fill. The problem of finding an ordering that will yield minimum fill has been shown to be NP-complete [Garey and Johnson (1979)]. Nonetheless, many different approaches to ordering have been suggested for reducing fill. For the purposes of this thesis, the most relevant ordering method is that of generalized nested dissection [Lipton, Rose, and Tarjan (1979), Gilbert (1980)], which is explained below.
Generalized nested dissection utilizes a recursive divide-and-conquer approach to produce an ordering. Consider a graph G with n nodes. Generalized nested dissection proceeds by finding a small node (vertex) separator S0 of G, and ordering these nodes last, assigning them numbers n-|S0|+1 to n. Suppose that removal of S0 from G results in two connected components G00 and G01. Separators S00 and S01 are then found for G00 and G01, and the nodes of these separators are ordered from n-(|S0|+|S00|+|S01|)+1 to n-|S0|. The process then continues recursively until all the nodes of G have been ordered.
19
Let the fill-factor be defined as the ratio of fill to the original number of non-zeros. Then generalized nested dissection yields a fill-factor of O(logn) for n2xn2xn2 matrices corresponding to planar graphs, finite elements graphs, and sev- eral other classes of graphs [Gilbert and Tarjan (1987)]. Moreover, a fill-factor of O(logn) is asymptotically optimal [Hoffman, Martin, and Rose (1973)].
One of the interesting properties of the support tree preconditioners to be developed in the next chapter is that they can be easily ordered to have zero fill Cholesky factorizations. This property follows from the fact that the graphs of the preconditioners are trees.
2.3.2 Parallel performance
There are three stages in the direct solution of sparse linear systems which must be parallelized:
1. computation of the ordering
2. computation of the Cholesky factors
3. solution of the triangular systems
The ordering computations can be parallelized to some extent. In particular, generalized nested dissection has reasonable parallel potential: first, the processes for finding separators can be parallelized; second, the ordering computations at each level of recursion are independent and may be performed in parallel. Hence, an ordering can be determined using generalized nested dissection with logarithmic parallel speedup [Heath, et al (1990)].
Perhaps a bigger issue than that of parallelizing the ordering algorithm is that of selecting the ordering itself. On serial machines, the goal of ordering is to minimize fill, since fill affects both storage requirements and the work required to both factor and solve the resulting systems. The desire to achieve good parallel performance is often at odds with the desire to minimize fill and total work. For example, Heath, et al (1990) consider the case of factoring an nxn tridiagonal matrix. The associated graph is a simple path of length n. By factoring inward, starting at the ends, a no-fill factorization can be achieved (since a simple path is a tree), but at the cost of O(n) parallel steps. On the other hand, if nested dissection were applied to the problem, the result would be a factorization with a fill factor of O(logn), but only O(logn) parallel steps in the factorization. As yet, the proper trade-off between parallel work and fill has not been determined.
Given an ordering and the resultant factorization, then the remaining problem is to parallelize the substitution algorithms used to solve the triangular systems.
Forward substitution is implemented straightforwardly in a serial manner by:
y1
=
-L---(--b-1---,1---1----) , and
yi =
-L---(--1-i-,---i---)
i­1 bi­ L(i, j) y j , i =
2, ..., n
,
j=1
while backward substitution is given by:
xn =
U-----(--b-n--n-,---n----) , and
xi =
U-----(--1-i--,---i--)
i+1 yi­ U (i, j) x j , i =
n ­ 1, ..., 1
.
j=n
Unfortunately, it is very difficult to efficiently parallelize forward and backward substitution. The serial formulas
above point out the inherent data dependencies - each new solution value may depend on one or more of the preced-
ing solution values. High computational rates are even difficult to achieve when the triangular factors are dense, and
the situation is made even worse in the sparse case. In the dense case, the products contained within each sum in the
substitution formulas can be performed in parallel, and the sum computed in a sequence of parallel steps logarithmic
in the number of terms. In the sparse case, however, there are very few products within each sum, so the parallel
potential is greatly reduced. Furthermore, the speedup that is obtained in the dense case is largely done by exploiting
the regularity of the structure of the dense factors; this regularity is largely lost in the sparse case [Heath, et al
20 (1990)]. Anderson and Saad (1989) studied the problem of triangular solution and proposed a method known as level scheduling for preprocessing sparse triangular matrices in order to maximize parallelism. Level scheduling is best understood as a graph reordering operation in which sets of independent nodes are numbered consecutively. For example, on a square mesh, one common ordering that can be obtained through level scheduling is by diagonal, starting at a corner. On an nxn mesh, this yields 2n-1 sets such that all the nodes in each set are independent and can be solved for in parallel once the previous set has been solved Figure 2.7 illustrates the interpretation of level scheduling in terms of graph theory. Both graphs in the figure have 25 vertices. In Figure 2.7a, the independent sets correspond to vertices that lie along common diagonals. In Figure 2.7b, the independent sets correspond to levels in the tree. In general, an nxn mesh (corresponding to an n2xn2 matrix) will have O(n) diagonals, while a tree with n2 nodes will have O(logn) levels. Therefore, using simple level scheduling, more potential parallelism exists for tree structures than for mesh structures. This observation is important in understanding the parallelism inherent in the support tree conjugate gradient method developed in Chapter 3.
a)
b)
Figure 2.7: Graph-theoretic Interpretation of Level Scheduling. a) Level scheduling of a mesh yields sets that lie along diagonals. b) Level scheduling of a tree yields sets that correspond to levels of the tree.
2.4 Iterative Methods for the Solution of Sparse Linear Systems
As was the case for the previous subsection, this subsection is not intended to be a complete review of the state-ofthe-art in iterative methods. Rather, it is intended to bring the reader up to speed with those particular characteristics of iterative methods that will be needed to understand the remainder of this thesis. For more complete discussions of iterative methods, the reader is referred to Axelsson (1994), Hackbusch (1994), and Hageman and Young (1981).
Consider solving
Ax = b
(2.15)
iteratively. Finding an iterative solution means finding a sequence { x(n)} of approximations to the solution x such that x(n) x as n gets large. We shall call each x(n) an iterate. Let r(n) = A x(n)­b. r(n) is called the residual, and is a measure of the accuracy of the nth iterate. Typically, an iterative method is halted when the size of the residual drops below a certain tolerance.
2.4.1 The classical iterative methods
Linear, stationary, first-order iterative methods have the form [Hageman and Young (1981)]:
21
x(n + 1) = Gx(n) + k
(2.16)
The basic iterative method defined by (2.16) is linear because G and k do not depend on x(n). The method is stationary, since G and k do not change. Finally, the method is first-order since x(n+1) depends only on x(n), and not on addi- tional previous iterates. The matrix G is called the iteration matrix and is derived from the coefficient matrix A. The basic iterative method converges if and only if the spectral radius of G is strictly less than 1; that is, (G) < 1, where (G) = max{||: (G)}.
The first method we shall consider is called the RF method [Hageman and Young (1981)], and is given by
or, equivalently, as
x(n + 1) = (I­A)x(n) + b
(2.17)
x(n + 1) = x(n)­(Ax(n)­b) or
(2.18)
x(n + 1) = x(n)­r(n)
(2.19)
In the RF method, the iteration matrix is (I-A), and, from (2.18), can also be viewed as updating the current iterate with a correction vector that is given in this case by the residual. So, another way of viewing an iterative method is as a predict-test-correct loop: the current iterate is a prediction of the solution; this is tested by computing the residual and comparing the magnitude of the residual against a tolerance; if the residual is too large, the current iterate is corrected in some way to produce the next iterate (prediction). Convergence can be improved by finding a better iteration matrix, which is equivalent to finding a better way to correct each iterate.
Some intuition can be gained by observing that the coefficient matrix A is a mapping between two vector spaces, the domain and the range: A:D R . By examination of (2.19) with respect to A as a mapping, we see an obvious problem with the correction step: each iterate x(n) is a vector in the domain, D , while the correction vector r(n) is in the range, R . In general, R is rotated and scaled with respect to D, so the residual r(n) does not point directly from x(n) to the solution x. Figure 2.8 illustrates the mismatch of vector spaces in the predict-test-correct loop for the RF method. R D D x x
x(n)
A
Ax(n) b
r(n)
x(n+1) x(n)
predict
test
correct
Figure 2.8: The Basic Predict-Test-Correct Step of the RF Method.
Preconditioning is a technique for accelerating the convergence of an iterative method. In the context of the basic iterative method defined by (2.16), preconditioning is a way of determining a better iteration matrix. Consider again the original linear system to be solved, (2.15). Now, let B be some non-singular matrix, of the same size as A, and consider the solution of the linear system
22
B­1Ax = B­1b
(2.20)
B is called a preconditioner for A. If B is chosen properly, then the preconditioned system will be easier to solve than the original system, and the iterative solution method will converge more quickly. The basic iterative method for the preconditioned system (2.20) is given by
or, in predict-test-correct form, as
x(n + 1) = (I­B­1A)x(n) + B­1b
(2.21)
x(n + 1) = x(n)­B­1( Ax(n)­b)
(2.22)
In equations (2.21) and (2.22) above, expressions involving B-1 are not meant to imply that B-1 is explicitly known. Instead, a term B-1z should be understood as the vector w obtained by solving Bw = z.
One way of viewing the preconditioner B is as an approximation to the mapping A, so that B-1 approximately transforms the residual from R into a vector space that is more similar to D . This observation, along with examination of (2.20) shows that the best possible preconditioner for A is B = A. Of course, applying B = A as a preconditioner means solving systems of the form Bw = z, for B = A, which is the original problem to be solved. The key, then, is to find a preconditioner B that approximates A in some sense, but leads to systems that are easier to solve.
Many different preconditioners have been proposed. An interesting observation is that the classical iterative methods can all be viewed as instances of (2.21) with different preconditioners. For example, suppose A can be written as
A=L+D+U
(2.23)
where L is strictly lower diagonal, D is diagonal, and U is strictly upper diagonal. Then the classical iterative methods are as follows:
· The Jacobi method is defined when all diagonal elements are non-zero by [Hageman and Young (1981)]
x(n + 1) = (I­D­1A)x(n) + D­1b So, the Jacobi method can be defined by the use of D as the preconditioner. · The Gauss-Seidel method is defined by [Hageman and Young (1981)]
(2.24)
x(n + 1) = (I­(L + D)­1A)x(n) + (L + D)­1b
(2.25)
So, the Gauss-Seidel method can be defined by the use of (L+D), the lower triangular part of A, as the preconditioner.
· The Symmetric Successive OverRelaxation (SSOR) method is defined by [Hageman and Young (1981)]
x(n + 1) = (I­Q­1A)x(n) + Q­1b
where
Q
=
2-----­-1------ -1-- D
+
L-1--
D­1-1-- D
+
U

, and 0 < < 2 is a relaxation parameter.
So, the SSOR method can be defined by the use of Q, above, as the preconditioner.
(2.26)
2.4.2 Conjugate gradient-type methods In this subsection, we present a brief overview of the method of conjugate gradients (CG) and the extension to the method of preconditioned conjugate gradients (PCG). CG was first developed as a direct solution method by Hestenes
23
and Steifel (1956). CG can be shown, in the absence of rounding errors, to converge to the exact solution in n steps, where A is nxn. Rounding errors destroy this process, however, and CG was not considered as a viable direct solution method. Reid (1971) noted that CG converged well for large sparse problems, and sparked interest in the use of CG as an iterative method. An excellent derivation of CG and PCG can be found in Axelsson and Barker (1984). Golub and O'Leary (1989) contains an annotated bibliography that cover the development of CG between 1948 and 1976. In the paragraphs to follow, we essentially summarize the excellent treatment of Axelsson and Barker (1984). Since the focus of this thesis is on the development of a new version of PCG, we will focus on the convergence rates of the varieties of PCG. In order to do this, we define a model problem, which is simply Poisson's equation defined on the unit square with Dirichlet boundary conditions:
2u(x, y) = f (x, y) (x, y) (0, 1) Ч (0, 1)
(2.27)
u(0, y) = u(1, y) = u(x, 0) = u(x, 1) = 0
We discretize the problem with the 5 point Laplacian, yielding an nxn rectangular mesh. The coefficient matrix corresponding to this problem is n2xn2. The choice of mesh and matrix size is made to provide consistency with later chap- ters.
2.4.2.1 Steepest descent
CG is best understood as an extension of the method of steepest descent, which in turn is derived by viewing the solution of a linear system as finding the minimum of a linear functional. In particular, when the coefficient matrix A is symmetric and positive definite, the solution to Ax = b can be formulated as a minimization problem for the quadratic functional f(x) defined by
f (x)
=
1-- xt Ax­bt x + c 2
Equation (2.28) has a unique minimum, x^ , which is the solution to Ax = b.
We wish to develop an iterative method of the form
(2.28)
x(k + 1) = x(k) + kd(k)
(2.29)
where d(k) is a direction vector. k is then a measure of how far along the new direction vector we wish to search. To specify the iterative method, we must specify how to choose d(k) and k at each step.
For fixed f(x), equation (2.28) defines an ellipsoid in n-space, centered around x^ . The iterates x(k) are points on ellipsoids centered around x^ . For a given x(k), let g(k) = g(x(k)) be the gradient at x(k). g(k) is perpendicular to the ellipsoid and points out, away from x^ . The gradient defines the direction of the maximum rate of change in the functional at a given point. The method of steepest descent is defined by taking d(k) = -g(k) (hence the name steepest descent), and taking k to minimize f(x(k) + kd(k)). It is easily shown that
g(k) = g(x(k)) = Ax(k)­b and
(2.30)
k = (---(d--d-(--k(--k-)-,-)-,--A--g--d-(--k(--k-)-)-)--) where (x,y) is the standard Euclidean inner product given by (x,y) = xty.
(2.31)
24
Before presenting the steepest descent algorithm, it is useful to point out that, with d(k) = -g(k), (2.29) becomes x(k + 1) = x(k)­k g(k) . Combining this with the definition of g(k) in (2.30), a recursive formula for computing the gradient can be easily derived:
g(k + 1) = g(k)­kAg(k)
(2.32)
A procedure for solving Ax = b by the method of steepest descent is given below. The procedure utilizes the recursive formula (2.32) to update the gradient, which saves one matrix-vector multiply.
2.8 Procedure steepest_descent ( A, x(0), b, ) { x = x(0); g = Ax - b; = (g, g); while ( > ) do { h = Ag; = / (g, h); x = x - g; g = g - h; = (g, g); } return ( x ); }; The catch with the method of steepest descent is that the gradient does not point directly towards x^ , and the geometry of the ellipsoids defined by the functional may be such that the gradient does not point very close to x^ until the iterates are already very near convergence. To see this, consider a coefficient matrix A with (A) = {1 < 2 <...< n}and a very large spectral condition number ( A) = n / 1 . Then n >> 1. The eigenvalues of A define the relative lengths of the axes of the ellipsoids defined by the quadratic functional (2.28). Therefore, a large condition number corresponds to ellipsoids that are relatively long and thin with respect to some pair of axes. For such an ellipsoid, the gradient is nearly perpendicular to the long axis, and so the method of steepest descent will march back and forth along the long axis, slowly moving inward towards x^ . Convergence in this case is quite slow. The rate of convergence of steepest descent is given by the following theorem [after Axelsson and Barker (1984)]: 2.9 Theorem: The rate of convergence of the method of steepest descent is given by x(k)­x^ A ----(--(-A-A---)-)---+­---1-1--k x(0)­x^ A where ( A) = n / 1 is the spectral condition number of A, and x A = (x, Ax)1 / 2 . Less formally, given > 0, the number of iterations required to reduce the initial error by a factor of is bounded above by (1 / 2)( A)ln(1 / ) + 1 [Axelsson and Barker (1984)]. Thus, for constant , the convergence rate of steepest descent is O((A)). On the model problem (2.27), (A) = O(n2) [Axelsson and Barker (1984)]. Therefore, the rate of convergence of steepest descent is O(n2). 2.4.2.2 Conjugate gradients Convergence can be accelerated with the use of conjugate directions. Let d(i) and d(j) be direction vectors. Then d(i) and d(j) are A-conjugate (or A-orthogonal) if (d(i), Ad(j)) = 0. The following theorem can be proved [Golub and Ortega (1993)]:
25
2.10 Theorem: If A is a real nxn symmetric positive definite matrix, and {d(1),...,d(n)} is a set of nonzero A-conjugate direction vectors, then for any x(0), with iterates defined by (2.29), and k defined by (2.31), the iterates converge to the solution of Ax = b in no more than n steps.
The choice of
k = (---g-(--(d--k--(-+-k--)-1-,--)--A,---A-d---(-d-k--(-)-k)--)--) and
(2.33)
d(k + 1) = ­ g(k + 1) + kd(k) defines the method of conjugate gradients (CG) [Golub and Ortega (1993), Axelsson and Barker (1984)].
(2.34)
Reid (1971) studied various implementations of CG with regard to computational labor, storage requirements, and accuracy. Following the algorithm in Axelsson and Barker (1984), which incorporates the implementation favored by Reid, a procedure for computing the solution of Ax = b using CG is given below:
2.11 Procedure conjugate_gradients ( A, x(0), b, ) { x = x(0); g = Ax - b; = (g, g); = 0; d = 0; while ( > ) do { d = -g + d; h = Ad; = / (d, h); x = x + d; g = g + h; = (g, g); = / ; = ; } return ( x ); };
For CG, the rate of convergence is given by the following theorem [after Hackbusch (1994)]: 2.12 Theorem: The rate of convergence of the method of conjugate gradients is given by the following:
x ( k ) ­ x^
A

--------(--(-A--A--)--)--+­---1--1-k
----------------------2----------------------1 + --------(--(-A--A--)--)--+­---1--1-2k
x ( 0 ) ­ x^
A
where ( A) = n / 1 is the spectral condition number of A, and x A = (x, Ax)1 / 2 .
26
Again, less formally, given > 0, the number of iterations required to reduce the initial error by a factor of is bounded above by (1 / 2) ( A)ln(2 / ) + 1 [Axelsson and Barker (1984)]. Thus, for constant , the convergence rate of CG is O( (A)) .
On the model problem (2.27), (A) = O(n2) [Axelsson and Barker (1984)]. Therefore, the rate of convergence of CG is O(n)
2.4.2.3 Preconditioned conjugate gradients
As with steepest descent, preconditioning can accelerate the convergence of CG. The resulting method is called preconditioned conjugate gradients (PCG).
Because of the requirement that the iteration matrix be symmetric and positive definite, preconditioning for CG must be performed with a similarity transformation. Let A~ = CACt. Then A~ is symmetric and positive definite, and CG can be applied to the system
where x~ = C­t x, and b~ = Cb .
A~ x~ = b~
(2.35)
By algebraic manipulation, it is possible to rearrange the statements in the algorithm implementing CG on the preconditioned system (2.35), avoid all references to the preconditioning factors C and Ct, and instead implement preconditioning as a transformation of the residual with the preconditioner B = (CtC)-1 [see Golub and van Loan (1989), Golub and Ortega (1993)]. A procedure for computing the solution of Ax = b using PCG with preconditioner B is given below [after Axelsson and Barker (1984)].
2.13 Procedure preconditioned_conjugate_gradients ( A, x(0), b, B, ) { x = x(0); g = Ax - b; solve Bh = g; = (g, h); = 0; d = 0; while ( > ) do { d = -h + d; h = Ad; = / (d, h); x = x + d; g = g + h; solve Bh = g; = (g, h); = / ; = ; } return ( x ); };
Since PCG is an implementation of CG, the convergence results of Theorem 2.12 for CG apply. In particular, given > 0 , the number of iterations required to reduce the initial error by a factor of is bounded above by
1-2
( A~ )ln(2 / ) + 1 [Axelsson and Barker (1984)]. Thus, for constant , the convergence rate of PCG is O(
(A~ )) .
27
A simple set of algebraic manipulations shows that (A~ ) = (CACt) = (B­1 A) = (A, B). Therefore, the convergence rate of PCG is O( (B­1 A)) = O( (A, B)). We call the expression (A,B) = (B-1A) the generalized condition number of the ordered pair of matrices (A, B).
Axelsson and Barker (1984) stated three criteria that define a good preconditioner B for a coefficient matrix A, which can be rephrased as follows: 1. (B-1A) should be significantly less than (A);
2. B should be easy to factor, and the factors should not require much storage (in comparison to the storage requirements of A);
3. the system Bw = z should be substantially easier to solve than Ax = b.
The most well-known preconditioners are diagonal scaling, the incomplete Cholesky factorization, the modified (and relaxed) incomplete Cholesky factorization, and the SSOR preconditioner. Each of these is discussed below with attention to the three points listed above.
· diagonal scaling
The simplest preconditioner for CG is the preconditioner that defines the classical Jacobi method, B = diag(A) . The corresponding variant of PCG is often called diagonal scaled conjugate gradients, or DSCG. For the model problem (2.27), (B-1A) = O(n2) = (A), so the asymptotic rate of convergence is not improved with diagonal scaling. B in this case does not need to be factored. The storage required for the preconditioner is O(n2). And, the preconditioned system is very easy to solve, since it simply requires dividing each vector entry by the corresponding diagonal value of B.
Even though the asymptotic rate of convergence is not improved, diagonal scaling can sometimes make the difference between convergence and non-convergence for an ill-conditioned matrix A. Moreover, diagonal scaling generally achieves some reduction in the number of iterations, and is so cheap to apply that it might as well be done.
· incomplete Cholesky
The incomplete Cholesky factorization as a preconditioner for CG was first proposed by Meijerink and van der Vorst (1977). The variant of PCG that utilizes incomplete Cholesky preconditioning is often called incomplete Cholesky conjugate gradients, or ICCG. The idea behind ICCG is to approximate the coefficient matrix A by performing the Cholesky factorization, but ignoring parts of the factors.
Recall that for a sparse matrix A, the Cholesky factors C and Ct are often less sparse than A. Let J be the
matrix that has a 1 wherever A has a nonzero, and is zero elsewhere. J defines the sparsity pattern of A,.
Let K define the sparsity pattern of (C+Ct). Then J K . The zero-fill incomplete Cholesky factors of A,
C0
and
C
t 0
are obtained
by performing
all the steps in factoring A, except those
that would change a zero
to a nonzero. Thus, if K0 defines the sparsity pattern of (C0 +C0t ), then J = K0.
The use of C0
and C0t
as preconditioner factors defines ICCG(0); the preconditioner is B
=
C0
C
t o
.
Other
variants of ICCG can be defined by specifying the level of fill that is allowed in the factors. For example,
ICCG(1) allows one level of fill; the fill that results from non-zeros of A is allowed, but that fill is not
28
allowed to propagate and create more fill. ICCG(i) allows i levels of fill. For the model problem (2.27), (B-1A) = O(n2) = (A), so the asymptotic rate of convergence is not improved with incomplete Cholesky preconditioning [Gustafsson (1978)]. In practice, the constant that accompanies the asymptotic rate is quite small, because ICCG usually requires far fewer iterations to converge than does DSCG or (unpreconditioned) CG. Because fill is not propagated, the factorization is fairly easy to perform, and the preconditioner requires the same amount of storage, O(n2), as does the coefficient matrix. Solving the preconditioned systems requires performing two sparse triangular solves, which are easy to perform serially, but are difficult to efficiently parallelize (see §2.3). · modified incomplete Cholesky The modified incomplete Cholesky factorization was proposed by Gustafsson (1978). The corresponding variant of PCG is often called modified incomplete Cholesky conjugate gradients, or MICCG. The idea behind MICCG is to take the absolute value of the fill that was ignored in computing the IC preconditioner, and add it back to the diagonal. Therefore, MICCG can be viewed as a variant of ICCG with the approximation errors added back into the diagonal [van der Vorst (1989b)]. As with ICCG, various levels of fill can be allowed. Axelsson and Lindskog (1986) proposed a relaxed version of MICCG. Instead of adding all the approximation error back into the diagonal, a parameter , with 0 < 1 is defined, and times the error is added in [van der Vorst (1989b)]. Therefore, = 0 defines ICCG (no error added to the diagonal), and = 1 defines MICCG. The relaxed version is often called relaxed incomplete Cholesky conjugate gradients, or RICCG. For the model problem (2.12), (B­1 A) = O(n) [Gustafsson (1978)], so the asymptotic rate of convergence is significantly improved by MICCG. However, van der Vorst (1989b) reports that, while MICCG has been observed to converge much faster than ICCG on academic model problems, the situation is often reversed for real industrial problems. He explored the effects of varying the parameter on the convergence rate, and found that the convergence was similar for = 0 and = 1 . The convergence improved slowly as increased from 0, achieving the best results for = 0.95 . Between 0.95 and 1.0, the convergence rate sharply decreased again. Axelsson and Lindskog (1986) made similar observations. As for ICCG, the computation of the MICCG factors is fairly easy to perform, and the preconditioner requires the same amount of storage, O(n2), as does the coefficient matrix. Also, solving the preconditioned systems requires performing two sparse triangular solves, which are easy to perform serially, but are difficult to efficiently parallelize (see §2.3). · symmetric successive over-relaxation (SSOR) The iteration matrix from the method of symmetric successive over-relaxation is positive definite for 0 < < 2 , and can be used as a preconditioner in CG. Recall from §2.4.1 that, for A = L + D + Lt, the SSOR matrix for relaxation parameter is given by
B
=
-2----­-1------ -1-- D
+
L-1-- D­1-1-- D
+
U

(2.36)
For the model problem (2.27) with optimal relaxation parameter , (B­1 A) = O(n) [Axelsson and Barker (1984)]. The factors of the SSOR preconditioner are generated as a result of the construction; equation (2.36) defines the LDL factorization of the preconditioner. The preconditioner requires the same amount of storage, O(n2), as does the coefficient matrix. As was the case for ICCG and MICCG, solving the preconditioned systems requires performing two sparse triangular solves, which are easy to perform serially, but are difficult to efficiently parallelize (see §2.3).
29 2.4.2.4 Parallel performance In this section, we examine some of the details behind the parallel implementation of CG and PCG. As in §2.4.2, we assume an n2xn2 matrix for consistency with later chapters. van der Vorst (1989b) stated three performance requirements for a good preconditioner. The first of his performance requirements was essentially identical to the first of Axelsson and Barker (1984), and we do not bother to state it. The second two requirements are elaborations of requirement 3 of Axelsson and Barker (1984), above: 1. the amount of work per iteration step should be roughly the same as for unpreconditioned CG; 2. the computational speed for each iteration step should have the same order of magnitude as the unpreconditioned CG process. To analyze the parallel performance of CG and the various versions of PCG, we use the parallel vector models of Blelloch (1990), which comprise a unifying framework for examining the parallel complexity of algorithms. Serial complexity is typically analyzed in terms of an ideal machine architecture, the random access machine, or RAM. Parallel complexity can be analyzed in terms of an ideal parallel architecture, the vector RAM, or V-RAM. A V-RAM is essentially a serial RAM with the addition of a vector processor and vector memory. Each location in vector memory can contain an arbitrarily long vector of scalar values. Each instruction executed by the vector processor can reference one or more vectors from vector memory, and one or more scalars from scalar memory. The reader interested in more details is referred to Blelloch (1990). The complexity of an algorithm executing on a V-RAM can be characterized by two measures: the step complexity, and the element complexity. The step complexity is simply defined as the number of (parallel) steps executed sequentially; step complexity can be thought of as the parallel complexity. The element complexity is the sum over the steps of the lengths of the vectors operated on at each step; element complexity can be thought of as the serial complexity. The basic CG algorithm as given by Procedure 2.11 requires, per iteration: one matrix vector multiply, two vector inner products, and three SAXPY operations (ax+y, see Dongarra, et al (1991)). van der Vorst (1989b) notes that all these operations can be implemented fairly efficiently on vector machines. The formulation of PCG given as Procedure 2.13 requires all these operations, plus an additional operation of solving the preconditioned system. This solution step is typically implemented as two triangular solves and/or a diagonal scaling. A sparse matrix vector multiply of an n2-vector with an n2xn2 sparse matrix, assuming that the number of non-zeros in any row of the matrix is bounded by a constant, has step complexity of O(1), and element complexity of O(n2). This is because the operations to determine each output vector element are independent and may be performed in parallel. Each such operation involves a constant number of operations, and there are O(n2) of them. A vector inner product operation has step complexity of O(logn), and element complexity of O(n2). The n multiplies required for an inner product can all be performed in parallel. Computing the sum of products requires 2logn steps of pairwise sums: n2/2 sums the first step, n2/4 the next, and so on for a total of O(n2) operations. A SAXPY operation takes a vector times a scalar and adds it to another vector. All elements of the scalar-vector multiply can be performed in parallel, as can each element in the vector-vector sum. Therefore, the step complexity is O(1), and the element complexity is O(n2). The vector inner product has the largest step complexity and is therefore the bound on the complexity of each iteration of CG. Thus, each iteration of (unpreconditioned) CG has step complexity O(logn), and element complexity O(n2). Now, consider the complexity of applying a preconditioner. The simplest preconditioner is diagonal scaling. All the operations involved can be performed in parallel, yielding a step complexity of O(1), and an element complexity of O(n2). The other preconditioners, IC, MIC, and SSOR, all require triangular solves.
30 The naive implementation of a triangular solve is purely serial -- each element of the solution vector must be solved for one at a time. This yields a step complexity of O(n2) and an element complexity of O(n2), which is clearly a burden for a loop that would otherwise require only O(logn) steps. As discussed in §2.3, it is possible to use level scheduling to find a good parallel ordering for triangular solution. For the model problem, an nxn mesh with an n2xn2 coefficient matrix, a good ordering is to walk along the diagonals, solving for elements on each diagonal in parallel. The asymptotic performance of this procedure is better, but is still fairly poor. Walking the diagonals has step complexity of O(n), and element complexity of O(n2). Again, this is a burden on a loop with step complexity of O(logn). With respect to van der Vorst's performance requirements for a good preconditioner, only diagonal scaling can be applied without significantly slowing each iteration. There are techniques that can be applied to speed up the preconditioning. For example, with rectangular meshes (such as our model problem) there is a technique developed by Eisenstat (1981) that solves the explicitly preconditioned system (2.35). This technique cannot be applied to meshes with triangles, and is therefore not completely general.
2.5 Domain Decomposition Methods
Divide-and-conquer is a powerful algorithmic principle. When applied to the solution of linear systems of equations, divide-and-conquer yields the class of methods called domain decomposition. The name arises because the methods involve partitioning the original domain of the problem into a number of smaller subdomains, for which solution can proceed independently in parallel. Domain decomposition methods involve both direct and iterative solvers. The article by Chan and Mathew (1994) is an excellent survey of domain decomposition methods. Additional treatments can be found in Golub and Ortega (1993) and Hackbusch (1994). 2.5.1 Non-Overlapping subdomains The basic domain decomposition method involves partitioning a domain into non-overlapping subdomains separated by an interface subdomain. The idea behind domain decomposition is to solve the interface equations that connect the subdomains. This partial solution can then be used to compute the solution on each of the subdomains independently in parallel. Variations on the basic method include different methods used to solve the interface equations, and different methods that result when overlapping subdomains are used. Figure 2.9 illustrates a region, , its decomposition into non-overlapping regions 1, 2, 3, 4, and the interface region B. The linear systems corresponding to the region and its decomposition are shown in the figure as well. By ordering the nodes in the decomposition so that nodes in the subdomains are grouped together, and nodes in the interface region are ordered last, the linear system corresponding to the decomposition can be written in the block arrowhead form shown in the figure and below as equation (2.37). We assume that the original linear system Ax = b is symmetric and positive definite.
A1 0 0 0 B1 x1
b1
0 A2 0 0 B2 x2
b2
0 0 A3 0 B3 x3 = b3
0 0 0 A4 B4 x4
b4
B1t B2t B3t B4t AS xS
bS
(2.37)
31
1
2

B
3
4
Ax = b a)
A1 0 0 0 B1 x1
b1
0 A2 0 0 B2 x2
b2
0 0 A3 0 B3 x3 = b3
0 0 0 A4 B4 x4
b4
B1t B2t B3t B4t AS xS
bS
b)
Figure 2.9: Basic Domain Decomposition. a) Original domain and corresponding linear system. b) Subdomains and corresponding block-arrowhead system. In equation (2.37), the blocks Ai correspond to the linear system restricted to the subdomains i, respectively; AS represents the linear system restricted to the interface nodes. Similarly, the xi represent the vectors of unknowns corresponding to the subdomains and the interface region, while the bi represent the reordering of the input vector to be consistent with the partitioning. The off-diagonal blocks Bi represent the interactions between the subdomains and the interface region.
Performing Gaussian elimination on the blocks in equation (2.37) yields:
where: and
I1 0 0 0 A1­1B1 0 I2 0 0 A­21B2 0 0 I3 0 A3­1B3 0 0 0 I4 A4­1B4 0000 S
x1 x2 x3 = x4 xS
A 1­1 b 1 A 2­1 b 2 A 3­1 b 3 A 4­1 b 4 b^ S
4 S = AS ­ Bit Ai­1Bi i=1
(2.38) (2.39)
32
4
b^ S = bS ­
Bit Ai­1bi
i=1
(2.40)
The matrix S in (2.39) is called the Schur complement. The Schur complement embodies all the interactions between subdomains. Solving the subsystem of (2.38) that contains S solves the linear system at all the interface nodes. The Schur complement subsystem is given below:
S xS = b^ S The other subsystems of (2.38) for the subdomains i, i = 1,...,4 are given by:
(2.41)
xi = Ai­1bi ­ Ai­1Bi x^ S
(2.42)
It is clear from the form of equation (2.42) that the subsystems for the subdomains are independent, involving only quantities belonging to the subdomain and to the interface region. Thus, once (2.41) has been solved for the unknowns in the interface region, the remaining subsystems can be solved in parallel. This coarse grain parallelism is a major benefit of domain decomposition. Golub and Ortega (1993) note that domain decomposition and its variants are the best known parallel algorithms for solving narrow banded systems.
For general linear systems, the Schur complement method of domain decomposition suffers from the fact that the Schur complement is dense and computationally intensive to solve directly. Typically, an iterative method such as preconditioned conjugate gradients is used to solve the Schur complement system. The condition number of the Schur complement system of a second order elliptic operator discretized on an nxn mesh is O(n), which is a significant improvement over the condition number of O(n2) for the original system [Chan and Mathew (1994)]. A variety of preconditioners have been developed for use in the iterative solution of the Schur complement system. The reader is referred to Chan and Mathew (1994) for a survey.
2.5.2 Overlapping subdomains
The earliest method of domain decomposition dealing with overlapping subdomains was developed in the pioneering work of H. A. Schwarz over a century ago [Schwarz (1870)]. While variants of Schwarz's method have been devel- oped, the based method for overlapping subdomains is still based on that work. For simplicity of exposition, we follow the treatment of Chan and Mathew (1994), and deal with a domain partitioned into two overlapping subdomains, 1 and 2. Let 1 denote that part of the boundary of 1 that is contained in 2, and let 2 denote the part of the boundary of 2 that is contained in 1. Figure 2.10 illustrates the decomposition.
1
2
1
2
Figure 2.10: Decomposition of a domain into overlapping subdomains.
Now, let x be the n-vector of unknowns in the domain , and let xi be the ni-vector of unknowns in the subdomain i,
i = 1, to an
2. Then ni-vector
x = x1 x2 by selecting
and x1 x2 . For i the elements that belong
= to
1th, e2,dloemt Raiinbetih. eThreecnt,anxgiu=larRmi xat.riCxotnhvaetrrseesltyr,icRtsit
an n-vector extends an
ni-vector to an corresponding
n-vector by filling with zeros in to the subdomains are therefore
entries corresponding to given by Ai = Ri ARit .
elements
of

­
i
.
The
coefficient
matrices
33
The multiplicative Schwarz method generates a sequence of iterates starting with an initial estimate x(0) by executing the following set of updates:
x(k + 1 / 2) = x(k) + R1t A1R1(b ­ A x(k))
(2.43a)
x(k + 1) = x(k + 1 / 2) + R2t A2R2(b ­ A x(k + 1 / 2))
(2.43b)
The multiplicative Schwarz method is a generalization of the block Gauss-Seidel method. However, unlike the standard Gauss-Seidel method, with sufficient overlap, the convergence rate of the multiplicative Schwarz method is independent of the mesh size [Chan and Mathew (1994)].
The additive Schwarz method generates a sequence of iterates starting with an initial estimate x(0) by executing the following set of updates:
x(k + 1 / 2) = x(k) + R1t A1R1(b ­ A x(k))
(2.44a)
x(k + 1) = x(k + 1 / 2) + R2t A2R2(b ­ A x(k))
(2.44b)
The additive Schwarz method is a generalization of the block Jacobi method. Again, with sufficient overlap, the additive Schwarz method has a convergence rate that is independent of the mesh size. Because the correction term in (2.44b) does not reference the update from (2.44a), the two updates in the additive method can be computed in parallel [Chan and Mathew (1994)].
2.6 Multilevel Methods
Multilevel methods refer to a family of methods designed to solve partial differential equations (PDEs), and are gen- eralizations of a method known as multigrid. Multigrid and multilevel are often used interchangeably in the literature. These methods are fairly new; the multigrid paper by Brandt (1977) is often pointed to as the seminal paper in the field. Multilevel methods have received a great deal of attention from the scientific and engineering community because of their impressive theoretical properties: for a PDE defined on n2 grid points, many multigrid methods have optimal (O(1)) or near-optimal (O(logkn)) convergence rates [Guo (1992)]. Moreover, the total number of operations required can be as low as O(n2). In this section, we present a very high level introduction to multigrid. More detailed presentations can be found in the paper by Press and Teukolsky (1991), the tutorial by Briggs (1987), or in the text- books by Axelsson and Barker (1984), Golub and Ortega (1993), or Hackbusch (1994).
2.6.1 Basic multilevel concepts
We first consider a two-grid method. Consider a linear elliptic PDE in two dimensions defined on the unit square that has been discretized on a uniform square mesh n vertices on a side. The result is a linear system of equations
Anxn = bn where the subscript n serves to denote the resolution of the discretization.
(2.45)
(2.45) can be solved iteratively by one of the methods discussed above, say Gauss-Seidel, for example. Then each iteration produces an approximation to the solution, and we denote the kth approximation by xn(k). Recall from §2.4 that the kth residual, rn(k) is defined by rn(k)=Anxn(k)-bn. The residual is often called the defect. If we now solve the equation
34
then the solution xn to (2.45) is given by
An zn(k) = rn(k)
(2.46)
xn = xn(k) + zn(k)
(2.47)
The catch with this approach is, of course, that (2.46) is just as hard to solve as the original equation (2.45). However, many iterative methods will usually converge quickly given a good starting approximation. Therefore, a good approximation to (2.46) may be sufficient to accelerate the convergence of the iterative method used to solve (2.45). The question then is how to generate a good approximation.
Consider constructing a mesh over the unit square with only m=n/2 vertices on a side. The corresponding linear system is
Amxm = bm
(2.48)
Since we have discretized the same equation over the same region, changing only the mesh size, we would expect that a solution to (2.48), expanded in some reasonable way, would be a good approximation to (2.45). Or, given the residual rn(k), we could generate a smaller residual vector rm(k) (that is, restrict the residual), and solve the smaller system
Am zm(k) = rm(k) Then, we could expand zm(k) to form zn(k) (by interpolation, for example), and use zn(k) to update xn(k):
(2.49)
xn(i + 1) = xn(k) + zn(k)
(2.50)
The steps above describe the basic idea behind multigrid, and comprise one iteration of the coarse-grid correction scheme [Press and Teukolsky (1991)]:
i) compute the kth approximation; ii) compute the kth defect; iii) restrict the defect to a coarser grid; iv) solve the defect equation on the coarse grid to find the correction; v) interpolate the correction to the finer grid; vi) use the correction to compute the (k+1)st approximation.
The coarse-grid correction scheme has intuitive appeal, and has formal justification as well. The way to analyze the coarse-grid correction scheme is to use Fourier analysis and look at the error in terms of frequency components. The residual at each iteration consists of a number of components of various frequencies. It can be shown that an iterative method such as Gauss-Seidel gradually reduces the amplitudes of the components of the residual. However, high frequency components are reduced more quickly than low frequency components; for this reason, many iterative methods are called smoothers. The key to the effectiveness of the coarse-grid correction scheme is that the low frequency components of the fine grid residual become high frequency components of the coarse grid residual produced by restriction. That is, the components whose amplitudes are reduced most slowly on the fine grid are reduced quickly on the coarse grid!
The basic multigrid method is a generalization of the coarse-grid correction method described above. Let {Gi} be a sequence of successively finer grids, where G0 is the coarsest, and Gn is the finest. At each iteration, we produce the residual rn(k), and restrict it to form rn-1(k). Now, instead of directly solving for the correction zn-1(k), we recursively apply the coarse-grid correction idea: we perform several iterations of smoothing on the equation An-1zn-1(k)=rn-1(k), then restrict the resulting residual to the next coarser grid, Gn-2. This process of smoothing and restricting continues until the coarsest grid, G0, is reached. Then, A0z0(k)=r0(k) is solved for the correction z0(k). Then, z0(k) is interpolated
35 to form z1(k), and A1z1(k)=r1(k) is smoothed several times. The process of computing corrections then proceeds through ever finer grids until zn(k) is determined and used to compute xn(k+1). One multigrid cycle is now complete. 2.6.2 Multilevel preconditioners Recall that preconditioners approximate the original coefficient matrix. Multilevel methods do exactly the same thing, approximate the original coefficient matrix, but with a matrix of lower resolution. Therefore, it is a natural extension to use multilevel methods in preconditioning. Multilevel methods can be used to form preconditioners by considering all operations to take place in a vector space of dimension equal to the total number of nodes in the multilevel scheme. The expanded coefficient matrices at each level then consist of the original coefficient matrices augmented with diagonal blocks of identity matrices. Restriction and interpolation operators can likewise be defined by matrices. Consider a basic two-level scheme with fine coefficient matrix A, coarse coefficient matrix C, and restriction and interpolation operators R and P, respectively. A preconditioner B for A can then be defined by B=PCR. Different multilevel methods then define different preconditioners which can all be analyzed in the same way as the preconditioners discussed in §2.4.2.3. The basic multigrid method has a rate of convergence of O(1) for a regular differential operator and a quasi-uniform discretization mesh [Bank and Dupont (1981), Braess and Hackbusch (1983)]. There are many variants of multigrid which achieve optimal or near-optimal convergence rates under more general conditions. For example, the multilevel preconditioner of Bramble, Pasciak, and Xu (1990) was proved by Oswald (1991) to have condition number O(1). The multilevel preconditioner of Axelsson and Vassilevski (1989, 1990) also has optimal condition number O(1). 2.6.3 The difficulty with multilevel methods The difficulty in applying multilevel methods lies in the requirement for a nested set of meshes or matrices which discretize the problem at different levels of resolution. Constraints of geometry and physics often impose a certain minimum mesh resolution in order that the discrete problem be a good approximation to the continuous problem. Given a mesh at this minimum resolution, it is possible to further refine it in order to obtain finer meshes for application of a multigrid method. However, the mesh representing the minimum resolution may already be fine enough and further refinement may be unnecessary. Standard multigrid methods cannot be applied in this case, since a coarse mesh is unavailable. Moreover, in many applications, only the coefficient matrix is known, and no information about the meshing process is available. Again, standard multigrid methods cannot be applied. Brandt, McCormick, and Ruge (1982) proposed a method for applying multigrid techniques given only a coefficient matrix. The method, known as Algebraic MultiGrid (AMG), was further refined by Stuben (1983). Essentially, AMG defines a method to construct coarser grids, given the matrix corresponding to the finest grid. AMG is applicable to the same class of matrices (non-singular Laplacian matrices) as the techniques described later in this thesis, and yields convergence rates similar to other multigrid methods [Stuben (1983)]. However, the algorithms involved are very complex and difficult to analyze. Judging from the lack of recent publications, AMG has apparently fallen out of favor within the numerical community. In conclusion, multigrid methods are very efficient and practical when a nested sequence of matrices or meshes is available. However, when only a coefficient matrix is supplied, multigrid methods are difficult or impossible to apply.
36
37 3 Support Trees: Construction and Application In this chapter, we introduce a new class of preconditioners for the preconditioned conjugate gradient (PCG) algorithm, which we call support tree preconditioners. We call the variant of PCG that utilizes these preconditioners support tree conjugate gradient, or STCG. Support tree preconditioners can be constructed for linear systems with coefficient matrices that are real, symmetric, and diagonally dominant. In this chapter, we show how to construct support trees for a more restricted set of matrices, those that are real, symmetric, and diagonally dominant with only nonpositive off-diagonal elements. An extension to all symmetric and diagonally dominant matrices is presented in Chapter 7. Support trees have the following advantages as preconditioners: · They are easy to construct. · They depend only on the coefficient matrix, and not on the differential equation or the meshing process. · They are designed for efficient parallel evaluation. · They are very sparse and therefore have relatively small resource requirements (both storage and work). · They significantly improve convergence rates. This chapter first presents the intuition behind the concept of support trees. Then, an algorithm for the construction of support trees is presented, including a discussion of how to implement STCG. Finally, the chapter closes with a discussion of the computational properties of support trees.
38 3.1 Communication and Mixing
First, some definitions. 3.1 Definition: An nxn matrix L is a Laplacian matrix, or Laplacian, if L is real, symmetric, and diagonally dominant with non-positive off-diagonals. 3.2 Definition: An nxn matrix L is a generalized Laplacian matrix (generalized Laplacian) if L is real, symmetric, and diagonally dominant. Recall from Chapter 2 that a real symmetric matrix A corresponds to an unweighted, undirected graph in which every pair of nonzero off-diagonals aij=aji corresponds to a edge between nodes vi and vj. For the case in which A is a Laplacian matrix, we can augment the graph by weighting the edges with the absolute values of the corresponding off-diagonal elements. More formally, let A be an nxn Laplacian matrix. Then A corresponds to an edge-weighted, undirected graph G = G(A) defined by: · G has vertex set V = {v1,...vn}, where n is the number of rows/columns in A, and node vi corresponds to row/column i of A; · G has edge set E = {(vi,vj) : A(i,j) 0}; · edge (vi,vj) E has weight wt((vi,vj)) = |A(i,j)|. An example of the correspondence between a Laplacian matrix and a graph is illustrated in Figure 3.1.
9 ­2 ­3 ­4 A = ­2 2 0 0 ­3 0 3 0 ­4 0 0 4
v2
2
4 v1 3
v4
v3
Figure 3.1: The correspondence between Laplacian matrices and weighted undirected graphs.
Consider the multiplication of vector x with matrix A, y = Ax. One view of the multiplication is as communication of information between adjacent nodes of the graph corresponding to the matrix: each node sends its value to its neighbors (multiplied by the weight of the connecting edge), and each node computes its new value as a weighted sum of its current value and the values from its neighbors. For example, Figure 3.2 illustrates the simple case of communication in a matrix corresponding to a path on 4 points. Now, consider what happens in an iterative method like Conjugate Gradients (CG). The ith iterate in CG is the minimum error solution of the system Ax = b projected into Ki(A; r0) = span{r0, Ar0, A2r0,..., Ai-1r0}, where r0 = b-Ax0 [Dongarra, et al (1991), Golub and Ortega (1993)]. Ki(A; r0) is called a Krylov subspace. Each multiplication by the matrix A increases the radius of information propagation by 1 mesh edge. The expression defining the Krylov subspace shows that after i iterations, information from the residual can only have propagated i mesh edges. Moreover, in addition to the limitation of the radius of propagation, the magnitude of the information may decrease as the radius increases. Figure 3.3 illustrates an example for a 25x25 square mesh, in which the starting vector is an impulse function located at the center of the grid. The propagation of information outward from the impulse is clearly observable. Figure 3.3a shows the starting vector. Figure 3.3b shows the effect of a single matrix multiplication. Figure 3.3c shows the effect
39
1
0
0
0
x
1
1 ­1 0 0 1
­1 = ­1 3 ­2 0 0
0
0 ­2 5 ­3 0
0
0 0 ­3 3 0
-1 * 1 1 y = Ax -1 * 0
-2 * 0
-3 * 0
0
0
0
-2 * 0
-3 * 0
y1
-1
0
0
Figure 3.2: Matrix multiplication as communication. The matrix multiplication is shown at the left. The top right shows the values of x superimposed on the graph of the matrix; edge weights have been omitted from the figure. The middle right shows the communication operations that make up the matrix multiplication. The bottom right shows the result of the matrix multiplication.
of 10 matrix multiplications; while the information from the impulse function has spread nearly to the edges of the mesh, the magnitude has decreased dramatically. Figure 3.3d show that, after 100 multiplications (corresponding to the 100th iteration of CG), the 100th Krylov subspace encompasses the entire mesh, but the magnitude of the information propagated is small.
Another way to look at the effect of a matrix multiplication is as one step of a mixing process. A matrix multiplication corresponds to having each node "mix" its value with the values from its neighbors. This viewpoint provides an insight into the convergence of iterative methods. The convergence rate of iterative methods in general, and CG in particular, can be related to the rate at which mixing takes place, which in turn is a function of both the rate at which information is propagated across the mesh and the rate at which magnitude is reduced with each multiplication. The solution to a linear system is the fixed point of the iteration, the point at which further information propagation produces no change to the value of the iterate; that is, the information from the initial vector has been completely "mixed".
Figure 3.3 and the discussion above motivate the heuristic argument that convergence rate is a function of graph diameter; convergence requires complete mixing, and complete mixing requires information from every node to reach every other node. In fact, on an nxn mesh (which has n2 nodes) this is a very good heuristic -- the diameter of an nxn mesh is 2n, while the convergence rate of CG is O(n) [Guo (1990)].
The idea behind support trees is to accelerate the mixing process by increasing the rate of information propagation. This is implemented in a novel way -- by providing an alternate communication network with a smaller diameter so that fewer steps are necessary to get information from one side of the graph to the opposite side. For an nxn planar graph with a diameter of n, the corresponding support tree has a diameter of only logn. A support tree is constructed by recursively finding edge separators and adding a node for each separator with edges connecting nodes at different levels. Each support tree edge therefore defines a subgraph of the original graph, and the weight of each edge is equal to the total weight of the edges in the boundary of the corresponding subtree. The support tree is therefore able to carry roughly the same volume of communication in/out of a subtree as did the edges in the original graph. But, the support tree is constructed so that the communication distance is shorter. Hence, information mixes more rapidly.
40
1
0.8
0.6
0.4
0.2
0 25
20
25
15
20
10 5
15 10 5
00
a) y = x
1 0.8 0.6 0.4 0.2 0 25 20 15 10
5
5
00
b) y = Ax
25 20 15 10
x 107 8 6 4 2 0 -2 -4 -6 25 20 15 10
5
5
00
c) y = A10x
25 20 15 10
x 1088 1.5
1
0.5
0
-0.5
-1
-1.5 25
20
25
15
20
10 5
15 10 5
00
d) y = A100 x
Figure 3.3: Repeated matrix multiplication on a 25x25 grid. a) the starting condition: y = x b) after 1 multiplication: y = Ax c) after 10 multiplications: y = A10x d) after 100 multiplications: y = A100x
From the standpoint of preconditioners as approximate inverses, the support tree preconditioners are constructed to approximate the communication network represented by the coefficient matrix. In some sense, then, a support tree preconditioner is intended to approximate the topological properties of the coefficient matrix, rather than the algebraic properties.
3.2 Support Tree Construction
The procedures used in the construction of a support tree are presented as Procedures 3.3 through 3.5 below. In these procedures, the weights of the edges of the support tree are set equal to the total weight of the edges on the boundary of the subgraph induced by the tree edge. Support tree edge weights can be assigned in many other ways. In Chapter 5, we present a weighting based on the ratio of boundary edges to internal nodes; this weighting has some very nice theoretical properties. In all other chapters, however, we utilize boundary weighted support trees.
41 3.3 Procedure: partition_fn set_of_graphs partition_fn (G) { % input:G = an edge-weighted graph on n nodes; % output:{Gi} = a collection of subgraphs of G 1. find S, an edge separator of G; 2. let {Gi} be the connected components of G ­ S ; 3. return({Gi}); } % end partition_fn 3.4 Procedure: generate_support_tree tree generate_support_tree (G, partition_fn) { % input: G = an edge-weighted graph on n nodes; % partition_fn = a function which returns a set of two or more subgraphs % output:T = support tree for the graph G 1. create a new node S; 2. create a new tree T containing only the node S; 3. T = generate_support_tree_sub (T, S, G, partition_fn); 4. return(T); } % end generate_support_tree 3.5 Procedure: generate_support_tree_sub tree generate_support_tree_sub (T, Si, Gi, partition_fn) { % input:T = a tree; % Si = a node of T, the root of the subtree to be created % Gi = a subgraph whose support tree is to be rooted at Si % partition_fn = a function which returns a set of two or more subgraphs % output:T = T Ti, where Ti is the support tree for Gi 1. {Hi} = partition_fn(Gi); 2. for each Hi {Hi} { 3. create a node Ri in T corresponding to Hi; 4. compute i, the total weight of the edges on the frontier of Hi; 5. create an edge of weight i in T connecting Ri to Si; 6. if Hi 1 then T = generate_support_tree_sub (T, Ri ,Hi, partition_fn); } %end for 7. return(T); } % end generate_support_tree_sub
42 The process of building a support tree is illustrated in Figure 3.4. The figure represents building a support tree for a finite element mesh that was derived for a cracked plate. The original mesh is presented in Figure 3.4a. Each additional illustration takes the support tree construction process down one more level of recursion. At each level, edges of the separators are drawn as dotted lines, while remaining edges are solid. Figure 3.4f is the final support tree. The crack is not visible in the illustration, since the points are separated by only a small amount, but runs from (0.0,0.5) to (0.5,0.5). A singularity exists at the inner end of the crack, which requires very fine meshing to resolve adequately; the fine meshing can be seen around the center of the mesh. The reason for the name support tree is revealed by looking at the figure. The original mesh is planar, with the support tree sticking out in the third dimension. The mesh appears to be hanging from the support tree; that is, the mesh appears to be supported by the tree. Each node of a support tree defines a subgraph of the graph; the root corresponds to the entire graph, while leaves correspond to individual nodes. Each non-leaf node of a support tree also defines a separator, in particular, the separator used to partition the associated subgraph. Finally, every edge in the support tree corresponds to the collection of edges that make up the frontier of the subgraph associated with the node on the leaf side of the edge. 3.2.1 Partitioning the graph The process of graph partitioning is at the heart of the support tree construction procedure. Graph partitioning, reviewed in Chapter 2, is a process of deleting edges of a graph G in order to produce two or more subgraphs of roughly the same size that are disconnected from each other. The set of edges removed is called an edge-separator. Graph partitioning can also be performed by deleting vertices; the set of vertices which, upon removal, partitions the graph is called a vertex separator. In this thesis, we shall only be concerned with edge separators. The goal of graph partitioning is to find small separators. Any graph partitioning algorithm is applicable to the construction of support trees, provided that the algorithm can be applied to the underlying graph. For example, if only the coefficient matrix is known, then one of the combinatorial algorithms must be used. When geometric information is available, then a geometric algorithm can be used as well. One of the decisions that must be made in constructing a support tree is deciding upon the branching factor of each node. We have found that, for relatively regular problems, a good solution is to match the branching factor to the dimensionality of the space: a support tree for a mesh in d dimensions has a branching factor of 2d. Thus, the support tree for a path is a binary tree, the support tree for a square mesh is a quadtree, and so on. For exotic graphs that may be highly irregular, a somewhat irregular support tree is also desirable. In Chapter 5, we present a method for construction of irregular support trees in which the branching factor at each node depends upon the topology of the underlying subgraph. 3.2.2 Weighting the edges of a support tree Recall that we have compared the convergence of an iterative method to a mixing process. Each of the constituent matrix/vector products propagates information one step, and the goal in constructing support trees is to accelerate mixing by reducing the distance across the graph. But just reducing the distance is not sufficient. The volume of communication between subsets must be maintained while distance is reduced. Consider a subgraph Gi of a graph G that resulted from some number of recursive partitioning steps. The collection of edges (u,v) such that u Gi, and v Gi is called the frontier of Gi, which we denote frontier(Gi). Each of the edges (u,v) frontier(Gi) has a weight wt(u,v) associated with it. The frontier weight of Gi, (Gi) is the sum of the weights of the frontier edges. Imagine that these edges are pipes with capacities given by the weights. Then (Gi) is the total capacity of the edges with which Gi communicates with the rest of the graph. Hence, the edge of the support tree that leads down to Gi must be able to accommodate the same capacity as the frontier of Gi. That is, the same volume of information must flow through the support edge as can flow through frontier(Gi).
43
6 5 4 3 2 1 0 1 0.5 6 5 4 3 2 1 0 1 0.5
00
1 0.8 0.6 0.4 0.2
a)
00
1 0.8 0.6 0.4 0.2
c)
6 5 4 3 2 1 0 1 0.5 6 5 4 3 2 1 0 1 0.5
00
1 0.8 0.6 0.4 0.2
b)
00
1 0.8 0.6 0.4 0.2
d)
6 5 4 3 2 1 0 1 0.5
00
1 0.8 0.6 0.4 0.2
e)
5 4 3 2 1 0 1 0.5
00
1 0.8 0.6 0.4 0.2
f)
Figure 3.4: Support tree construction. The steps in the construction of a support tree are illustrated. a) the original mesh b) one level of partitioning c) two levels of partitioning d) three levels of partitioning e) four levels of partitioning f) five levels of partitioning: the final tree
The reasoning above (which is formalized in the proofs of Chapter 4), provides the intuition behind weighting the support tree edges by the total weight of the edges on the frontier of the associated subgraph. In Chapter 5 we discuss a more elaborate way to weight the edges of both regular and irregular support trees that guarantees sufficient support of boundary edges, but also provides properties that are useful for theoretical analysis of general support tree performance. The boundary edge weighting used in the algorithms of this section are sufficient for regular graphs, however.
44 3.3 Implementation of Support Tree Conjugate Gradient
We use support tree preconditioners in a variant of PCG. We call our variant of PCG support tree conjugate gradient (STCG). Support tree matrices are large and sparse, larger, in fact, than the original matrix. For a simple path on n nodes, the coefficient matrix A is nxn, while the corresponding binary support tree matrix T is (2n-1)x(2n-1). How can we make use of a preconditioner that is larger than the original matrix? The answer is to consider T a computational implementation of a smaller matrix. This is explained below. Let T be a support tree matrix. Then, if T is ordered from leaves to root, T has the form
T= DR
(3.1)
Rt S
where D is nxn and diagonal. Rows/columns 1 through n of T correspond to the nodes of the original mesh, which are the leaves of the tree. The other rows/columns correspond to internal nodes of the tree, and constitute the additional variables that make the support tree matrix larger than the original matrix. In graph-theoretic terms, D represents the total connectivity at the leaves. R and Rt represent the connections between leaves and internal nodes of the tree, and S represents the internal nodes and connections in the tree. Figure 3.5 illustrates an example for a quadtree support tree constructed for a 2x4 mesh.
Let A be an nxn coefficient matrix and T be an mxm support tree matrix for A. Assume that A and T are ordered so that
T has the block decomposition shown above. Consider performing Gaussian reduction to the internal nodes of T,
which shown
is the block that D fills
S. This process reduces S to a diagonal matrix Sd. In addition, out to become a dense nxn matrix K. Denote the reduction of
R T
and Rt by T~ .
are zeroed out, and it can be The Gaussian reduction can
be implemented as matrix multiplication: pre-multiplication by a matrix G, and post-multiplication by Gt, as shown
below.
GT Gt = K 0 = T~
(3.2)
0 Sd
Let A~ be the mxm matrix constructed from A by adding m-n rows and columns of zeros:
A~ = A 0
(3.3)
00
Similarly, for any n-vector x, let x~ be the m-vector obtained by adding m-n zeros to x:
x~ = x
(3.4)
0
Consider the Gaussian reduction denoted by G and Gt to A~ . The elementary operations of G consist of adding multiples of row/column i, for i {n+1,...,m} to row/column j, for j {1,...,n}. But, all the rows/columns of A~ are zero for i {n+1,...,m}. Therefore, A~ is unchanged by the given Gaussian reduction operations. We therefore have:
G A~ Gt = A~
(3.5)
A similar argument shows that, for any m-vector x~ constructed by augmenting an n-vector x with zeros:
45
v5
v6
v7
v8
v1
v2
v3
v4
d1 + 2 ­1 0 0 ­1 0 0 0
­1 d2 + 3 ­1 0 0 ­1 0 0
0 ­1 d3 + 3 ­1 0 0 ­1 0
0 0 ­1 d4 + 2 0 0 0 ­1
­1 0
0
0 d5 + 2 ­1 0
0
0 ­1 0 0 ­1 d6 + 3 ­1 0
0 0 ­1 0 0 ­1 d7 + 3 ­1
0
0
0 ­1 0
0 ­1 d8 + 2
v13
v11
v12
v9
v10
v5
v6
v7
v8
v1
v2
v3
v4
D
R
d1 + 2 0 0 0 0 0 0 0 ­2 0 0 0 0
0 d2 + 3 0 0 0 0 0 0 ­3 0 0 0 0
0 0 d3 + 3 0 0 0 0 0 0 ­3 0 0 0
0 0 0 d4 + 2 0 0 0 0 0 ­2 0 0 0
0 0 0 0 d5 + 2 0 0 0 0 0 ­2 0 0
0 0 0 0 0 d6 + 3 0 0 0 0 ­3 0 0
0
0
0
0
0
0 d7 + 3 0 0 0 0 ­3 0
0 0 0 0 0 0 0 d8 + 2 0 0 0 ­2 0
­2 ­3 0 0 0 0 0 0 8 0 0 0 ­3
0 0 ­3 ­2 0 0 0 0 0 8 0 0 ­3 0 0 0 0 ­2 ­3 0 0 0 0 8 0 ­3
0 0 0 0 0 0 ­3 ­2 0 0 0 8 ­3
0 0 0 0 0 0 0 0 ­3 ­3 ­3 ­3 12
Rt
S
Figure 3.5: The structure of support tree matrices. At the top is a mesh and the corresponding matrix. At the bottom is a support tree constructed for the mesh, and the corresponding matrix. The block structure of the matrix is illustrated.
G x~ = x~
(3.6)
We now have enough tools to show how an mxm support tree matrix T may be used as a preconditioner for an nxn matrix A, where n < m.
Consider solving A~ x~ = b~ , where A~ is as defined in (3.3), and both x~ and b~ are constructed as in (3.4). This system is singular, so more than one solution exists. We need to show how to find a unique solution that can be easily converted into a solution to Ax = b . Using T as a preconditioner is equivalent to solving the system
T ­1 A~ z = T ­1b~
(3.7)
where z = x , x is the solution to Ax = b , and y is some unknown vector. y
Applying Gaussian reduction to T ­1 , where GT Gt = T~ yields
46
or, using (3.2),
G­tT ­1G­1G A~ z = G­tT ­1G­1Gb~
(3.8)
T~ ­1G A~ z = T~ ­1Gb~
(3.9)
We now apply the same reduction to A~ :
T~ ­1G A~ GtG­t z = T~ ­1Gb~
(3.10)
Now, recalling from above the effect of the particular Gaussian reduction on A~ and b~ , as given by (3.5) and (3.6), we have:
T~ ­1 A~ G­t z = T~ ­1b~
(3.11)
That is, we can use the reduced matrix T~ as a preconditioner for a system involving a coefficient matrix A~ G­t instead of using T to precondition A. Moreover, the structure of this alternate system is useful. Equation (3.11) above, in block form, is
K­1 0 A 0 I 0 x = K­1 0 b
0
S
­1 d
00
H21 H22
y
0 Sd­1 0
Multiplying out the matrix terms yields:
(3.12)
K­1A 0 x = K­1 0 b
0 0y
0 Sd­1 0
(3.13)
In equation (3.13) above, the variables corresponding to the extra nodes of the support tree have no influence on the solution to Ax = b . Therefore, we only need to use K as a preconditioner for A, and solve
K­1A = K­1b
(3.14)
The catch is that K is dense, and requires too much work to use, both to compute the triangular factors of K, and to solve the resulting systems. However, since the added variables in y have no effect on the solution x, we can use the sparse support tree matrix T as a preconditioner for A by simply augmenting the vectors x and b with zeros, solving (3.7). and throwing away the extra variables. The advantage in using (3.7) is that T is extremely sparse, and is also structured for efficient computation, meaning that solving the larger, sparser system (3.7) is more efficient than solving the smaller, denser system (3.14). The intuition is to think of T as a sparse, computationally efficient form of the dense preconditioner K.
We can now present the STCG algorithm, which is a variant of the PCG algorithm presented as Procedure 2.12 in Chapter 2. For convenience in exposition, Procedure 2.12 is reproduced here.
47 2.12 Procedure preconditioned_conjugate_gradients ( A, x(0), b, B, ) { x = x(0); g = Ax - b; solve Bh = g; = (g, h); = 0; d = 0; while ( > ) do { d = -h + d; h = Ad; = / (d, h); x = x + d; g = g + h; solve Bh = g; = (g, h); = / ; = ; } return ( x ); }; We now state the STCG algorithm as Procedure 3.6: 3.6 Procedure support_tree_conjugate_gradients ( A, x(0), b, T, ) { n = dim(A); m = dim(T); x = x(0); g = Ax - b; g~ = augment(g,m-n); solve T h~ = g~ ; h = h~ (1:n); = (g, h); = 0; d = 0; while ( > ) do { d = -h + d; h = Ad; = / (d, h); x = x + d; g = g + h; g~ = augment(g,m-n); solve T h~ = g~ ; h = h~ (1:n); = (g, h); = / ; = ; } return ( x ); }; The only differences between PCG (2.12) and STCG (3.6) are at the points where the preconditioner is applied. In
48 STCG, the residual must be augmented with zeros before the preconditioned system is solved, which is performed by the statement g~ = augment(g,m-n). Then, following the solution step, performed by solve T h~ = g~ , the solution must be reduced in size by dropping elements corresponding to the added zeros, which is performed by h = h~ (1:n) (where h~ (1:n) is the notation from Matlab [Mathworks, Inc., (1992)] for elements 1 through n of vector h~ ). Therefore, most of the STCG algorithm is executed with n-vectors and the nxn matrix A. The only step that involves the added variables is in solving the preconditioned system, which is done efficiently because of the structure of the support tree. In Chapter 4, we show how an interpretation of Laplacian matrices as resistive networks also leads to the conclusion that a support tree can be used as a preconditioner. The demonstration in Chapter 4 is based on physical principles about current flow. 3.4 Computational Properties of Support Trees A good preconditioner B for a coefficient matrix A should satisfy three criteria [Axelsson and Barker (1984), vanderVorst (1989)]: 1. Preconditioning with B should reduce the number of iterations required for PCG to converge. 2. B should be easy to construct. That is, the cost of constructing the preconditioner B should be small with respect to the total cost of solving the linear system. 3. The preconditioned system Bz = r should be easy to solve. On both serial and parallel machines, this means that the time required to solve Bz = r should be small with respect to the time required for an unpreconditioned iteration. On serial machines, a good preconditioner should require relatively little work to solve, and should be structured for efficient execution. On parallel machines, a good preconditioner should be well-structured for parallel execution. In the subsections below, we address each of these criteria with respect to support tree preconditioners, with special emphasis on parallel implementations. 3.4.1 Reduction in the number of iterations Recall from the review in Chapter 2 that the generalized condition number of an ordered pair of matrices (A,B) is given by the ratio of the maximum and minimum generalized eigenvalues: (B­1 A) = ( A, B) = max( A, B) / min( A, B) The rate of convergence of PCG for coefficient matrix A and preconditioner B is O( (B­1 A)) [Axelsson and Barker (1984)]. To compare convergence rates, we consider as our model problem the two-dimension Dirichlet problem on the unit square discretized by linear finite elements into an nxn square mesh. When the preconditioner is the identity (no preconditioning), the condition number is O(n2) [Johnson (1987)]. Diagonal scaling (DSCG) and the incomplete Cholesky (ICCG preconditioners are also O(n2) [Gustafsson (1978)]; although DSCG yields improvements over no preconditioning, and ICCG is known to be an improvement over diagonal scaling, neither actually improves the asymptotic convergence rate. The modified incomplete Cholesky (MICCG) preconditioner is O(n), but requires determination of a relaxation parameter to achieve the optimal convergence rate [Gustafsson (1978), Axelsson and Lindskog (1986)]. The SSOR preconditioner with optimal relaxation parameter is also O(n) [Axelsson and Barker (1984)]. In comparison, we show in Chapter 4 that support tree preconditioners have a generalized condition number of O(nlogn). Thus, support tree preconditioners have better asymptotic properties than diagonal scaling and incomplete
49
Cholesky, but not as good as modified incomplete Cholesky or SSOR preconditioning. However, it should be noted that support tree preconditioners do not require the computation of any optimizing parameters, as in the case with modified incomplete Cholesky and SSOR. Furthermore, in this section we also show that the regular structure of support trees make their parallel performance much better than any of the others listed here except diagonal scaling. Support tree preconditioners are also more sparse than either modified incomplete Cholesky or SSOR preconditioners.
3.4.2 Ease of construction
The algorithm for support tree construction, presented in §3.2, is very straightforward and relies only on a subroutine to perform graph partitioning. As explained above, graph partitioning is a well-researched problem for which a number of efficient solutions have been proposed.
The algorithm for support tree construction contains two inherent levels of parallelism: parallelism within the partitioning code, and parallelism by subgraph. For example, consider partitioning a subgraph Gi. The partitioning code can be parallelized in various ways. Then, after partitioning Gi into Gi1,...Gi4, the partitioning processes for each of the Gij can be executed on separate processors. The cost of construction of a support tree preconditioner T must include the cost of factoring T into triangular matrices, T = VVt. The structure of a support tree yields an ordering for factoring the associated matrix T with zero fill. Moreover, the zero-fill ordering is a by-product of the support tree construction procedure. The tree is constructed from root to leaves, while the zero-fill factorization proceeds from leaves to root. Therefore, the order in which tree nodes are created is simply reversed to find the zero-fill ordering.
The zero-fill ordering can be used, with some modification, to perform Cholesky factorization in parallel. The key in parallel factorization is to find sets of independent nodes to factor in parallel. As discussed in the next section, a procedure called leaf-raking can be used to determine an ordering for parallel evaluation of independent nodes. When ordered properly, T can be factored in O(logn) parallel steps.
3.4.3 Ease of solution
Consider the process of solution on a serial processor. A support tree is large, but very sparse. A support tree matrix T for a coefficient matrix A will be stored, in application, in the form of its Cholesky factors V and Vt. The serial work is proportional to the total number of non-zeros in the Cholesky factors. Table 3.1 and Table 3.2 list the resource requirements for diagonal scaling (DSCG), incomplete Cholesky (ICCG), and support tree (STCG) preconditioners of square and cubic meshes, respectively. For the tables, lower order terms have been ignored. In 2D, a quadtree support tree was used for comparison, while in 3D an octtree was used. The tables make clear the sparsity of support trees: despite having more nodes than the original matrix, the support tree has fewer non-zeros than the incomplete Cholesky preconditioner, and even fewer non-zeros than the original matrix itself. Moreover, the advantages of support trees increase with increasing dimensionality: in 2D, the support tree has roughly 80% of the non-zeros that the incomplete Cholesky factors have; in 3D, the fraction drops to less than 50%.
Table 3.1: Preconditioner Resource Requirements for an nxn Mesh.
2D (nxn) storage + * /
DSCG n2 0 0 n2
ICCG 5n2 3n2 4n2 n2
STCG 4n2 2n2 (8/3)n2 (4/3)n2
Table 3.2: Preconditioner Resource Requirements for an nxnxn Mesh.
3D(nxnxn) DSCG storage n3
+
0
*
0
/
n3
ICCG 7n3 5n3 6n3 n3
STCG (24/7)n3 2n3 (16/7)n3 (8/7)n3
Suppose that T is ordered to yield a zero-fill Cholesky factorization T = VVt. The triangular factors V and Vt correspond to edge-weighted directed trees, one tree with all edges directed from leaves to root, and the other with edges
50
directed from root to leaves. In the directed interpretation, row indices correspond to the heads of arcs and column indices to the tails. For example, V(i,j) 0 corresponds to a directed edge (vj,vi) for which vi is the head of the directed edge, and vj is the tail. Figure 3.6 illustrates a simple example.
2 0 0 -1 0
0 1 0 -1 0
a)
0 0 1 0 -1
-1 -1 0 3 -1
0 0 -1 -1 2
1.4 0 0 0 0
1.4 0 0 -.7 0
01000
0 1 0 -1 0
=
00100
*
0 0 1 0 -1
-.7 -1 0 1.2 0
0 0 0 1.2 -.8
0 0 -1 -.8 .58
0 0 0 0 .58
4
1
1
b) 2
3
1
1
1
0
4
1
.8
4
1
.8
=
2
3
*
2
3
1
.7
1
.7
1
0
1
0
Figure 3.6: Graph-theoretic interpretation of Cholesky factorization. a) Cholesky factorization of a Laplacian matrix. b) Equivalent factorization of an undirected tree into two directed trees.
Recall that, to solve Tz = r, we solve two triangular systems: Vy = r, and Vtz = y. By referring to Figure 3.6 and recalling the interpretation of triangular matrices as directed graphs, we see that the solution process consists of propagating weighted averages up the tree (solving Vy = r), and then propagating corrections back down the tree (solving Vtz = y). We can make the process somewhat more efficient for parallel execution by using the root-free Cholesky factorization: T = CDCt, where C is unit lower triangular, and D is diagonal. Then the solution process consists of propagating averages up (solving Cy = r), scaling all values in parallel (computing w = D-1y), then propagating corrections down the tree (solving Ctz = y). The fact that the Cholesky factors correspond to directed trees can be used to optimize the solution procedure for parallel processors. The directed arcs represent dependencies: nodes at the heads of arrows are dependent on values from the nodes at the tails. Hence, leaves are entirely independent, and may be solved in parallel. If the leaves are then removed from the tree, a new, smaller tree results, with leaves that are again independent. We call this evaluation process leaf-raking, since all existing leaves are "raked" off the tree at each step. Parallel node evaluation by leaf-raking is a special case of a more general parallel algorithm known as parallel tree contraction [Reid-Miller, et al (1993)]. A complete binary tree with n leaves (2n-1 total nodes) can be evaluated using leaf raking in only 2 log n parallel steps. As part of the initialization process for STCG, the order in which nodes should be evaluated is determined, and the linear systems are reordered to maximize data locality at each step. We call this ordering rake-order. Figure 3.7 illustrates the process of leaf raking on a simple tree. An analogous process exists for the downward directed tree: expansions from parents to children can be performed independently in parallel. Leaf raking can result in impressive parallel performance. For example, consider the case of a quadtree support tree for an nxn mesh. The first and last steps in the evaluation of the preconditioned system can be performed by evaluating n2 nodes in parallel. Leaf raking is only one source of parallelism that can be exploited in the solution of the preconditioned system. The second source is evaluation by subtree. Each subtree of a support tree is independent of other subtrees. Hence, with a parallel-vector processor architecture such as the Cray C-90, separate subtrees can be assigned to separate processors, and only a single message from each processor to a central processor is necessary to combine results for complete evaluation of a single triangular factor. Each of the subtrees can be evaluated efficiently using the vector capabilities of each processor. Figure 3.8 illustrates the procedure for a simple quadtree support tree assuming p = 16 processors. On a massively parallel machine, clusters of processors can be assigned to subtrees. Interprocessor communication is
51 rake rake rake Figure 3.7: Leaf Raking and the Solution of a Lower Triangular System. A linear system corresponding to a tree directed from leaves to root is shown at the left. In the first parallel step, the solutions at the leaves are computed, and the right hand side values at the parents are updated. In succeeding parallel steps, the process is repeated at the leaves obtained when the previous set of leaves is removed. At the last step (not shown), the solution at the root is computed. p1 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 p16 Figure 3.8: Parallel evaluation of subtrees. With 16 parallel-vector processors, the quadtree is partitioned up at level 3, with each subtree being assigned to a separate processor. By applying leaf raking, each of the subtrees can be efficiently evaluated using the vector capabilities of each processor. To combine the results, one processor is selected as the central processor, and the other processors each send a single number to it. minimal since each processor must send/receive at most two messages during evaluation of a triangular factor, as long as every processor is assigned either a single node or a subtree. The theoretical efficiency of STCG in solving the preconditioned system on a per-iteration basis can be compared with that of other methods using the parallel-vector models of Blelloch (1990), which were presented in §2.4.2.4. Consider solving the preconditioned systems for DSCG, ICCG, and STCG applied to an nxn mesh: · DSCG is the most efficient of the methods. The preconditioned system can be solved in a single parallel step, yielding a step complexity of O(1), and an element complexity of O(n2). · For ICCG, a naive triangular solve method would have step complexity of O(n2), and asymptotic element complexity of O(n2) as well. Using the more efficient diagonal ordering (see §2.4.2.4), in which nodes that lie along a common diagonal are solved in parallel, yields step complexity of O(n), and element complexity of O(n2). · For STCG using leaf raking, step complexity is O(logn), and element complexity is O(n2).
52 3.5 Summary In this section, we have presented the intuition that led to the development of support tree preconditioners. We presented an algorithm for the construction of a support tree preconditioner for an arbitrary Laplacian matrix, and showed how to implement the STCG algorithm. We stated that the condition number of STCG is O(nlogn) for an nxn mesh, and showed how the implementation of STCG could be made very efficient for parallel processors. In the next three chapters, we provide theoretical and practical demonstrations of the properties of STCG. In Chapters 4 and 5, we prove the convergence properties of STCG through analysis of generalized condition numbers, and show the applicability of STCG to Laplacian matrices. In Chapter 6, we present the results of numerical experiments that demonstrate the actual performance of the STCG algorithm. In Chapter 7, we show how to extend STCG to generalized Laplacian matrices.
53 4 Support Trees: Theory In this chapter, we present a theoretical analysis of the convergence properties of support tree preconditioners. The analysis relies on interesting isomorphisms between Laplacian matrices, undirected graphs with self-loops, and grounded resistive networks. The theory interprets matrix multiplication as current flow in resistive networks and shows how condition numbers are based on a concept of support of one network for another. 4.1 Matrices and Graphs Recall the definition of Laplacian matrices from Chapter 2: An nxn matrix L is a Laplacian matrix, or Laplacian, if L is real, symmetric, and diagonally dominant with non-positive off-diagonals. A one-to-one correspondence exists between a subset of undirected graphs and Laplacian matrices. Given an undirected graph with positive edge weights, a corresponding Laplacian matrix can be constructed. Let G = (V,E) be an undirected graph with vertex set V = {v1...vn}, edge set E = {(vi,vj): vi is adjacent to vj}, and edge weights w(vi,vj). The Laplacian matrix of G, L = L(G), is an nxn real symmetric matrix such that: · L(i,j) = L(j,i) = -w(vi,vj), where w(vi,vj) is the weight of the edge between vi and vj; · L(i, i) = w(vi, v j) . viadjv j Figure 4.1 illustrates several edge-weighted graphs and their Laplacian matrices. The Laplacian matrices illustrated in Figure 4.1 are all singular. In particular, they all have the zero row/column sum property: the sum of all the elements in any row/column is zero. The zero row/column sum property implies singularity because it means that the constant vector is an eigenvector corresponding to eigenvalue zero. Given an nxn Laplacian matrix L with the zero row/column sum property, it is easy to construct the corresponding graph G = G(L):
54
v2
2
4 v1 3
v4
v3
9 ­2 ­3 ­4 L = ­2 2 0 0 ­3 0 3 0 ­4 0 0 4
v1
2
v2
8 ­2 ­1 ­5
5
1 3 L = ­2 5 ­3 0
­1 ­3 8 ­4
4
v4
v3
­5 0 ­4 9
Figure 4.1: Graphs and Laplacian Matrices.
· G has vertex set V = {v1,...,vn}, where n is the number of rows/columns in L, and vi corresponds to row/ column i of L; · G has edge set E = {(vi,vj): L(i,j) 0}; · edge (vi,vj) E has weight wt(vi,vj) = |L(i,j)|. So there is an isomorphism between Laplacian matrices with the zero row/column sum property (that is, singular Laplacian matrices) and edge-weighted, undirected graphs. To deal with non-singular Laplacians, it is necessary to expand the class of graphs.
A Laplacian L can be made positive definite (and hence non-singular) by adding positive weight to one or more of the diagonal elements. That is, for L a Laplacian having the zero row/column sum property, L can be made non-singular by adding positive weight di to L(i,i) for some i. In terms of the associated graph G = G(L), we represent the added diagonal weight di as a self-loop on node vi of weight di. Figure 4.2 illustrates diagonal weighting on Laplacians and their associated graphs.
1 v2 2
4 v1 3
v4
v3
9 ­2 ­3 ­4 L = ­2 3 0 0 ­3 0 3 0 ­4 0 0 4
22 v1
5
1
4 v4
v2
10 ­2 ­1 ­5
3 L = ­2 5 ­3 0 ­1 ­3 3 ­4
v3
­5 0 ­4 9
Figure 4.2: Non-singular Laplacians and Self-loops.
We have now demonstrated an isomorphism between all Laplacian matrices and undirected graphs with self-loops, in which all edges are weighted with positive weights.
4.2 Matrices and Resistive Networks
There is also an isomorphism between Laplacian matrices and resistive networks. Consider a simple circuit consisting of two nodes vj and vk separated by a resistor with resistance rjk, as in Figure 4.3. The current between vj and vk, denoted ijk, is a function of the voltage difference between the nodes and the resistance rjk:
i jk
=
-u---j--­---u---kr jk
(4.1)
where uj and uk are the voltages at nodes vj and vk, respectively. Or, since conductance is the reciprocal of resistance, we have
55
i jk = c jk(u j­uk)
(4.2)
where cjk, the conductance between vj and vk is given by
cjk = 1 / r jk
(4.3)
rjk
vj
vk
ijk
Figure 4.3: Simple resistive circuit.
By symmetry in the circuit, we also have
ikj = ckj(uk­u j)
(4.4)
Let ij and ik be the net current flow out of node vj and vk, respectively. Since cjk = ckj, we can rewrite the equations above as a linear system:
or, in matrix notation,
i j = c jk ­c jk u j
ik
­c jk c jk uk
(4.5)
i = Cu
(4.6)
We call C the conductance matrix for the resistive circuit. The conductance matrix maps applied voltages at the nodes to net currents at the nodes. Because conductance is the property of interest to us, we will label resistors in figures by their conductances.
We can generalize these equations to resistive circuits with an arbitrary number of nodes. Consider a resistive network with n nodes. Suppose that nodes vj and vk are connected, as above, with a resistor having conductance cjk. Let ejk, for j < k be the n-vector with 1 in the jth component and -1 in the kth. Then let
E jk
=
e
jk
e
t jk
(4.7)
Ejk is the nxn matrix having +1 in positions Ejk(j,j) and Ejk(k,k), -1 in positions Ejk(j,k) and Ejk(k,j), and zero elsewhere. Equation (4.5) can then be written as
ij ik
= cjkE jk
uj uk
(4.8)
Since the net current flow at a node is given by the sum of the current flows between the node and its neighbors, we have for any node vj:
i j = c jk(u j­uk) kadj j
(4.9)
Or, for all nodes in the circuit:
i
=

k
adj
j,
k
>
c jkE jku j
=
Cu
(4.10)
56 In the equation above, the conductance matrix C is now the sum of all the conductance matrices for the individual resistive connections. The sum is taken for adjacencies with nodes of higher index to avoid duplication. The conductance matrix C is exactly the Laplacian matrix of the weighted graph G that has the same topology as the resistive circuit, with edge weights given by the conductances of the individual connections. Figure 4.4 illustrates a resistive network and its associated conductance matrix. Compare this with the weighted graph and Laplacian in Figure 4.1.
c14 = 4 v4
v2
c12 = 2 v1 c13 = 3 v3
2 ­2 0 0 3 0 ­3 0 4 0 0 ­4
9 ­2 ­3 ­4
C = ­2 2 0 0 + 0 0 0 0 + 0 0 0 0 = ­2 2 0 0 0 0 0 0 ­3 0 3 0 0 0 0 0 ­3 0 3 0
0 0 0 0 0 0 0 0 ­4 0 0 4 ­4 0 0 4
Figure 4.4: Resistive network and conductance matrix.
The conductance matrices for resistive circuits have the zero row/column sum property. This property makes sense from a physical standpoint: when all the nodes in a circuit have the same voltage, there is no net flow of current at any node. However, we need to extend the resistive circuit isomorphism to include non-singular Laplacians. Since a conductance matrix is a Laplacian matrix, it can be made non-singular by adding positive weight to one or more of the diagonal elements. In the case of resistive circuits, this can be interpreted as adding a resistive connection to a ground node that is fixed at voltage zero. This is formalized below. 4.1 Definition (augmented matrix): Let L be a Laplacian matrix. Then L = C + D, where C is the conductance matrix of a resistive circuit with n nodes, and D is an nxn diagonal matrix with non-negative entries. Let F be the conductance matrix corresponding to the circuit of C augmented with a ground node vn+1 such that F(i,n+1) = F(n+1,i) = -D(i,i), and F(n + 1, n + 1) = D(i, i) . That is, each node in the circuit is coni nected to the ground node with a conductance equal to the additional diagonal weight at that node. We call F the augmented matrix, or augmentation, of L. Let d = diag(D) = [D(1, 1), ..., D(n, n)]t, and h = dk = tr(D). Then F can be written in block form as k
F = L ­d ­dt h
(4.11)
4.2 Lemma: Let L be a Laplacian matrix. Let F be the augmentation of L. For any vector of applied voltages u = u1 ... un t , let w = u1 ... un 0 t , i = Lu , and j = Fw. Then we have ik = jk, for all k = 1...n.
57 proof:
By construction, using equation (4.11), F = L d . Partitioning w in the same way yields dt h
w = u . Substituting and multiplying, we obtain Fw = L d u = Lu = i .
0
dt h 0
dtu
dtu

Thus, any Laplacian matrix is isomorphic to a resistive network. Now we can move between three different, equivalent representations of the same object. In what follows, we will cease to distinguish between undirected weighted graphs and resistive networks, and will use both representations interchangeably.
4.3 Support Trees and Resistive Networks
In Chapter 3, we presented the intuition for support trees in terms of making communication across the mesh more efficient. We now augment this intuition by presenting support trees in terms of resistive networks.
The previous subsection showed that a Laplacian matrix corresponds to a grounded resistive network; the Laplacian corresponds to the conductance matrix that defines the network. Furthermore, matrix-vector multiplication is a mapping from voltages at each node to net current flow at each node. For example, consider the simple example of the conductance matrix shown in Figure 4.5. The top of the figure shows the conductance matrix and the corresponding network in which edges are labeled with conductances. The bottom of the figure shows a matrix-vector multiply and its network interpretation. The input vector denotes the voltages assigned to each node of the network. The individual terms in the matrix-vector multiply give the current flow from one node to another: for example, a12u2 = i12 = -1/2, which is the current flow from v1 to v2. The output vector gives the net current flow at each node. A negative net flow indicates flow into the node -- the node is a current sink. A positive net flow is flow out of the node -- the node is a current source. In the figure, node v1 is a sink, v4 is a source, and nodes v2 and v3 have no net current flow.
A
4 ­1 ­1 ­2
a)
­1 2 0 ­1
­1 0 2 ­1
­2 ­1 ­1 4
v1
1
v2
1
21
v3
1 v4
A
u
i
4 ­1 ­1 ­2 0
­3
b)
­1 2 0 ­1 1 / 2 = 0
­1 0 2 ­1 1 / 2
0
u1=0 i31 = 1/2
i21 = 1/2 i41 = 2
u2=1/2 i42 = 1/2
­2 ­1 ­1 4 1
3
u3=1/2 i43 = 1/2 u4=1
Figure 4.5: Matrix-vector multiplication maps voltages to currents. a) A conductance matrix and the corresponding network. b) A matrix-vector multiply, and the resulting interpretation in terms of current flow.
58 The nodes v2 and v3 which have no net current flow are particularly interesting to us. Consider node v2. As seen in the figure, v2 has current flowing both in and out of it; the inward flow exactly balances the outward flow, however. The reason that the inward and outward flows balance is that the voltage at v2 is the weighted average of the voltages at its neighbors. A function that satisfies the local averaging property is called harmonic [Doyle and Snell (1984)], and so we call nodes like v2 and v3 which have zero net current flow harmonic nodes. The concept of harmonic nodes are essential to the construction of support trees. All non-leaf nodes of support trees are harmonic nodes. Consider the process of constructing a support tree T for the coefficient matrix A (see §3.2). Suppose that, at some step in the process, a subgraph Gi is partitioned into components Gi0 and Gi1. Then, a support tree node is created with edges to each component, and each edge is weighted to support the total communication out of the connecting component. If the support tree node is harmonic, then its voltage is the weighted average of all the voltages in the tree, and it doesn't alter the net current flow through it. That is, the net communication between each subgraph and the rest of the graph is left unchanged. The specific communication effects are of course altered, but the overall communication with respect to each subgraph is unchanged. Therefore, a support tree effectively reduces the communication distance while accurately preserving global communication effects. Internal support tree nodes are made harmonic by the simple process of setting their net current flow to zero. To be more specific, let T be a support tree for an nxn Laplacian matrix A. Then, as explained in §3.3, there is an ordering of the nodes in T such that
T= DR Rt S
(4.12)
where D is an nxn diagonal matrix and corresponds to the nodes of A, S is square and corresponds to the internal nodes of the tree and their interconnections, and R and Rt correspond to the connections between nodes of A and internal nodes of T. Now, if r(i) = b - Ax(i) is the ith residual, then the usual preconditioned system that must be solved at the ith step is B z(i) = r(i) , where B is the preconditioner. The preconditioned system using support trees with har-
monic internal nodes is Tw = s(i) , where, for T in the block diagonal form above, s(i) = r(i) , and w = z(i) .
0
y
Augmenting the residual with zeros ensures that the internal nodes of the support tree are harmonic so that the tree only propagates local averages. The quantities in the vector y represent weighted average voltages for different subgraphs, and can be ignored for the purposes of computing the next step in the PCG algorithm. Recall from Chapter 3 that the leaves of the support tree correspond to nodes of the original mesh. By construction, a leaf of a support tree is grounded if and only if the corresponding mesh node is grounded. Since the coefficient matrix A is assumed to be non-singular, at least one node of A must be grounded; hence, at least one leaf node of T is grounded. By construction, T is Laplacian. Therefore, T is non-singular. It is interesting to note that, in Chapter 3, we came to the same result about how to augment the residual vectors by a completely different route, and also concluded that the values in vector y could be ignored.
4.4 Generalized Eigenvalues and Support Numbers To begin this section, recall from Chapter 2 that is an eigenvalue of a matrix A if there exists a vector x such that Ax = x. We denote the set of eigenvalues of A by (A). Further recall from Chapter 2 that is a generalized eigenvalue of the ordered pair of matrices (A,B) if there exists a vector x such that Ax = Bx. We denote the set of generalized eigenvalues of (A,B) by (A,B). Note that (A) = (A,I), where I is the identity matrix. There exist n generalized eigenvalues if and only if the matrix B is non-singular. If B is
59 singular, there may be fewer than n eigenvalues -- this is the case when Ax 0, but Bx = 0. In addition, there may be an infinite number of eigenvalues if A and B have a common null space -- that is, there exists x such that Ax = 0 = Bx [Golub and VanLoan (1989)]. When there exists a vector x and a unique such that Ax = Bx, we will call a finite generalized eigenvalue. In what follows, we will be concerned with only finite generalized eigenvalues. In application, the preconditioner B will be non-singular, and only finite generalized eigenvalues will exist. For simplicity of exposition, we make the following definition: 4.3 Definition: is a finite generalized eigenvalue of the ordered pair of matrices (A,B) if there exists a vector x such that Ax = Bx, and is unique. We denote the collection of finite generalized eigenvalues by (A,B). The primary tool that we will use for bounding finite generalized eigenvalues is the Support Lemma. This lemma appears in a slightly different form as Corollary 2.1 in Axelsson (1992). 4.4 Lemma (Support Lemma): Suppose that A and B are Laplacian matrices. If (A,B) is a finite generalized eigenvalue, and B-A is positive semi-definite, then . proof: First, assume that both A and B are non-singular and hence positive definite. Suppose the lemma is false and there exists (A,B) such that > . Let y be an eigenvector corresponding to . Then yt(B­A) y = 0 Now > , so there is an > 0 such that - = . This yields yt[B­A] y = yt[(­)B­A] y = yt(B­A) y ­ ytBy which must be less than zero, since the first term is zero and B is positive definite. This contradicts the assumption of B-A positive semi-definite. Therefore, we must have . Now, if either A or B is singular, we simply note that any y corresponding to (A,B), where is a finite generalized eigenvalue, may not lie in the null space of B. Hence the term ytBy above is always positive, and the result follows.
Based on the Support Lemma, we define the concept of support of one matrix for another. 4.5 Definition: The support, = (A,B), of matrix B for A is the greatest lower bound over all satisfying the Support Lemma. That is, = lim inf{: B-A is positive semi-definite}. Note that the support number of an ordered pair of matrices (A,B) is an upper bound on the largest finite generalized eigenvalue of (A,B). That is, if (A,B), then (A,B). Therefore, max(A) = max(A,I) (A,I). The concept of support has a physical meaning in terms of resistive networks. Consider the networks corresponding to matrices A and B. (A,B) is the gain factor that must be applied to B to guarantee that, for a given set of voltages, at least as much current flows in B as in A. This concept is made clearer in the next lemma.
60
4.6 Lemma: Let A be a Laplacian matrix corresponding to the graph G = (VG,EG), consisting of a single simple cycle on n nodes, with edge weights given by wjk. Let H = (VH,EH) be the graph corresponding to G, but missing edge e(i,j), and let B be the matrix corresponding to H. Then (A,B) , where
= wij (k, l) EH w---1--k--l + 1 In particular, if G is a unit weight graph (that is, wjk = 1, jk {1...n}), then (A,B) n. proof:
(4.13)
Assume without loss of generality that the cycle contain n nodes which are numbered in order around the cycle, and that the deleted edge is between nodes n and 1.
Let eij, i A
=
n i
­ =
1 1
wi,
i
+
1
ei,
i
+
1
eti,
i
+
1
+
w1,
ne1,
n
e1t ,
n
and
(4.14)
n­1
B =
wi, i + 1ei, i + 1eti, i + 1
i=1
We need to find such that B-A is positive semi-definite. By substituting (4.14) and (4.15) into B ­ A , then expanding and rearranging terms, we get
(4.15)
B ­ A
=
(

­
1
)
n i
­ =
1 1
wi,
i
+
1ei,
i
+
1eti,
i
+
1
­
w1,
n
e1,
ne1t ,
n
Now, it is easy to see that
(4.16)
e1,n = e1,2 + e2,3 + ... + en ­ 1,n Substituting (4.17) into (4.16) yields
(4.17)
B ­
A
=
(
­
n­ 1) i=
1 1
wi,
i
+
1ei,
i
+
1eti,
i
+
1
­
w1,
n­ n i=
1 1
n j
­ =
1 1
ei,
i
+
1et
j,
j
+
1
(4.18)
Setting
(­1)
=
w1,
n

(
k,
l)

H
----1----wk, l
, then expanding and rearranging terms:
B ­ A
=
w1,
n­ n i=
2 1j
n =
­ i
1 +
1
-w----i--,--i---+----1w j, j + 1
ei,
i
+
1 e t i,
i
+
1
­
ei,
i
+
1et
j,
j
+
1
­
e j,
j
+
1 e t i,
i
+
1
+
w-----j--,---j--+----1wi, i + 1
e
j,
j
+
1et
j,
j
+
1
(4.19)
But the innermost sums are easily recognized as outer products, so (4.19) reduces to:
61
n ­ 2 n ­ 1
B ­
A
=
w1,
n i
=
1

j
=
i
+
1

-w----i--,--i---+----1w j, j + 1
ei,
i
+
1
­
-w----j--,---j--+----1- e wi, i + 1
j,
j
+
1
-w----i--,--i---+----1w j, j + 1
ei,
i
+
1
­
w-----j--,---j--+----1- e wi, i + 1
j,
j
+
t
1

Each of the terms on the right hand side above is an outer product, and hence is positive semidefinite. Therefore, the entire right hand side is positive semi-definite and by Lemma 3.1 we have the desired result.
(4.20)
Finally, for a cycle with unit edges, substitute wij = 1, 1 i,j n into
(­1)
=
w1,
n

(k,
l)

H
----1----wk, l
and we get (-1) = n -1, or = n.

Physics texts and texts on circuit theory generally discuss the rules that are used to reduce circuit complexity by combining multiple circuit elements into a single element. It is useful at this point to review some of these rules. In particular, the two rules which we shall employ deal with resistive (conductive) elements of the same type connected either in parallel or in series. When two resistors of resistances r1 and r2 are connected in series, they may be replaced by a single resistor of resistance r, where
r = r1 + r2
(4.21)
This law can be phrased in terms of conductors. Using the fact that conductance is the reciprocal of resistance, we have that two conductors of conductances c1 and c2 connected in series may be replace by a single conductor of conductance c, where
1-- = --1-- + --1-c c1 c2
(4.22)
When resistors are connected in parallel, then the formulas above hold with the roles of resistance and conductance reversed. That is, two resistors of resistances r1 and r2 in parallel can be combined into a single resistor of resistance r, where
1-- = --1-- + --1-r r1 r2
(4.23)
And two conductors of conductances c1 and c2 connected in parallel can be combined into a single conductor of conductance c, where
c = c1 + c2 Figure 4.6 illustrates the rules for circuit reduction.
(4.24)
Since we have demonstrated that Laplacian matrices and resistive networks are isomorphic, it should come as no surprise that there exist matrix operations which correspond to the rules for circuit reduction. The rule for combining parallel conductors corresponds to matrix addition, and yields the important property of linearity for the networks that we are dealing with. If A = A1 + A2, then for every vector x, Ax = A1x + A2x. Similarly, if we have two networks defined over the same set of nodes, and with corresponding matrices B1 and B2, then we can short together corresponding nodes of the two networks to form a combined network with matrix B = B1 + B2. An example is shown in Figure 4.7.
62
a)
r1 c1 = 1/r1
r2 c2 = 1/r2
=
r = r1 + r2
1/c = 1/c1 + 1/c2
r1
b)
c1 = 1/r1
= 1/r = 1/r1 + 1/r2
r2
c = c1 + c2
c2 = 1/r2
Figure 4.6: Rules for circuit reduction. a) resistors/conductors in series b) resistors/conductors in parallel
1
1
1
+
1
1 1= 1 1
1 1
1
1
=1
1 21 1
3 ­1 ­1 ­1
1 0 0 ­1
4 ­1 ­1 (­ 1 ­ 1)
4 ­1 ­1 ­2
­1 1 0 0 + ­1 0 1 0
0 1 0 ­1 0 0 1 ­1 =
­1 2 0 ­1 ­1 0 2 ­1
­1 2 0 ­1 = ­1 0 2 ­1
­1 0 0 1
­1 ­1 ­1 3
(­ 1 ­ 1) ­1 ­1 4
­2 ­1 ­1 4
Figure 4.7: The linearity of resistive networks. The top of the figure illustrates combining resistive networks to form a single network. The bottom figure illustrates the operation with the matrices corresponding to the networks.
The rule for combining conductors in series corresponds to a single step of Gaussian elimination in which only a sin- gle row/column (a single node) is reduced. Consider the example in Figure 4.8, where we have replaced the series rule for conductors by the equivalent c = c1c2 / (c1 + c2) . and ordered the nodes for convenient elimination. In Figure 4.8a, a simple path on 3 points is illustrated, along with its corresponding Laplacian matrix. To eliminate v1, the central node, the off-diagonals in row and column 1 of the Laplacian must be eliminated. Elimination of A(2,1) and A(1,2) is performed by adding 1 times row1 to row2, and 1 times column 1 to column 2, where 1 = c1 / (c1 + c2) . This adds fill of ­c1c2 / (c1 + c2) to entries A(2,3) and A(3,2), and subtracts c12 / (c1 + c2) from entry A(2,2), yielding A1(2,2) = c1c2 / (c1 + c2) . A similar analysis shows that the second step of Gaussian elimination changes only A1(3,3), yielding A2(3,3) = c1c2 / (c1 + c2) . From Figure 4.8c, the 2x2 block at the lower right of A2 is easily recognized as the Laplacian matrix corresponding to a network with two nodes and a single connecting edge of conductance c1c2 / (c1 + c2) .
Gaussian elimination also explains the more general star-delta transformation of circuit theory [Bollabas (1979)]. In fact, the reduction of conductors in series is simply the star-delta transformation with only two input conductors. Figure 4.9 illustrates the star-delta transformation with three input conductors; the configurations of the input and output networks for this case are the star and delta for which the transformation was named.
Figure 4.9 suggests a formula for determining the conductance of any wire obtained through star-delta transformation. Let v0 be the central node with neighbors v1,...,vn in a star configuration. Let ci be the conductance of the wire connecting v0 to vi. Reduction of v0 will connect all the other nodes. Examination of the figure suggests that cij, the
63
c1 + c2 ­c1 ­c2
v2
v1
v3
a)
­c1 c1 0
c1
c2
­c2 0 c2
c1 + c2 0
­c2
b)
1 0 0 c1 + c2 ­c1 ­c2 1 ­c1 0 ­c1 1 0 ­c1 c1 0 0 1 0 =
0 ----c--1---c---2---- ­----c--1---c---2---c1 + c2 c1 + c2
0 0 1 ­c2 0 c2 0 0 1
­c2
­----c--1---c---2---c1 + c2
c2
c1 + c2 0
­c2
c1 + c2 0
0
c)
1 00 0 10
0
----c--1---c---2---- ­----c--1---c---2---c1 + c2 c1 + c2
1 0 ­c2 01 0
=
0
----c--1---c---2---c1 + c2
­----c--1---c---2---c1 + c2
­c2 0 1
­c2
­----c--1---c---2---c1 + c2
c2
00 1
0 ­----c--1---c---2---- ----c--1---c---2---c1 + c2 c1 + c2
----c--1---c---2---- ­----c--1---c---2----
d)
c1 + c2 c1 + c2
­----c--1---c---2---- ----c--1---c---2---c1 + c2 c1 + c2
v1
v2
----c--1---c---2---c1 + c2
Figure 4.8: Gaussian elimination and circuit reduction. a) Laplacian matrix corresponding to the path on three points shown b) First step in reducing graph/matrix from a c) Second step in reducing graph/matrix from a d) Laplacian matrix corresponding to the path on two points shown.
conductance of the wire connecting vi to vj, is given by
cij
=
-c--i------c---j ck
k
(4.25)
That is, the conductance of the wire connecting vi to vj upon reduction of v0 is given by the product of the conductances of the wires from v0 to vi and vj, divided by the sum of the conductances of all the wires connecting to v0. This formula is easily proved by performing Gaussian elimination on v0. This formula is useful because it allows us to easily determine conductances resulting from circuit reduction.
Resistive networks and linearity provide a clear physical intuition for Lemma 4.6 above. Consider supporting a cycle on n nodes with edges of unit weight by a simple path on n nodes, also with edges of unit weight. Figure 4.10 illus- trates the example. The cycle contains two paths from node v1 to node vn: a path of length 1 and conductance 1, and a path of length n-1 and conductance 1/(n-1). The total conductance in the cycle from v1 to vn is therefore 1 + 1 / (n ­ 1) = n / (n ­ 1) . The total conductance in the path from v1 to vn is 1/(n-1). Therefore, for the path to
64
support the cycle, the conductance of the path must be increased by a factor of n. This multiplication factor corresponds to the support number.
c2 + c3 + c4 ­c2 ­c3 ­c4
­c2
c2 0 0
a)
­c3
0 c3 0
­c4
0 0 c4
v2
c2
v1
c4
c3
v4
v3
v2
c2 + c3 + c4
0
0
0
0
-c---2--c---3----+-----c---2---c---4- ­---------c---2---c---3---------- ­---------c---2---c---4---------c2 + c3 + c4 c2 + c3 + c4 c2 + c3 + c4
---------c---2---c---4---------c2 + c3 + c4
b)
0
­---------c---2---c---3---------- -c---2--c---3----+-----c---3---c---4- ­---------c---3---c---4----------
c2 + c3 + c4 c2 + c3 + c4 c2 + c3 + c4
---------c---2---c---3---------c2 + c3 + c4
0
­---------c---2---c---4---------- ­---------c---3---c---4---------c2 + c3 + c4 c2 + c3 + c4
-c---2--c---4----+-----c---3---c---4c2 + c3 + c4
v4
---------c---3---c---4---------- v3
c2 + c3 + c4
Figure 4.9: Gaussian elimination and the star-delta transformation. a) Laplacian matrix and corresponding graph b) Matrix after Gaussian elimination of row/column 1, and corresponding graph.
v2 a) v1
vn-1
c2 = 1/(n-1)
vn
v1 c1 = 1 vn
c = n/(n-1)
v1
vn
v2
vn-1
c = 1/(n-1)
c = 1/(n-1)
b)
v1
vn
v1
vn
v1
vn
Figure 4.10: Support numbers and conductances. a) In a simple cycle, the effective conductance from v1 to vn is n/(n-1) b) In a simple path, the effective conductance from v1 to vn is 1/(n-1) For the path to support the cycle, its conductance must be increased by a factor of n. This gain factor is equivalent to the support number.
65 We can compute the support number of any ordered pair of matrices (A,B), where A and B are Laplacian matrices, by applying the physical intuition above. Consider breaking up A into pieces A1+A2+...+Am in such a way that the pieces are particularly simple in structure. Next we break up B into corresponding pieces B1,...,Bm, splitting conductors if necessary, so that Bi supports Ai. The following lemma shows how to analyze the support numbers of the pieces to determine the overall support number. 4.7 Lemma: Let A and B be Laplacian matrices corresponding to resistive networks G and H such that H is a subnetwork of G. Let {G1, G2,..., Gm} be any partitioning of G such that G = Gi, and let {A1, A2,...,Am} be the matrices corresponding to the Gi. Let {H1, H2,..., Hm} be a corresponding partitioning of H, with associated matrices {B1,B2,...,Bm}. Then (A,B) max{(Ai,Bi)}. proof: We want to find the minimum such that (B-A) is positive semi-definite. Equivalently, this means finding the minimum such that for any vector x 0, we have the following inequalities: xt(B­A)x 0 xt((B1 + ... + Bm)­(A1 + ... + Am))x 0 xt(B1­A1)x + ... + xt(Bm­Am)x 0 Clearly, if we can find any such that xt(Bi ­ Ai) x 0 for all x and i, then xt(B ­ A) x 0 for all x, and so (A, B) . Therefore, (A,B) max{(Ai,Bi): i = 1,...,m}.
The lemmas and examples of this section provide some physical intuition for the concept of support. The key in bounding max(A,B) is to determine a such that B-A is positive semi-definite. The method which we have elaborated shows that may be considered to be the minimum number of copies of B that are necessary to replace each conductor (edge) of A by a path of conductors in B. We determine the number of copies needed by partitioning B so that every edge of A is supported by the edges in a single partition of B (although several edges of A may be supported by a single partition of B), and finding the partition with the greatest support requirement. To see how to apply this general combinatorial procedure for bounding generalized eigenvalues, consider bounding the maximum finite generalized eigenvalue max(A,B) for the matrices/networks shown in Figure 4.11. The network B can be partitioned into three pieces as shown, one supporting the edges of A in common with B, and one each for the edges of A not in B. In the first partition, each edge of B1 supports the corresponding edge of A1. The minimum support is for the diagonal edge: the wire with conductance 1/3 must be multiplied by a gain factor of 6 in order to support the corresponding wire of conductance 2. Hence, (A1,B1) 6. In each of the next two partitions, a single wire of conductance 1 must be supported by a path of length 2 with conductances of 1/3 and 1/2. The total conductance of the path is 1/5, so a gain factor of 5 is required for the path to support the edge. For each partition i, (Ai,Bi) 6, so by the lemma above, (A,B) 6. By the Support Lemma, max(A,B) (A,B) 6. In fact, using Matlab [Mathworks, Inc. (1992)], we obtained max(A,B) = 4.7321. It is useful to assign some terminology to associate with our combinatorial procedure for bounding generalized eigenvalues. Let the edges in B be called support edges. Then the edges in A are supported edges. For each partition i, we can compute the total conductance of the edges in Ai that are supported, at least in part, by e Bi. For edge e, we call the ratio of total supported conductance to support conductance the congestion of e in partition i of the support mapping, and denote it by e(A,B). Similarly, if f is an edge in A, then f is supported by a path in B; that is, the current flowing through f is routed via some path in B. We call the length of the support path the dilation of f in the support
66
1 4 ­1 ­1 ­2
1 3 ­1 ­1 ­1
A = ­1 2 0 ­1 = 1
21
B = ­1 1 0 0 = 1
1
­1 0 2 ­1
­1 0 1 0
­2 ­1 ­1 4 1
­1 0 0 1
max(A,B) (A,B) = ?
1
A1 = 1
2
1/2
A2 = 1
A3 =
1 1/2
B1 = 1/2
1/3
B2 = 1/2
1/3
B3 =
1/3
(A1,B1) 6
(A2,B2) 5
(A3,B3) 5
4.7321 = max(A,B) (A,B) maxi{(Ai,Bi)} = 6 Figure 4.11: Partitioning matrices/networks for eigenvalue analysis. At the top of the figure, networks A and B are illustrated. An upper bound on max(A,B) is obtained by partitioning A and B and determining the support number of the partitions.
mapping, and denote it by f(A,B). Note that congestion and dilation as used here are generalizations of the notions of congestion and dilation of graph embeddings (see the review in Chapter 2). For any support mapping of (A,B), the support number is bounded above by the maximum product of dilation and congestion, where dilation is determined for each edge in A, and congestion is determined over all the edges in B supporting the given edge in A. That is,
( A, B) max{ f ( A, B) e( A, B): f E Ai, e EBi e supports f } .
(4.26)
For example, consider again the two networks in Figure 4.11. The dilation for each of the edges of A1 is 1, since each edge is supported by a single edge of B1. The congestion for the horizontal edge of B1 is 2, as is the congestion for the vertical edge. The congestion for the diagonal edge of B1 is 6. The maximum product of congestion times dilation in partition 1 is therefore max{2 1, 2 1, 6 1} = 6 . Similarly, the dilations for the edges in A2 and A3 are both 2, since both edges are routed over paths of length 2. The maximum congestion along either support path is 3, so the support numbers for partitions 2 and 3 are both 6. The support number obtained using the maximum product of congestion times dilation is 6, as was obtained when path conductances were computed, but the bounds for partitions 2 and 3 were not as tight. The congestion times dilation approach is, in general, simpler, but not as accurate as computing exact path conductances.
4.5 Condition Number Bounds for Support Trees: Preliminary Lemmas
The PCG method for coefficient matrix A and preconditioner B is known to have a convergence rate of O( (B­1 A)) , where the condition number of B-1A, (B-1A), is given by (B­1 A) = max(B­1 A) / min(B­1 A)
67
(see Theorem 2.12 and the discussion of PCG in §2.4.2.3).
If (B­1 A) , then B­1 A x = x for some vector x. By multiplying both sides by B, this implies that Ax = Bx . That is, is a finite generalized eigenvalue of the ordered pair of matrices (A,B). Hence, bounding the condition number of a preconditioned system involves bounding generalized eigenvalues. The lemma below shows how to use the technology developed in the previous subsection to bound the condition number of a preconditioned system, which we will refer to as the generalized condition number.
4.8 Lemma: Let A and B be non-singular Laplacian matrices, and suppose that B is a preconditioner for A. Then, (B­1 A) ( A, B) (B, A)
proof:
(B­1 A) = max(B­1 A) / min(B­1 A) = max( A, B) / min( A, B) = max( A, B) max(B, A) ( A, B) (B, A)
In Chapter 3, we addressed the problem of using a support tree matrix T as a preconditioner for a matrix A. The difficulty for application purposes was the difference in size between T and A. We proved that Gaussian elimination could be applied to the problem to yield an equivalent preconditioner K for A that was the same size as A. However, we did not use K, but rather showed how to use the more computationally efficient T by adding and then deleting variables. We now need to show how to analyze the condition number that results from preconditioning A with T, which means that once again we have to find a way to deal with the difference in sizes.
4.9 Lemma: Let A and B be Laplacian matrices. Let G be a matrix representing 1 or more reduction steps of Gaussian elimination. Then (A,B) = (GAGt,GBGt).
proof:
Let (A,B), and x a corresponding generalized eigenvector. Then
Ax = Bx
G Ax = G Bx
GAx = GBx Furthermore, G is non-singular, so there exists y such that Gty = x. Making this substitution yields
So (GAGt, GBGt) .
GAGt y = GBGt y
Since G is non-singular, we can perform the same sequence of operations in reverse for any
68
(GAGt, GBGt) to show that (A,B), which proves the lemma.
Lemma 4.9 allows us to apply Gaussian elimination in our analysis without fear of changing the generalized eigenvalues. From a physical standpoint, this was expected -- since Gaussian elimination is equivalent to circuit reduction, it is natural to reduce the complexity of circuits before attempting to analyze them. However, we still haven't dealt explicitly with the fact that the coefficient matrix and the support tree matrix are different in size. The following lemma is useful for this.
4.10 Lemma: Let A be an nxn non-singular Laplacian matrix, and let T be the mxm matrix of a support tree for A, ordered consistently with A. Let A~ be the mxm matrix which contains A in the first diagonal nxn block, and is zero elsewhere. Let T~ be obtained from T by Gaussian elimination of the internal nodes of the support tree with diagonal blocks K and Sd, where K is nxn and corresponds to the nodes of A. Then, i ( A~ , T ) = ( A~ , T~ ) ii = 0 is in ( A~ , T ) with multiplicity m-n iii { ( A~ , T ): 0} = ( A, K )
proof:
We assume that the nodes of A, which are the leaves of T, are ordered v1,...,vn, so that any node vj with j > n is an internal node of the support tree.
To prove i), let G be the matrix that implements Gaussian elimination of the internal nodes of T. Gaussian elimination of the internal nodes adds multiples of the rows and columns n+1 through m to other rows and columns. Since rows/columns n+1 through m are identically zero in A~ , we have
And, by Lemma 4.9,
G A~ Gt = G A 0 Gt = A 0 = A~
00
00
( A~ , T ) = (G A~ Gt, GT Gt) = ( A~ , T~ )
To prove ii), let yi be the (m-n)-vector that has a 1 in position i and is zero elsewhere. Let zi be the m-vector given by zi = [0t, yit]t ; zi has a 1 in position n+i, and is zero elsewhere. Then, for
i {1, ..., m ­ n} , A~ zi =
A0 00
0 yit
= 0, and T zi = 0, so ( A~ , T ) with multiplicity
m-n.
To prove iii), we have from i) and ii) that = 0 is a generalized eigenvalue of (A~ , T~ ) with mul-
tiplicity Since A~
m-n. Furthermore, as is symmetric and T~ is
in ii), the m-vectors zi are eigenvectors corresponding to = 0. symmetric and non-singular, there are m orthogonal generalized
eigenvectors of (A~ , T~ tors, so the remaining
). n
The vectors zi comprise must have the form v =
m-n [ xt,
of the orthogonal generalized 0t]t , with A~ v = T~ v for some
eigenvec (A~ ,
T~ ). But then we have
69
A~ v = A 0 x = Ax
00 0
0
and
T~ v = K 0 x = Kx
0 Sd 0
0
Therefore, we must have Ax = Kx, so (A, K).

4.11 Corollary: Let A be a non-singular Laplacian and T the matrix of a support tree constructed for A. Let A~ , T~ , and K be as defined in Lemma 4.10. Then (K ­1 A) = ( A~ , T ) (K, A) . proof: From Lemma 4.8, (K ­1 A) ( A, K ) (K, A) . From Lemma 4.10, max(A,K) = max(A~ , T~ ) = max(A~ ,T), so (A,K) = (A~ ,T) Lemma 4.10 and Corollary 4.11 accurately reflect our physical intuition that equivalent circuits should have equivalent effects. That is, the tree and the reduced tree have equivalent effects on the original network. We can now use the network obtained from the support tree by circuit reduction operations to analyze the effects of the support tree.
4.6 Condition Numbers for Regular Meshes
In this section, we prove condition number bounds for regular meshes in d-dimensions. The meshes are assumed to be d-dimensional cubes with n nodes on a side, where n = 2k. Each mesh can be embedded in the unit d-dimensional cube with nodes located at all points given by (i1, i2,...,id), where = 1/(n-1). Each node v is connected to all other nodes w for which the distance between v and w is equal to . Thus, for d=1, we have a unit weight path, for d=2 a square mesh, for d=3 a cubic mesh, and so on. We further assume that all edges have unit weight. The proof techniques demonstrated in these sections hold for regular meshes with non-unit weights, as long as the difference between maximum and minimum edge weights is bounded by a constant.
We assume that all support trees are constructed using recursive coordinate partitioning. Therefore, at each step, the current subgraph is partitioned into 2d pieces by coordinate bisection with respect to each coordinate axis. Since n = 2k, the support trees are all regular 2d-ary trees of uniform depth log2n. All edges are weighted by the total weight of the edges on the boundary of the induced subgraph.
To simplify the presentation, we will cease to distinguish between a matrix and its corresponding graph. Therefore,
the coefficient matrix pwohret rter.eeT~ Tw=il(lVdTe,EnTo)t.e
A A~
will will
correspond to the mesh A = (VA,EA). The denote the mxm matrix which contains A
support tree matrix in the first diagonal
T will correspond to a nxn block, and is zero
supelse-
the matrix obtained from T by Gaussian elimination of the internal nodes of the support tree
with diagonal blocks K and Sd, where K is nxn and corresponds to the nodes of A. We will refer to K as the reduced tree.
The basic proof technique demonstrated here is straightforward and based directly on the results from the previous section. We have, from Lemmas 4.9 and 4.10, that the effect of the tree on the mesh is the same as the effect of the reduced tree K on the mesh. Furthermore, from Corollary 4.11, (K ­1 A) = ( A~ , T ) (K, A) . Therefore, we will prove a bound on the condition number by first embedding the mesh in the tree and determining (A~ ,T) then embedding the reduced tree in the mesh and determining (K,A).
70 In the proofs which follow, we only consider the support of edges between nodes of the mesh, and do not examine the support of the ground connections. Recall, however, that by construction, the support tree leaves have the same ground connections as the mesh. Therefore, the support of the ground connections is unity. 4.6.1 Regular meshes in 1D In this section, we assume that the mesh corresponding to the coefficient matrix A is a path on n points with unit weight edges. A might be the matrix from a finite difference discretization of the Dirichlet problem in the unit interval, for example. For this example, we obtain (K-1A~ ) = O(nlog n) . While this is a simple example, it will serve to illustrate the flavor of the proofs to follow. Figure 4.12 illustrates the mesh and tree for n = 8.
v1
v2
v3
v4
v5
v6
v7
v8
Figure 4.12: Support tree for a 1D mesh. The 1D mesh is at the bottom of the figure -- a simple path on 8 points with unit edges. The support tree with unit edges is illustrated above the mesh. The leaves of the tree correspond to the nodes of the mesh.
In Chapter 3, we constructed support trees with edges weighted by the size of the frontier of the induced subgraph. In this section, such a support tree would have most of the edges of weight 2, instead of 1. This difference does not affect the asymptotic size of the condition number and simply complicates the analysis. We are setting up the following methodology. First, to compute (A~ ,T), we route all the wires of A along paths in T. This is fairly easy to do because of the way T is constructed. Next, to compute (T,A~ ), we need to reduce T to K, and route all the wires of K through A and find the maximum support number; this gives us (K,A), which, by Lemma 4.10, is an upper bound on max(T, A~ ). To do this, we need an upper bound on the conductance values of the wires in K, which requires some analysis of the circuit reduction procedure.
Recall from §4.4 that, for graphs A and B of compatible sizes, and given a mapping of A into B, e(A,B) denotes the congestion of edge e VB, and f(A,B) denotes the dilation of edge f VA. We further define (A,B) = max{e(A,B) : e VB}, and (A,B) = max{f(A,B) : f VA}. From section 4.4 we have that ( A, B) = max{ e( A, B) f ( A, B)} ( A, B) ( A, B) 4.12 Lemma: Let A be the Laplacian matrix of a 1d mesh with n vertices, and let T be the Laplacian matrix of the support tree with unit edges constructed for the mesh. Then (A~ ,T) = O(logn).
proof:
Let the
oVn=ly{evd1g,.e..s,vonf}A~beartheeedngoedsesofofAA, w, aenodnalyssnuemeed
that they are ordered to map A into T.
from
left
to
right.
Since
71 Any edge in T must support at most two edges of A. To see this, consider any node vt of T. vt implicitly defines a subgraph of A consisting of all the leaf nodes that have vt as an ancestor; call this subgraph At. At has at most two boundary edges, so the edge from vt to its parent must support at most two edges (since edges internal to At do not have to be mapped through the ancestor to vt). But, the edges of T are weighted by the number of boundary edges in the induced subgraphs of A. Therefore, we can partition each edge in T into pieces of unit weight, each of which supports exactly one edge of A. Hence, the maximum congestion in T is 1, so (A,T) = 1. The maximum dilation for any edge in A clearly comes from the edge that must be mapped through the root of T. The length of this path is 2log2n, so (A,T) = 2log2n. Therefore, ( A~ , T ) ( A~ , T ) ( A~ , T ) = 1 2log2n = O(logn) .
In order to bound (T,A~ ), we will compute (K,A). To simplify this computation, we will consider sets of edges of K that all have the same conductance. We will then partition A so that each set of edges is supported by a separate partition. From Lemma 4.7, the maximum support number over all the partitions is an upper bound on (K,A). 4.13 Lemma: Let T be a balanced binary tree with unit weight edges, n leaves, and height log2n. Let K be the reduction of T to its leaves. Then the edges of K can be classified into log2n sets such that all the edges in a set have the same conductance. proof: Since circuit reduction is equivalent to Gaussian elimination, the order in which nodes are reduced does not affect the final conductances. Consider reducing the tree from the root to the leaves one level at a time. Each reduction combines all pairs of input edges and creates a single edge for each pair. The output conductance is given by the product of the input conductances divided by the sum of the input conductances. Since we are reducing from the root down, every node has two edges of conductance 1, so the total conductance at an internal node is at least 2. Therefore, since all conductances are less than or equal to 1, the output conductance of a wire can be no greater than 1/2 times the smallest of the two input conductances. We can state this observation another way. Let l1 and l2 be two leaves of the tree. Then, after reduction of all the internal nodes of the tree, the conductance between l1 and l2 will be bounded above by 1/2m, where m is the number of internal nodes on the path joining l1 to l2 in the original tree. The root of the tree T divides the original graph A into two subgraphs A0 and A1. The conductances in K between nodes of A0 and A1 will all be the same, since T is perfectly balanced. Moreover, the conductances will be bounded above by 1/22h-1, where h is the height of T. Now, consider all the internal nodes vl1,...,vlm at level l of T, where the root is at level 0, and m = 2l. Each vlk defines a subtree containing two disjoint subgraphs. As above, the conductances in K of all the wires between nodes in different subgraphs will be the same, and these conductances will be bounded above by 1/22(h-l)-1. Therefore, each set of internal nodes of the same height define a set of edges in K that all have the same conductances. There are log2n different heights, and the conductances are a function of the height of the subtrees.
72
4.14 Lemma: Let A and T be as defined above. Then (T,A~ ) = O(n)1. proof: We reduce T to K and compute (K,A). By Lemma 4.10, (T,A~ ) = (K,A). Let h = log2n. Let the root of T be at level 0, and the leaves at level h. Using the results of the previous lemma, we partition K into subgraphs such that each subgraph contains edges of roughly the same conductance. The edge weights in T are all either 1 or 2. By assuming all edge weights are 2, we increase the total conductance of T, and make T harder to support. We therefore assume that all the edges in T are of weight 2; by computing the support number with uniform edge weights, we obtain an upper bound on the actual support number. Let Ki, i = 1,...,h denote the subgraph made up of edges that cross subtree roots at level i; the edges of Ki have conductances bounded above by 2/22(h-i)-1. We must therefore partition A similarly. Let A0, A1,...,Ah be partitions of A constructed by splitting the edges of A such that all the edges of Ai, i > 0, have weight 1/2i. That is, Ai = 1 / 2i A. A0 contains the remaining conductance and will not be used further. Figure 4.13 illustrates the partitioning of K for the mesh and tree of Figure 4.12.
The mapping of Ki into Ai is the obvious one. Embed Ai in a line so that the nodes are ordered linearly from left to right. Embed Ki with the same ordering. Then an edge of Ki is mapped along the simple path in Ai that joins its endpoints. Consider supporting the edges of Ki by the edges of Ai. There are n / 2i nodes in each subgraph with a common ancestor at level i in T. (Equivalently, every internal node of T at level i is the root of a subtree with n / 2i leaves and defines a subgraph of Ki with n / 2i nodes.) There is one edge between every node in one subgraph to every node in the opposite subgraph of a pair; since n = 2h , the total edge count per pair is
n2 / 22i = 22(h ­ i)
(4.27)
A single edge of Ai only supports those edges of Ki which connect nodes that have a common ancestor at level i in the tree. Therefore,
(K i, Ai) = 22(h ­ i)
(4.28)
Ai is simply a linear path. So, by the construction of T, the edges of Ki have a dilation that is one less than the number of nodes in a connected subgraph. Therefore,
(Ki, Ai) = 2(n / 2i) = 2h ­ i + 1
(4.29)
Now, ( A, B) = ( A, B) ( A, B) when the edges of A and B are of unit conductance. In our case we must multiply the right hand side by the maximum conductance of the edges in A to determine the maximum conductance that must be supported by B. Similarly, the left hand side must therefore be multiplied by the minimum conductance in B. Therefore, the formula for the case of non-unit conductances is
1. In reading a preliminary version of this work, Dr. John Rief of Duke University found an error in the calculations and reduced the asymptotic bound to O(n) instead of O(nlogn).
73
a)
v1
v2
v3
v4
v5
v6
v7
v8
b)
c)
Figure 4.13: Partitioning of the reduced support tree. a) Mesh and support tree. The subtrees rooted at level 1 induce subgraphs of the mesh. b) Gaussian elimination of the subtrees yield complete graphs on the leaves. c) K1 consists of only the edges between nodes on opposite sides of the subtree root.
( A, B) = ----(--A----,---B----)-------k---(m---A-i--n-,--(-B-B---)-)-----k---m----a---x--(---A-----) Applying (4.30) for A = Ki and B = Ai , we obtain
(4.30)
(Ki, Ai)
=
-2---2---(--h--­---i--)------2---h----­---i---+----1-------2---­--2---(--h---­--i--)---+----21 / 2i
=
2h + 2
(4.31)
This expression on the right of (4.31) is independent of i, so all the partitions have the same support. Therefore,
(K, A) = 2h + 2 = 4n = O(n)
(4.32)
We now have a complete bound on the condition number.
74 4.15 Theorem: For A and T as defined, (T ­1 A~ ) = O(nlogn) . proof: From Lemma 4.12, we have (A~ ,T) = O(logn). From Lemma 4.14, we have (T,A~ ) = O(n). Applying Lemma 4.8 yields the result.
4.6.2 Regular meshes in d dimensions (d>1)
Let A correspond to a cube in d dimensions, with n=2h nodes on a side. Then A contains N = nd = 2dh total nodes.
Assume that the edges of A have unit weight. The tree T is constructed by recursive coordinate bisection, and each
edge of T is weighted by the number of edges in the frontier of the subgraph of A induced by the edge (see §3.2). T is
h = log2n in will show in
height, and each this section that
internal node the condition
has 2d children. The number obtained by
root of T is at level 0, and the leaves using T as a preconditioner for A is
are at level h. O(d2nlog n)
We
First, we show that (A~ ,T), the support of T for A~ , is O(logn).
4.16 Lemma: Let A and T be as defined above. Then (A~ ,T) = O(logn).
proof:
Any edge in T must support all the boundary edges of the induced subgraph of A. The edges of T are weighted by the number of boundary edges in the induced subgraphs of A. Therefore, we can partition each edge in T into pieces of unit weight, each of which supports exactly one edge of A. Hence, the maximum congestion in T is 1, so (A,T) = 1.
The maximum dilation for any edge in A clearly comes from an edge that must be mapped through the root of T. The length of this path is 2log2n, so (A,T) = 2log2n. Therefore, ( A~ , T ) ( A~ , T ) ( A~ , T ) = 1 2log2n = O(logn) .
Let K be the complete graph formed by reducing the internal nodes of T. Next we show that (K,A), the support of A for the reduced tree K, is O(n). As in the case for d=1, we compute (K,A) by mapping sets of edges of K into uniform partitions of A. The sets of edges of K are all those with subtree roots at the same level, and define subgraphs K0,...,Kh. Ki is the subgraph of K that contains only the edges between nodes in different components resulting from the ith partitioning step. Hence, if e is an edge in Ki connecting nodes u and v, then in T the highest internal node on the only path between u and v is at level i. Ki consists of 2di components, each of which is a 2d-partite graph. To compute the support number, it is necessary to have an upper bound on the conductance of edges in Ki. Let v be an internal node of T at level i. Then v has 2d children, but not all the children have the same boundary size, so the connecting edges have different weights. By assuming each edge has the weight of the maximum edge at level i, all the edges in Ki will have the same upper bound. Moreover, the conductance of K will only increase, making K harder to support. Therefore, the support number resulting from this assumption will be an upper bound on the true support number. We formalize this approach and determine the support number in the lemma below.
75
4.17 Lemma: Let A, T, and K be as defined above. Then (K, A) = O(d2n) .
proof: We prove this by performing conductance experiments. Let the subgraphs Ki be as defined above. We will show a support mapping such that the support for each Ki is independent of i. Consider a subtree of T rooted at node u at level i-1. Then, u has 2d children. Each of the children of u is a node at level i. Each node at level i defines an induced subgraph of A, which is a cube characterized by the following parameters: · the length of an edge is
· the size of a face is
ei = n / 2i
(4.33)
fi
=
eid ­ 1 =
(n
/
2i
d )
­
1
· the size of the boundary is
(4.34)
i 2d f i
=
2d(n
/
2i
d )
­
1
· the number of nodes in the subgraph is
(4.35)
ni
=
eid
=
(n
/
2i
d )
· since the tree is boundary weighted, each edge between u and a child of u has weight 2d f i , since this is the maximum size of the frontier of any subgraph of A induced by a subtree of T rooted at level i.
(4.36)
Now we perform our electrical experiment. Apply the same voltage to every leaf node of every subtree rooted at a child of u, and let the other nodes in the tree be harmonic. Then the edges of each subtree can be combined from leaves to root so that the net effect of applying the same voltage to the leaves can be summed up as applying that voltage to a single conductor connected to u.
Figure 4.14 illustrates the electrical experiment for a binary tree. Leaf nodes l1 and l2 have a common parent v1 and are each connected to v1 by an edge of weight v. If the voltage applied to l1 and l2 is identical, then the effect is the same as if v1 were connected to a single node l12 of the same voltage with a conductor of conductance 2. v1 is connected to its parent w1 by an edge with conductance w. We now reduce v so that l12 is connected to w1 by a single edge of conductance w = ----w-w----+----2-2------v-v , in accordance with the circuit reduction rules discussed in §4.4.
The edge weights in T reduce geometrically, so in the electrical experiment above, each subtree rooted at level i reduces to a single node connected to u by a conductor with conductance bounded above by 4d f i . (Doyle and Snell (1984) use this procedure to show that an infinite binary tree of unit resistors has a total root-to-leaf resistance of 1/2, or a total conductance of 2.)
76
w1 w v1
v
v
w
v2
v
v
combine
w1 w v1 2v
reduce w v2 2v
w1 w' l12
w' l34
l1
l2
l3
l4
l12
l34
Figure 4.14: Reduction of a tree when leaves have the same voltage. A tree can be recursively reduced to a single edge when all leaves have the same voltage.
Thus, u effectively has 2d children, each connected to u by a conductor of conductance gu 4d f i . We are now interested in the effective conductance between each of these children of u. An upper bound on this conductance can be obtained by reducing u, while ignoring the connection between u and its parent (this connection can only decrease the effective conductance). Let gi denote this upper bound, then gi can be computed as in (4.37), below.
gi = 4----2d---d-f---i---4---4d---d--f--i-f--i = -4---2d---d-f---i
(4.37)
Now, each edge of conductance g represents the total conductance in all the edges in the bipar-
tite subgraph of Ki that joins all the leaf nodes in two level i-1 in T. Each such bipartite subgraph contains
of ni2
the subtrees rooted at children of u at identical edges. Each of these edges
has conductance ki given by (4.38).
ki
=
-4---2d---d-f---i / ni2
=
4----d----f---i 2d ni2
Therefore, ki is an upper bound on the conductance of every edge in Ki.
(4.38)
Now we need to look at supporting each edge of Ki by a path in A. Let A0,...,Ah-1 be partitions of A obtained by dividing each edge of A into h=log2n pieces, with the pieces in Ai each conductance 1/2i. We embed Ki in Ai as follows. Let (u,w) be an edge of Ki, where u and w are nodes of the mesh with coordinates (u1,...,ud) and (w1,...,wd) respectively. We map (u,w) to a path in Ai by reducing the difference in each dimension in order. That is, we map (u,w) first to v1 = (w1,u2,...,ud), then v2 = (w1,w2,u3,...,ud) and so on. This is not an optimal mapping, in that the boundary edges that cross the first dimension are more heavily congested than edges on other boundaries. However, it is sufficient for this proof. This is a standard construction, and additional details can be found in many books on algorithms, such as Leighton (1992).
Every edge in Ki arises from the reduction of a subtree of T rooted at some node v at level i. Let
w be some child of v and Ai(w) the induced subgraph of Ai. In the worst case, a boundary edge
of Ai(w) with must support an edge from every node in Ai(w) with the same first coordinate to
every edge in the half space of Ai(w). There are ei/2 nodes that
Ai(v) have
on the
the opposite side of the first same first coordinate, and ni
coordinate partition from ­ 1 / 2 = (2dni) / 2 in the
half space. Therefore, since this is the worst case,
77
(Ki, Ai)
=
2----d---n---i--e--i 4
(4.39)
The longest path in Ai(v) is from some corner to the diagonally opposite corner. Given the mapping defined above, the length of this path is dei. Therefore,
(Ki, Ai) = dei
(4.40)
Again, as in the d=1 case, we need to weight the congestion by the maximum conductance of the edges being mapped, and divide the product by the conductance of the edges in Ai, which is 1/2i. Taking (4.38), (4.39), and (4.40), this yields
(Ki, Ai)
=
---2-------d------n4------i----e-----i--------(---d---e---i--)---------4-2------dd------n---f---i2---i-1 / 2i
=
-d---2----f--i--e---i2---2---i ni
=
-d---2---(--n-----/--2---i--)--d----+----1---2---i (n / 2i)d
=
d2n
Applying Lemma 4.7 yields (K, A) = maxi(Ki, Ai) = O(d2n) for constant d.

With both support numbers determined, we can now bound the generalized condition number.
(4.41)
4.18 Theorem: For A, T, and K as defined, (K ­1 A) = O(d2nlog n) proof: From Lemma 4.12, we have
(A,K) = (A~ ,T) = O(logn). From Lemma 4.17, we have
(4.42)
(K, A) = O(d2n) . (4.42) and (4.43), together with Lemma 4.8, yield (K ­1 A) = ( A, K ) (K, A) = O(logn) O(d2n) = O(d2nlog n)
(4.43)
4.6.3 Extensions to the regular case In the preceding portion of this subsection, we have showed that, for regular rectangular meshes in d dimensions with n = 2k nodes on a side, the condition number obtained with a support tree preconditioner is O(nlog n) . The restriction that n = 2k was for ease of proof. Examination of the proof shows that the important conditions are that the depth of the tree be O(logn) and that the size of the boundary of each set be within a constant factor of the size of the separator of the set. Both of these conditions hold for arbitrary n. Similarly, increasing the connectivity by adding diagonal edges does not affect the asymptotic size of the condition number. Increasing connectivity by a constant factor only increases the sizes of boundaries and separators by a constant factor, which does not affect the asymptotic bound on the condition number. On the other hand, the edge weights
78 in the mesh must be bounded by a constant for the proofs to hold. 4.7 Summary In this chapter, we demonstrated an isomorphism between Laplacian matrices, undirected edge-weighted graphs, and resistive networks. We used this isomorphism to prove that the convergence rate of STCG for a regular mesh in d dimensions was O( nlogn) , where n is the number of nodes on a side of the mesh. While an interesting result, a more general result, applicable to a wider variety of meshes, is desirable. In certain special cases, the results of this chapter can be generalized, but the proofs are quite intricate. In the next chapter, we show how the results can be generalized to a wider variety of graphs using results from multicommodity flow. The generalization comes at the cost of an additional factor of log3n. That is, using multicommodity flow, we are able to prove that STCG converges as O( nlog4n) for regular meshes. For more complex graphs, the convergence depends on a quantity known as the flux of the graph, which is a measure of the graph connectivity.
79 5 Extended Analysis This chapter extends the analytical results of the previous chapter to more general cases. The work reported here was done jointly with Gary Miller and Bruce Maggs. The analysis of the previous chapter is similar to analysis presented elsewhere for other techniques. For example, the textbooks of Hageman and Young (1981) and Hackbusch (1994) use the 2D regular rectangular mesh as the model grid for presentation of general iterative methods. In the research domain, Greenbaum, et al (1989) also used the 2D regular rectangular mesh in their comparative study of various CG methods. However, application problems rarely exhibit the kind of regular structure associated with the model grids of the previous chapter. Moreover, several assumptions were implicit in the model grids of the previous chapter. Some assumptions are easily dealt with by straightforward modifications of the proofs. The assumptions that cannot be handled by modifications of previous results are the following: 1. irregular graph structure Despite the utility of the rectangular mesh as a model problem, many application problems are defined on irregular grids. Convergence proofs for support trees require embedding the reduced tree into the mesh. For a regular mesh, this is difficult but possible to do explicitly. For an irregular mesh, explicit mapping is so difficult as to be effectively impossible. An approach that permits implicit mapping is required. 2. unequal partitions In the earlier proofs of convergence rate, we relied on the fact that the support tree had depth logn. This depth ensured that the tree could support the mesh with a logn gain factor, and that the conductance of any reduced tree edges was bounded above by (1/2)2i, where i was the depth of the root of the subtree being considered. However, these bounds imply that all partitioning steps produce subgraphs that are approximately equal in size. Not all separators produce equal-sized subgraphs. For example, the sphere separator of Miller, et al (1992) may produce subgraphs of sizes n/3 and 2n/3, where n is the number of nodes in the original graph. The Leighton-Rao separator [Leighton and Rao (1988)] has no guarantee on the relative size of the resultant subgraphs; the separator simply minimizes the ratio of boundary edges to internal
80
nodes of the smallest subgraph. Rao (1987) defined a k-ratio edge separator as a binary edge separator for which the ratio of subgraph sizes is (k-1)/k. From the discussion above, a 3-ratio separator is sufficient to make the convergence analysis of the previous chapter fail (the conductance of the edges in the reduced tree could be too large). Many separators (Leighton-Rao, for example) cannot even guarantee a bounded k for every step of the construction of a support tree. 3. unbounded frontier sizes A close look at the convergence analysis of the previous chapter shows that a key factor in determining the support of the mesh for the tree is the ratio of the size of the frontier of a subgraph to the size of the subgraph's own separator. Recall that the frontier of a subgraph is the set of edges with exactly one endpoint in the subgraph. Intuitively, the importance of this ratio can be justified. The size of the separator is a measure of the connectivity of a subgraph, and a subgraph must be sufficiently well connected to support paths between all of the frontier edges. The separators used in the convergence analysis were nice in the sense that they always produced subgraphs for which the frontier/separator ratio was bounded by a constant. For example, for a rectangular mesh in d dimensions, the frontier/separator ratio is bounded above by 2d. In general, for arbitrary graphs and arbitrary separators, no such bound may be possible. In the subsections that follow, these problems will be addressed.
5.1 Irregular Graphs and Implicit Embedding
The solution to dealing with the problems of irregular graphs and explicit embeddings comes from the area of combinatorial optimization -- specifically from results in multicommodity flow. A brief review of multicommodity flow was presented in §2.2.2. Recall the definition of the flux of a graph G = (V,E), denoted by = (G) :
c(x, y)

=
minS

V
-x--------S--,---y--------S----------------min( S S )
(5.1)
The flux is a measure of the connectivity of a graph. If G is a graph with n nodes and flux , and S is any subset of G with S n / 2 , then the frontier of S has at least S edges; that is, S is connected to the rest of G by at least S edges.
Now, suppose that H and G are both graphs with n nodes and that we wish to embed H into G. Recall from §2.1, that embedding H into G means that for every edge in H, we must specify a path in G. Any edge in G may lie on one or more paths of the embedding, and the number of paths that include an edge e is the congestion of e. The congestion of the embedding is the maximum congestion of any edge in G. The dilation of the embedding is the maximum length of any path of the embedding.
Intuitively, the congestion and dilation of an embedding is related to the flux, (G), of the target graph G. Let G1 and G2 be graphs with G1 = G2 = n , and (G1) < (G2). Consider the embeddings of another n-node graph H into each of G1 and G2. Any subset S of nodes in H corresponds to subsets S1 and S2 in G1 and G2 respectively. Since (G1)<(G2), there are fewer edges out of S1 than out of S2, so the congestion of the embedding into G1 is larger than the congestion of the embedding into G2. Similarly, let v be a vertex in H with corresponding nodes v1 and v2 in G1 and G2, respectively. Because (G1) < (G2), the number of nodes of G1 within edge radius r of v1 is less than the number of nodes of G2 within edge radius r of v2. Thus, it takes longer paths in G1 to reach all nodes from v1 than it does in G2 to reach all nodes from v2. Therefore, the dilation of the embedding of H is larger in G1 than in G2.
81 Leighton and Rao (1988) bounded the congestion and dilation of embeddings with respect to the flux of the target graph. We repeat here the key result, Theorem 2.5 of §2.2.2. 2.5 Theorem: (Leighton-Rao) Consider any n-node bounded degree graph H, and any 1-1 embedding of the nodes of H onto the nodes of an n-node bounded degree graph G with flux . The edges of H can be routed as paths in G with congestion and dilation O(l--o---g----n-) . Equation 4.26 bounds support using congestion and dilation. Theorem 2.5 supplies us with bounds on congestion and dilation, without explicitly mapping edges onto paths! This implicit mapping comes at the cost of a complexity factor of log2n, as we show below. We can now prove the following: 5.1 Theorem: Let G = G(A) be a graph in d dimensions with unit edges corresponding to a Laplacian matrix A. Let T be a boundary-weighted support tree constructed for G by some process of recursive bisection. Suppose that there exists a constant k such that, for any subgraph Gi of G constructed during the partitioning process with Gi0 and Gi1 obtained by partitioning Gi, the following conditions hold: i. (Gi0), (Gi1) (Gi) ; ii. k (Gi) (Gi) , where (Gi) denotes the weight of edges on the boundary of Gi. Then (A, S) = O(l--o---(g--G-4---n)--) , where S is the Laplacian matrix obtained by reducing the interior nodes of T. proof: (A, S) : Recall from the previous chapter that we determine this quantity by mapping each edge of G onto a path in T and examining the support. Since T is boundary weighted, each edge of T can be partitioned to provide unit support for each edge of G. The maximum length path in T has length 2 logn + 1 , so the conductance of the path is O(logn). Hence, (A, S) = O(logn) (S, A) : Let K be the reduction (Schur complement) of T obtained by applying Gaussian elimination to T, eliminating all the internal nodes and stopping at the leaves. Then S is the Laplacian matrix corresponding to K. T is a support tree of depth h = logn , where the root is at level 0, and the leaves are at levels h-1 and h. As before, we partition K, the reduced tree, into subgraphs K0,...,Kh-1 such that Ki consists of all the edges in K between nodes u and w such that the highest node on the path in T from u to w is at level i. Similarly, we partition G into G0,...,Gh-1 by dividing each edge of G into logn pieces, each of equal conductance. We will map K into G by mapping each Ki into the corresponding Gi. Ltnaenvtcvesnbeo f(a1nth/ie2n)teeidrngnaeolsdneoosfdienKovGfva,Treaantbdolehuvenendlceeid. iLnaebKtovGv,evthbbeeystuhbeg(srGauvpb)hgroa(f1phK/ 2ioi)fnhGd­uiicneddkubcye(GdGvbv).yTv(h.1eT/ hc2oe)rnhed­uairce-. Consider embedding Kv into Gv. By the Leighton-Rao Theorem (Theorem 2.5), the dilation of the embedding is O(lognv / (Gv)) . Since we are embedding the complete graph on nv points, rather than a bounded-degree graph, the congestion of the embedding is O(nv lognv / (Gv)) . We now have that
82
(S, A) k(Gv) (1 / 2)h ­ i -l--o-(--gG---n--v-v-) n----v-----(-l-G-o---gv--)-n----v logn
k (1 / 2)h ­ i -l--o-(--gG---3--v-n-) n (1 / 2)i
= O(l--o---(g--G-3---n)--)
Therefore,
(A, S) = (A, S) (S, A) = O(l--o---(g--G-4---n)--)
This immediately yields the following.
5.2 Corollary: Suppose A is a Laplacian matrix with corresponding graph G that is a regular rectangular mesh in d dimensions with n nodes on a side. Suppose T is a support tree for G constructed as in 5.1 with Laplacian matrix S corresponding to the graph obtained by reducing the interior nodes of T. Then, (A, S) = O(nlog4n) .
proof:
It is easy to verify that G satisfies the conditions of Theorem 5.1. Furthermore, (G) = O(1 / n) . Therefore, (A, S) = O(l--o---(g--G-4---n)--) = O(l--o1---g--/-4-n--n--) = O(nlog4n)
Compare Corollary 5.2 with Theorem 4.19. Using Leighton-Rao, we were able to avoid explicitly embedding graphs, yet obtained nearly the same result. Implicit embedding with Leighton-Rao essentially incurs a cost of O(log3n), which is a small price to pay for the additional simplicity and generality. Theorem 5.1 applies to a much larger class of graphs than the rectangular grids considered in 4.19.
Theorem 5.1 addresses the problem of irregular graphs, but does not completely solve it. The requirement for a highly regular graph structure has been replaced by a looser requirement that the flux of the subgraphs is monotonically increasing with the partitioning process. For regular graphs such as rectangular meshes, this requirement can be met. However, another requirement is that the partition is a bisection, and it is possible to construct a graph for which bisection yields decreasing flux. Figure 5.1 illustrates a planar graph for which a bisection yields decreasing flux.
Finding a separator that will guarantee increasing flux is a difficult problem. Leighton and Rao (1988) proposed a flux cut that would partition a graph using the separator that defined the flux. This would seem to be a good candidate for a partitioning algorithm that would guarantee increasing flux. However, even a series of flux cuts does not provide such a guarantee. The graph of Figure 5.1 provides a counterexample. The bisection illustrated is a flux cut, yet the flux decreases after the cut.
For most graphs with a moderately homogeneous structure, the flux will generally increase with partitioning. Thus, while we can deal with a larger class of graphs at this point, we still lack the analytic tools to handle all graphs.
83
G
G1
G2
(G) = 3/4
(G1) = 1/2
Figure 5.1: A bisection that yields decreasing flux.
(G2) = 1/6
5.2 Dealing with Unequal Partitions Another unrealistic assumption that we have been making is that the partitioning process yields subgraphs of roughly equal size. However, many of the best performing graph partitioning algorithms do not conform to this requirement. The problem with unequal partitions is that some subtree may be relatively shallow, and yield conductances in the Schur complement that are too large for the original graph to support. To be able to build support trees using real separators, we need to be able to weight the tree in such a way as to yield a common upper bound on the conductances in the reduced graph. To solve this problem, we work backwards from the goal. Consider weighting a tree such that, when interior nodes are reduced starting with the parents of the leaves and working upwards, all the conductances from the leaves to the lowest unreduced ancestor are proportional to the number of leaves in the subtree. Figure 5.2 illustrates this property.
x
y
v0
v1
reduce v0, v1
g
g0
g1
s0 nodes g0 = 1/s0
s1 nodes g1 = 1/s1
s0+s1 nodes g = 1/(s0+s1)
Figure 5.2: Reducing a tree for which leaf-to-subtree-root conductances are proportional to the number of nodes in the subtree
Referring to Figure 5.2, we need to determine the values of x and y that will yield the desired conductances when v0 and v1 are reduced. Node v0 has s0 connections of conductance g0, and 1 connection of conductance x. Therefore, applying Gaussian reduction to v0 yields s0 connections to the root of conductance g, given by
84
g = s---0---g---0-g---0---x-+-----x- = s---0----+----x-s--0-------x--
(5.2)
where the last step follow from the fact that g0 = 1 / s0 . Now, setting the value for g obtained above (by reducing v0) equal to the desired value in Figure 5.2, and solving for x yields
x = s---0-
(5.3)
s1
A similar derivation yields
y = s---1-
(5.4)
s0
That is, by weighting the tree edges by the ratio of the sizes of the corresponding subtrees, the root-to-leaf conductances are all equal and given by the reciprocal of the number of nodes in the subtree. Now we can determine conductances in the reduced tree independently of the shape of the tree.
Unfortunately, the derivation above solves one problem, but causes another. We now can easily compute conductances in the reduced tree, but have lost the capability to support the mesh with the tree. To support the mesh, the edges of the tree must be at least as large as the weight of the boundary edges in the induced subgraph of the mesh. Weighting with x and y as defined in (5.3) and (5.4) above means that at least one branch of the tree will have an edge of weight less than one, which is insufficient to support the induced subgraph. Equivalently, the leaf-to-root conductances, while identical, are too small to support the mesh.
However, the general idea has merit, and can be extended to provide the answer we need. To do so, we need to define a new separator.
5.3 Definition: Let G = (V,E) be a graph. For any subgraph H induced by a set of nodes S V , let (H) denote the weight of the edges on the boundary of H. Suppose E is an edge separator that partitions G into subgraphs G0 and G1. Then the boundary ratio of E , (E ) = (G0,G1) is given by
(E )
=
max


----(G--G---0-0---),
----(--G----1---) G1

(5.5)
5.4 Definition: Let G = (V,E) be a graph. An optimal boundary ratio separator for G is an edge separator E that minimizes (E ). That is, if E is any edge separator of G, then
(E )
=
min E
:G0

G1
=

G
max
----(G--G---0-0---),
----(--G----1---) G1

.
(5.6)
Since the value of the optimal boundary ratio separator is unique, we can unambiguously refer to the value without reference to the separator, and denote the value by (G).
Now, consider constructing and weighting a support tree using optimal boundary ratio separators. We want the con- ductances in the reduced tree to be large enough to support the mesh, which means that the conductances of the edges in a subtree T0 with s0 nodes should be at least (T0)/s0. We achieve this if the conductances are given by (G0), where G0 is the subgraph induced by T0.
85
Now, what should the edge weights be in the tree? The situation is illustrated in Figure 5.3.
Following the same procedure as before, reducing v0 and v1 to find the values of x and y yields:
x = -s--00----­--0----
(5.7)
y = -s--11----­--1----
(5.8)
x
y
v0
v1
reduce v0, v1

0
1
s0 nodes 0 (G0)/s0
s1 nodes 1 (G1)/s1
s0+s1 nodes (G)/(s0+s1)
Figure 5.3: Reducing a tree for which leaf-to-subtree-root conductances are proportional to the boundary ratio of the subtree
Note first that the values for x and y are dependent only on information from the induced subgraph. This means that the formulas (5.7) and (5.8) can be applied when more than two subgraphs result from a partitioning. Therefore, we are no longer limited to binary partitions. However, the values for x and y in (5.7) only make sense as edge weights if both x>0, and y>0. This implies that we must have both 0, 1 > . That is, must be monotonically increasing with optimal boundary ratio cuts. That this is true is shown in the next lemma. First, we need a basic proposition.
5.5
Proposition:
If
a-b
>
-cd
,
and
a,
b,
c,
d
are
all
positive,
then
a-b
>
-a----+-----cb+d
.
proof:
a-b
>
-cd

ad
>
bc

ab
+
ad
>
ab
+
bc

a(b
+
d)
>
b(a
+
c)

a-b
>
-a----+-----cb+d
5.6 Lemma: Let G = (V,E) be a graph, and (E ) be the boundary ratio of an edge separator E . Suppose that G is recursively partitioned using optimal boundary ratio separators. Then is monotonically increasing with each partitioning. That is, if Gi is a subgraph produced at some stage of the partitioning process, and Gi is partitioned into subgraphs Gi0 and Gi1, then (Gi) < (Gi0) and (Gi) < (Gi1). proof: Let H be a subgraph produced at some stage of recursive partitioning, and consider the parti-
86
tioning of H with an optimal boundary ratio separator. Referring to Figure 5.4, H has a boundary made up of boundary segments of weight a and b, and is partitioned by an optimal boundary ratio separator of weight e0 into subgraphs A and B. Thus,
(H)
=
max ----(-A--A----),
----(-B--B----)
=
max

a-----+-A----e---0-,
b-----+-----e---0B

a
A
e0
B
b
Figure 5.4: Partitioning of subgraph H with an optimal boundary ratio separator into subgraph A and B. a, b, and e0 are the weights of boundary segments.
Now, suppose that one of the two subgraphs is recursively partitioned with an optimal boundary ratio separator. Without loss of generality, assume A is partitioned into subgraphs C and D. Referring to Figure 5.5 for the definition of the terms, we have:
(A)
=
max ----(-C--C-----),
----(---D-----) D
=
max

c-----+-----e-C-1----+-----e---3-,
-d----+-----e---2----+-----e---3 D

c
C
e1
e3
B
b
d
D
e2
Figure 5.5: Partitioning of subgraph A from Figure 5.4 with an optimal boundary ratio separator.
To complete the proof, we need to show that ( A) (H ) . We consider four cases.
1.
(H)
=
----(---A----) A
=
c-----+-----d----+-----e---1----+-----e---2 C+D
and
(A)
=
----(---D-----) D
=
d-----+-----e---2----+-----e---3 D
By the definition of the case being considered,
(A) =
d-----+-----e---2----+-----e---3 D

c-----+-----e--1----+-----e---3C
=
----(---C-----) C
.
Applying 5.5, we obtain
(A) =
d-----+-----e---2----+-----e---3 D

-c----+-----d----+-----e---1----+-----e---2----+----2----e---3C+D

c-----+-----d----+-----e---1----+-----e---2 C+D
=
(H)
87
2. (H ) = ----(---A----) = c-----+-----d----+-----e---1----+-----e---2 and ( A) = ----(---C-----) = -c----+-----e--1----+-----e---3-
A
C+D
C
C
By the definition of the case being considered,
(A)
=
-c----+-----e--1----+-----e---3C

d-----+-----e---2----+-----e---3 D
=
----(---D-----) D
.
Applying 5.5, we again obtain
(A) =
-c----+-----e--1----+-----e---3C

-c----+-----d----+-----e---1----+-----e---2----+----2----e---3C+D

-c----+-----d----+-----e---1----+-----e---2 C+D
=
(H)
3.
(H)
=
----(---B----) B
=
b-----+-----e---1----+-----e--2B
and
(A)
=
----(---D-----) D
=
d-----+-----e---2----+-----e---3 D
We prove this by contradiction. Suppose that (H ) > ( A) . Then,
(H)
=
b-----+-----e---1----+-----e--2B
>
-d----+-----e---2----+-----e---3 D

-c----+-----e--1----+-----e---3C
.
Applying 5.5 using the first and third fractions above, we obtain
(H)
=
b-----+-----e---1----+-----e--2B
>
-b----+-----c----+-----2---e---1----+-----e---2----+-----e---3 B+C

-b----+-----c----+-----e---2----+-----e---3 B+C
=
----(-B--B---------C--C----)-
.
From this inequality and the initial conditions defining this case, we have that
(H)
>
max
----(-D--D-----),
----(-B--B---------C--C-----)

That is, partitioning D from BC yields a smaller boundary ratio that partitioning A=CD from B. This contradicts the optimality of the (A,CD) partition. Therefore, we must have (H ) ( A) .
4.
(H)
=
----(---B----) B
=
b-----+-----e---1----+-----e--2B
and
(A)
=
----(---C-----) C
=
-c----+-----e--1----+-----e---3C
We again prove this by contradiction. Suppose that (H ) > ( A) . Then,
(H)
=
b-----+-----e---1----+-----e--2B
>
-c----+-----e--1----+-----e---3C

d-----+-----e---2----+-----e---3 D
.
Applying 5.5 using the first and third fractions above, we obtain
(H) =
b-----+-----e---1----+-----e--2B
>
-b----+-----d-----+----e---1----+-----2---e---2----+-----e---3B+D

-b----+-----d-----+----e---1----+-----e---3B+D
=
----(-B--B---------D--D-----)
.
From this inequality and the initial conditions defining this case, we have that
(H)
>
max
----(-C--C-----),
----(-B--B---------D--D-----)

That is, partitioning C from BD yields a smaller boundary ratio that partitioning A=CD from B. This contradicts the optimality of the (A,CD) partition. Therefore, we must have (H ) ( A) .
The four cases above prove the lemma for the partitioning illustrated in Figure 5.4 and Figure
88
5.5. These cases and the associated figures also represent the general case. For any other partitioning of H and A into two pieces, no other boundary segments are added. Instead, some segments may go to zero. However, the conditions required by Proposition 5.5 still hold, and the lemma follows.
Now, we build support trees using recursive optimal boundary ratio partitioning using a two-phase process. In the first phase, the partitioning is performed, and the tree structure is built up. In the second phase, the edge weights of the support tree are computed level-by-level from leaves to roots: edges that connect leaf nodes are weighted with the value of the optimal boundary ratio separator that yielded the leaf; internal edges are weighted using (5.7). We can now prove the following theorem, which is similar to Theorem 5.1, but relaxes two restrictions: that the partitioning is binary, and that the subgraphs formed by partitioning are equal in size. 5.7 Theorem: Let G = G(A) be a graph in d dimensions with unit edges corresponding to a Laplacian matrix A. Let T be a boundary-weighted support tree constructed for G by recursive partitioning using optimal boundary ratio separators, and weighted as discussed above. Suppose that there exists a constant k such that, for any subgraph Gi of G constructed during the partitioning process with Gi0 and Gi1 obtained by partitioning Gi, the following condition holds: (Gi0), (Gi1) (Gi) . Then (A, S) = O(l--o---(g--G-4---n)--) , where S is the Laplacian matrix obtained by reducing the interior nodes of T.
proof:
(A, S) : Recall from Theorem 5.1 that we determine this quantity by mapping each edge of G onto a path in T and examining the support. In Theorem 5.1, since T was boundary weighted, each edge of T was partitioned to provide unit support for each edge of G. All we need to do in this case is to show that the support of each edge in T for each edge in G is O(1).
Consider an edge e at level i in T, which connects nodes u and v, where u is the node on the root side of e. Let the subgraphs of G induced by u and v be denoted U and V, with optimal boundary ratios i-1, and i, respectively. Let V denote the number of nodes in V. Let w be the weight of edge e. Then w is given by
w = --V--i---­----i---i-i--­-­---11- We need only show that w is at least as large as (V), the size of the boundary of V. Let V1,...,Vk be the other subgraphs of U produced by the partitioning process. Then we have the following:
w = --V--i---­----i---i-i--­-­---11- > --V---------i--i--i---­---1- =
V i ­ 1=
V

max
----(V--V----),
----(V--V---1-1---),
...,
----(--V----k---) Vk


V

----(--V----) = V
(V )
That is, w is larger than the size of the boundary of V.
Since w is larger than the boundary size and V was chosen arbitrarily, each edge of T can provide unit support to every boundary edge in its induced subgraph. The maximum length path in T has length 2 logn + 1 , so the conductance of the path is O(logn). Hence, (A, S) = O(logn)
(S, A) : As before, let K be the reduction (Schur complement) of T obtained by applying Gaussian elimination to T, eliminating all the internal nodes and stopping at the leaves. S is the Laplacian matrix corresponding to K.
89
T is a support tree of depth h = logn , where the root is at level 0, and the leaves are at lev- els h-1 and h. As before, we partition K, the reduced tree, into subgraphs K0,...,Kh-1 such that Ki consists of all the edges in K between nodes u and w such that the highest node on the path in T from u to w is at level i. Similarly, we partition G into G0,...,Gh-1 by dividing each edge of G into logn pieces, each of equal conductance. We will map K into G by mapping each Ki into the corresponding Gi.
Let v be an internal node of T at level i. Let Gv be the subgraph of G induced by v. There are
nv n (1 / 2)i nodes in Gv, and hence in Kv, the subgraph of Ki induced by Gv. By the way in
which T was constructed, the conductances of the edges of Kv are identical, and equal to
---(--G-----) n
=
----(--G-----) n
.Consider
embedding
Kv
into
Gv.
By Leighton-Rao (Theorem 2.5), the dilation of the embedding is O(lognv / (Gv)) . Since we are embedding the complete graph on nv points, rather than a bounded-degree graph, the con- gestion of the embedding is O(nv lognv / (Gv)) .
We now have that
(S, A) = ----(-n-G-----) -l--o-(--gG---n--v-v-) n----v-----(-l-G-o---gv--)-n----v logn -l--o-(--gG---3--v-n-) = O(l--o---(g--G-3---n)--)
Therefore,
(A, S) = (A, S) (S, A) = O(l--o---(g--G-4---n)--)
90
page 91
6 Support Trees: Evaluation
Previous sections presented the construction of support trees, the implementation of the support tree conjugate gradient method (STCG), and the theoretical analysis of the convergence properties of STCG. The theoretical analysis showed that the condition number for an nxn mesh was O(nlog2n) using STCG, while the presentation on implementation of STCG showed that the tree structure of support tree preconditioners should lead to efficient execution. To examine the efficiency of the implementation, and to investigate the size of the constant in the condition number, we performed an empirical evaluation of the performance of STCG, by comparison with the performance using diagonal scaling (DSCG) and incomplete Cholesky preconditioning (ICCG) using a single vector processor of a Cray C90. This evaluation was performed in collaboration with Marco Zagha, who was responsible for the Cray implementation. Cray C-90 time was provided by the Pittsburgh Supercomputing Center. A version of this section appeared as a CMU technical report [Gremban, Miller, and Zagha, (1994)], and in abbreviated form as a conference paper [Gremban, Miller, and Zagha, (1995)].
Similar performance evaluations of other conjugate gradient (CG) methods have been performed. Greenbaum, Li, and Chow (1989) compared the performance of four different variations of the preconditioned conjugate gradient (PCG) methods: diagonal scaling, incomplete Cholesky, hierarchical basis function, and Neumann-Dirichlet domain decomposition. The latter two are instances of multi-level preconditioning, and will not be discussed further here. All their tests were performed on a prototype of the NYU Ultracomputer and varied the number of processors used from 1 to 8. Their model problem was a time-independent version of the diffusion equation defined on the unit square with Dirichlet boundary conditions:
(x, y)u(x, y) = f (x, y)
(6.1a)
(x, y) (0, 1) Ч (0, 1)
(6.1b)
u(0, y) = u(1, y) = u(x, 0) = u(x, 1) = 0 The main conclusions to be drawn from the Greenbaum, et al (1989) study are the following:
(6.1c)
1. In serial mode, ICCG requires nearly twice as much processing time per iteration as does DSCG. However, the reduction in the number of iterations is sufficiently large (more than a factor of three for the test
page 92 cases reported) that ICCG is, overall, faster than DSCG. 2. As the number of processors grows, the advantage in using ICCG decreases. In the experiments reported, on as few as 8 processors, DSCG outperformed ICCG in terms of total execution time. The reason for this is the difficulty in parallelizing the triangular solves required by the ICCG preconditioning (see the next subsection below for a more complete discussion). A similar study was performed by Heroux, Vu, and Yang (1991). They compared DSCG, ICCG, least-squares polynomial preconditioning, and the multifrontal sparse Cholesky method. We shall discuss only the results for DSCG and ICCG. All experiments were performed on a Cray Y-MP using either 1 or 8 of the vector processors. The problems were obtained by assigning artificial values to various Harwell-Boeing matrices (most of which are patternonly). The main conclusions to be drawn from the Heroux, et al (1991) study are the following: 1. ICCG produced significant reductions in the number of iterations for most problems as compared to DSCG (at times by more than a factor of 1/4). However, on even a single vector processor, the total execution time of ICCG was greater than that of DSCG. On 8 processors, the ICCG:DSCG execution time ratio typically increased. This is consistent with the results of the Greenbaum, et al (1989) study, since a single vector processor of a Cray Y-MP can be viewed as collection of 128 parallel processors. 2. A breakdown of the solution time indicated that the primary reason for the increased execution time of ICCG was in the application of the preconditioner. The breakdown further showed that little improvement was gained in applying the preconditioner using 8 vector processors. Recall that application of the preconditioner requires the solution of two triangular systems. In general, it is difficult to parallelize triangular solves (see the discussion in Chapter 2, and Heath, et al, (1990)). The Greenbaum, et al (1989) and Heroux, et al (1991) studies both point out the need for an effective parallel preconditioner -- one that significantly reduces the number of iterations, but is also efficient to execute on parallel architectures. In the remainder of this section, we present an evaluation of STCG that suggests that both criteria, effectiveness and efficiency, are met by support tree preconditioners. We used the work of Greenbaum, et al (1989) as a guide in our evaluation procedure. We took a typical problem, discretized it at various levels of resolution to obtain problems of various sizes, and compared the performance of the three PCG methods as a function of problem size. We took the model problem used by Greenbaum, et al (1989). as our two-dimensional model problem, but also compared the results for more complicated right hand sides. Since the model problem used regular meshes, we also compared the performance of the preconditioners on a sequence of irregular two-dimensional meshes. Finally, we extended the study to three dimensions, and compared results for two different sequences of three dimensional regular meshes. All experiments were performed on a Cray C-90, using a single vector processor. 6.1 Empirical Evaluation of STCG Greenbaum, et al (1989) and Heroux, et al (1991) both conducted empirical evaluations of preconditioner performance with respect to convergence rates, and execution time (per iteration and total) on multiple processors. Greenbaum, et al conducted their research on a simple analytically defined PDE, which allowed them to scale the problem by varying the mesh size, and examine the performance as a function of problem size. Heroux et al. used various matrices from the Harwell-Boeing set with artificial values. Several conclusions were common to both studies. In particular, both studies found that ICCG significantly improved the convergence rate on even fairly small matrices. However, because ICCG lacks significant potential parallelism, both studies also found that the advantages of ICCG essentially vanish on vector and parallel machines.
page 93
In this section, we will demonstrate that STCG is superior to ICCG for solving large problems using serial machines, and is easily and effectively parallelized. Consequently, STCG vastly outperforms ICCG and DSCG for solving large problems on vector and parallel machines.
Because we are interested in the effects on performance as the scale of the problem changes, we primarily follow the methodology used by Greenbaum, et al in their study of preconditioners. We limit ourselves, to only comparing DSCG (diagonally scaled conjugate gradient), ICCG (incomplete Cholesky conjugate gradient), and STCG (support tree conjugate gradient). We compare the performance of the three solution methods versus problem size with respect to number of iterations and total running time over all iterations. In separate sections, we present the results for problems defined on a 2D regular mesh, a 2D irregular mesh, and two kinds of 3D regular meshes.
In all the results reported below, we report only the time utilized by the iterative process, and do not include the time required for formation of the preconditioners. While total time is important, in many instances the linear system will be solved many times, and the cost of forming the preconditioner can be amortized over the number of times the system is solved. Additionally, we are currently investigating the performance of various partitioning methods as one step towards constructing a version of STCG that is optimized from end to end. Currently, the code used to generate support tree preconditioners is written in NESL, an experimental data-parallel language [Blelloch (1993)]. The various implementations of PCG were written in FORTRAN.
We made no attempt to go beyond the obvious optimizations to improve the performance of ICCG. Numerous other authors have reported on the effects of ordering on ICCG [see, for example, Duff and Meurant (1989)], and on parallel implementations of ICCG [see Dongarra, et al (1991), van der Vorst (1989a), and van der Vorst (1989b)]. Rather than reproduce their work, we decided to extrapolate values for an optimistic implementation of ICCG.
We applied the results of other researchers discussed above in order to determine an optimistic execution time for ICCG. First, we assumed that a good node ordering could be computed and that solving the preconditioned system could be performed at the same Mflop rate as the sparse matrix-vector multiply performed at each iteration. We further assumed that the relative amount of work per iteration of ICCG was roughly twice that of DSCG. These assumptions yielded an optimistic time per iteration of ICCG to be a little more than twice that of DSCG. To be generous, we assigned a time per iteration for an optimistic ICCG to be exactly twice that of DSCG. We used this factor of two in all comparisons reported in this paper. We refer to the extrapolated optimistic ICCG as ICCG_OPT.
All results were obtained using a single processor on the Cray C-90 at the Pittsburgh Supercomputing Center.
In the discussions of the experiments that follow, all experimental results are presented as graphs. The raw results in tabular form can be found in §6.2.
6.1.1 Two-dimensional problem on regular nxn meshes
In their work, Greenbaum, et al (1989) considered the discretization of a time-independent version of the diffusion equation defined on the unit square with Dirichlet boundary conditions (see equations 6.1). For our experiments on regular meshes, we used the same equation with (x,y) = 1.0, which reduces (6.1a) to Poisson's equation:
2u(x, y) = f (x, y)
(6.2)
We discretized the equation using the 5-point finite difference operator for the Laplacian, and varied the size of the nxn mesh using n ranging from 8 to 512 in powers of 2. In graph-theoretic terms, the resulting coefficient matrices correspond to graphs that are nxn meshes with unit weight edges and self-loops on all boundary nodes.
The support tree preconditioners for this problem were constructed using recursive coordinate partitioning in which, for each subset of points, the subset was split into four parts by bisecting first with respect to the x-coordinates and then with respect to the y-coordinates. Hence, each support tree had the form of a quadtree.
page 94
6.1.1.1 Smooth input data For our initial experiments, we used the same forcing function as Greenbaum, et al: f (x, y) = ­2x(1­x)­2y(1­y)
Our starting vector was x0 = 0 . We used as our stopping criterion the condition reported to be superior by Arioli, et al (1992):
2 = ---A---------b---­----A-x^-----1--x-^-+-------b--------
(6.3)
We halted when 2 1.0 x 10-10.
Figure 6.1a shows the results in terms of number of iterations for convergence. The figure clearly shows that, while ICCG outperforms STCG in terms of number of iterations required for convergence on small meshes, the curves cross, and STCG is superior as the meshes get fairly large.
The total execution times are plotted in Figure 6.1b, with the extrapolated optimistic ICCG plotted as ICCG_OPT. Both STCG and ICCG_OPT outperform DSCG in total time, although STCG is the fastest method overall. Moreover, as the problem size increases, the difference between STCG and ICCG_OPT is increasing.
Iterations total time (msec)
350 300 250 200 a) 150 100 50 0 8
9000.0 8000.0 7000.0
ICCG
DSCG
6000.0
5000.0
ICCG-OPT
DSCG
b) 4000.0 3000.0
STCG
STCG ICCG
2000.0 1000.0
16 32 64 128 256 512 sqrt(Mesh Size)
0.0 8 16 32 64 128 256 512 sqrt(Mesh Size)
Figure 6.1: Results for 2D Regular Meshes, Smooth Input. a) Iterations to convergence. b) Total time for iterative process on Cray C-90 (msecs).
6.1.1.2 Random input The forcing function used in the previous subsection was very smooth, and the problem converged to the solution fairly quickly. In a second set of experiments, we selected a more difficult right hand side. We used a random vector in which each component was independently selected from the uniform distribution on [0,1].
page 95 We used the same stopping criterion as before, and halted when 2 1.0 x 10-10. Our starting vector was again x0 = 0. Figure 6.2a shows the results in terms of number of iterations for convergence. In this set of experiments, convergence required as many as three times the number of iterations for the same size mesh as did the smooth input, and differences between the preconditioners became more pronounced. STCG started out performing similarly to ICCG, but improved rapidly, outperforming ICCG on the largest meshes.
Iterations total time (msec)
400 350 300 250 200 a) 150 100 50 0 8
12000.0 10000.0 8000.0
ICCG DSCG
DSCG
6000.0 b)
ICCG-OPT
ICCG
4000.0
STCG
2000.0
STCG
16 32 64 128 256 512 sqrt(Mesh Size)
0.0 8 16 32 64 128 256 512 sqrt(Mesh Size)
Figure 6.2: Results for 2D Regular Meshes, Random Input. a) Iterations to convergence. b) Total time for iterative process on Cray C-90 (msecs).
Figure 6.2b shows total time for the iterative process. As above, we also show the results for an extrapolated optimistic ICCG_OPT. STCG clearly had the best total execution time. Moreover, the difference between STCG and the other methods increased with increasing mesh size. 6.1.1.3 Impulse function input In a third set of experiments, we selected an additional difficult right hand side. We used an impulse function for b, defined by b0 = 1.0, bi = 0.0 for i > 0. In our node ordering, node 0 is the lower left hand corner of the mesh. We used the same stopping criterion as before, and halted when 2 1.0 x 10-10. Our starting vector was again x0 = 0. Figure 6.3a shows the results in terms of number of iterations for convergence. In this set of experiments, convergence required even more iterations for the same size mesh as did the random input, and differences between the preconditioners became even more pronounced. Again, STCG started out with performance similar to that of ICCG, but significantly outperformed ICCG on the largest meshes Figure 6.3b shows total time for the iterative process. Since STCG requires less work per iteration than does ICCG_OPT, and because STCG is highly vectorizable, STCG was the clear winner in terms of execution time.
page 96
Iterations total time (msec)
1000 900 800 700 600 a) 500 400 300 200 100 0 8
30000.0
DSCG
25000.0 20000.0
ICCG
DSCG
b) 15000.0
ICCG-OPT
ICCG
10000.0
5000.0
STCG
STCG 16 32 64 128 256 512 sqrt(Mesh Size)
0.0 8 16 32 64 128 256 512 sqrt(Mesh Size)
Figure 6.3: Results for 2D Regular Meshes, Impulse Function Input. a) Iterations to convergence. b) Total time for iterative process on Cray C-90 (msecs).
6.1.2 Two-dimensional problem on irregular meshes The results for the PDE on a 2D regular mesh are one indication of the utility of STCG. Most application problems are not defined on regular meshes, however, so it is worthwhile to investigate the relative performance of STCG on an irregular case. We were fortunate to have available to us a nested sequence of meshes developed for an application problem -- the computation of stress on a two-dimensional cracked plate. There are 9 meshes in all, with 10x2i nodes in each mesh, i = 0,1,2,3,4,5,6,8,9,10. (The data for the mesh with i = 7 was unavailable.) Each mesh is a refinement of the next smaller (coarser) mesh. This sequence enabled us to investigate the performance of STCG as a function of grid size for an irregular mesh. Figure 6.4 illustrates the coarsest and finest of the meshes. The crack in the plate runs from the center to the left side, parallel to the x-axis. The crack was defined by creating two nodes for each visible mesh point; the two nodes are not connected to each other; one connects only to nodes above the crack, while the other connects only to nodes below the crack. The crack data consisted of pattern-only information and node coordinates. We used the pattern information to construct non-singular coefficient matrices by augmenting the Laplacian matrices of the meshes with additional diagonal weight di = 1.0 added to the nodes corresponding to the four corners. Mesh edges were given unit weights. The support tree preconditioners for this set of problems had the form of quadtrees and were constructed using recursive coordinate partitioning. We performed two sets of experiments. The first was conducted with a random vector (values selected uniformly between 0.0 and 1.0) as the input. The second was conducted with an impulse function as input (b0 = 1.0, bi = 0.0, for i > 0). For all the crack meshes, node 0 is the node at the lower left of the mesh. For the experiments done with the crack meshes, we again used 2 as the stopping criterion, and halted when 2 1.0 x 10-10. Our starting vector was again x0 = 0 .
page 97
a)
b)
Figure 6.4: Crack Meshes. a) crack00 with 10 nodes. b) crack10 with 10240 nodes. Figure 6.5 illustrates the results of the experiments using the random vector as input. Figure 6.5a illustrates the number of iterations needed to converge to the specified tolerance as a function of the mesh size. The horizontal axis (mesh size) is plotted logarithmically. Both ICCG and STCG converge more rapidly than DSCG. While ICCG initially outperforms STCG, STCG converges more rapidly on the larger meshes. Figure 6.5b illustrates the total time taken to converge as a function of the mesh size. Again, we obtained a curve for ICCG_OPT by assuming that such an implementation would require only twice the time per iteration of DSCG. However, even this optimistic ICCG performed no better in overall time than DSCG; the two curves track each other almost perfectly. The advantage of STCG over the other methods is apparent, and the advantage is increasing with increasing mesh size. The largest crack mesh is only 10240 nodes, which is quite small for many applications. Figure 6.6 illustrates the results of the experiments using the impulse function as input. Figure 6.6a illustrates the number of iterations needed to converge, while Figure 6.6b illustrates the total time taken for the iterative process. Again we see that STCG started off requiring more iterations than ICCG, but does not increase as fast as ICCG. On the largest meshes, STCG required fewer iterations than did ICCG. Again, because of the vectorizable nature of the support tree preconditioners, STCG was the clear winner in terms of execution time.
page 98
Iterations
250 200 150 a) 100 50 0 10
total time (msec)
DSCG
400.0 350.0 300.0 250.0
ICCG ICCG-OPT DSCG
ICCG STCG
b) 200.0 150.0 100.0
40 160 640 2560 10240 Mesh Size
50.0 0.0 10
STCG 40 160 640 2560 10240 Mesh Size
Figure 6.5: Results on 2D Irregular Meshes, Random Input. a) Iterations to convergence. b) Total execution time for iterative process on Cray C-90 (msecs).
total time (msec)
Iterations
350 300 250 200 a) 150 100 50 0 10
DSCG
600.0 500.0 400.0
ICCG
ICCG-OPT DSCG
ICCG
300.0 b) 200.0
STCG
100.0
40 160 640 2560 10240 Mesh Size
0.0 10
40 160 640
Figure 6.6: Results on 2D Irregular Meshes, Impulse Function Input. a) Iterations to convergence. b) Total execution time for iterative process on Cray C-90 (msecs).
STCG 2560 10240 Mesh Size
page 99
6.1.3 Three-Dimensional problem on regular nxnxn meshes
In Chapter 3, we showed that the advantage of STCG in terms of work required per iteration should increase with increasing graph dimensionality. To investigate this empirically, we performed a number of experiments in three dimensions using a regular nxnxn mesh. In this set of experiments, we extended the two-dimensional problem from section 6.1.1 into three dimensions. That is, we considered the discretization of Poisson's equation defined on the unit cube with Dirichlet boundary conditions:
2u(x, y, z) = f (x, y, z)
(6.4a)
(x, y, z) (0, 1) Ч (0, 1) Ч (0, 1)
(6.4b)
u(0, y, z) = u(1, y, z) = u(x, 0, z) = u(x, 1, z) = u(x, y, 0) = u(x, y, 1) = 0
(6.4c)
We discretized the equation using the 7-point finite difference operator for the Laplacian, and varied the size of the nxnxn mesh using n ranging from 8 to 512 in powers of 2. In graph-theoretic terms, the resulting coefficient matrices correspond to graphs that are nxnxn meshes with unit weight edges and self-loops on all boundary nodes.
The support tree preconditioners for this set of problems had the form of oct-trees and were constructed using recursive coordinate partitioning.
We ran two sets of experiments. The first was conducted with random vectors (values selected uniformly between 0.0 and 1.0) as the input. The second was conducted with impulse functions as input (b0 = 1.0, bi = 0.0, for i > 0). For the nxnxn mesh, node 0 is a corner node.
For these experiments, we again used 2 as the stopping criterion, and halted when 2 1.0 x 10-10. Our starting vector was x0 = 0 .
Figure 6.7 illustrates the results of the experiments conducted with random vectors as input. Figure 6.7a illustrates the number of iterations required for convergence, while Figure 6.7b illustrates the total execution time required for the iterative process.
Figure 6.8 illustrates the results of the experiments conducted with impulse functions as input. Figure 6.8a illustrates the number of iterations required for convergence, while Figure 6.8b illustrates the total execution time required for the iterative process.
For both random vectors and impulse functions, the problem converged extremely quickly, so it is difficult to draw definite conclusions. As for previous problems, in both of the nxnxn cases, STCG began by requiring more iterations for convergence than did ICCG. As observed in the previous problems, the rate of increase in the number of iterations for STCG appears to be less than that of ICCG. In terms of execution time, STCG is superior to STCG and roughly the same as ICCG_OPT.
page 100
total time (msec)
Iterations
80 70 60 50 40 a) 30 20 10 0 8 160 140 120 100 a) 80 60 40 20 0 8
1800.0
DSCG
1600.0 1400.0
ICCG
1200.0 1000.0
DSCG
STCG ICCG
b) 800.0 600.0 400.0 200.0
STCG ICCG-OPT
16
32
64
cuberoot(Mesh Size)
0.0
8
16
32
64
cuberoot(Mesh Size)
Figure 6.7: Results on 3D nxnxn Meshes, Random Input. a) Iterations to convergence. b) Total execution time for iterative process on Cray C-90 (msecs).
total time (msec)
3000.0
DSCG STCG ICCG
2500.0 2000.0 b) 1500.0 1000.0 500.0
ICCG
DSCG
ICCG-OPT STCG
16
32
64
cuberoot(Mesh Size)
0.0
8
16
32
64
cuberoot(Mesh Size)
Figure 6.8: Results on 3D nxnxn Meshes, Impulse Function Input. a) Iterations to convergence. b) Total execution time for iterative process on Cray C-90 (msecs).
Iterations
page 101
6.1.4 Three-Dimensional problem on regular 8x8xn meshes
We stated in Chapter 3 that convergence is a function of the graph diameter. In three dimensions, the volume of a cube increases so rapidly with respect to diameter that it is difficult to construct a cubic 3D problem with a diameter large enough to require many iterations. Therefore, we defined an alternate 3D problem that would allow us to investigate convergence as a function of the graph diameter. In this set of experiments, we modified the three-dimensional problem of equation (6.4) by extending it along one of the three dimensions. That is, we considered the discretization of Poisson's equation defined on a box:
2u(x, y, z) = f (x, y, z)
(6.5a)
(x, y, z) (0, 1) Ч (0, 1) Ч (0, 8n)
(6.5b)
Furthermore, we used mixed boundary conditions: Dirichlet conditions on the long ends of the box, and Neumann conditions on the sides:
u(x, y, 0) = u(x, y, 8n) = 0
(6.5c)
xu(x, 0, z) = xu(x, 1, z) = 0
(6.5e)
yu(0, y, z) = yu(1, y, z) = 0
(6.5f)
For our experiments, we discretized the equation using the 7-point finite difference operator for the Laplacian, and varied the size of the 8x8xn mesh using n ranging from 8 to 1024 in powers of 2. In graph-theoretic terms, the resulting coefficient matrices correspond to graphs that are 8x8xn meshes with unit weight edges and self-loops on all boundary nodes of the 8x8 faces. The support tree preconditioners for this set of problems had the form of binary trees and were constructed using recursive coordinate partitioning.
We ran two sets of experiments. The first was conducted with random vectors (values selected uniformly between 0.0 and 1.0) as the input. The second was conducted with impulse functions as input (b0 = 1.0, bi = 0.0, for i > 0). For the 8x8xn mesh, node 0 is a corner node. For these experiments, we again used 2 as the stopping criterion, and halted when 2 1.0 x 10-10. Our starting vector was x0 = 0 .
Figure 6.9 illustrates the results of the experiments with random vectors as inputs. Figure 6.9a illustrates iterations required to converge, while Figure 6.9b illustrates total time required for the iterative process.
Figure 6.10 illustrates the results of the experiments with impulse functions as inputs. Figure 6.10a illustrates iterations required to converge, while Figure 6.10b illustrates total time required for the iterative process.
The results of this set of experiments are particularly interesting. The large diameters of the graphs and the Neumann boundary conditions on the sides of the boxes led to problems that required very many iterations to converge. The differences between the preconditioners is now very apparent. While in all cases, STCG required more iterations than ICCG for small meshes, the number of iterations required for STCG is almost constant with respect to mesh diameter, while that of ICCG is clearly increasing. By the time the mesh diameter is over 512, STCG requires fewer than half the number of iterations of ICCG.
The difference in execution time is even more dramatic. As stated previously, STCG vectorizes extremely well. For problems of the size considered here, the vector lengths at the lowest level of the support tree range from thousands to hundreds of thousands.
Iterations total time (msec)
page 102
900 800 700 600 500 a) 400 300 200 100 0 8
6000.0 5000.0
DSCG
DSCG
4000.0 b) 3000.0
ICCG
ICCG-OPT
2000.0
ICCG
1000.0
STCG
STCG 16 32 64 128 256 512 1024 Mesh Length
0.0 8 16 32 64 128 256 512 1024 Mesh Length
Figure 6.9: Results on 3D 8x8xn Mesh, Random Input. a) Iterations to convergence. b) Total execution time for iterative process on Cray C-90 (msecs).
Iterations total time (msec)
1800 1600 1400
DSCG
12000.0 10000.0
DSCG
1200
8000.0
1000 a) 800
b) 6000.0
600 400 200 0 8
ICCG STCG 16 32 64 128 256 512 1024 Mesh Length
4000.0
2000.0
ICCG
ICCG-OPT
0.0
STCG
8 16 32 64 128 256 512 1024
Mesh Length
Figure 6.10: Results on 3D 8x8xn Mesh, Impulse Function Input. a) Iterations to convergence. b) Total execution time for iterative process on Cray C-90 (msecs).
6.2 Tabulated Experimental Results 6.2.1 Results from 2D regular meshes
page 103
Table 6.1: Results of Experiments on 2D Square Meshes, Smooth Input
size
iterations
time/iteration (msecs)
total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8 10 9 10 .29 .43 .39
2.9
3.9 3.9
16 22 13 19 .28 .88 .41
6.2 11.4 7.8
32 40 21 28 .36 2.61 .54 14.4 54.8 15.1
64 73 29 37 .66 9.56 1.03 48.0 280.0 38.0
128 121 40 48 1.83 37.00 2.90 222.0 1480.0 139.0
256 178 56 64 5.63 144.94 8.91 1002.5 8116.7 570.4
512 336 101 79 24.30 578.69 37.73 8164.9 58447.6 2981.0
Table 6.2: Results of Experiments on 2D Square Meshes, Random Input
size
iterations
time/iteration (msecs)
total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8 25 11 18 .26 .43 .35
6.6
4.7 6.3
16 44 16 25 .27 .86 .38 11.8
13.7 9.4
32 76 24 33 .34 2.60 .50 25.8
62.5 16.4
64 123 37 41 .61 9.44 .94 75.3 349.1 38.7
128 184 55 54 1.68 36.73 2.76 308.9 2020.4 148.9
256 257 77 66 5.67 144.95 8.96 1456.4 11161.1 591.1
512 357 106 81 24.54 578.78 36.42 8761.8 61350.7 2950.0
Table 6.3: Results of Experiments on 2D Square Meshes, Impulse Input
size
iterations
time/iteration (msecs)
total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8 27 11 20 .26 .43 .35
7.0
4.7 6.9
16 53 17 28 .27 .86 .38
14.2 14.6 10.5
32 96 29 40 .34 2.58 .49
32.2 74.7 19.4
64 176 54 54 .56 9.38 .87
99.2 506.3 46.9
128 326 98 74 1.65 36.28 2.66 537.6 3555.0 195.8
256 580 178 101 5.62 143.55 8.50 3259.2 25551.7 858.1
512 990 300 125 23.50 572.17 35.58 23266.5 171649.9 4447.0
6.2.2 Results from 2D irregular meshes
page 104
Table 6.4: Results of Experiments on 2D Irregular Meshes, Random Input.
size
iterations
time/iteration (msecs) total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
10 20 40 80 160 320 640 2560 5120 10240
10 7 17 10 23 13 34 15 45 22 60 30 83 41 148 73 156 94 206 109
10 .27 .31 .33
2.7 2.2 3.3
16 .28 .33 .34
4.7 3.3 5.5
22 .28 .37 .35
6.4 4.8 7.6
29 .26 .44 .35
8.9 6.6 10.1
39 .26 .59 .36 11.7 12.9 14.2
48 .28 .89 .40 16.7 26.7 19.3
52 .32 1.50 .47 26.8 61.6 24.2
77 .53 4.97 .76 77.8 363.1 58.8
88 .84 9.46 1.26 131.7 889.2 110.9
98 1.45 18.35 2.02 298.1 1999.9 198.0
Table 6.5: Results of Experiments on 2D Irregular Meshes, Impulse Input.
size
iterations
time/iteration (msecs) total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
10 20 40 80 160 320 640 2560 5120 10240
10
7 10 .27 .31 .33
2.7 2.2 3.3
17 10 16 .28 .33 .35
4.7 3.3 5.6
26 13 23 .27 .36 .34
7.1 4.7 7.9
36 17 31 .26 .44 .35
9.3 7.4 11.0
51 24 39 .26 .58 .37 13.4 14.0 14.3
72 33 49 .28 .89 .40 20.0 29.4 19.7
101 48 59 .32 1.48 .47 32.1 71.2 27.7
181 93 87 .53 4.93 .77 95.4 458.3 66.9
255 130 95 .82 9.40 1.21 209.4 1222.2 115.1
338 174 112 1.38 18.27 1.99 467.8 3178.4 222.9
6.2.3 Results from 3D regular meshes (nxnxn)
Table 6.6: Results of Experiments on nxnxn Regular Meshes, Random Input.
size
iterations
time/iteration (msecs) total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8
28 11 20 .32 1.54 .45
9.0 16.9 8.9
16 45 15 26 .78 10.13 1.07 35.0 152.0 27.7
32 62 23 29 4.46 78.23 6.28 276.7 1799.3 182.1
48 71 23 33 13.88 260.41 20.48 985.3 5989.4 675.9
Table 6.7: Results of Experiments on nxnxn Regular Meshes, Impulse Input.
size
iterations
time/iteration (msecs) total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8 34 12 23 .31 1.53 .43 10.7 18.3 9.8 16 61 20 34 .74 9.94 1.05 45.0 198.8 35.6 32 107 34 44 4.20 76.76 5.53 449.4 2609.8 243.1 48 144 45 54 12.62 251.93 18.69 1818.4 11336.8 1009.1
page 105
6.2.4 Results from 3D regular meshes (8x8xn)
page 106
Table 6.8: Results of Experiments on 8x8xn Regular Meshes, Random Input.
size
iterations
time/iteration (msecs)
total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8 16 32 64 128 256 512 1024
38 15 51 18 72 24 115 38 186 66 292 94 426 138 815 261
29 .30 1.49 .48 11.5 22.3 13.8 31 .38 2.68 .58 19.2 48.2 18.0 29 .49 5.01 .80 35.4 120.3 23.2 32 .66 9.54 1.13 76.3 362.7 36.3 38 1.15 18.66 1.98 214.6 1231.8 75.2 53 1.99 37.67 3.24 580.9 3446.7 171.9 72 3.74 72.95 5.91 1591.6 10066.6 425.2 90 7.05 145.01 11.57 5741.8 37848.2 1041.7
Table 6.9: Results of Experiments on 8x8xn Regular Meshes, Impulse Input.
size
iterations
time/iteration (msecs)
total time (msecs)
n DSCG ICCG STCG DSCG ICCG STCG DSCG ICCG STCG
8 49 16 35 .30 1.48 .46 14.8 23.6 16.2 16 64 22 39 .36 2.65 .57 23.2 58.4 22.2 32 98 32 41 .48 4.94 .77 46.7 158.2 31.7 64 145 47 45 .69 9.47 1.06 100.7 445.2 47.6 128 246 79 54 1.16 18.57 1.88 285.3 1467.1 101.7 256 453 147 63 1.95 36.58 3.31 881.3 5377.3 208.7 512 870 282 83 3.71 72.62 5.95 3230.7 20479.8 493.9 1024 1714 553 111 6.96 144.32 11.32 11935.6 79811.1 1256.7
page 107 6.3 Summary and Discussion In this chapter, we presented an evaluation of support tree preconditioners. Through numerical experiments run on a single vector processor of a Cray C-90, we have demonstrated that on both irregular and regular meshes: · the performance of STCG, in terms of iterations to converge, meets or exceeds the performance of ICCG, which in turn, outperforms DSCG. In all but one of the sets of experiments reported here, STCG began to outperform ICCG on fairly small matrices (2000 to 5000 nodes), with the difference in performance increasing with the size of the problem. In the experiments in which STCG did not outperform ICCG in terms of convergence rate, convergence was extremely rapid, so acceleration from preconditioning had a minimal effect, and STCG exhibited performance very close to that of ICCG. On problems that take many iterations to converge, STCG requires far fewer iterations than does ICCG. · in terms of execution time, STCG outperforms both ICCG and DSCG on scalar processors, and far outperforms them on vector processors. On a scalar machine, execution time is the product of the number of iterations and the time/work per iteration. In comparison to DSCG, our analysis showed that STCG requires slightly less than twice the amount of work per iteration, and our experiments showed that STCG requires fewer than half the number of iterations. Hence, STCG is preferable to DSCG for large problems on a scalar processor. Analysis also showed that STCG requires less work per iteration than ICCG, and our experiments showed that, in most cases, STCG requires fewer iterations. Therefore, STCG is also preferable to ICCG on scalar processors. All our experiments were performed on a single vector processor of a Cray C-90. Without exception, for large meshes STCG outperformed both DSCG and ICCG, often by very wide margins.The reason for the performance advantage is that the STCG preconditioner has a tree structure, which allows all nodes at a given level to be evaluated in parallel. STCG preconditioners can be easily and efficiently level scheduled by leaf raking. The lower triangular matrices that appear in ICCG will not, in general, allow as many nodes to be evaluated in parallel as can be evaluated in STCG. For example, in the case of square meshes, moderate parallel efficiency can be obtained by ordering the nodes so that the incomplete Cholesky preconditioner is evaluated along diagonals of the mesh [Dongarra, et al (1991), Golub and Ortega (1993), van der Vorst (1989b)]; for an nxn mesh, this ordering requires 2n parallel steps with an average of n/2 nodes evaluated in parallel at each step. In contrast, the STCG preconditioner for an nxn mesh yields 2 log n parallel steps with an average of n2/logn nodes evaluated at each step. For irregular graphs, the ordering problem is even more complicated. Figure 6.11 shows the graph structure of the incomplete Cholesky preconditioner for the fifth mesh in the crack series (160 nodes). An examination of the graph shows that it would be difficult to determine an optimal evaluation order for level scheduling. In contrast, Figure 6.12 shows the graph structure of the support tree preconditioner for the same graph. The simplicity of the support tree structure is apparent. Moreover, we believe that the regular structure of the support tree also makes implementation easier on distributed memory machines by reducing the amount of communication and synchronization required. Additional parallelism of STCG is possible due to the tree structure of the STCG preconditioner -- separate subtrees may be evaluated in parallel on multiple vector processors. .
page 108 Figure 6.11: The graph structure of the incomplete Cholesky preconditioner for the 160 node crack mesh. Figure 6.12: The graph structure of the support tree preconditioner for the 160 node crack mesh.
page 109
7 Extensions and Applications of Combinatorial Analysis
Chapters 3-6 of this thesis presented a description of a new class of combinatorial preconditioners. The theoretical properties of these preconditioners were analyzed with a collection of tools based on the equivalence of Laplacian matrices, resistive networks, and edge-weighted, undirected graphs. In this chapter, we show how the same set of tools can be used to extend the domain of support trees to all symmetric diagonally dominant matrices. We also show how the techniques used to analyze support tree performance can be used in the analysis of a standard problem in linear algebra.
7.1 Symmetric and Diagonally Dominant Matrices
In the preceding chapters, support trees were defined and analyzed for coefficient matrices that were symmetric, diagonally dominant, and had non-positive off-diagonal elements. There is a very straightforward way to extend support trees to handle all symmetric and diagonally dominant matrices. Consider the case of real symmetric diagonally dominant matrices with some positive off-diagonal elements. One of the simplest examples is
M = 11
(7.1)
11
Writing out the equation for the first component of i = Mu yields i1 = u1 + u2 = u1­(­u2) . That is, i1 looks like the current resulting from a resistive connection between node n1 and the negative of node n2! Therefore, we get the should get the same result for i1 and i2 using M as we would from the matrix of a network twice as large in which node n1 is connected to a node n2 and n2 is connected to n1, where u1 = -u1 and u2 = -u2. The corresponding linear system is shown below.
page 110
i1
1 0 0 ­1 u1
i2 = 0 1 ­1 0 u2
(7.2)
­i1
0 ­1 1 0 ­u1
­i2
­1 0 0 1 ­u2
A positive off-diagonal in some sense represents a negative conductance, but can be realized in a network of twice the size using only positive conductances. The networks corresponding to the matrices in (7.1) and (7.2) are illustrated in Figure 7.1.
v1 c12 = -1 v2
v1 c12 = 1
v2 c12 = 1
-v1
-v2
1 0 0 ­1
11
0 1 ­1 0
11
0 ­1 1 0
­1 0 0 1
Figure 7.1: Resistive Networks with Negative Conductance. a) A simple network with negative conductance. b) The corresponding network with positive conductances.
We now formalize these observations. First, we expand the notion of a Laplacian matrix to that of a generalized Laplacian, which may include positive off-diagonals: 7.1 Definition: (generalized Laplacian) L is a generalized Laplacian matrix (generalized Laplacian) if L is real, symmetric, and diagonally dominant. Next, we define the notion of an expanded matrix, which formalizes the relationship between generalized Laplacian matrices like that in (7.1), and the larger related Laplacian matrices like that in (7.2). 7.2 Definition: (expanded matrix) Let L be an nxn generalized Laplacian matrix. Then L = N + P, where N is a Laplacian matrix and P is symmetric and diagonally dominant with non-negative off-diagonals. Let M = M1 + M2 be a 2nx2n matrix constructed as follows: · M1(i,j) = M1(n+i,n+j) = N(i,j), 1 i,j n · if P(i,j) = P(j,i) 0, then · M2(i,i) = M2(n+i,n+i) = P(i,i); · M2(j,j) = M2(n+j,n+j) = P(j,j); · M2(i,n+j) = M2(n+j,i) = -P(i,j); · M2(j,n+i) = M2(n+i,j) = -P(j,i). M is a 2nx2n Laplacian matrix; we call M the expanded matrix, or expansion, of L. Note that, if M is a standard Laplacian, then the expansion of M is simply M = L 0 . 0L
page 111
7.3 Lemma: Let L be an nxn generalized Laplacian matrix. Let M be the expansion of L. Let u be any vector of applied voltages u = u1 ... un t , and let w = u1 ... un (­u1) ... (­un) t , i = Lu , and j = Mw. Then, for all k {1...n} , we have ik = jk = ­ jn + k.
proof:
Let k {1,...,n}. From the construction of M, we have that L can be written as L = N + P, where N is a Laplacian and P is symmetric and diagonally dominant with non-negative off-diagonals. Let R = {r1,...,rm} be the set of non-zero indices of the kth row of N, and S = {s1,...sq} be the set of non-zero indices of the kth row of P. Assume that r1 and s1 are the indices of the diagonal elements: r1 = k = s1. Then,
ik
=
R
N
(
k,
rl
)url
+
S
P(k,
st
)ust
and,
jk
=
F ( k, R
rl)wrl
+
F ( k, S
st
+
n)wst
=
R
N
(k,
rl)url
+
S\s1
­P(
k,
st
)(
­ust)
+
P(
k,
s1
)us1
=
R
N
(
k,
rl
)url
+
S
P(k,
st
)ust
= ik
And a similar derivation shows ik = -jk+n.

The definitions and lemma above show that a generalized Laplacian formally corresponds to a Laplacian of twice the size, the expansion. Since the expansion is a Laplacian, all the tools developed in the previous chapters can now be applied. We can now construct a support tree for any symmetric diagonally dominant matrix L by first constructing the expansion M, and then using the graph structure of M to construct a support tree for M. STCG can then be applied to the linear system defined by M, which is only a constant factor larger than that defined by L.
It may be the case that while L is non-singular with some positive off-diagonals, the graph corresponding to M consists of two unconnected components. This can be easily detected by running a connected components algorithm on the graph of M. Such algorithms have run times of order O(mlogn), where m is the number of edges and n is the number of nodes. Since we are dealing with sparse graphs, m is O(n), so connectivity can be determined in nearly linear time.
Let L be a generalized Laplacian with expansion M. It may be that the graph topology underlying L contains information that may be used to construct the support tree for M. This is an area of research that we have not pursued.
7.2 Bounding the Largest Eigenvalue
In this section, we show how the theoretical tools developed for support tree analysis can be applied to a standard problem in linear algebra -- bounding the eigenvalues of a matrix. This is a problem of both theoretical and practical interest. For example, given a symmetric positive definite matrix A, for polynomial preconditioning and for Chebyshev acceleration, it is necessary to know an interval I = [a,b] which contains the spectrum of A, (A). [Ashby (1987), Hageman and Young (1981)].
page 112 A common method for finding an upper bound on the eigenvalues is the Gerschgorin Circle Theorem. Following the treatment of Golub and Ortega (1993), let A be a square matrix of order n, and define ri = aij , i = 1, ..., n ji i = {z: z­aii ri} , i = 1, ..., n Then the i are disks in the complex plane centered at aii with radius ri. 7.4 Gerschgorin's Theorem: All the eigenvalues of A lie in the union of the disks 1,..., n. Moreover, if S is a union of m disks such that S is disjoint from all the other disks, then S contains exactly m eigenvalues of A (counting multiplicities). Thus, using Gerschgorin's Theorem, the magnitude of max, the largest eigenvalue of A, must be less than or equal to the furthest extent of any of the Gerschgorin disks. That is, for a matrix with all real eigenvalues: max maxi{aii + ri} Gerschgorin's Theorem provides a quick and easy way to estimate eigenvalues. For a real symmetric matrix, simply compute the sum of the absolute values of all the elements on a row/column of the matrix; the largest sum is an upper bound on max. The combinatorial techniques developed for the analysis of support tree preconditioners can be used to quickly supply a bound on the maximum eigenvalue for real symmetric non-diagonal matrices that can be tighter than that obtained using Gerschgorin's Theorem. In particular, Lemma 7.7 will show that for matrices corresponding to connected graphs, the method is to simply find the largest sum of two diagonal elements that are connected by a non-zero off-diagonal; that is,
max max{aii + a jj:aij 0} .
(7.3)
For many graphs, this method often provides a tighter bound than does Gerschgorin's Theorem. A similar result for all Laplacian matrices is presented in Theorem 7.8.
To illustrate the application of Gerschgorin's Theorem and our combinatorial result, several example matrices are presented in Figure 7.2. All of the eigenvalues were computed using Matlab [MathWorks (1992)].
· The Dirichlet matrix of order 4 shown at the top of the figure is derived from a finite difference discretiza- tion of Laplace's equation in one dimension with Dirichlet boundary conditions: the actual value of max is 3.6180, while the Gerschgorin and combinatorial bounds are both 4.0.
· The Poisson matrix of order 9 shown at the center of the figure is the Laplacian matrix of a 3x3 mesh: the actual value of max is 6.0, the Gerschgorin bound is 8.0, and the combinatorial bound is 7.0. For the Dirichlet and Poisson matrices, the Gerschgorin bounds are quite good, and the combinatorial bound pro- vides little improvement.
· The Laplacian matrix of a "wagon wheel" graph of order 9, is shown at the bottom of the figure: the actual value of max is 9.0, the Gerschgorin bound is 16.0, and the combinatorial bound is 11.0. The theory behind this new method of combinatorial eigenvalue estimation is only the newest of many results that combine the seemingly different areas of matrix theory, graph theory, and circuit theory. Fiedler (1973) was one of the first to establish an interesting relationship between a graph and its corresponding connectivity matrix. He showed that 2, the second-smallest eigenvalue of the connectivity matrix of a graph, is non-zero if and only if the graph is
page 113 2 ­1 0 0 D = ­1 2 ­1 0 0 ­1 2 ­1 0 0 ­1 2 Dirichlet matrix of order 4. max = 3.6180, Gerschgorin bound = 4.0, combinatorial bound = 4.0 2 ­1 0 ­1 0 0 0 0 0 ­1 3 ­1 0 ­1 0 0 0 0 0 ­1 2 0 0 ­1 0 0 0 ­1 0 0 3 ­1 0 ­1 0 0 P = 0 ­1 0 ­1 4 ­1 0 ­1 0 0 0 ­1 0 ­1 3 0 0 ­1 0 0 0 ­1 0 0 2 ­1 0 0 0 0 0 ­1 0 ­1 3 ­1 0 0 0 0 0 ­1 0 ­1 2 Poisson matrix of order 9. max = 6.0, Gerschgorin bound = 8.0, combinatorial bound =7.0 3 ­1 0 0 0 0 0 ­1 ­1 ­1 3 ­1 0 0 0 0 0 ­1 0 ­1 3 ­1 0 0 0 0 ­1 0 0 ­1 3 ­1 0 0 0 ­1 W = 0 0 0 ­1 3 ­1 0 0 ­1 0 0 0 0 ­1 3 ­1 0 ­1 0 0 0 0 0 ­1 3 ­1 ­1 ­1 0 0 0 0 0 ­1 3 ­1 ­1 ­1 ­1 ­1 ­1 ­1 ­1 ­1 8 "Wagon wheel" matrix of order 9. max = 9.0, Gerschgorin bound = 16.0, combinatorial bound = 11.0 Figure 7.2: Example matrices with maximum eigenvalues, Gerschgorin bounds, and combinatorial bounds. connected; he called 2 the algebraic connectivity of the graph. Pothen, et al (1990), and Hendrickson and Leland (1992) are among the proponents of the spectral approach to graph partitioning, which uses the eigenvectors of the connectivity matrix of a graph to partition the graph. Chandra, et al (1989), and Doyle and Snell (1984) discuss the relationship between the resistance of the electrical network corresponding to a graph and properties of random walks on the graphs. Our theory builds primarily on these latter results dealing with the electrical resistance of a graph. In particular, we show that the largest eigenvalue of a matrix is bounded by the gain factor needed for one type of circuit to conduct the same amount of current as the circuit corresponding to the matrix. Since (A) = (A,I), we can apply the same methods used for bounding finite generalized eigenvalues of Laplacian
page 114
matrices to bounding eigenvalues of any real symmetric matrices. We start by bounding eigenvalues of generalized Laplacian matrices. The trick is to use the augmented matrix instead of the generalized Laplacian. This is justified with the following lemma.
7.5 Lemma: Let A and B be Laplacian matrices with augmentations E and F respectively. If is a finite generalized eigenvalue with corresponding eigenvector x such that
Ax = Bx
then proof:
Ey = Fy , where y = x . 0
A and B are Laplacian matrices, so there exist matrices M, N, R, and S such that A = M + R, B = N + S, where M and N have the zero row/column sum property, and both R and S are diagonal. let r = diag(R), and s = diag(S), where diag(A) = [a11,...,ann]t. The augmentation process yields matrices E and F, where
E=
A ­r , F = ­rt rt1
B ­s , and 1 = ­st st1
1 ... 1 t.
Let (A,B), with associated unit eigenvector x. Then, Ax = Bx
1tAx = 1tBx
1t(M + R)x = 1t(N + S)x
1tMx + 1tRx = 1tNx + 1tSx M and N have the zero column sum property, 1tMx = 0 = 1tNx , so the equation above yields
1tRx = 1tSx
rtx = stx
Now, let y = [xt,0]t, and consider Ey and Fy:
Fy = B ­s x = Bx
­st st1 0
­st x
Ey = A ­r x = Ax = Bx = Fy
­rt rt1 0
­rt x
­st x

page 115
The lemma above holds for Laplacian matrices. To deal with generalized Laplacians (those with some positive offdiagonal values), we need to first compute the expansion, then the augmentation. That an upper bound on the eigenvalues of the expansion is also an upper bound of the eigenvalues of the original generalized Laplacian is shown in the next lemma. 7.6 Lemma: Let A be a generalized Laplacian matrix, and let M be the expansion of A. Then max(A) max(M). proof: If A contains no positive off-diagonals, then M is simply double the size of A, with a copy of A at the upper left and lower right corners (and 0 elsewhere). Therefore the eigenvalues of M are simply the eigenvalues of A with twice the multiplicity. Thus, max(A) max(M). Suppose A contains at least one positive off-diagonal. Then M is constructed so that, given any vector u, M u = Au ­u ­Au Let x be a unit eigenvector corresponding to m = max(A). Then
Mx ­x
=
Ax ­Ax
=
m x ­m x
=
m
x ­x
So m is also an eigenvector of M. Therefore max(A) = m max(M).
Consider bounding the largest eigenvalue of the matrix A corresponding to a simple path on 4 points with no ground- ing. That is, we are trying to bound max(A) = max(A,I). The steps in determining a combinatorial bound are illustrated in Figure 7.3. The first step is to augment A to form E, and I to form J. Then, we use the combinatorial techniques developed in Chapter 4 to bound max(E,J), the largest finite generalized eigenvalue of (E,J). To do this, the network corresponding to J is partitioned to support each of the edges in E. The worst support is for the central edge between nodes v2 and v3. This edge has conductance 1 and is supported by a path of length 2 with conductances of 1/2, yielding a support number of 4. Therefore max(A) 4.0, which in this case is identical to the Gerschgorin estimate. The actual eigenvalue determined using Matlab is 2.6180.
This example previews the technique that will be used to prove the main result in this chapter.
page 116
1
1
1
v1
v1
v2
v3
v4
1
a)
1 ­1 0 0
A = ­1 2 ­1 0 0 ­1 2 ­1
0 0 ­1 1
v2
v3
v4
1
1
1
1000 I = 0100 0010 0001
1
1
1
v1
v2
v3
v4
v1
v2
v3
v4
1 11 1
v0 b) 1 ­1 0 0 0 ­1 2 ­1 0 0 B = 0 ­1 2 ­1 0 0 0 ­1 1 0 0 0 0 00
v0 1 0 0 0 ­1 0 1 0 0 ­1 J = 0 0 1 0 ­1 0 0 0 1 ­1 ­1 ­1 ­1 ­1 4
v1
1
v2 v2
1
v3 v3
1
v4
c)
1 1/2
1/2 1/2
1/2
1
12=3
23=4
34=3
Figure 7.3: Bounding Eigenvalues with Augmentation and Support Analysis. a) A is the matrix of a path, while I is the identity matrix. b) B is the augmentation of A; J is the augmentation of I; v0 is the ground node. c) The edges of J have been partitioned to support the edges of B. The edges of B have been disconnected from each other in order to clarify the support relationships.
page 117
7.7 Lemma: Let A be a generalized Laplacian matrix corresponding to a connected graph. Let ri = aij , ji i = 1, ..., n . The largest eigenvalue of A, max, is bounded above by
proof:
max max{aii + a jj:aij 0}
Let A be a Laplacian matrix and B its augmentation. Let J be the augmentation of the identity matrix. Let vi be any node in the resistive network corresponding to B. Let i0 be the weight of the connection (if any) between vi and the ground node. Let the weights of the connections from vi to other nodes be denoted i1,...,im(i). Since the graph of A is connected, every node is connected to at least one other node. Suppose that vj is adjacent to vi, and let i1 = j1 be the weight of the edge between vi and vj. See Figure 7.4 for an illustration.
j2 ... jm(j)
j1=i1
im(i) ... i2
vj
j0
i0
vi
ground node Figure 7.4: Labeling the weights of connections to a node.
The network corresponding to J consists only of edges unit weight between the ground node and all the other nodes of B. Each of these connections to ground must be partitioned to provide support to the edges of B. Partition the edge from ground to node vi into m(i)+1 pieces such that the piece supporting the edge of B with weight ik has itself weight ik given by ik = -m----(-i--)-i--k----- il l=0 Similarly, partition the edge from ground to vj such that each edge of weight jk is supported by an edge of weight jk given by jk = -m----(-i--)--j--k----- jl l=0 This weighting assigns support proportional to the product of the conductance of the edge being supported and the length of the support path. Now, consider supporting the edge between vi and vj; this edge has weight i1 = j1. This is supported by a path of length 2, with total path conductance of
page 118
cij = --------------i----1----i----l---+1--------------------j----1----j---l = -----------i--l---+--i-1-------------j-l
The last equality follows from the fact that i1 = j1.
The support number is the gain factor needed to make the path conductance greater than or equal to the weight of the edge, and is therefore given by the ratio of the edge conductance to the path conductance. Therefore, the support of the edge being considered, ij, is given by
ij
=
-----i-1cij
=
i1 / -----------i--l---+--i-1-------------j-l
=
il + jl
From the relationship between Laplacian matrices and resistive networks, for any node vk, m(i) akk = jl . l=0 Therefore, we obtain
ij = aii + a jj . Similarly, from the definition of the support weighting, the support for the edge grounding node vi, ii, is


ii
=
i0 / i0
=
i
0
/
-m----(-i--)-i--0-----

=
m(i) il
=
aii


i
l
l=0
l=0
Applying the techniques from Chapter 4, we find that (B,J) max{ij}. Then, by applying Lemma 4.4, we have the result for Laplacian matrices.
Finally, any generalized Laplacian can be expanded to a Laplacian and the same procedure applied. Expansion does not change any of the diagonal values, so the result holds on the original matrix.
Now we have the tools needed to prove the main result.1
7.8 Theorem: Let A be a real symmetric matrix. Let ri = aij , i = 1, ..., n . The largest eigenvalue of A, ji max, is bounded above by
proof:
max max{{(aii + a jj):aij 0} {akk:akl = 0, l k}}
1. We would like to acknowledge and thank Dr. J. Demmel at the University of California at Berkeley who reviewed an early version of this chapter and found an error in a stronger version of this theorem.
page 119
Lemma 7.7 handled the case in which A was a generalized Laplacian corresponding to a connected graph. Therefore, consider the case when A is a generalized Laplacian, but corresponding to a graph with two or more connected components. Then A is called reducible, and there exists an ordering of the vertices in the graph corresponding to A such that A is block diagonal [Golub and Ortega (1993), Varga (1962)]. Each component with two or more vertices can be dealt with as in the proof of Lemma 7.7, and the same result holds. The catch comes when a component contains only a single, grounded node; this corresponds to a non-zero diagonal element akk for which all other entries in row/column k are zero. In such a case, only the grounded edge needs to be supported, and the support number is the conductance of that edge: akk. Figure 7.5 illustrates a simple example.
v1 1
v2 1 1
v3 5
v1
v2
v3
1
1
1
a) 2 ­1 0 A = ­1 2 0 0 05
100 I = 010 001
v1
v2
v3
1
1 1
5
v0 b) 2 ­1 0 ­1 B = ­1 2 0 ­1 0 0 5 ­5 ­1 ­1 ­5 7
v1
v2
v3
1
1
1
v0
1 0 0 ­1 J = 0 1 0 ­1 0 0 1 ­1 ­1 ­1 ­1 3
v1
v1
1
1 v2 1 v2
1/2
1/2 1/2 1/2
c)
5
v3
1
11=2
12=4
v0
22=2
33=5
Figure 7.5: Support Analysis for a Two-Component Graph. a) A is the matrix of a graph with two components; I is the identity matrix. b) B is the augmentation of A; J is the augmentation of I. c) The edges of J have been partitioned to support the edges of B. The edges of B have been disconnected to clarify the support relationships.
Now, consider the case in which A is symmetric, but not a generalized Laplacian. Assume that A is irreducible (that is, the graph of A contains a single connected component). Then A must not be diagonally dominant. In this case, A = L + D, where L is a generalized Laplacian with the zero row/column sum property, and D is a diagonal matrix. At least one of the elements of D must be negative.
page 120 Let = maxi{ dii } , and let B = A + I. Then B is a generalized Laplacian, and max(B) = max(A) + , By Lemma 7.7, max(B) max{(bii + b jj) / 2 : bij 0} . But, bii = aii + , so max(A) = max(B)­ max{(bii + b jj) / 2 : bij 0}­ = max{((aii + + a jj + ) / 2) : bij 0}­ = max{((aii + a jj) / 2 + ) : bij 0}­ = max{(aii + a jj) / 2 : bij 0} Now, in the case that A is reducible, the argument above holds as long as all the components have more that one vertex. In the case in which one or more components has a single, grounded vertex, then essentially the same sequence of steps follows. B is a generalized Laplacian, so we have: max(B) max{{(bii + b jj) / 2 : bij 0} {bkk : bkl = 0, l k}} As for the irreducible case, we then subtract from both sides, and the result follows.
As an example of the improved bounds possible with this combinatorial estimate, consider the matrix/graph shown in Figure 7.6. The graph resulted from the finite element discretization of a cracked plate (the crack runs from the center of the left side to the center of the plate), and is the first in a sequence of mesh refinements. The matrix shown is the Laplacian of the graph in which all edges have been assigned unit weight. · The Gerschgorin bound on the largest eigenvalue of the matrix is 18.0. · The combinatorial bound using the formula from Theorem 7.8 is 12.0. · The largest eigenvalue (obtained using Matlab) is 10.0. 7.3 Summary In this chapter, we have shown how to extend the use of support trees as preconditioners to the class of generalized Laplacian matrices, which are matrices which are symmetric and diagonally dominant. The method is straightforward, involving creation of a graph of double the size of the original graph (corresponding to the expansion of the generalized Laplacian), and constructing a support tree for that graph. There may exist methods to construct support trees for generalized Laplacian that do not involve creation of the expanded graph; we have not yet researched this issue. The class of generalized Laplacians are the largest class of matrices for which support trees can presently be constructed. The extension of support tree technology to the class of symmetric positive definite matrices is the next log-
page 121
4
7
10
3 ­1 0 0 ­1 ­1 0 0 0 0
­1 2 0 0 0 ­1 0 0 0 0
0 0 2 ­1 0 ­1 0 0 0 0
0 0 ­1 3 0 ­1 ­1 0 0 0
3
6
­1 0 0 0 3 ­1 0 ­1 0 0
2
9
­1 ­1 ­1 ­1 ­1 9 ­1 ­1 ­1 ­1
0 0 0 ­1 0 ­1 3 0 0 ­1
0 0 0 0 ­1 ­1 0 3 ­1 0
0 0 0 0 0 ­1 0 ­1 3 ­1
0 0 0 0 0 ­1 ­1 0 ­1 3
1
5
8
Figure 7.6: Finite Element Mesh and Laplacian Matrix The graph was obtained from a finite element discretization of a cracked plate. The crack runs from the left side to the center. Nodes 2 and 3 are colocated in space, but lie on opposite sides of the crack, and are not connected. The matrix is the Laplacian of the graph with unit edges.
ical step, and remains a research issue.
In addition to the extension of the support tree technology to generalized Laplacians, we also demonstrated the application of combinatorial techniques to the problem of bounding the largest eigenvalue of a symmetric matrix. We showed that, in some cases, the combinatorial estimate can be better than an estimate made using Gerschgorin's Theorem. The combinatorial estimate has a particularly simple form, and can be easier to compute that the Gerschgorin estimate.
page 122
123 8 Discussion and Recommendations This thesis presented a new approach to the parallel iterative solution of linear systems. In this chapter, we discuss the results presented in the previous chapters, and present recommendations for future work in this area. 8.1 Support Tree Conjugate Gradients The support tree conjugate gradients (STCG) method is a variation of preconditioned conjugate gradients (PCG), and is characterized by the form of the preconditioner. Standard preconditioned conjugate gradients methods, like diagonal scaling (DSCG), incomplete Cholesky (ICCG), modified incomplete Cholesky (MICCG), or symmetric successive over-relaxation (SSOR-CG) are constructed based on the algebraic properties of the coefficient matrix. In fact, each of the standard preconditioners can be defined by a straightforward algebraic equation involving a decomposition of the coefficient matrix into additive terms. In contrast, a support tree preconditioner is defined by a construction procedure that is dependent upon the topological properties of the coefficient matrix. STCG can only be applied when the coefficient matrix is a generalized Laplacian; that is, the coefficient matrix must be symmetric and diagonally dominant. The construction procedure reported in Chapter 3 only applies to Laplacian matrices (symmetric, diagonally dominant, with non-positive off-diagonals), although Chapter 7 reported a technique that can be used on a linear system with a coefficient matrix that is a generalized Laplacian to construct an equivalent linear system with a Laplacian coefficient matrix. Unlike standard preconditioners, support trees were designed with parallel computation in mind. The construction of support trees is a straightforward implementation of recursive divide-and-conquer, which can be easily parallelized. The application of support trees takes advantage of the parallel efficiency obtainable with tree structures. 8.1.1 STCG performance Three requirements for a "good" preconditioner B given a coefficient matrix A were stated in similar terms by both Axelsson and Barker (1984), and van der Vorst (1989). We can evaluate STCG based on these requirements. 1. (B-1A) should be significantly less than (A).
124 In Chapter 4, we defined a model problem discretized onto an nxn mesh for which (A) = O(n2) [Guo(1990)]; we showed that (B­1 A) = O(nlogn) for B the reduction of a support tree. In contrast, we have the following for the standard preconditioners [Guo (1990)]: · DSCG is O(n2); · ICCG is O(n2); · MICCG is O(n) with the optimal relaxation parameter; · SSOR-CG is O(n) with the optimal relaxation parameter. Therefore, STCG has a better condition number than the simple DSCG and ICCG preconditioners, but not as good as the more elaborate MICCG and SSOR-CG preconditioners. However, these more elaborate preconditioners require optimal relaxation parameters to achieve the best results, and the computation of these parameters depends on algebraic properties of the coefficient matrices and can be difficult to compute. 2. The preconditioner should be easy to compute. Support trees are straightforward to compute using standard methods for graph partitioning. No elaborate, special purpose data structures are required. 3. The preconditioned system should be easy to solve; that is, the time required to solve the preconditioned system should be small with respect to the time required for an unpreconditioned iteration. Support trees are very sparse; as shown in Chapter 3, support trees can be more sparse (that is, have fewer non-zeros) than the original coefficient matrix. Moreover, the support tree provides an extremely regular data structure for efficient execution. Therefore, STCG can be implemented at least as efficiently as general versions of ICCG (recall from Chapter 3 that there is a particularly efficient implementation of ICCG applicable to matrices whose corresponding graphs have no triangles), MICCG, or SSOR-CG; additionally, the regular structure of STCG should provide more efficiency. Only DSCG is more efficient on a per iteration basis than STCG, but DSCG requires significantly more iterations. Conditions 1 and 3 are not independent. In practice, the reduction in the number of iterations (condition 1) must be balanced against the time required to solve the preconditioned system (condition 3). A large reduction in condition number can lead to a significant reduction in the number of iterations, and justify the user of a preconditioner that requires a comparatively large amount of computation time to solve the preconditioned system. We have shown that support trees yield a significant reduction in the condition number while also requiring little time to solve the preconditioned system. 8.1.2 STCG parallel performance STCG was designed with parallel performance in mind. The construction of a support tree is an application of a recursive divide-and-conquer process. When bisection is used, each step of construction yields two smaller, simpler subproblems. Therefore, a complete support tree for a mesh with n2 nodes can be constructed in O(logn) parallel steps. Additionally, each partitioning step in support tree construction requires application of some graph partitioning algorithm. There is parallelism inherent in the partitioning algorithm which can also be taken advantage of. During application of STCG, each iteration involves solving the preconditioned system. As discussed in Chapter 3, this can be done particularly efficiently in parallel by applying leaf raking and the parallel evaluation of subtrees. In general, for a mesh with n2 nodes, STCG requires O(logn) parallel steps to solve the preconditioned system. In contrast, with diagonal ordering, ICCG, MICCG, and SSOR-CG require O(n) parallel steps. Again, DSCG is the most
125 efficient, requiring O(1) diagonal steps, although requiring many more iterations. 8.2 STCG is not Multigrid While similar in some respects to multilevel methods, STCG is not a multilevel method. The defining characteristic of a multilevel method or a multilevel preconditioner is the approximate solution of the underlying PDE at multiple levels of resolution. In contrast, STCG simply passes averaged information across the mesh using an alternate structure; no solution is computed at any level except the original. For most multilevel methods, each grid is a discretization of the underlying PDE, and the method depends on having a nested sequence of grids. In contrast, STCG makes no claims about the underlying PDE, and multiple grids are not required. Most multilevel methods, construction is bottom up, from coarse grids to fine. That is, the development of a multilevel method requires grid refinement; an exception to this is AMG (Algebraic MultiGrid). In contrast, STCG starts with the finest grid and does not utilize a nested sequence. The general statements above about multilevel methods do not apply to AMG. However, AMG is a complicated algorithm that applies local analysis to determine a coarse grid given an initial fine grid. AMG is applicable to the same class of matrices that STCG was initially constructed for - Laplacian matrices, but we have shown how STCG can be extended. Furthermore, we believe that STCG is a simpler algorithm. An example helps to highlight the difference in behavior between full multigrid, STCG, and CG. All three algorithms were run on the same problem, so that the number of iterations and the behavior of the iterates could be compared. · Figure 8.1 illustrates the qualitative convergence behavior of full multigrid on a simple example for which convergence took only 6 iterations of a complete V-cycle. The full multigrid used a single iteration of Gauss-Seidel for smoothing at each step. Notice that the shape and magnitude of the solution are nearly achieved at the first iteration. Succeeding iterations do little more than adjust the values of the iterates. · Figure 8.2 illustrates the behavior of STCG on the same simple example. The support tree used was constructed using binary partitioning and was boundary weighted. STCG took 21 iterations to converge, but only the first 5 iterates are shown. In the case of STCG, little of the solution's final shape is exhibited in the first iterate. Interestingly, though, the mesh partitioning is visible in the rough shape of the first iterate. Succeeding iterations add both shape and value. · illustrates the behavior of unpreconditioned CG on the same problem. CG took 28 iterations to converge, but only the first 5 iterates are shown. In the case of CG, the first iterate exhibits much of the shape of the final solution, but the values are too low. The figure shows that the iterates of CG change slowly, compared to those of the other two methods. The experiment reported in Figures 8.1 through 8.3 help place STCG within the taxonomy of iterative methods. CG is the most local of the three methods compared. The behavior of CG shows that local information (e.g.: the shape of the curves in Figure 8.3) is accurately communicated with the first iterate, but global information such as the average magnitude of the solution values is slow to propagate. CG is easy to implement, and requires no special knowledge of the PDE or the underlying mesh. The behavior of full multigrid shows that both local information and global information is propagated rapidly. Full multigrid is the most complex of the methods to implement, and often requires information beyond simply the coefficient matrix and the forcing function. STCG lies somewhere in between full multigrid and CG, both in performance and difficulty of implementation. STCG propagates averaged global information, but smooths out local variation in the early stages of iteration. STCG is straightforward to implement, and requires only the coefficient matrix and forcing function for construction.
126
25 k=5
20 k=4 15
k=3 k=2
k=1 10
solution
5
0
0
10
20
30
40
50
60
70
Figure 8.1: The convergence behavior of full multigrid. The first five iterates of full multigrid are shown as dotted lines. k is the iteration number. The solution is the solid line at the top of the figure.
25
20
solution
k=5
k=4 15
k=3
10
k=2
k=1 5
0
0
10
20
30
40
50
60
70
Figure 8.2: The convergence behavior of support tree conjugate gradient. The first five iterates of support tree conjugate gradients are shown as dotted lines. The solution is the solid line at the top of the figure.
25
20 solution 15 k=5
k=4 10
k=3
5
k=2
k=1
0
-5
-10 0
10
20
30
40
50
60
70
Figure 8.3: The convergence behavior of conjugate gradients.
The first five iterates of conjugate gradients are shown as dotted lines.
The solution is the solid line at the top of the figure.
127 8.3 Recommendations for Future Work 8.3.1 Optimal support trees In the preceding chapters, we chose simple rooted trees for the structure of our preconditioners. This topology was simply chosen because it naturally reflected the properties of the recursive divide-and-conquer approach that was used. The optimal shape for a preconditioner is an open question. Reflecting on the similarities and differences between support tree preconditioners and multilevel preconditioners, it is likely that the optimal shape includes some cycles. Recall that support trees are primarily characterized by supporting efficient communication across a mesh. Multilevel preconditioners, on the other hand, involve solving the problem on a coarser mesh. Figure 8.4 illustrates both types of preconditioners for a simple 4x4 mesh. The support tree shown in a) is easy to construct and has excellent parallel properties, but does not converge as quickly as the multilevel preconditioner shown in b) that is difficult to construct and has poorer parallel properties.
a)
b)
Figure 8.4: The topology of a support tree and a multilevel preconditioner. a) Support tree preconditioner for a 4x4 mesh. b) Multilevel preconditioner for a 4x4 mesh.
Recall that, for an nxn square mesh, the condition number of the coefficient matrix is O(n2). With a support tree preconditioner, the generalized condition number drops to O(nlog4n), while with a multilevel preconditioner, the generalized condition number is O(1). Clearly, solving the equation at a coarser level (multilevel) is more powerful than just passing averaged information (support trees). On the other hand, for an arbitrary graph, it is easier to construct a support tree, given only a coefficient matrix, than it is to devise a multilevel solution. A worthwhile research goal for the future would be investigate ways to combine the two techniques of STCG and multigrid to develop an easy to implement and powerful preconditioning technique. 8.3.2 Efficient implementation for generalized Laplacians In Chapter 7, we showed how to construct a Laplacian matrix equivalent to a generalized Laplacian. This construction involved doubling the number of nodes in the graph, and then making connections based on the sign of the connection in the original matrix. While this is satisfactory from a theoretical point of view, it is less than satisfactory from a practical point of view to double the size of the problem.
128 The generalized Laplacian clearly contains all the information in the expanded Laplacian of twice the size. It should therefore be possible to analyze the generalized Laplacian and construct the support tree without ever making the transformation to the larger, equivalent, expanded Laplacian matrix. A research goal for the future should be to focus on the mapping from a generalized Laplacian to its expansion and develop techniques to construct support trees for generalized Laplacians without ever performing the expansion step. 8.3.3 Extension to all symmetric positive definite matrices We discussed support trees initially in the context of Laplacian matrices, which are symmetric, diagonally dominant, and have only non-positive off-diagonals. In Chapter 7, we showed how to extend the approach to generalized Laplacians which are symmetric and diagonally dominant, but may have otherwise arbitrary off-diagonals. The next logical step is to extend the methodology to all symmetric positive definite matrices. 8.3.4 Additional numerical experiments Since STCG is a new method, more experimentation is needed to fully characterize it. The following additional numerical experiments should be performed: · Test STCG over a larger range of problems. In particular, problems should be used that have parameters that vary across the mesh, and are defined on highly irregular meshes. · Test STCG on multiple vector processors. In this thesis, we demonstrated the efficiency of STCG on a single vector processor of a Cray C-90. The performance improvement should be even greater if multiple vector processors are used and the support tree implementation takes advantage of both level scheduling and multiple independent subtrees. · Test STCG on a massively parallel processor. The structure of the support tree is very regular and involves relatively little communication and should therefore be a good candidate for efficient implementation on an MPP. · End-to-end timings of STCG should be performed. The performance analysis presented in this thesis only dealt with the performance of the iterative solution phase and ignored the timing for the construction phase. The construction of support trees requires repeated application of some graph partitioning algorithm, and the efficient parallel implementation of graph partitioning is a research topic in itself. A complete study of the performance of STCG should be conducted that includes the timings for construction using a variety of efficiently implemented graph partitioning algorithms. 8.3.5 Additional theory The analysis of support trees involved an interesting application of graph theory to linear systems and should be continued to further explore the relationships between graph theory and linear systems.
129 9 References [1] Alon, N., Seymour, P., and Thomas, R. (1990). A separator theorem for graphs with an excluded minor and its applications. Proc. of the 22nd Annual ACM Symposium on Theory of Computing, pp. 293-299. [2] Alvarado, F. L., and Schreiber, R. (1993). Optimal parallel solution of sparse triangular systems. SIAM J. Sci. Comput. 14(2):446-460. [3] Anderson, E., and Saad, Y. (1989). Solving sparse triangular linear systems on parallel computers. Int. J. of High Speed Computing 1(1):73-95. [4] Arioli, M., Duff, I., and Ruiz, D. (1992). Stopping criteria for iterative solvers. SIAM J. Matrix Anal. Appl. 13(1):138-144. [5] Ashby, S. F. (1987). Polynomial preconditioning for conjugate gradient methods. UIUCDCS-R-87-1355, Department of Computer Science, University of Illinois at Urbana-Champaign. [6] Axelsson, O. (1992). Bounds of eigenvalues of preconditioned matrices. SIAM J. Matrix Anal. Appl., 13(3):847-862. [7] Axelsson, O. (1994). Iterative Solution Methods. Cambridge University Press. [8] Axelsson, O., and Barker, V. A. (1984). Finite Element Solution of Boundary Value Problems. Academic Press. [9] Axelsson, O., and Lindskog, G. (1986). On the rate of convergence of the preconditioned conjugate gradient method. Numer. Math. 48:499-523. [10] Axelsson, O., and Vassilevski, P.S. (1989). Algebraic multilevel preconditioning methods. I. Numer. Math., 56:157-177.
130 [11] Axelsson, O., and Vassilevski, P.S. (1990). Algebraic multilevel preconditioning methods. II. Numer. Math., 56:157-177. [12] Bank, R. E., and Dupont, T. F. (1981) An optimal order process for solving finite element equations. Math. Comput. 36:35-51. [13] Blelloch, G. E. (1993). NESL: A nested data-parallel language. CMU-CS-93-129, School of Computer Science, Carnegie Mellon University. [14] Blelloch, G. E. (1990). Vector Models for Data-Parallel Computing. MIT Press. [15] Blelloch, G., Feldmann, A., Ghattas, O., Gilbert, J., Miller, G., O'Hallaron, D. R., Schwabe, E., Shewchuk, J., and Teng, S. -H. (1992). Automated parallel solution of unstructured PDE problems. Proc. of the 1992 DAGS/ PC Symposium. [16] Blelloch, G. E., Heroux, M. A., and Zagha, M. (1993). Segmented operations for sparse matrix computation on vector multiprocessors. CMU-CS-93-173, School of Computer Science, Carnegie Mellon University. [17] Bollabas, B. (1979). Graph Theory: An Introductory Course. Springer-Verlag. [18] Braess, D. and Hackbusch, W. (1983). A new convergence proof for the multigrid method including the Vcycle. SIAM J. Numer. Anal., 20:986-975. [19] Bramble, J. H., Pasciak, J. E., and Xu, J. (1990). Parallel multilevel preconditioners. Math. Comp. 55:1-22. [20] Brandt, A. (1977). Multi-level adaptive solutions to boundary-value problems. Math. Comp. 31:333-390. [21] Brandt, A., McCormick, S. F., and Ruge, J. (1982). Algebraic multigrid (AMF) for automatic algorithm design and problem solution. A preliminary report. Inst. Comp. Studies, Colorado State University. [22] Briggs, W. L. (1987). A Multigrid Tutorial. SIAM. [23] Chan, T. F., and Mathew, T. P. (1994). Domain decomposition algorithms. Acta Numerica, pp. 61-143. [24] Chandra, A. K., Raghavan, P., Ruzzo, W. L., Smolensky, R., and Tiwari, P. (1989). The electrical resistance of a graph captures its commute and cover times. Proceedings of the 21st Annual ACM Symposium on Theory of Computing, pp. 574-586. [25] Chartrand, G. (1977). Introductory Graph Theory. Dover. [26] Dagum, L. (1993). Automatic partitioning of unstructured grids into connected components. Proc. Supercomputing `93. [27] Djidjev, H. N. (1982). On the problem of partitioning planar graphs. SIAM J. Alg. Disc. Meth. 3(2):229-240. [28] Donath, W. E. (1988). Logic Partitioning. in Preas, B. T., and Lorenzetti, M. J., eds., Physical Design Automation of VLSI Systems, pp. 65-86. Benjamin/Cummings. [29] Donath, W. E., and Hoffman, A. J. (1972). Algorithms for partitioning of graphs and computer logic based on eigenvectors of connection matrices. IBM Technical Disclosure Bulletin, 15:938-944. [30] Dongarra, J. J., Duff, I. S., Sorensen, D. C., and van der Vorst, H. A. (1991). Solving Linear Systems on Vector and Shared Memory Computers. SIAM.
131 [31] Doyle, P. G., and Snell, J. L. (1984). Random Walks and Electric Networks. Carus Mathematical Monographs #22, Mathematical Association of America. [32] Duff, I. S., Erisman, A. M., and Reid, J. K. (1986). Direct Methods for Sparse Matrices. Clarendon Press. [33] Duff, I. S., and Meurant, G. A. (1989). The effect of ordering on preconditioned conjugate gradients. BIT 29:635-657. [34] Eisenstat, S. C. (1981). Efficient implementation of a class of preconditioned conjugate gradient methods. SIAM J. Sci. Stat. Comput. 2:1-4. [35] Farhat, C., and Lesoinne, M. (1993). Automatic partitioning of unstructured meshes for the parallel solution of problems in computational mechanics. Int. J. Num. Meth. Eng. 36:745-764. [36] Fiduccia, C. M., and Mattheyses, R. M. (1982). A linear time heuristic for improving network partitions. Proc. 19th Design Automation Conference, pp. 175-181. [37] Fiedler, M. (1973). Algebraic connectivity of graphs. Czechoslovak Math. J. 23(98): 298-305. [38] Ford, L. R., and Fulkerson, D. R. (1956). Maximal flow through a network. Canad. J. Math., 8:399-404. [39] Ford, L. R., and Fulkerson, D. R. (1962). Flows in Networks. Princton Univ. Press. [40] Garey, M. R., and Johnson, D. S. (1979). Computers and Intractability. Freeman. [41] Garey, M. R., Johnson, D. S., and Stockmeyer, L. (1976). Some simplified NP-complete graph problems. Theoretical Computer Science, pp. 237-267. [42] Gazit, H. and Miller, G. L. (1987). A parallel algorithm for finding a separator in planar graphs. Proc. of the 28th Annual Symposium on Foundations of Computer Science, pp. 238-248. [43] George, A., and Liu, J. W. (1981). Computer Solution of Large Sparse Positive Definite Systems. PrenticeHall. [44] Gilbert, J. R. (1980). Graph Separator Theorems and Sparse Gaussian Elimination. Ph. D. Thesis, Department of Computer Science, Stanford University. [45] Gilbert, J. R., Hutchinson, J. P., and Tarjan, R. E. (1984). A separator theorem for graphs of bounded genus. J. Algorithms 5:391-407. [46] Gilbert, J. R., and Tarjan, R. E. (1987). The analysis of a nested dissection algorithm. Numer. Math. 50(4):377-404. [47] Golub, G. and O'Leary, D. (1989). Some history of the conjugate gradient and Lanczos algorithms: 19481976. SIAM Rev. 31:50-102. [48] Golub, G., and Ortega, J. M. (1993). Scientific Computing: An Introduction with Parallel Computing. Academic Press. [49] Golub, G. H., and Van Loan, C. F. (1989). Matrix Computations. Johns Hopkins University Press. [50] Greenbaum, A., Li, C., and Chao, H. Z. (1989). Comparison of linear system solvers applied to diffusion-type finite element equations. Numer. Math. 56:529-546.
132 [51] Gremban, K. D., Miller, G. L, and Teng, S. -H. (1994). Moments of inertia and graph separators. 5th Annual ACM-SIAM Symposium on Discrete Algorithms. [52] Gremban, K. D., Miller, G. L., and Zagha, M. (1994). Performance evaluation of a new parallel preconditioner. CMU-CS-94-205, School of Computer Science, Carnegie Mellon University. [53] Gremban, K. D., Miller, G. L., and Zagha, M. (1995). Performance evaluation of a new parallel preconditioner. Proc. of the 9th International Parallel Processing Symposium, pp. 65-69. [54] Guattery, S. and Miller, G. L. (1994). On the performance of spectral graph partitioning methods. CMU-CS94-228. School of Computer Science, Carnegie Mellon University. [55] Guattery, S. and Miller, G. L. (1995). On the performance of spectral graph partitioning methods. Proc. of the 6th Annual ACM/SIAM Symposium on Discrete Algorithms. [56] Guo, X. -Z. (1992). Multilevel Preconditioners: Analysis, performance enhancements, and parallel algorithms. CS-TR-2903, Department of Mathematics, University of Maryland. [57] Gustafsson, I. (1978). A class of first order factorizations. BIT, 18:142-156. [58] Hackbusch, W. (1994). Iterative Solution of Large Sparse Systems of Equations. Springer-Verlag. [59] Hageman, L. A., and Young, D. M. (1981). Applied Iterative Methods. Academic Press. [60] Hajek, B. (1988). Cooling schedules for optimal annealing. Math. Oper. Res. 13:311. [61] Harary, F. (1969). Graph Theory. Addison-Wesley. [62] Heath, M. T., Ng, E., and Peyton, B. W. (1990). Parallel algorithms for sparse linear systems. in Parallel Algorithms for Matrix Computations. SIAM. [63] Hendrickson, B., and Leland, R. (1992). An improved spectral graph partitioning algorithm for mapping parallel computations. SAND92-1460, Sandia National Laboratories. [64] Heroux, M. A., Vu, P., and Yang, C. (1991). A parallel preconditioned conjugate gradient package for solving sparse linear systems on a Cray Y-MP. Appl. Num. Math. 8:93-115. [65] Hestenes, M. R., and Stiefel, E. (1952). Methods of conjugate gradients for solving linear systems. J. Res. Nat. Bur. Standards B 49:409-436. [66] Hoffman, A. J., Martin, M. S., and Rose, D. J. (1973). Complexity bounds for regular finite difference and finite element grids. SIAM J. Num. Anal. 10:364-369. [67] Johnson, C. (1987). Numerical Solution of Partial Differential Equations by the Finite Element Method. Cambridge University Press. [68] Jordan, E. (1869). Sur les assemblages de lignes. Journal Reine Angew. Math, 70:185-190. [69] Kernighan, B. W., and Lin, S. (1970). An efficient heuristic procedure for partitioning graphs. Bell Sys. Tech. J., 49:291-307. [70] Khaira, M. S., Miller, G. L., and Sheffler, T. J. (1992). Nested Dissection: A survey and comparison of various nested dissection algorithms. CMU-CS-92-106R, Computer Science Department, Carnegie Mellon University.
133 [71] Lang, K. and Rao, S. (1994). Finding near-optimal cuts: an empirical evaluation. Proc. of the 4th Annual ACM-SIAM Symposium on Discrete Algorithms. [72] Leighton, F. T. (1983). Complexity Issues in VLSI. Foundations of Computing, MIT Press. [73] Leighton, F. T. (1992). Introduction to Parallel Algorithms and Architectures: Arrays, Trees, Hypercubes. Morgan Kaufmann. [74] Leighton, F. T., and Rao, S. (1988). An approximate max-flow min-cut theorem for uniform multicommodity flow problems with applications to approximation algorithms. Proc. of the 29th Annual Symposium on Foundations of Computer Science, pp. 422-431. [75] Leiserson, C. E. (1983). Area Efficient VLSI Computation. Foundations of Computing, MIT Press. [76] Lipton, R. J., Rose, D. J., and Tarjan, R. E. (1979). Generalized nested dissection. SIAM J. Num. Anal. 16:346-358. [77] Lipton, R. J., and Tarjan, R. E. A separator theorem for planar graphs. SIAM J. Appl. Math. 36:177-189. [78] MathWorks, Inc. (1992). MATLAB Reference Guide. [79] Meijerink, J. A., and van der Vorst, H. A. (1977). An iterative solution method for linear systems of which the coefficient matrix is a symmetric M-matrix. Math. Comp. 31:148-162. [80] Miller, G. L. (1986). Finding small simple cycle separators for 2-connected planar graphs. J. Comp. Sys. Sci. 32(3):265-279. [81] Miller, G. L., Teng, S. -H., Thurston, W. and Vavasis, S. A. (1992). Automatic mesh partitioning. Proc. of the 1992 Workshop on Sparse Matrix Computations: Graph Theory Issues and Algorithms. [82] Nour-Omid, B., Raefshy, A., and Lyzenga, G. (1987). Solving finite element equations on concurrent computers. in Noor, A. K., ed., Parallel Computations and Their Impact on Mechanics, pp. 209-228. The American Society of Mechanical Engineers, AMD-Vol. 86. [83] Oswald, P. (1991). On discrete norm estimates related to multilevel preconditioners in the finite element method. Proc. of the Int. Conf. Theory of Functions. [84] Pothen, A., Simon, H. D., and Liou, K. (1990). Partitioning sparse matrices with eigenvectors of graphs. SIAM J. Matrix Anal. Appl. 11(3):430-452. [85] Press, W. H., Flannery, B. P., Teukolsky, S. A., and Vetterling, W. T. (1988). Numerical Recipes in C: The Art of Scientific Computing. Cambridge University Press. [86] Press, W. H., and Teukolsky, S. A. (1991). Multigrid methods for boundary value problems. 1. Computers in Physics, Sep/Oct:514-519. [87] Rao, S. (1987). Finding near optimal separators in planar graphs. Proc. of the 28th Annual Symposium on Foundations of Computer Science, pp. 225-237. [88] Reid, J. K. (1971). On the method of conjugate gradients for the solution of large sparse systems of equations. in Reid, J. K. ed., Large Sparse Sets of Linear Equations, pp. 231-254. Academic Press. [89] Reid-Miller, M., Miller, G. L., and Modugno, F. (1993). List ranking and parallel tree contraction. in Reif, J., ed., Synthesis of Parallel Algorithms, Morgan Kaufmann.
134 [90] Shahrokhi, F. and Matula, D. W. (1990). The maximum concurrent flow problem. J. Association of Computing Machinery 37(2):318-334. [91] Simon, H. D. (1991). Partitioning of unstructured problems for parallel processing. Comp. Sys. in Eng. 2(2/ 3):135-148. [92] Stuben, K. (1983). Algebraic multigrid (AMG): Experiences and comparisons. Appl. Math. Comp. 13:419451. [93] Tarjan, R. E. (1983). Data Structures and Network Algorithms. SIAM. [94] Teng, S. -H. (1991). Points, Spheres, and Separators: A unified geometric approach to graph partitioning. CMU-CS-91-184, School of Computer Science, Carnegie Mellon University. [95] van der Vorst, H. A. (1989a). ICCG and related methods for 3D problems on vector computers. Comp. Physics Comm. 53:223-235. [96] van der Vorst, H. A. (1989b). High performance preconditioning. SIAM J. Sci. Stat. Comput. 10(6):11741185. [97] Varga, R. (1962). Matrix Iterative Analysis. Prentice-Hall. [98] Williams, R. D. (1991). Performance of dynamic load balancing algorithms for unstructured mesh calculations. Concurrency: Practice and Experience, 3(5):457-481.

KD Gremban

File: combinatorial-preconditioners-for-sparse-symmetric-diagonally.pdf
Author: KD Gremban
Published: Thu Apr 25 12:40:40 2013
Pages: 142
File size: 0.69 Mb


Commentary Survey, 29 pages, 0.27 Mb

Sobre el libro, 1 pages, 1.34 Mb

SÉRGIO BALLERINI, 120 pages, 0.86 Mb
Copyright © 2018 doc.uments.com