Abstract:
The Present invention provides a system and method for fast computing the Cholesky factorization of a positive definite matrix. In order to reduce the computation time of matrix factorizations, the present invention uses three atomic components, namely MA atoms, M atoms, and an S atom. The three kinds of components are arranged in a configuration that returns the Cholesky factorization of the input matrix.

Description:
CROSS-RELATED APPLICATIONS 
     This application is related to and claims priority to the U.S. Provisional Patent Application No. 60/767,130, entitled FAST MATRIX FACTORIZATION ALGORITHMS, filed on Mar. 6, 2006 the entire contents of which are incorporated herein by reference. 
    
    
     STATEMENTS REGARDING FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT 
     The invention described herein was made in the performance of work under Air Force Small Business Innovation Research (SBIR) Contract FA8650-05-M-3556. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates generally to computer systems for the solution of arithmetic problems and specifically to matrix factorization. 
     BACKGROUND OF THE INVENTION 
     The innermost computational kernel of many large numerical problems is often a large sparse matrix problem, which typically consumes a significant portion of the overall computational time required by the problem. Applications in numerous fields make intensive use of matrix computations, including Aerospace and automotive industries, computational fluid dynamics (CFD), defense, digital content creation, digital media, electronics, energy, finance, economic and financial forecasting, computational chemistry, molecular biology, computational physics, civil engineering, environmental engineering, gaming, geophysics, image processing, information processing services, life sciences, media, medicine, semiconductors, telecommunications, weather and climate research, weather forecasting, etc. 
     The methods for solving linear systems of equations are usually divided into direct and iterative. Also, depending on the structure of the problem, they can be divided into the ones that solve dense problems and the ones that solve sparse problems. It is not clear the best way to solve a large linear system of equations. However there are some indications that the selection of the kind of method depends very much on the particular problem: the sparsity and nonzero structure of the matrix, the efficiency of the preconditioner for the iterative method, and even a bit on the right hand side. In general, it is accepted to use direct methods for 1D and 2D problems, and iterative methods for 3D problems. 
     Direct methods are general techniques that provide high accuracy because they are analytical solutions. They usually have high memory costs and are advantageous when different right hand vectors are present. Examples of direct methods are: matrix inverse, Gaussian elimination, LU decomposition, QR decomposition, and Cholesky factorizaton 
     Iterative methods generate a sequence of iterates that are approximate solutions, and hopefully converge quickly towards the exact solution. Iterative methods efficiency depends on the type of the problem and the preconditioner used. If the preconditioner provides a matrix with a good condition number then the solution can be faster than the direct solution. The preconditioner is a transformation matrix that is used to convert the coefficient matrix into one with a more favorable spectrum (related with an improvement of the condition number). Iterative methods generally have lower memory costs but changing the right-hand vector implies solving the whole problem again. Iterative methods can be divided into stationary and non stationary methods. Non stationary methods differ from stationary methods in that the computations involve information that changes at each iteration. Examples of stationary methods are the Jacobi&#39;s method, Gauss-Seidel, Successive Overrelaxation (SOR), and Symmetric SOR. Examples of non stationary methods include Conjugate Gradient, Minimum Residual, and Generalized Minimum Residual. 
     In general, the problem of solving these systems of equations is addressed by software solutions, which translates into the use of traditional processor-based von Neumann architectures. For direct methods, that are the methods that can guarantee exact solutions, current solutions are still slow for a large number of applications, where, given the size of the problem, can take from hours to months to be solved. 
     There is then a need for a system and method for faster solutions of matrix problems, able to guarantee the delivery of accurate results. It is desired that this new systems and method could be easily integrated into a large number of engineering and science applications. 
     SUMMARY OF THE INVENTION 
     The Present invention provides a system and method for fast computing the Cholesky factorization of a positive definite matrix. In order to reduce the computation time of matrix factorizations, the present invention uses three atomic components, namely MA atoms, M atoms, and an S atom. The three kinds of components are arranged in a configuration that returns the Cholesky factorization of the input matrix. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  shows the MA-atom, one of the components of an embodiment of the present invention. 
         FIG. 2  shows the S-atom, one of the components of an embodiment of the present invention. 
         FIG. 3  shows the M-atom, one of the components of an embodiment of the present invention. 
         FIG. 4  illustrates the Cholesky array, a matrix factorization array in accordance to an embodiment of the present invention. 
         FIG. 5  illustrates the dataflow in the Cholesky array, in accordance to an embodiment of the present invention. 
         FIG. 6  shows a diagram of the data initialization of the Cholesky array, in accordance to an embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     The following description is presented to enable one of ordinary skill in the art to make and use the invention and is provided in the context of a patent application and its requirements. Various modifications to the preferred embodiment and the generic principles and features described herein will be readily apparent to those skilled in the art. Thus, the present invention is not intended to be limited to the embodiment shown but is to be accorded the widest scope consistent with the principles and features described herein. 
     An embodiment of the present invent is a hardware architecture for the implementation of the Recursive Cholesky Factorization Algorithm. The goal of this factorization is to find a lower triangular matrix with positive diagonal elements L=[1 ij ], given a square Hermitian positive definite matrix A∈Mn, so that: A=L×(Lc) T , Where Lc is the complex conjugate of L, and (Lc) T  is the transpose of the matrix (Lc). 
     The problem of finding the elements 1 ij  can be expressed as a nonlinear system of n(n+1)/2 equations whose solution is: 
     
       
         
           
             
               l 
               jj 
             
             = 
             
               
                 
                   a 
                   jj 
                 
                 - 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     
                       j 
                       - 
                       1 
                     
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     l 
                     ji 
                     2 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 l 
                 ji 
               
               = 
               
                 
                   
                     1 
                     
                       l 
                       ii 
                     
                   
                   ⁡ 
                   
                     [ 
                     
                       
                         a 
                         ij 
                       
                       - 
                       
                         
                           ∑ 
                           
                             k 
                             = 
                             1 
                           
                           
                             i 
                             - 
                             1 
                           
                         
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             l 
                             ik 
                           
                           · 
                           
                             l 
                             jk 
                           
                         
                       
                     
                     ] 
                   
                 
                 ⁢ 
                 
                   ∀ 
                   
                     j 
                     &gt; 
                     i 
                   
                 
               
             
             , 
             
                 
             
             ⁢ 
             
               
                 with 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       1 
                     
                     0 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     
                       l 
                       ik 
                     
                     · 
                     
                       l 
                       jk 
                     
                   
                 
               
               = 
               0. 
             
           
         
       
     
     In its recursive implementation, the Cholesky factorization of a matrix A=[a ij ] n×n  (overwriting the matrix) is obtained by the successive execution of the following steps: 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             
                               
                                 
                                   1 
                                   ) 
                                 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   a 
                                   11 
                                 
                               
                               ← 
                               
                                 
                                   a 
                                   11 
                                 
                               
                             
                             ⁢ 
                             
                               
 
                             
                             ⁢ 
                             2 
                           
                           ) 
                         
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           a 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                       
                       ← 
                       
                         
                           
                             a 
                             
                               i 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               1 
                             
                           
                           
                             a 
                             11 
                           
                         
                         ⁢ 
                         
                           ∀ 
                           
                             i 
                             ≥ 
                             2 
                           
                         
                       
                     
                     ⁢ 
                     
                       
 
                     
                     ⁢ 
                     3 
                   
                   ) 
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   a 
                   ij 
                 
               
               ← 
               
                 
                   a 
                   ij 
                 
                 - 
                 
                   
                     
                       a 
                       
                         i 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         1 
                       
                     
                     · 
                     
                       a 
                       
                         j 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         1 
                       
                     
                   
                   ⁢ 
                   
                     ∀ 
                     i 
                   
                 
               
             
             , 
             
               j 
               ≥ 
               2. 
             
           
         
       
     
     Recursive Cholesky enables super-modular architecture in hardware. The present architecture is composed by three basic atoms. The first and most important one is called the MA-Atom, where MA stands for Multiply-Add. This atom is composed by a multiplier, an adder and a register as shown in  FIG. 1 . The objective of the MA-Atom atom is to compute the third step of the recursive Cholesky algorithm. The other two remaining atoms (called S-atom and M-atom), shown in  FIG. 2  and  FIG. 3 , are intended for the calculation of the first and second steps respectively. 
     These atoms are then used as fundamental building blocks in the complete parallel architecture shown in  FIG. 4 . Suppose that this architecture will be used for factorizing a dense matrix A∈Mn, so there are n rows and n columns. If the blocks are indexed in a matrix-wise fashion, the inputs for the multiplier in the MA-atom, (row i and column j) are connected to the outputs of the atoms S-atom il  and S-atom il . As shown in the  FIG. 4 , the result of this multiplication is then subtracted to the value on the register of the MA-atom (i+1)(j+1) . All the M-atoms share as input the lower output of the S-atom and the other input comes from MA-atom( i+1)2  for the M-atom il . Finally, the S-atom receives its input from the register in the MA-atom 22 . These operations can be summarized as follows:
 
