## Section: New Results

### Communication avoiding algorithms for dense linear algebra

Our group continues to work on algorithms for dense linear algebra operations that minimize communication. During this year we focused on improving the performance of communication avoiding QR factorization as well as designing algorithms for computing rank revealing and low rank approximations of dense and sparse matrices.

In [2] we discuss the communication avoiding QR factorization of a dense matrix. The standard algorithm for computing the QR decomposition of a tall and skinny matrix (one with many more rows than columns) is often bottlenecked by communication costs. The algorithm which is implemented in LAPACK, ScaLAPACK, and Elemental is known as Householder QR. For tall and skinny matrices, the algorithm works column-by-column, computing a Householder vector and applying the corresponding transformation for each column in the matrix. When the matrix is distributed across a parallel machine, this requires one parallel reduction per column. The TSQR algorithm, on the other hand, performs only one reduction during the entire computation. Therefore, TSQR requires asymptotically less inter-processor synchronization than Householder QR on parallel machines (TSQR also achieves asymptotically higher cache reuse on sequential machines). However, TSQR produces a different representation of the orthogonal factor and therefore requires more software development to support the new representation. Further, implicitly applying the orthogonal factor to the trailing matrix in the context of factoring a square matrix is more complicated and costly than with the Householder representation.

We show how to perform TSQR and then reconstruct the Householder vector representation with the same asymptotic communication efficiency and little extra computational cost. We demonstrate the high performance and numerical stability of this algorithm both theoretically and empirically. The new Householder reconstruction algorithm allows us to design more efficient parallel QR algorithms, with significantly lower latency cost compared to Householder QR and lower bandwidth and latency costs compared with Communication-Avoiding QR (CAQR) algorithm. Experiments on supercomputers demonstrate the benefits of the communication cost improvements: in particular, our experiments show substantial improvements over tuned library implementations for tall-and-skinny matrices. We also provide algorithmic improvements to the Householder QR and CAQR algorithms, and we investigate several alternatives to the Householder reconstruction algorithm that sacrifice guarantees on numerical stability in some cases in order to obtain higher performance.

In [4] we introduce CARRQR, a communication avoiding rank
revealing QR factorization with tournament pivoting. Revealing the rank of a matrix is an operation that appears in many
important problems as least squares problems, low rank approximations,
regularization, nonsymmetric eigenproblems.
In practice the QR factorization with column pivoting often works
well, and it is widely used even if it is known to fail, for example
on the so-called Kahan matrix. However in terms of communication, the QR factorization with column
pivoting is sub-optimal with respect to lower bounds on communication. If the algorithm is
performed in parallel, then typically the matrix is distributed over
$P$ processors by using a two-dimensional block cyclic partitionning.
This is indeed the approach used in the `psgeqpf` routine from
ScaLAPACK. At each step of the decomposition, the QR factorization
with column pivoting finds the column of maximum norm and permutes it
to the leading position, and this requires exchanging $O\left(n\right)$ messages,
where $n$ is the number of columns of the input matrix. For square
matrices, when the memory per processor used is on the order of
$O({n}^{2}/P)$, the lower bound on the number of messages to be exchanged
is $\Omega \left(\sqrt{P}\right)$. The number of messages exchanged during the
QR factorization with column pivoting is larger by at least a factor
of $n/\sqrt{P}$ than the lower bound.

In this paper we introduce CARRQR, a communication optimal (modulo polylogarithmic factors) rank revealing QR factorization based on tournament pivoting. The factorization is based on an algorithm that computes the decomposition by blocks of $b$ columns (panels). For each panel, tournament pivoting proceeds in two steps. The first step aims at identifying a set of $b$ candidate pivot columns that are as well-conditioned as possible. These columns are permuted to the leading positions, and they are used as pivots for the next $b$ steps of the QR factorization. To identify the set of $b$ candidate pivot columns, a tournament is performed based on a reduction operation, where at each node of the reduction tree $b$ candidate columns are selected by using the strong rank revealing QR factorization. The idea of tournament pivoting has been first used to reduce communication in Gaussian elimination, an algorithm referred to as CALU.

We show that CARRQR reveals the numerical rank of a matrix in an analogous way to QR factorization with column pivoting (QRCP). Although the upper bound of a quantity involved in the characterization of a rank revealing factorization is worse for CARRQR than for QRCP, our numerical experiments on a set of challenging matrices show that this upper bound is very pessimistic, and CARRQR is an effective tool in revealing the rank in practical problems.

Our main motivation for introducing CARRQR is that it minimizes data transfer, modulo polylogarithmic factors, on both sequential and parallel machines, while previous factorizations as QRCP are communication sub-optimal and require asymptotically more communication than CARRQR. Hence CARRQR is expected to have a better performance on current and future computers, where commmunication is a major bottleneck that highly impacts the performance of an algorithm.