Dense Symmetric Indefinite Factorization on GPU Accelerated Architectures

Baboulin, Marc; Dongarra, Jack; Rémy, Adrien; Tomov, Stanimire; Yamazaki, Ichitaro

doi:10.1007/978-3-319-32149-3_9

Cited by 7 publications

(17 citation statements)

References 23 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This paper extends our previous proceedings paper [16] presented at the PPAM 2015 conference. Section 2 describes the three algorithms for solving dense symmetric indefinite systems (i.e., the Bunch-Kaufman and Aasen's algorithms, and the RBTs) and their implementations on the hybrid CPU/GPU architecture.…”

Section: Introductionsupporting

confidence: 80%

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

Section: Introductionsupporting

confidence: 80%

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

show abstract

“…Although our focus of this paper is on the deterministic algorithms with theoretical error bounds, there are growing interests in randomized algorithms . When combined with the iterative refinements, these randomized algorithms may compute the solution of the desired accuracy without pivoting, while obtaining the high performance on modern computers …”

Section: Related Workmentioning

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%

“…This is also true on a GPU that has become a crucial component in scientific and engineering computation. Nevertheless, with a careful designing and tuning of the implementation, the symmetric indefinite factorization process can be accelerated using the GPU …”

Section: Introductionmentioning

confidence: 99%

“…Our previous work only considered the cases where the matrix can fit all at once in the GPU memory. As the amount of the GPU memory is limited, this assumption may not hold for many matrices that are of interest.…”

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

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

A Randomized LU-based Solver Using GPU and Intel Xeon Phi Accelerators

Baboulin

Khabou

Rémy

2015

Euro-Par 2015: Parallel Processing Workshops

View full text Add to dashboard Cite

We present a fast hybrid solver for dense linear systems based on LU factorization. To achieve good performance, we avoid pivoting by using random butterfly transformations for which we developed efficient implementations on heterogeneous architectures. We used both Graphics Processing Units and Intel Xeon Phi as accelerators. The performance results show that the pre-processing due to randomization is negligible and that the solver outperforms the corresponding routines based on partial pivoting.

show abstract

Dense Symmetric Indefinite Factorization on GPU Accelerated Architectures

Cited by 7 publications

References 23 publications

Solving dense symmetric indefinite systems using GPUs

Solving dense symmetric indefinite systems using GPUs

Non‐GPU‐resident symmetric indefinite factorization

A Randomized LU-based Solver Using GPU and Intel Xeon Phi Accelerators

Contact Info

Product

Resources

About