Communication-Avoiding Symmetric-Indefinite Factorization

Ballard, Grey; Becker, Dulcenia; Demmel, James; Dongarra, Jack; Druinsky, Alex; Peled, Inon; Schwartz, Oded; Toledo, Sivan; Yamazaki, Ichitaro

doi:10.1137/130929060

Cited by 13 publications

(23 citation statements)

References 29 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…On the other hand, the backward errors of the CA Aasen's algorithm were about an order of magnitude greater than the standard algorithms. As explained elsewhere, this is expected because the backward errors of the CA Aasen's algorithm depend linearly to the block size (ie, n d = 128). A few iterations of iterative refinement can smooth out the residual norm.…”

Section: Numerical Resultsmentioning

confidence: 88%

“…In this section, we discuss the 3 symmetric indefinite factorization algorithms, the partitioned Bunch‐Kaufman, the partitioned Aasen's, and the CA Aasen's, which are studied in this paper.…”

Section: Algorithmsmentioning

confidence: 99%

“…Recently, a CA variant of the Aasen's algorithm was developed by replacing all the element‐wise operations with block‐wise operations . For avoidance of storing the whole matrix H , it computes the block row of H at each step, which is then discarded.…”

Section: Algorithmsmentioning

confidence: 99%

“…As a result, it can obtain a great speedup when the matrix is significantly greater than the GPU memory. We note that this implementation is different from the previous CA Aasen's algorithm proposed and studied elsewhere . Although the previous algorithm avoids some of the communication (instead of hiding the communication), it accesses all the previously factorized column of L for each panel factorization; some of which may not fit in the GPU memory.…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Non‐GPU‐resident symmetric indefinite factorization

Yamazaki

Tomov

Dongarra

2016

Concurrency and Computation

Self Cite

View full text Add to dashboard Cite

Summary We study various algorithms to factorize a symmetric indefinite matrix that does not fit in the core memory of a computer. There are two sources of the data movement into the memory: one needed for selecting and applying pivots and the other needed to update each column of the matrix for the factorization. It is a challenge to obtain high performance of such an algorithm when the pivoting is required to ensure the numerical stability of the factorization. For example, when factorizing each column of the matrix, a diagonal entry, which ensures the stability, may need to be selected as a pivot among the remaining diagonals, and moved to the leading diagonal by swapping both the corresponding rows and columns of the matrix. If the pivot is not in the core memory, then it must be loaded into the core memory. For updating the matrix, the data locality may be improved by partitioning the matrix. For example, a right‐looking partitioned algorithm first factorizes the leading columns, called panel, and then uses the factorized panel to update the trailing submatrix. This algorithm only accesses the trailing submatrix after each panel factorization (instead of after each column factorization) and performs most of its floating‐point operations (flops) using BLAS‐3, which can take advantage of the memory hierarchy. However, because the pivots cannot be predetermined, the whole trailing submatrix must be updated before the next panel factorization can start. When the whole submatrix does not fit in the core memory all at once, loading the block columns into the memory can become the performance bottleneck. Similarly, the left‐looking variant of the algorithm would require to update each panel with all of the previously factorized columns. This makes it a much greater challenge to implement an efficient out‐of‐core symmetric indefinite factorization compared with an out‐of‐core nonsymmetric LU factorization with partial pivoting, which only requires to swap the rows of the matrix and accesses the trailing submatrix after each in‐core factorization (instead of after each panel factorization by the symmetric factorization). To reduce the amount of the data transfer, in this paper we uses the recently proposed left‐looking communication‐avoiding variant of the symmetric factorization algorithm to factorize the columns in the core memory, and then perform the partitioned right‐looking out‐of‐core trailing submatrix updates. This combination may still require to load the pivots into the core memory, but it only updates the trailing submatrix after each in‐core factorization, while the previous algorithm updates it after each panel factorization.Although these in‐core and out‐of‐core algorithms can be applied at any level of the memory hierarchy, we apply our designs to the GPU and CPU memory, respectively. We call this specific implementation of the algorithm a non–GPU‐resident implementation. Our performance results on the current hybrid CPU/GPU architecture demonstrate that when the matrix is much larger than the GPU mem...