1)  S   low =( R   22 ) −½ 
 
2)  M   il   =S   low   ·R   (i+1)2   ∀i∈N,  2 ≦i≦n− 1
 
3)  R   ij   =R   (i+1)(j+1)   −M   il   ·M   jl   ∉i, j∈N,  2≦ i, j≦n− 1,
 
where S low  represents the lower output of the S-atom, M il  stands for the output of the M-atom il  and R ij  is the value on the register of the MA-atom ij . Due to de connections described above the resulting data flow inside the atomic array is the one illustrated in  FIG. 5 .
 
     At the first clock cycle all registers in the array are reset and have a value of zero. Then the matrix A is fed by diagonals from below adding a zero padding (see  FIG. 6 ). After n clock cycles all the registers in the MA-atoms are loaded with the elements of the matrix A so that R ij =a (i-1)(j-1) , 2≦i, j ≦n, and the last row of matrix A is located in the registers at the bottom of the atomic array. Due to the high parallel nature of the architecture, at this same clock cycle the entire first column of the matrix L is now available at the left part of the array:
 
 S   high   =l   l1 ,
 
 M   il   =l   i1 , 2 ≦i≦n, 
 
where S high  represents the higher output of the S-atom.
 
     In the next clock cycle, (n+1) zeros are fed to the array from below and the second column of L is available, again at the left side of the array so:
 
 S   high   =l   22 ,
 
 M   i1   =l   (i+1)2 , 2≦ i≦n− 1.
 
     The process continues and in the (n+k)-th clock cycle the k-th column of the matrix L is computed and available at:
 
 S   high   =l   kk ,
 
 M   i1   =l   (i+k)2 , 2≦ i≦n−k. 
 
     Finally, after (2n-1) clock cycles the process finishes having computed the whole matrix L. 
     Although the present invention has been described in accordance with the embodiment shown, one of ordinary skill in the art will readily recognize that there could be variations to the embodiments and those variations would be within the spirit and scope of the present invention. Accordingly, many modifications may be made by one of ordinary skill in the art without departing from the spirit and scope of the appended claims.