US 8229990 B2 Abstract A signal-bearing medium tangibly embodying a program of machine-readable instructions executable by a digital processing apparatus to perform a method to at least one of reduce a memory space requirement and to increase a processing efficiency in a computerized method of linear algebra processing. A hybrid full-packed data structure is generated for processing data of a triangular matrix by one or more dense linear algebra (DLA) matrix subroutines designed to process matrix data in a full format, as modified to process matrix data using said hybrid full-packed data structure into a hybrid full-packed data structure, as follows. A portion of the triangular matrix data is determined that would comprise a square portion having a dimension approximately one half a dimension of the triangular matrix data. A first triangular portion of the triangular matrix data is fitted into a first location relative to data of the square portion, and a second triangular portion of the triangular matrix data is fitted into a second location relative to data of the square portion, such that the first triangular portion, the second triangular portion, and the square portion fit together to form the rectangular data structure. The hybrid full-packed data structure provides a substantially rectangular full format data structure for an entirety of the triangular matrix data and the triangular matrix comprises a triangular or symmetric/Hermitian matrix.
Claims(5) 1. A non-transitory signal-bearing storage medium tangibly embodying a program of machine-readable instructions executable by a digital processing apparatus to perform a method to at least one of reduce a memory space requirement and to increase a processing efficiency in a computerized method of linear algebra processing, said method comprising:
generating a hybrid full-packed data structure for processing data of a triangular matrix by one or more dense linear algebra (DLA) matrix subroutines designed to process matrix data in a full format, as modified to process matrix data using said hybrid full-packed data structure, as follows:
determining a portion of said triangular matrix data that would comprise a square portion having a dimension approximately one half a dimension of said triangular matrix data;
fitting a first triangular portion of said triangular matrix data into a first location relative to data of said square portion; and
fitting a second triangular portion of said triangular matrix data into a second location relative to data of said square portion,
wherein said first triangular portion, said second triangular portion, and said square portion fit together to form said rectangular data structure,
wherein said hybrid full-packed data structure provides a substantially rectangular full format data structure for an entirety of said triangular matrix data and said triangular matrix comprises a triangular or symmetric/Hermitian matrix.
2. The non-transitory signal-bearing storage medium of
3. The non-transitory signal-bearing storage medium of
4. The non-transitory signal-bearing storage medium of
5. The non-transitory signal-bearing storage medium of
Description This Application is a Continuation Application of U.S. patent application No. 10/671,933, filed on Sep. 29, 2003, to Gustayson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING A HYBRID FULL-PACKED STORAGE FORMAT”, having; now U.S. Pat. No. 7,386,582, issuing on Jun. 10, 2008. The following seven Applications, including the present Application, are related: 1. U.S. patent application Ser. No. 10/671,887, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING COMPOSITE BLOCKING BASED ON L1 CACHE SIZE”, having; 2. U.S. patent application Ser. No. 10/671,933, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING A HYBRID FULL-PACKED STORAGE FORMAT”, having; 3. U.S. patent application Ser. No. 10/671,888, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING REGISTER BLOCK DATA FORMAT”, having; 4. U.S. patent application Ser. No. 10/671,889, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING LEVEL 3 PREFETCHING FOR KERNEL ROUTINES”, having; 5. U.S. patent application Ser. No. 10/671,937, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING PRELOADING OF FLOATING POINT REGISTERS”, having; 6. U.S. patent application Ser. No. 10/671,935, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING A SELECTABLE ONE OF SIX POSSIBLE LEVEL 3 L1 KERNEL ROUTINES”, having; and 7. U.S. patent application Ser. No. 10/671,934, filed on Sep. 29, 2003, to Gustavson et al., entitled “METHOD AND STRUCTURE FOR PRODUCING HIGH PERFORMANCE LINEAR ALGEBRA ROUTINES USING STREAMING”, having, all assigned to the present assignee, and all incorporated herein by reference. 1. Field of the Invention The present invention relates generally to techniques for improving performance for linear algebra routines, with special significance to optimizing the matrix multiplication process. More specifically, a hybrid full-packed data structure allows a subroutine based on a rectangular standard row/column major format to be used for standard packed triangular matrices, thereby providing a three-to-five times improvement in speed and a reduction in storage by a factor of two. 2. Description of the Related Art Scientific computing relies heavily on linear algebra. In fact, the whole field of engineering and scientific computing takes advantage of linear algebra for computations. Linear algebra routines are also used in games and graphics rendering. Typically, these linear algebra routines reside in a math library of a computer system that utilizes one or more linear algebra routines as a part of its processing. Linear algebra is also heavily used in analytic methods that include applications such as supply chain management, as well as numeric data mining and economic methods and models. The reason that linear algebra is so ubiquitous is that most engineering/scientific problems comprise non-linear scenarios which are combined by modeling as an aggregation of linearized sections, each respectively described by linear equations. Therefore, a linear network is formed that can be described in matrix format. It is noted here that the terms “array” and “matrix” are used interchangeably in the discussion of the present invention. In general, a matrix representation A can be “simplified” by making a plurality of coordinate transformations so that the solution then becomes trivial to obtain in the final coordinates. Common coordinate transformations include transformation into the identity matrix or into the LU (lower/upper) factors format. A lower triangular matrix is L, and an upper triangular matrix is U. Matrix A becomes equal to the product of L by U (i.e., LU). The process of coordinate transformation wherein two coordinate systems are combined into a single coordinate system involves matrix multiplication. Hence, the present invention focuses particularly on techniques that will particularly enhance matrix multiplication, but is not so limited. Typically, these linear algebra subroutines are stored in a math library of a computer tool that utilizes one or more linear algebra routines as a part of its processing. A number of methods are have been used to improve performance of new or existing computer architectures for linear algebra routines. However, because linear algebra permeates so many applications, a need continues to exist to optimize performance of matrix processing, including the need for efficiency in storing matrix data. In view of the foregoing exemplary problems, drawbacks, and disadvantages of the conventional systems, it is, therefore, an exemplary feature of the present invention to provide a technique that improves performance for linear algebra routines. It is another exemplary feature of the present invention to provide a method and structure to yield a solution to provide higher-performance linear algebra routines for traditionally-slow subroutines that process matrices stored in a triangular packed format. It is another exemplary feature of the present invention to improve factorization routines which are key procedures of linear algebra matrix processing. It is yet another exemplary feature of the present invention to reduce the storage requirements of standard row/column major format by a factor of two and maintain the same performance. In a first exemplary aspect of the present invention, described herein is a computerized method of linear algebra processing, including processing a matrix data of a triangular packed format matrix in at least one matrix subroutine designed to process matrix data in a full format, using a hybrid full-packed data structure that provides a rectangular data structure for the triangular packed data. In a second exemplary aspect of the present invention, described herein is an apparatus for linear algebra processing including a processor for processing a matrix data of a triangular packed format matrix in at least one matrix subroutine designed to process matrix data in a full format, using a hybrid full-packed data structure that provides a rectangular data structure for the triangular packed data. In a third exemplary aspect of the present invention, described herein is a signal-bearing medium tangibly embodying a program of machine-readable instructions executable by a digital processing apparatus to perform the above-described method of processing matrix data. In a fourth exemplary aspect of the present invention, described herein is a method of at least one of solving and applying a scientific/engineering problem, including at least one of using a linear algebra software package that computes one or more matrix subroutines according to the above-described method; providing a consultation for purpose of solving a scientific/engineering problem using the linear algebra software package; transmitting a result of the linear algebra software package on at least one of a network, a signal-bearing medium containing machine-readable data representing the result, and a printed version representing the result; and receiving a result of the linear algebra software package on at least one of a network, a signal-bearing medium containing machine-readable data representing the result, and a printed version representing the result. In a fifth exemplary aspect of the present invention, described herein is a computerized method of converting data in a triangular matrix into a rectangular data format, including determining a portion of the matrix data stored in the triangular packed format that would comprise a square portion having a dimension approximately one half a dimension of the triangular packed format. In a sixth exemplary aspect of the present invention, described herein is a data structure in a computer program used for processing matrix data, the data structure used to store a matrix data from a triangular matrix format, the data structure providing a rectangular structure for the data from the triangular matrix, wherein the data structure includes a first portion, a second portion, and a third portion. The first portion includes a square portion that includes the matrix data stored in the triangular packed format that would comprise a square portion having a dimension approximately one half a dimension of the triangular packed format. The second portion includes a first triangular portion of matrix data stored in the triangular packed format that remains after the square portion is eliminated. The third portion includes a second triangular portion of matrix data stored in the triangular packed format that remains after the square portion and the first triangular portions are eliminated. The data structure fits together the first portion, the second portion, and the third portion to form a rectangular data structure. In a seventh exemplary aspect of the present invention, described herein is a method of providing a service that includes utilizing the methods of the present invention. The present invention provides an efficient method to save memory space for storing matrix data that is in the conventional triangular packed format. It also provides a method to increase speed and performance for linear algebra routines using the traditionally-slow subroutines that process matrices stored in the conventional triangular packed format. The foregoing and other exemplary features, aspects and advantages will be better understood from the following detailed description of exemplary embodiments of the invention with reference to the drawings, in which: Referring now to the drawings, and more particularly to As previously mentioned, a number of methods have been used to improve performance of computer architectures for linear algebra processing. However, the input data structures of matrices have not changed for conventional programming languages. That is, two data structures are used for symmetric matrices, including “packed” and “full”. The “packed” format uses half the storage, but performs three to five times slower. “Full” format uses twice the storage of packed, but performs three to five times faster than packed. As shown in Triangular and symmetric matrices T, S are special cases of a full square matrix A (e.g., having order N, where A has n rows and n columns). Triangular and symmetric matrices can be represented in full format. Assuming an example where N=4, the 4×4 matrix A will have 16 elements.
Because S above is symmetric, it has six redundant elements (e.g., s The following exemplary description of the present invention refers to a current linear algebra computing standard called LAPACK (Linear Algebra PACKage) and various subroutines contained therein. Information on LAPACK is readily available on the Internet. When LAPACK is executed, the Basic Linear Algebra Subprograms (BLAS), unique for each computer architecture and provided by the computer vendor, are invoked. LAPACK includes a number of factorization algorithms, some of which will be mentioned shortly. However, it is noted that the present invention is more generic. That is, the concept presented in the present invention is not limited to LAPACK, as one of skill in the art would readily recognize after having taken the present application as a whole. The present invention is intended to cover the broader concepts discussed herein and contend that the specific environment involving LAPACK is intended for purpose of illustration rather than limitation. As an example, Dense Linear Algebra Factorization Algorithms (DLAFAs) include almost entirely of matrix multiply subroutine calls such as Double-precision Generalized Matrix Multiply (DGEMM). At the core of level 3 Basic Linear Algebra Subprograms (BLAS) are “L1 kernel” routines which are constructed to operate at near the peak rate of the machine when all data operands are streamed through or reside in an L1 cache. The current state-of-the-art for DLAFAs is based on using level three BLAS on the two matrix data formats, “full format” and “packed format”. Because these data formats are not the data formats used by the level 3 BLAS routines, excessive data copying is necessary, resulting in a performance loss. The most heavily used type of level 3 L1 DGEMM kernel is Double-precision A Transpose multiplied by B (DATB), that is, C=C−A^T*B, where A, B, and C are generic matrices or submatrices, and the symbology A^T means the transpose of matrix A. It is noted that DATB is the only such kernel employed by today's state of the art codes, although it is only one of six possible kernels. More specific to the present invention, the triangular (packed) format Because of this varying stride, matrix subroutines in LAPACK for the packed format exist only in level 2 BLAS, which is significantly slower than level 3 BLAS matrix subroutines for the full format. As seen in Hybrid Full-Packed (HFP) Data Structures and Algorithms As explained earlier, the problem addressed in the present invention is that triangular and symmetric arrays On the other hand, although the same arrays stored in packed format A most widely accepted/utilized library for this area is the LAPACK standard, which supplies algorithms for both of the formats just described. An explanation of “conventional storage” and “packed storage” can be found at pages 107-109 of LAPACK User's Guide, 2nd Edition, which is readily available via the Internet. Some of the concepts of the two storage formats are already demonstrated pictorially in The present invention addresses these two problems of storage space and speed by combining features of both formats into a new hybrid format, referred to hereinafter as the “Hybrid Full-Packed (HFP) format”, to obtain high performance using level 3 BLAS. Linear algebra matrices stored in this Hybrid Full-packed (HFP) format are compatible with level 3 BLAS routines. That is, they are plug-compatible with routines that conform to the level 3 BLAS standard. The present invention also takes advantage of LAPACK (and the BLAS) allowing “UPLO” specifiers, which indicate that the matrix under consideration is upper triangular or lower triangular. It should be obvious from Before providing details for the HFP conversion process, it should be obvious that the HFP format provides a savings in storing triangular matrix data. The advantage for speed comes from recognizing that the HFP data structure is fully compatible with matrix subroutines in LAPACK written in the faster full (rectangular) format. Thus, as shown in To more fully describe HFP in geometric terms, two size-equal or nearly size-equal isosceles triangles make a near square or square when they are concatenated along their diagonals. To store the original packed array (conceptually, an N by N array), HFP and its (implied) subarrays will be utilized as follows. Let N>1 be given. Define n The expression “floor (N/2)” means that, if N is even, then n HFP will concatenate two packed arrays of size n An example is given below. In general, there are two possible cases: N being even, and N being odd. All HPF subarrays in this example are assumed to be in standard column-major (Fortran) format, but this assumption is not necessary. First case, N=
The HFP format arrays used to hold the arrays shown above (UHFP for the left, LHFP on the right) include two full arrays stored contiguously and shown below. The first full array, T, holds two triangles, T
The second full array contains the near square, S
The LHFP S It follows that LHFP S
Furthermore, because of symmetry, UHFP S The example for N odd generalizes (i.e., holds for all odd N>1) and the combined array, holding matrices T and S An example for the second case, N even, is given below, where N=8 and n Second Case, N=8 (Even Number):
Again, both UHFP and LHFP formats include two full arrays. The first full array T holds two triangles T
The second full array contains the square S
As a measure of performance, if any LAPACK level 3 routine that uses the standard, traditional packed storage scheme is taken, this routine implements a level 3 block-based algorithm by using packed level 2 BLAS and level 1 BLAS. On average, performance is a factor of three slower than the LAPACK full format version. In contrast, the present invention proposes that, instead, a Simple Related Block Algorithm (SRBA) using block size, in succession, NB=n There are approximately 120 such routines in LAPACK. An exemplary SRBA example in coding format is given below for the LAPACK routine, DPPTRF (Double-precision, Packed Positive-definite TRiangular Factorization), i.e., the packed Cholesky factorization. This example using DPPTRF is only for purpose of demonstration, since it should be obvious, after taking the present application as a whole, that the approach using an SRBA, as presented in The SRBA includes four subroutine calls to existing level 3 BLAS-based LAPACK codes. Experience with the LAPACK algorithms makes it clear that this example is general for LAPACK algorithms. Further, the technique can be applied to other LAPACK-like algorithms. In step In step In step Based on the determination in step
As a programming note, it is noted that a user could also input data that is already in HFP format. In that case, the above calls to DPTHF (packed to hybrid format transformation) and DHFTP (hybrid to packed format transformation) are not needed. (When the original matrix is in full format, subroutiness DFTHF and DHFTF would be used.) A user provided with routines DPTHF and DHFTP would allow the user to readily perform conversions between (i.e., to and from) standard packed and HFP formats. A user provided with routines DFTHF and DHFTF would allow the user to readily perform conversions between (i.e., to and from) standard full and HFP formats. Thus, this present invention affords any library development team the opportunity to replace all of its packed level 2 codes with new simple level 3 codes based on existing LAPACK level 3 full format codes. It also affords any library development team the opportunity to replace all of its full level 3 codes with new simple level 3 codes based on existing LAPACK level 3 full format codes. The appeal is especially strong for Symmetric MultiProcessor (SMP) codes, since level 3 BLAS, as well as several of the LEQs (Linear EQuations), algorithms usually have good SMP implementations. It is noted that DPTHF and DHFTP offer efficient SMP implementations and that DFTHF and DHFTF offer efficient SMP implementations. Finally, a library development team need only further develop their full format level 2 BLAS and slowly migrate out the current packed level 2 BLAS, as HFP level 2 BLAS are easily implemented by calls to full format level 2 BLAS. These new codes (packed level 2 BLAS using HFP format input) will be efficient since no calls to DPTHF or DHFTP are needed as then the data format is already HFP. Now, because of symmetry and because an array holding A also holds A The following provides a second exemplary embodiment to that used above for explanation. Let N be given and n The case N=9 (This is identical to that of the first example):
Both UHFP and LHFP formats consist of two full arrays. The first full array T holds two triangles T The same is true for uplo=‘U’. In the ‘L’ case, T
Because of symmetry, arrays UHFP T and LHFP T are identical. The second full array S
Because of symmetry, UHFP S Together these two arrays (concatenation along the row dimension) form a single full array of size 2*n When N is even, triangular arrays T Following is an example where N=8 (Note: This is identical to that of the first example) for N=8.
Both UHFP and LHFP formats consist two full arrays. The first full array T holds two triangles T In the ‘U’ case, T
Again, array UHFP T is identical to array LHFP T. The second full array S
Again, array UHFP S Together these two arrays (concatenation along the row dimension) form a single full array of size 2*n Again, we can just refer to HFP format. Any packed LAPACK L3 routine can be taken for implementation. It has a full L3 block algorithm. A simple related partition algorithm SRPA with partition sizes n It is noted that in Example 1, SRBA is used instead of the SRPA used here. Blocking refers to the array and partitioning refers to matrices. However, in the context of the present invention, there is really no difference. An example for DPPTRF is given. The SRPA consists of four subroutine calls to existing L3 codes. It should be clear that this following example is general.
It is noted that lines 1-7 and lines 10 to 21 are independent of ILU. Only lines 8-9 and lines 22-23 depend on UPLO and they refer to the original packed format. Users can use routines DPTHF and DHFTP, since this method is quite general to replace all their packed L3 codes with new simple L3 codes based on existing L3 full format codes. The appeal is especially strong for SMP codes as all ESSL L3 BLAS are enabled for SMP as well as several of the LEQ's algorithms have good SMP implementations. The DPTHF and DHFTP subroutines offer efficient SMP implementations. Finally, full format L2 BLAS can be developed to replace current packed L2 BLAS, as HFP L2 BLAS are easily implemented by calls to full format L2 BLAS. These new codes will be efficient as no calls to DPTHF or DHFTP are needed as the data format is already HPF. Exemplary Hardware/Software Implementation In addition to the hardware/software environment described above, a different aspect of the invention includes a computer-implemented method for performing the invention. Such a method may be implemented, for example, by operating a computer, as embodied by a digital data processing apparatus, to execute a sequence of machine-readable instructions. These instructions may reside in various types of signal-bearing media. Thus, this aspect of the present invention is directed to a programmed product, comprising signal-bearing media tangibly embodying a program of machine-readable instructions executable by a digital data processor incorporating the CPU This signal-bearing media may include, for example, a RAM contained within the CPU Whether contained in the diskette The second aspect of the present invention can be embodied in a number of variations, as will be obvious once the present invention is understood. That is, the methods of the present invention could be embodied as a computerized tool stored on diskette The second aspect of the present invention additionally raises the issue of general implementation of the present invention in a variety of ways. For example, it should be apparent, after having read the discussion above that the present invention could be implemented by custom designing a computer in accordance with the principles of the present invention. For example, an operating system could be implemented in which linear algebra processing is executed using the principles of the present invention. In a variation, the present invention could be implemented by modifying standard matrix processing modules, such as described by LAPACK, so as to be based on the principles of the present invention. Along these lines, each manufacturer could customize their BLAS subroutines in accordance with these principles. It should also be recognized that other variations are possible, such as versions in which a higher level software module interfaces with existing linear algebra processing modules, such as a BLAS or other LAPACK module, to incorporate the principles of the present invention. Moreover, the principles and methods of the present invention could be embodied as a computerized tool stored on a memory device, such as independent diskette It should also be obvious to one of skill in the art that the instructions for the technique described herein can be downloaded through a network interface from a remote storage facility. All of these various embodiments are intended as included in the present invention, since the present invention should be appropriately viewed as a method to enhance the computation of matrix subroutines, as based upon recognizing how linear algebra processing can be more efficient by using the principles of the present invention. In yet another aspect of the present invention, it should also be apparent to one of skill in the art that the principles of the present invention can be used in yet another environment in which parties indirectly take advantage of the present invention. For example, it is understood that an end user desiring a solution of a scientific or engineering problem may undertake to directly use a computerized linear algebra processing method that incorporates the method of the present invention. Alternatively, the end user might desire that a second party provide the end user the desired solution to the problem by providing the results of a computerized linear algebra processing method that incorporates the method of the present invention. These results might be provided to the end user by a network transmission or even a hard copy printout of the results. The present invention is intended to cover all these various methods of using the present invention, including the end user who uses the present invention indirectly by receiving the results of matrix processing done in accordance with the principles of the present invention. That is, the present invention should appropriately be viewed as the concept that efficiency in the computation of matrix subroutines can be significantly improved for triangular packed matrix subroutines by converting the triangular data into the hybrid full-packed data structure, thereby allowing the processing to be executed using full-format subroutines that inherently have higher performance. The present invention provides a generalized technique that improves performance for linear algebra routines. The method and structure discussed here, yields higher-performance linear algebra routine processing for traditionally-slow subroutines that process matrices stored in a triangular packed format and can provide three to five fold performance improvement over these subroutines. While the invention has been described in terms of exemplary embodiments, those skilled in the art will recognize that the invention can be practiced with modification within the spirit and scope of the appended claims. Further, it is noted that, Applicants' intent is to encompass equivalents of all claim elements, even if amended later during prosecution. Patent Citations
Non-Patent Citations
Classifications
Legal Events
Rotate |