show abstract

Section: Numerical Resultsmentioning

confidence: 88%

Section: Algorithmsmentioning

confidence: 99%

Section: Algorithmsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Non‐GPU‐resident symmetric indefinite factorization

Yamazaki

Tomov

Dongarra

2016

Concurrency and Computation

Self Cite

View full text Add to dashboard Cite

show abstract

“…This is often an effective programming paradigm for many of the LAPACK subroutines because the panel factorization is based on BLAS-1 or BLAS-2, which can be efficiently implemented on the CPU, while BLAS-3 is used for the submatrix updates, which exhibit high-data parallelism and can be efficiently implemented on the GPU [3,25]. Although the 7 of 15 another variant of the algorithm was proposed [12]. Hence, although copying the panel from the GPU to the CPU can be overlapped with the update of the rest of the trailing submatrix on the GPU, the look-ahead -a standard optimization technique to overlap the panel factorization on the CPU with the trailing submatrix update on the GPU -is prohibited.…”

Section: Bunch-kaufman Algorithmmentioning

confidence: 99%

Solving dense symmetric indefinite systems using GPUs

Baboulin

Dongarra

Rémy

et al. 2017

Concurrency and Computation

Self Cite

View full text Add to dashboard Cite

This paper studies the performance of different algorithms for solving a dense symmetric indefinite linear system of equations on multicore CPUs with a Graphics Processing Unit (GPU). To ensure the numerical stability of the factorization, pivoting is required. Obtaining high performance of such algorithms on the GPU is difficult because all the existing pivoting strategies lead to frequent synchronizations and irregular data accesses. Until recently, there has not been any implementation of these algorithms on a hybrid CPU/GPU architecture. To improve their performance on the hybrid architecture, we explore different techniques to reduce the expensive data transfer and synchronization between the CPU and GPU, or on the GPU (e.g., factorizing the matrix entirely on the GPU or in a communication-avoiding fashion). We also study the performance of the solver using iterative refinements along with the factorization without pivoting combined with the preprocessing technique based on random butterfly transformations, or with the mixed-precision algorithm where the matrix is factorized in single precision. This randomization algorithm only has a probabilistic proof on the numerical stability, and for this paper, we only focused on the mixed-precision algorithm without pivoting. However, they demonstrate that we can obtain good performance on the GPU by avoiding the pivoting and using the lower precision arithmetics, respectively. As illustrated with the application in acoustics studied in this paper, in many practical cases, the matrices can be factorized without pivoting. Because the componentwise backward error computed in the iterative refinement signals when the algorithm failed to obtain the desired accuracy, the user can use these potentially unstable but efficient algorithms in most of the cases and fall back to a more stable algorithm with pivoting only in the case of the failure. SOLVING DENSE SYMMETRIC INDEFINITE SYSTEMS USING GPUs 5 of 15 Figure 1. Symmetric indefinite factorization algorithm: (a) Bunch-Kaufman [5]; (b)A Aasen's [12], where the first block column L 1Wnt ;1 is the first n b columns of the identity matrix and OEL; U; P D LU.A/ returns the LU factors of A with partial pivoting such that LU D PA.CPU may be more efficient at performing the BLAS-1 and BLAS-2 based panel factorization, this implementation often obtains higher performance by avoiding the expensive data transfer (Figure 4). When the entire factorization is implemented on the GPU, up to two columns of the trailing submatrix must be scanned to select a pivot -the current column and the column with index corresponding to the row index of the element with the maximum modulus in the first column. This not only leads to the expensive global reduce on the GPU but also to irregular data accesses because only the lower-triangular part of the submatrix is stored. This makes it difficult to obtain high performance on the GPU. In the next two sections, we describe two other algorithms (i.e., communication-avoiding and randomization algorithms) t...

show abstract