Communication-Avoiding Parallel Algorithms for
Solving Triangular Systems of Linear Equations

arXiv:1612.01855v2 [cs.DC] 22 Mar 2017

Tobias Wicky
Department of Computer Science
ETH Zurich
Zurich, Switzerland
twicki@ethz.ch

Edgar Solomonik
Department of Computer Science
University of Illinois at Urbana-Champaign
Urbana, IL, USA
solomon2@illinois.edu

Abstract—We present a new parallel algorithm for solving
triangular systems with multiple right hand sides (TRSM).
TRSM is used extensively in numerical linear algebra computations, both to solve triangular linear systems of equations
as well as to compute factorizations with triangular matrices,
such as Cholesky, LU, and QR. Our algorithm achieves
better theoretical scalability than known alternatives, while
maintaining numerical stability, via selective use of triangular
matrix inversion. We leverage the fact that triangular inversion
and matrix multiplication are more parallelizable than the
standard TRSM algorithm. By only inverting triangular blocks
along the diagonal of the initial matrix, we generalize the
usual way of TRSM computation and the full matrix inversion
approach. This flexibility leads to an efficient algorithm for
any ratio of the number of right hand sides to the triangular
matrix dimension. We provide a detailed communication cost
analysis for our algorithm as well as for the recursive triangular
matrix inversion. This cost analysis makes it possible to
determine optimal block sizes and processor grids a priori.
Relative to the best known algorithms for TRSM, our approach
can require asymptotically fewer messages, while performing
optimal amounts of computation and communication in terms
of words sent.
Keywords-TRSM, communication cost, 3D algorithms

I. I NTRODUCTION
Triangular solve for multiple right hand sides (TRSM)
is a crucial subroutine in many numerical linear algebra
algorithms, such as LU and Cholesky factorizations [1], [2].
Moreover, it is used to solve linear systems of equations once
the equation matrix is decomposed using any factorization
involving a triangular matrix factor. We consider TRSM for
dense linear equations in the matrix form,
L · X = B,

where L ∈ Rn×n is a lower-triangular matrix while
B ∈ Rn×k , X ∈ Rn×k are dense matrices. We study the
communication cost complexity of two variants of the
TRSM algorithm for parallel execution on p processors
with unbounded memory. First, we present an adaptation
of a known recursive scheme for TRSM [3] along with a
complete communication cost analysis. Then, we demonstrate a new algorithm that uses selective triangular inversion

Torsten Hoefler
Department of Computer Science
ETH Zurich
Zurich, Switzerland
htor@inf.ethz.ch

to reduce the synchronization cost over known schemes,
while preserving optimal communication and computation
costs. Careful choice of algorithmic parameters, allows us
to achieve better asymptotic complexity for a large (and most
important) range of input configurations.
Our TRSM algorithm leverages matrix multiplication and
triangular matrix inversion as primitives. We provide a
communication-efficient parallel matrix multiplication algorithm that starts from a 2D cyclic distribution, a modest
enhancement to existing approaches. Triangular matrix inversion provides the key ingredient to the lower synchronization cost in our TRSM algorithm. Unlike general matrix
inversion, triangular inversion is numerically stable [4] and
can be done with relatively few synchronizations. We present
a known parallel approach for triangular inversion and
provide the first communication cost analysis thereof.
We invert triangular diagonal blocks of the L matrix at the
start of our TRSM algorithm, increasing the computational
granularity of the main part of the solver. Inverting blocks,
rather than the whole matrix, also allows our algorithm to
be work-efficient in cases when the number of right-hand
sides is smaller than the matrix dimension. We formulate
the algorithm in an iterative, rather than a recursive manner,
avoiding overheads incurred by the known parallel recursive
TRSM approach. This innovation reduces communication
cost by a factor of Θ(log(p)) relative to the recursive
algorithm when the number of right-hand sides is relatively
small. At the same time, across a large range of input
parameters, we achieve a synchronization cost
 improvement
1/6 2/3 
p
.
over the recursive approach by a factor of Θ nk
II. P RELIMINARIES
A. Execution Time Model
The model we use to calculate the parallel execution time of
an algorithm along its critical path is the α − β − γ model.
It describes the total execution time of the algorithm T in
terms of the floating point operations (flop) count F , the
bandwidth W (number of words of data sent and received)

and the latency S (number of messages sent and received)
along the critical path [5] in the following fashion:
T = α · S + β · W + γ · F.

For all the terms we only show the leading order cost in
terms of n, k and p. We assume that every processor can
send and receive one message at a time in point to point
communication. We do not place constraints on the local
memory size.

Scatter and gather also have the same cost [7],
Tscatter (n, p) = α · log p + β · n1p ,
Tgather (n, p) = α · log p + β · n1p .

Reduce-scatter uses the same communication-path and has
same communication cost but we have to add the additional
overhead of local computation,
Treduce−scatter (n, p) = α · log p + β · n1p + γ · n1p .

The cost of an all-to-all among p processors is
Talltoall (n, p) = α · log(p) + β ·

B. Notation
For brevity, we will sometimes omit specification of the
logarithm base, using log to denote log2 . We will make
frequent use of the unit step function
(
1x =

1:x>1

n log p
.
2

The combination of the algorithms leads to the following
costs for reduction, allreduction, and broadcast:
Treduction (n, p) = α · 2 log p + β · 2n1p + γ · n1p ,
Tallreduction (n, p) = α · 2 log p + β · 2n1p + γ · n1p ,
Tbcast (n, p) = α · 2 log p + β · 2n1p .

0 : x ≤ 1.

We use Π(x1 , . . . , xn )to denote single processors in an ndimensional processor grids.
To refer to successive elements or blocks, we will use the
colon notation where i : j = [i, i + 1, . . . , j − 1] i < j. To
refer to strided sets of elements or blocks, we will write
i : k : j = [i, i + k, i + 2k, . . . , i + αk]

max α s.t. αk < j.

The colon notation can be applied to a list and should there
be considered element-wise. To use subsets of processors,
we use the ◦ notation in the way that Π(x, ◦, z) = Π(x, 1 :
py , z) denotes a (1-dimensional) grid of processors in the
y-dimension.
Global matrices are denoted by capital letters whereas locally owned parts have square brackets: If L is distributed on
Π(◦, ◦, 1), every processor Π(x, y, 1) owns L[x, y]. Matrix
elements are accessed with brackets.
C. Previous Work
We now cover necessary existing building blocks (e.g.
collective communication routines) and previous work. In
particular, we overview related results on communication
cost of matrix multiplication and triangular solves.
1) Collective Communication: In [6], Chan et al. present
a way to perform reduction, allreduction and broadcast via
allgather, scatter, gather and reduce-scatter. The latter set of
collectives can be done using recursive doubling (butterfly
algorithms) [6], [7] for a power of two number of processors.
If we have a non-power of two number of processors, the
algorithm described in [8] can be used. For simplicity, we
do not consider reduction and broadcast algorithms that can
achieve a factor of two less in cost in specific regimes of
α and β [9]. If we use butterfly methods, the cost of an
allgather of n words among p processors is
Tallgather (n, p) = α · log p + β · n1p .

2) Matrix Multiplication: Communication-efficient parallel
algorithms for matrix multiplication have been analyzed
extensively [10]–[15]. In [16], Demmel et al. present algorithms that are asymptotically optimal for matrix multiplication of arbitrary (potentially non square) matrices. If
we neglect the memory terms, their work shows that matrix
multiplication can be done with the following costs.
Bandwidth: When multiplying a matrix A that is of
dimension n × n with a matrix B of dimensions n × k
with p processors, we obtain an asymptotic bandwidth cost
of

 
nk


O
√


p



 2 2/3 !
n k
WMM (n, k, p) =
O



p




2
O n

n>k·
k/p ≤n ≤ k ·

√
√

p
p

n < k/p.

We refer to the first of the cases of WMM , as the case of
two large dimensions, here the matrix A is much larger than
the right hand side B, when the best way of performing a
matrix multiplication is to use a two dimensional layout for
the processor grid. The second case, three large dimensions,
has matrices A and B of approximately the same size. A
three dimensional grid layout is optimal here. And the third
case, one large dimension, is the case where the right hand
side B is larger than the triangular matrix A, the best way
to do a matrix multiplication is to use a one dimensional
layout for the processor grid.
Latency: Assuming unlimited memory, matrix multiplication as presented in [16] can be done with a latency of
SMM (p) = O (log(p)) .


Flop Cost: Matrix multiplication takes O n2 k flops,
which can be divided on p processors and therefore we have

FMM (n, k, p) = O

n2 k
p


.

Previous Analysis: For the case where k = n the bandwidth analysis of a general matrix multiplication goes back
to what is presented in [12]. Aggarwal et al. present a
cost analysis in the LPRAM model. In that work, the
authors show that the same cost can also be achieved for
the transitive closure problem that can be extended to the
problem of doing an LU decomposition. The fact that these
bandwidth costs can be obtained for the LU decomposition
was later demonstrated by Tiskin [17]. He used the bulk
synchronous parallel (BSP) execution time model. Since the
dependencies in LU are more complicated than they are for
TRSM, we also expect TRSM to be able to have the same
asymptotic bandwidth and flop costs as a general matrix
multiplication.
3) Triangular Matrix Solve for Single Right Hand Sides:
Algorithms for the problem of triangular solve for a single
right hand side (when X and B are vectors) have been wellstudied. A communication-efficient parallel algorithm was
given by Heath and Romine [18]. This parallel algorithm
was later shown to be an optimal schedule in latency and
bandwidth costs via lower bounds [5]. However, when X
and B are matrices (k > 1), it is possible to achieve significantly lower communication costs relative to the amount of
computation required. The application of selective inversion
has been used to accelerate repeated triangular solves that
arise in preconditioned sparse iterative methods [19].
4) Recursive Triangular Matrix Solve for Multiple Right
Hand Sides: A recursive approach of solving the TRSMproblem was presented in the work of Elmroth et
 al. [3]. The

initial
problem,
L · X = B can be split into L· X1 X2 =


B1 B2 , which yields two independent subproblems:
L · X1 = B1 ,

L · X2 = B2 .

hence the subproblems are independent and can be solved
in parallel.
The other, dependent splitting proposed divides the triangular matrix, yielding two subtasks that have to be solved one
at a time

    
L11
L12

L22

·

X1
B1
=
,
X2
B2

where we obtain the dependent subproblems:
L11 · X1 = B1

and

L22 · X2 = B2 − L12 · X1 .

These problems are dependent as we need the solution X1
to solve the second problem.
Parallel TRSM algorithms with 3D processor grids can
reduce the communication cost in an analogous fashion to
matrix multiplication. Irony and Toledo [20] presented the
first parallelization of the recursive TRSM algorithm with a
3D processor grid. They demonstrated that the communication volume of their parallelization is O(nkp1/3 + n2 p1/3 ).
Thus each processor communicates O((nk + n2 )/p2/3 )
elements, which is asymptotically equal to WMM (n, k, p)
when k = Θ(n). However, they did not provide a bound

on the latency cost nor on the communication bandwidth
cost along the critical path, so it is unclear to what extent
the communication volume is load-balanced. Lipshitz [21]
provides an analysis of the recursive TRSM algorithm in the
same communication cost model as used in this paper. For
the case of k = n, his analysis demonstrates
TTRSM−L (n, n, p) = O(p2/3 · α + n2 /p2/3 · β + n3 /p · γ).

For some choices of algorithmic parameters, the analysis
in [21] should lead to the bandwidth cost,
WTRSM−L (n, k, p) = O

 2  
n k 2/3
p

,

which is as good as matrix multiplication, WMM (n, k, p).
However, it is unclear how to choose the parameters of the
formulation in [21] to minimize latency cost for general
n, k. Prior to presenting our main contribution (an inversionbased TRSM algorithm with a lower latency cost), we
provide a simpler form of the recursive TRSM algorithm
and its asymptotic cost complexity. Inversion has previously
been used in TRSM implementations [22], but our study is
the first to consider communication-optimality. We start by
presenting a subroutine for 3D matrix multiplication which
operates from a starting 2D distribution, simplifying the
subsequent presentation of TRSM algorithms.
III. M ATRIX M ULTIPLICATION
B = MM(L, X, Π2D , n, k, p, p1 , p2 )
Require:
√
√
The processor grid Π2D has dimensions p × p
L is an n × n matrix, distributed on Π2D in a cyclic layout,
so Π2D (x, y) owns L[x, y] of size √np × √np such that
√
√
L[x, y](i, j) = L(i p + x, j p + y).
X is a dense n × k matrix is distributed cyclically so that
Π2D (x, y) owns X[x, y] of size √np × √kp
√
p2 × p1 × p2 processor grid Π4D , such that
Π4D (x1 , x2 , y1 , y2 ) = Π2D (x1 +p1 x2 , y1 +p2 y2 ) owns blocks
L[x1 , x2 , y1 , y2 ] and X[x1 , x2 , y1 , y2 ]
2: L0 [x1 , y1 ] = Allgather (L[x1 , ◦, y1 , ◦], Π4D (x1 , ◦, y1 , ◦))
3: X 0 [x1 , y1 , x2 , y2 ]
= Transpose(X[x1 , x2 , y1 , y2 ], Π4D (x1 , x2 , y1 , y2 ), x2 , y1 )
4: X 00 [y1 , x1 , x2 , y2 ]
= Transpose(X 0 [x1 , y1 , x2 , y2 ], Π4D (x1 , x2 , y1 , y2 ), x1 , y1 )
5: X 000 [y1 , x2 , y2 ] =
Allgather(X 00 [y1 , ◦, x2 , y2 ], Π4D (◦, x2 , y1 , y2 ))
6: Π4D (x1 , x2 , y1 , y2 ) :
B 00 [x1 , y1 , x2 , y2 ] = L0 [x1 , y1 ] · X 000 [y1 , x2 , y2 ]
7: B 0 [x1 , y1 , x2 , y2 ]
= Scatter-reduce(B 00 [x1 , ◦, x2 , y2 ], Π4D (x1 , x2 , ◦, y2 ))
8: B[x1 , x2 , y1 , y2 ]
= Transpose(B 0 [x1 , y1 , x2 , y2 ], Π4D (x1 , x2 , y1 , y2 ), x2 , y1 )
Ensure:
B = LX is distributed the same way as X
1: Define a p1 ×

√

We present an algorithm for 3D matrix multiplication [10]–
[15] that works efficiently given input matrices distributed

cyclically on a 2D processor grid. The algorithm is wellsuited for the purposes of analyzing TRSM algorithms. We
√
√
define the algorithm using a p1 × p2 × p1 × p2 processor
√
√
grid, where p = p1 p2 in order to provide well-defined
√
√
transitions from a distribution on a p × p processor grid
to faces of a 3D p1 × p1 × p2 processor grid. The latter 3D
processor grid is being used implicitly in our construction.
√
The algorithm assumes divisibility among p, p1 , p2 and p2 .
A. Cost Analysis of the 3D Matrix Multiplication Algorithm
We analyze the algorithm with account for constant factors
in the key leading order costs. The communication costs
incurred at line 2, 5, and 7 correspond to the cost of
respective collectives, given in Section II-C1.
The transpose on line 4 always occurs on a square processor
grid, and so involves only one send and receive of a block.
The transposes on line 3 and line 8 are transposes on 2D
√
grids of p1 × p2 processors, with each processor owning
nk/p elements. The cost of these transposes is no greater
√
than an all-to-all among p processors, which can be done
with cost O(α · log(p) + β · nk log(p)/p). We consider only
the asymptotic cost of this transpose, since it will be low
order so long as p1  1. Based on the above arguments,
the cost for MM is given line-by-line in the following table.
2

Line 3

α · log(p2 ) + β · np2 1p2
1


O α · log(p) + β · nk log(p)
p

Line 5
Line 4

α · log(p1 ) + β ·
α + β · nk
p

Line 6
Line 7
Line 8

γ · np k
α · log(p1 ) + (β + γ) ·
α · l + β · nkl
p

Line 2

nk
p1 p2

2

nk
p1 p2

To leading order, the cost of MM is given by
n2 k
2nk 
1
+
γ
·
+
p
2
p2
p1 p2
p
1

nk log(p)
+ O α · log(p) + β ·
.
p

TMM (n, k, p, p1 , p2 ) =β ·

 n2

The last communication cost term (due to the rectangular
grid transpose) is only of leading order when p1 ≈ log(p). A
square processor grid is not a good initial/final layout for X
and B in this case, and the problem would be addressed by
choosing an alternative one. We disregard this issue, because
we will use the algorithm only for n ≥ k.
IV. R ECURSIVE TRSM
We provide a recursive TRSM algorithm for solving LX =
B using the techniques covered in Section II-C4. Our
algorithm works recursively on a pr × pc processor grid.
We will define the processor grid to be square (pr = pc )
when n ≥ k, but rectangular (pr < pc ) when n < k. So

long as p < k/n, we will choose pc = (k/n)pr . This
strategy implies the largest of the matrices L and B will be
partitioned initially so each cyclically-selected block is close
to square. The algorithm starts by partitioning the processor
grid into pc /pr square grids, if pc > pr , replicating the
matrix L and computing a subset of kpr /pc columns of X on
each. Then the algorithm partitions L into n/2 × n/2 blocks
recursively, executing subproblems with all processors. At a
given threshold, n0 , the algorithm stops recursing, gathers
L onto all processors, and computes a subset of columns of
X with each processor.
X = Rec-TRSM(L, B, Π2D , n, k, pr , pc , n0 )
Require:
L is a lower triangular n × n matrix, distributed on pr × pc
in a cyclic layout, so Π2D (x, y) owns L[x, y] of size pnr × pnc
such that L[x, y](i, j) = L(ipr + x, jpc + y).
B is a dense n × k matrix is distributed cyclically so that
Π2D (x, y) owns X[x, y] of size pnr × pkc
1: if pr = qpc and q > 1 then
2:
Define pr × pr × q processor grid Π3D , such that
Π3D (x, y, z) = Π2D (x1 , y + pr z) owns blocks
L[x, y, z], and B[x, y, z]
3:
L0 [x, y] = Allgather(L[x, y, ◦], Π3D (x, y, ◦))
4:
X[◦, ◦, z] = Rec-TRSM(L0 [◦, ◦], B[◦, ◦, z],
Π2D (◦, ◦, z), n, k/q, pr , pr , n0 )
5: else if n ≤ n0 or pr = pc = 1 then
6:
L = Allgather(L[◦, ◦], Π2D (◦, ◦))
7:
B[x + ypr ] = AllToAll(B[◦, y], Π2D (◦, y))
8:
Π2D (x, y) : X[x + ypr ] = L−1 B[x + ypr ]
9:
X[x, y] = AllToAll(B[x + ◦pr ], Π2D (◦, y))
10: else


L11
0
n
n
11:
Partition L =
so Lij ∈ R 2 × 2
L
L
21
22
 
 
B1
X1
n
12:
Partition B =
,X =
, so Bi , Xi ∈ R 2 ×k
B2
X2
13:
X1 = Rec-TRSM(L11 , B1 , Π2D , n/2, k, p, pr , pc , n0 ).
0
14:
B2 = B2 − MM(L21 , X1 , Π2D , n/2, k, p,
p1/3 (n/k)1/3 , p1/3 (n/k)2/3 ).
15:
X2 = Rec-TRSM(L22 , B20 , Π2D , n/2, k, p, pr , pc , n0 ).
16: end if
Ensure:
X = L−1 B is distributed on Π2D in the same way as B

A. Cost Analysis of the Recursive Algorithm
p
√
We select pc = max(pp, min(p, pk/n)) and pr =
√
p/pc = min( p, max(1, pn/k)). The cost of the allgather
on line 3 is


n2
Tpart−cols (n, pr ) = O β · 2 + α · log(p) ,
pr

since each L0 [x, y] ∈ Rn/pr ×n/pr and is lower triangular.
Once we have a square processor grid, we partition L,
yielding the recurrence,

n 1/3 1/3 n 2/3 
TRT (n, k, p, n0 ) =TMM n/2, k, p, p1/3
,p
k
k
+ 2TRT (n/2, k, p, n0 ).

We now derive the cost of the algorithm for different
relations between n, k, and p, as in the expression for TMM .
One large dimension: When n < k/p, we have pr = 1
and pc = p and the first allgather will be the only communication, therefore,


n2 k
.
TRT1D (n, k, p) = O α · log(p) + β · n2 + γ ·
p

√
Two large dimensions:
When n > k p, we will select
√
pr = pc = p and the column partitioning of B is not
performed. In this case, the MM algorithm will always have
p2 = 1 (it will be 2D). For sufficiently large k, this leads us
to the recurrence,
TRT2D (n, k, p, n0 ) =TMM2D (n/2, k, p) + 2TRT2D (n/2, k, p, n0 ),


n2 k
nk
+
γ
·
.
where TMM2D (n, k, p) = O α · log(p) + β · √
p
p

The bandwidth cost stays the same at every recursive level,
while the computation cost decreases by a factor of 2. At
the base case, we incur the cost TRTBC (n0 , k, p) =



n0 k log(p) 
n2 k
O α · log(p) + β · n20 +
+γ· 0
p
p

√
√
We select n0 = max( p, n log(p)/ p), so n/n0 ≤
√
p/ log(p), which results in the overall cost,


√
nk log(p)
n2 k
TRT2D (n, k, p) = O α · p + β ·
+γ·
.
√
p
p

The bandwidth cost above is suboptimal by a factor of
O(log(p)). The overhead is due to the recursive algorithm re-broadcasting some of the same elements of L
at every recursive level. We use an iterative approach for
our subsequent TRSM algorithm to avoid this redundant
communication.
Three large dimensions:
√
When k/p < n < k/ p , the algorithm partitions the
columns of B initially then recursively
partitions L. In
√ p
particular, we select
p
=
max(
p,
pk/n)
and pr =
c
√ p
p/pc = min( p, pn/k), so the first step partitions a
rectangular processor grid into max(1, k/n) fewer processor
grids. After the first step, which partitions B, we have
independent subproblems with pr processors. We now start
recursively partitioning L, yielding the cost recurrence,
T RT3D (n, k, p2r , n0 ) = TMM3D (n/2, k, p2r )
+ Tpart−cols (n, p)1k/n + 2TRT3D (n/2, k, p2r , n0 ).

Above, we always employ the MM algorithm in the
2/3
3D regime by selecting p1 = pr (n/l)1/3 and p2 =
2/3
pr (n/l)2/3 where l = kpr /pc . In this case, TMM reduces
to TMM3D (n, k, p) =



 2 
n k 2/3 nk log(p)
n2 k
O α · log(p) + β ·
+
+γ·
p
p
p

This gives to the cost recurrence, TRT3D (n, k, p2r , n0 ) =
n2
O α · log(p) + β ·
+ 2 1k
2
pr
pr n


nk log(p)
n2 k
n
+
+γ· 2
+ 2TRT3D ( , k, p2r , n0 ),
p2r
pr
2


 2 
n k 2/3

= O((n2 k/p2r )2/3 ), since
where we can see that nk log(p)
p2r
the initial partitioning will give n ≥ k. It is also easy to see
2
that np2 1 k = O((n2 k/p2r )2/3 ). With these simplifications,
r

n


 n2 k 2/3
T RT3D (n, k, p2r , n0 ) = O α · log(p) + β ·
p2r

2
n k
n
+γ· 2
+ 2TRT3D ( , k, p2r , n0 ).
pr
2

We observe that the bandwidth cost O((n2 k/p2r )2/3 ) decreases by a factor of 21/3 at every recursive level, and the
computation cost by a factor of 2. The base-case cost will
 2/3
be TRTBC (n0 , k, p2r ). We select n0 = n1/3 pk2
, giving
r
a total cost over all base cases of nn0 TRTBC (n0 , k, p2r ) =



nk log(p) 
nn0 k
n
log(p) + β · nn0 +
+
γ
·
O α·
n0
p2r
p2r
  2



2
npr 2/3
n k 2/3
n4/3 k5/3
=O α·
.
log(p) + β ·
+γ·
10/3
k
p2r
pr

Therefore, the overall cost incurred on each square processor
grid is TRT3D (n, k, p2r ) =
  2

 n2 k 2/3
npr 2/3
n2 k
O α·
log(p) + β ·
+
γ
·
.
k
p2r
p2r

When k ≤ n, we do not have a partitioning step and
p2r = p. Otherwise, we have p2r = np/k obtain the cost
TRT3D (n, n, np/k) =
  

 n2 k 2/3
np 2/3
n2 k
O α·
log(p) + β ·
+γ·
,
k
p
p

which is the same as for the case k ≤ n. For n = k, the
3D costs obtained above are the same as the most efficient
algorithms for n × n LU factorization. In the subsequent
sections, we show that a lower synchronization cost is
achievable via selective use of triangular matrix inversion.
V. T RIANGULAR I NVERSION
In this section, we derive the cost of inverting a lower
triangular matrix L of size n × n with p processors. Since
the input matrix is square, the dimensions of the processor
grid Π should be identical in two dimensions leaving us
with dim (Π) = p1 × p1 × p2 , where p = p21 p2 . We assume
the initial matrix to be cyclically distributed on the subgrid
Π(◦, ◦, 1).
A. Algorithmic Approach
In [23], a recursive method for inverting triangular matrices
was presented. A similar method for full inversion was
presented in [24]. When applied to a triangular matrix, those
methods coincide. The method uses the triangular structure
of the initial matrix to calculate the inverse by subdividing
the problem into two recursive matrix inversion calls, which
can be executed concurrently and then uses two matrix
multiplications to complete the inversion.

Since the subproblems are independent, we want to split the
processor grid such that two distinct sets of processors work
on either subproblem. We chose the base case condition to
be that the grid is one-dimensional in the dimension of p1
and we do redundant base case calculations in this subgrid.
For this section, we consider p2 ≥ p1 , a constraint that we
will fulfill anytime the method is called.
L−1 = RecTriInv(L, Π, p, p1 , p2 )
Require:
√
√
The processor grid Π has dimensions p × p
L is a lower triangular n × n matrix, distributed on Π in a
cyclic layout, so Π(x, y) owns L[x, y] of size √np × √np such
√
√
that L[x, y](i, j) = L(i p + x, j p + y).
1: if p1 = 1 then
2:
AllToAll (L[x, ◦], Π(x, ◦))
3:
L−1 = sequential inversion(L)
4: else
5:
Subdivide
L inton/2 × n/2 blocks,

6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

L11
0
L=
L21 L22
Subdivide the processor grid
p Π = [Π
p1 , Π2 ] such that
dim(Π1 ) = dim(Π2 ) = ( p/2 × p/2)
Redistribute (L11 , Π → Π1 )
Redistribute (L22 , Π → Π2 )
2/3
L−1
, p2 /22/3 )
11 = Rec-Tri-Inv(L11 , Π1 , p, p1 /2
−1
2/3
L22 = Rec-Tri-Inv(L22 , Π2 , p, p1 /2 , p2 /22/3 )
−1
L0−1
21 = −MM(L22 , L21 , Π, n, n, p, p1 , p2 )
−1
0−1
L21 = MM(L21 , L−1
11 , Π, n, , p, p1 , p2 )
−1
Assemble
" L from #the n/2 × n/2 blocks,
L−1
0
11
L−1 =
−1
L21 L−1
22

owns having a factor of 21/3 more rows and columns. This
redistribution is effectively an all-to-all between a larger and
a smaller set of processors. We can get a concrete bound
on the cost, by first performing an all-to-all to transition to
a blocked layout (each processor owns contiguous blocks
of the matrix). Then we can transition to a blocked layout
on the smaller processor grid by scattering each block to
at most 4 processors. Finally, we can perform an all-to-all
on the smaller processor grid to transition from the blocked
layout back to a cyclic one. The overall cost of these steps is
O(α · log(p) + β · n20 log(p)/p) This redistribution bandwidth
cost is dominated by the cost of the matrix multiplication.
The total cost for the recursive inversion is
TRecTriInv (n, p1 , p2 ) =β ·

n2 
21/3  n2
+
2
2p1 p2
− 1 8p1

21/3

+γ·


21/3 1 n3
+ O α log2 p .
−18 p

21/3

In contrast to LU factorization and our recursive TRSM
algorithm, the synchronization cost is logarithmic rather than
polynomial in p.
VI. I TERATIVE T RIANGULAR S OLVER
In this section, we present our main contribution, a 3D
TRSM algorithm that uses inversion of diagonal blocks to
achieve a lower synchronization cost. By precomputing the
inversions, we replace the latency-dominated small TRSMs
with more parallel matrix multiplications.

17: end if
16:

A. Block-Diagonal Triangular Inversion

Ensure:
LL−1 = 1 where L−1 is distributed the same way as L

In order to lower the synchronization cost of TRSM, first
we invert a set of triangular blocks along the diagonal of
the matrix, each with a distinct subset of processors. We
split Π into nn0 subgirds of dimensions r1 × r1 × r2 , where
r12 r2 = p nn0 . To have the proper layout for the inversion, a
transition from the original, cyclic layout on a subgrid to the
grid as described in Section III has to happen. Afterwards,
all the inversions can be done in parallel. To p
support our
inversion, we must have r2 > r1 and n0 ≥ r12 r2 . The
precise choices of r1 and r2 are given in the algorithm and
will be discussed in Section VII.

B. Total Cost of Triangular Inversion
This recursive approach of inverting a matrix has total cost,
TRecTriInv (n, p1 , p2 ) = 2TMM (n/2, n/2, p1 , p2 )+
TRecTriInv (n/2, p1 /21/3 , p2 /21/3 ) + Tredistr (n/2, p1 , p2 ),

with a base case cost of

TRecTriInv (n0 , 1, p2 ) = α · 2 log

p2
p1



+ β · 2n20 + γ · n30 .

n
The base case size will be n0 = 3/2
and therefore neither of
p1
the terms is of leading order. We observe that the bandwidth
cost of the matrix multiplication O((n3 /p21 )2/3 ) decreases
by a factor of 24/9 at every recursive level, and the computation cost by a factor of 2. The redistribution process requires
moving the matrices from a cyclic processor grid to a
smaller cyclic processor grid, with the block each processor

B. Triangular Solve using Partial Inversion
Initially, we want L to be distributed on the top level of the
three dimensional grid Π in a cyclic layout such that each
processor Π(x, y, 1) owns L (y : p1 : n, x : p1 : n) . Also,
we set the right hand side to be distributed on one
level of the grid with a blocked layout with a physical block size of b × pk2 such that each processor

Π(x, 1, z) owns B x : p1 : nb , zk/p2 : (z + 1)k/p2 .

L̃ = Diagonal-Inverter(L, Π, n, p1 , p2 , n0 )
Require:
The processor grid Π has dimensions p1 × p1 × p2
L is a lower triangular n×n matrix distributed cyclically on Π
such that processor Π (x, y, 1)) owns L[x, y] a lower triangular
n
× pn1 matrix such that L[x, y](i, j) = L(ip1 + x, jp1 + y).
p1
pn0
r = nn0
n

pn0 1/3
r1 = 4n
1/3
0
r2 = 16pn
n √
√
a p1 × p1 × p2 × p2

1: Define q =
2: Define
3: Define
4: Define

5:

6:
7:
8:

9:
10:
11:
12:

processor
√ grid Π4D , such that
Π4D (x1 , x2 , y1 , y2 ) = Π(x1 , x2 , y1 + p2 y2 ).
and Π4D (x1 , x2 , y1 , y2 ) owns blocks L[x1 , x2 , y1 , y2 ]
Define a block diagonal matrix LD [x1 , x2 , y1 , y2 ]
such that LD [x1 , x2 , y1 , y2 ][b] denotes
the block L[x1 , x2 , y1 , y2 ](bn0 : (b + 1)n0 , bn0 : (b + 1)n0 )
Scatter (LD [◦, ◦, y1 , y2 ][◦],
(x1 , x2 , 1, 1), Π4D (x1 , x2 , ◦, ◦))
√Π4D√
Define a p × p processor grid Π2D , such that
Π2D (x1 + p1 y1 , x2 +√p2 y2 )√= Π4D (x1 , x2 , y1 , y2 ).
√
√
Define a q × q × r × r processor grid ΠI4D , such that
√
√
I
Π4D (u1 , u2 , v1 , v2 ) = Π2D (u1 + qv1 , u2 + qv2 ) owns
blocks LD [u1 , u2 , v1 , v2 ].

I
AllToAll Lq
D [u1 , u2 , v1 , v2 ][◦], Π4D (u1 , u2 , ◦, ◦)
For i = 0 : nn0 − 1 do in parallel
q
For j = 0 : nn0 − 1 do in parallel


q
Define b = i + nn0 j

L̃D [◦, ◦, i, j][b] = RecTriInv (LD [◦, ◦, i, j][b],

ΠI4D [◦, ◦, i, j] , q, r1 , r2 )
14:
end for
15: end for 

16: AllToAll L̃D [u1 , u2 , v1 , v2 ][◦], ΠI4D (u1 , u2 , ◦, ◦)

17: Gather L̃D [◦, ◦, y1 , y2 ][◦],
Π4D (x1 , x2 , ◦, ◦), Π4D (x1 , x2 , 1, 1))
Ensure:
L̃D LD = 1 ∀i where L and L̃ are partitioned the same way
13:

Additionally, each processor has memory of the same size
as its part of B allocated for an update-matrix denoted as
Bj , j ∈ [1, p1 ], where also each processor
Π(x, y, z) owns

By x : p1 : nb , zk/p2 : (z + 1)k/p2 . The algorithm itself
consists of two parts: first ‘inversion’, we invert all the
base-cases on the diagonal in parallel as described in the
algorithm above and, second ‘solve’, we do the updates and
calculate the solution to TRSM.
VII. C OST A NALYSIS OF THE I TERATIVE TRSM
In this section we will derive a performance model for
the algorithm presented in Section VI. The total cost of
the algorithm is put together from the cost of its three
subroutines:
TIt−Inv−TRSM (n, k, n0 , p1 , p2 ) = TInv (n, p1 , p2 )+
TUpd (n, k, n0 , p1 , p2 ) + TSolve (n, k, n0 , p1 , p2 ).

Above the cost denoted by inversion is the part of the algorithm that inverts the blocks (Algorithm Diagonal-Inverter).
The solve part is in lines 4-5, and the update in lines 7-8.
X = It-Inv-TRSM(L, B, Π, n, k, p1 , p2 , r1 , r2 )
Require:
The processor grid Π has dimensions p1 × p1 × p2
L is a lower triangular n × n matrix is distributed on Π such
that Π(x, y, 1) owns L[x, y] of size n/p1 × n/p1 such that
L[x, y](i, j) = L(ip1 + x, jp1 + y)
B is a dense n × k matrix is distributed such that Π(x, 1, z)
owns B[x, z]of sizen/p1 × k/p2 , such that B[x, z](i, j) =
L(ip1 + x, zk/p2 + j)
Define blocks Si = in0 : (i + 1)n0 and Ti = in0 : n
1: L̃ = Diagonal-Inverter(L, Π, n, p1 , p2 , n0 )
2: Bcast (B [x, z] (S0 (x), ◦), Π(x, 1, z), Π(x, ◦, z))
3: for i = 0 : nn − 1 do
0
4:
Π(x, y, z) : X [y, z] (Si , ◦) =
5:
6:

L̃ [y, x] (Si , Si ) · B [x, z] (Si , ◦)
X [y, z]
(◦, y, z))
 (Si , ◦) = Allreduce (X [y, z] (Si , ◦), Π 
Bcast L̃ [x, y] (Ti+1 , Si ), Π(x, y, 1), Π(x, y, ◦)

Π(x, y, z) : By [x, z] (Ti+1 , ◦)+ =
L̃ [x, y] (Ti+1 , Si ) · X [y, z] (Si , ◦)
B0 [x, z] (Si+1 , ◦) =
8:
Allreduce(B◦ [x, z] (Si+1 , ◦), Π (x, ◦, z))
9:
Π(x, y, z) : B [x, z] (Si+1 , ◦) =
B [x, z] (Si+1 , ◦) − B0 [x, z] (Si+1 , ◦)
10: end for
Ensure:
B = LX where X is distributed the same way as B
7:

A. Inversion Cost
We invert the nn0 submatrices of size n0 × n0 along the
diagonal with distinct processor grids. The size of the
processor grids involved is r1 × r1 × r2 . The choices of
r1 and r2 are made such that the bandwidth cost of the
inversion is minimal. Additionally we have to account for
the cost that arises from communicating the submatrices to
the proper subgrids. This happens in lines 6, 9, 16, and 17
of the Algorithm Diagonal-Inverter. The respective costs are
summed up the the following table.

Line 16

0
α · log(p2 ) + β · nn
2p2
1


O α · log(p) + β · nn02plog p


O α · log(p) + β · nn02plog p

Line 17

α · log(p2 ) + β ·

Line 6
Line 9

nn0
2p2
1

These cost are never of leading order compared to the costs
that arise form the triangular inversion. With the derivations
done in Section V, we get the following costs for inversion:
Latency Cost: The total latency cost of inversion is

SInv (p) = O α log2 p .

Bandwidth Cost: In order to minimize the bandwidth cost
of triangular inversion, we choose a grid splitting to achieve
closest to ideal ratios for the subgrids processor layout r1
and r2 . This ratio is achieved when r2 = 4r1 . The choices
for r1 and r2 are therefore,
r1 =

 pn 1/3
0

4n


r2 =

and

16pn0
n

1/3
.

With this grid slicing, we get nn0 different sub-grids of
dimensions r1 × r1 × r2 . This setup leads to a cost for
inverting nn0 submatrices of
21/3
WInv (n0 , r1 , r2 ) = 1/3
2
−1



n20
n20
+
2
8r1
2r1 r2


.

Flop Cost: The flop cost of the inversion part is
FInv (n0 , p1 , p2 ) =

1
8

Bandwidth Cost: The cost of doing all the updates as
described in the algorithm in Section VI (Lines 5-9) is the
cost of both the allreductions and the broadcast,
WUpd (n, k, n0 , p1 , p2 ) =


n/n0 −1 
X
nn0 − in0
Wbcast
,
p
2 +
p21
i=1




n0 k
n0 k
Wallreduction
.
, p1 + Wallreduction
, p1
p1 p2
p1 p2

This yields to a total cost of WUpd (n, k, n0 , p1 , p2 ) =


n − n0
n0 k
nn0 − n
4
1p2 + 4
1p .
n0
p21
p1 p2 1

Flop Cost: The update flop cost is
FUpd (n, k, n0 , p1 , p2 ) =

nn20
.
p21 p2

n − n0
n0



knn0
p21 p2


.

D. Total Cost
B. Solve Cost
The complete solve cost can be derived by
n
TMM (n0 , k, p, p1 , p2 )
n0

TSolve (n, n0 , k, p, p1 , p2 ) =

Latency Cost: The latency cost of the solve part is

SSolve (n, n0 , p) = O


n
log p .
n0

Bandwidth Cost: The cost of the solve is one call to
triangular matrix multiplication for each base case. The
synchronization cost is again dominated by the nn0 cases.
The cost for these sums has been presented in Section III.
Including these, we obtain a total cost of
n
WSolve (n, k, n0 , p, p1 , p2 ) =
· WMM (n0 , k, p, p1 , p2 )
n0



 2 
n0 k
n
n0
+
4
=
·
1
1
p
p
2
1 .
n0
p21
p1 p2

Flop Cost: The flop cost of the solve part is
FSolve (n, k, n0 , p1 , p2 ) =

n
n0



n20 k
p21 p2

The total cost of the algorithm is the sum of its three parts
and leaves a lot of tuning room as with a choice of p1 = 1,
p2 = 1 or n0 = n one is able to eliminate certain terms.
Latency Cost: The total latency cost of the algorithm is a
sum of the previous parts,
SIt−Inv−TRSM (p1 , p2 , r1 , b) = SUpd (n, n0 , p1 , p2 )+
SSolve (n, n0 , p1 , p2 ) + SInv (p1 , p2 , r1 , b)
 

n
=O α
log p + log2 p
.
n0

Bandwidth Cost: The total bandwidth
cost for the TRSM
21/3
algorithm is, by abbreviating ν = 21/3
,
−1
WIt−Inv−TRSM (n, k, n0 , p1 , p2 , u, v, b) =
WUpd (n, k, n0 , p1 , p2 ) + WSolve (n, k, n0 , p1 , p2 )
+ WInv (n, b, p1 , p2 , u, v)
 2 



n0
n0 k
n
·
1
+
4
1
=
p2
p1
n0
p21
p1 p2


 2

n − n0
nn0 − n
n0 k
n0
n20
+
4
1p2 + 4
1p1 +ν
+
.
2
2
n0
p1
p1 p2
8r1
2r1 r2


.

Flop Cost: Lastly, the combined total flop cost is
FIt−Inv−TRSM (n, k, n0 , p1 , p2 ) = FUpd (n, n0 , p1 , p2 )

C. Update Cost
+FSolve (n, n0 , p1 , p2 )+FInv (n0 , u, v, p1 , p2 ) =

The complete solve cost can be derived by
VIII. PARAMETER T UNING

n/n0 −1

TUpd (n, k, n0 , p, p1 , p2 ) =

X

TMM (n−in0 , n0 , k, p, p1 , p2 ) .

i=1

Latency Cost: The update latency cost is

SUpd (n, n0 , p) = O

n2 k
n2 n
+ 20 .
2
p1 p2 p1 p2


n − n0
log p .
n0

In this section, we give asymptotically optimal tuning parameters for different relative matrix sizes to optimize performance. We only focus on asymptotic parameters as there
is a trade off between the constant factors on the bandwidth
and latency costs. The exact choice is therefore machine

dependent and should be determined experimentally. The
initial grid layout is dependent on the relative matrix sizes
of L and B since the update part of the algorithm is one of
the dominating terms in any case where there is an update
to be made and determines the case where is is infeasible.
The different layouts are shown in Figure 1.
4k
the processor
In the case where n
<
p ,
grid
layout
is
one-dimensional.
The
optimal
parameters are given in
the
following
table.



p1 =

1

r1 =

p2 =

p

r2 =

O (p)1/3


O (p)1/3

n0 =

n

Using this set of parameters will yield to a total cost of



n2 k
TIT1D (n, k, p) = O α · log2 p + log p + β · n2 + γ ·
.
p

Comparing these costs to the costs of TRT1D obtained in
Section IV-A, we can see that we are within the asymptotic
bounds of the original algorithm in bandwidth and flop cost,
but pay an extra factor of log p latency, since the inversion,
if performed on a 3D grid, requires log2 p steps. But since
the inversion is the least significant part of the routine in 1
large dimension, no gain was to be expected in this case.
√
In the case where n
>
4k p, the processor
grid
layout
is
two-dimensional.
The
optimal
parameters are given in the following table.

p1 =
r1 =

√

O

p


p2 =

k 1/4
n

1

n0 =



r2 =

p3/8

1/4

O
nk3 p1/2
O




k 1/4
n

p3/8

 

 n 3/4 1
2
TIT2D (n, k, p) = O α log p +
log p
k
p1/8


 2 
nk
n k
+β √
+γ √
.
p
p
Comparing these costs to the cost of TRT2D obtained in
Section IV-A, we can see that we are asymptotically more
p1/4
efficient in terms of latency by a factor of at least log
p as
well as in bandwidth by a factor of log p while having the
same flop cost asymptotically. This is a significant gain and
especially important as the occurrence of fewer right hand
sides k < n is high.
√
In the case where 4k
p ≤ n ≤ 4k p, the processor grid layout
is three-dimensional. The optimal parameters are given in
the following table.

r1 = O

pn 1/3
4k

p2 =

√

p4k
n


√

n0 = O min
nk, n

i1/3 
h √
r2 = O
min p nnk , p

2/3


i1/3 
h √
min p nnk , p

Using this set of parameters will yield to a total cost of


 
r
n
2
, 1 log p
TIT3D (n, k, p) = O α log p + max
k
!
 2 2/3
 2 !
n k
n k
+β
+γ √
.
p
p
Comparing these costs to the cost of TRT3D obtained in
Section IV-A, we can see that we are asymptotically more
1/6 2/3
efficient in terms of latency by a factor of nk
p
while
being able to keep bandwidth and flop costs asymptotically
constant.
IX. C ONCLUSION
S

W


1 Large Dimension n <

4k
p

F


standard

log p

n2

n2 k
p

new method

log2 p

n2

n2 k
p

√ 
2 Large Dimensions n > 4k p



Using this set of parameters will yield to a total cost of

p1 =

Figure 1. One-, two-, and three-dimensional layout dependent on relative
matrix sizes. Inverted blocks of the matrix in dark and input- and output
of the right hand side on the left and right size of the cuboid.

√

standard
new method

log2 p +

p


n 3/4 1
k
p1/8

new method

np 2/3
k

log2 p +

q

log p
n
k

n2 k
p

nk
√
p

n2 k
p

log p

3 Large Dimensions
standard

nk
log p √
p

log p

4k
p

√
≤ n ≤ 4k p
 2 2/3
n k
p



n2 k
p

2/3

n2 k
p
2n2 k
p

We present a new method for solving triangular systems for
multiple right hand sides. In the above table, we compare
to a baseline algorithm adapted from [3] that achieves costs
that are as good or better than the state of the art [18], [21],
[25]. Our algorithm achieves better theoretical scalability
1/6 2/3
p . For
than these alternatives by up to a factor of nk
certain matrix dimensions, a decrease of bandwidth cost by
a factor of log2 p is obtained by use of selective triangular
matrix inversion. By only inverting triangular blocks along
the diagonal of the initial matrix, we generalize the usual
way of TRSM computation and the full matrix inversion
approach. Fine-tuning the algorithm based on the relative
input sizes as well as the number of processors available
leads to a significantly more robust algorithm. The cost

analysis of this new method allows us to give recommendations for asymptotically optimal tuning parameters for a
wide variety of possible inputs. The detailed pseudo-code
provides a direct path toward a more efficient parallel TRSM
implementation.
R EFERENCES
[1] F. G. Gustavson, “Recursion leads to automatic variable
blocking for dense linear-algebra algorithms,” IBM Journal
of Research and Development, vol. 41, no. 6, pp. 737–755,
1997.
[2] E. Solomonik and J. Demmel, “Communication-optimal parallel 2.5-D matrix multiplication and LU factorization algorithms,” in Euro-Par 2011 Parallel Processing. Springer,
2011, pp. 90–109.
[3] E. Elmroth, F. Gustavson, I. Jonsson, and B. Kågström,
“Recursive blocked algorithms and hybrid data structures for
dense matrix library software,” SIAM review, vol. 46, no. 1,
pp. 3–45, 2004.
[4] J. J. Du Croz and N. J. Higham, “Stability of methods
for matrix inversion,” IMA Journal of Numerical Analysis,
vol. 12, no. 1, pp. 1–19, 1992.
[5] E. Solomonik, E. Carson, N. Knight, and J. Demmel, “Tradeoffs between synchronization, communication, and computation in parallel linear algebra computations,” in Proceedings
of the 26th ACM Symposium on Parallelism in Algorithms
and Architectures, ser. SPAA ’14. New York, NY, USA:
ACM, 2014, pp. 307–318.
[6] E. Chan, M. Heimlich, A. Purkayastha, and R. Van De Geijn,
“Collective communication: theory, practice, and experience,”
Concurrency and Computation: Practice and Experience,
vol. 19, no. 13, pp. 1749–1783, 2007.
[7] R. Thakur, R. Rabenseifner, and W. Gropp, “Optimization
of collective communication operations in mpich,” International Journal of High Performance Computing Applications,
vol. 19, no. 1, pp. 49–66, 2005.
[8] J. Bruck, C.-T. Ho, S. Kipnis, E. Upfal, and D. Weathersby, “Efficient algorithms for all-to-all communications in
multiport message-passing systems,” Parallel and Distributed
Systems, IEEE Transactions on, vol. 8, no. 11, pp. 1143–1156,
1997.
[9] J. L. Träff and A. Ripke, “Optimal broadcast for fully
connected processor-node networks,” Journal of Parallel and
Distributed Computing, vol. 68, no. 7, pp. 887–901, 2008.
[10] E. Dekel, D. Nassimi, and S. Sahni, “Parallel matrix and
graph algorithms,” SIAM Journal on Computing, vol. 10,
no. 4, pp. 657–675, 1981.
[11] R. C. Agarwal, S. M. Balle, F. G. Gustavson, M. Joshi, and
P. Palkar, “A three-dimensional approach to parallel matrix
multiplication,” IBM J. Res. Dev., vol. 39, pp. 575–582,
September 1995.

[12] A. Aggarwal, A. K. Chandra, and M. Snir, “Communication complexity of PRAMs,” Theoretical Computer Science,
vol. 71, no. 1, pp. 3 – 28, 1990.
[13] J. Berntsen, “Communication efficient matrix multiplication
on hypercubes,” Parallel Computing, vol. 12, no. 3, pp. 335–
342, 1989.
[14] W. F. McColl and A. Tiskin, “Memory-efficient matrix multiplication in the BSP model,” Algorithmica, vol. 24, pp. 287–
297, 1999.
[15] S. L. Johnsson, “Minimizing the communication time for
matrix multiplication on multiprocessors,” Parallel Comput.,
vol. 19, pp. 1235–1257, November 1993.
[16] J. Demmel, D. Eliahu, A. Fox, S. Kamil, B. Lipshitz,
O. Schwartz, and O. Spillinger, “Communication-optimal parallel recursive rectangular matrix multiplication,” in Parallel
Distributed Processing (IPDPS), 2013 IEEE 27th International Symposium on, May 2013, pp. 261–272.
[17] A. Tiskin, “Bulk-synchronous parallel gaussian elimination,”
Journal of Mathematical Sciences, vol. 108, no. 6, pp. 977–
991, 2002.
[18] M. T. Heath and C. H. Romine, “Parallel solution of triangular systems on distributed-memory multiprocessors,” SIAM
Journal on Scientific and Statistical Computing, vol. 9, no. 3,
pp. 558–588, 1988.
[19] P. Raghavan, “Efficient parallel sparse triangular solution
using selective inversion,” Parallel Processing Letters, vol. 8,
no. 01, pp. 29–40, 1998.
[20] D. Irony and S. Toledo, “Trading replication for communication in parallel distributed-memory dense solvers,” Parallel
Processing Letters, vol. 12, no. 01, pp. 79–94, 2002.
[21] B. Lipshitz, “Communication-avoiding parallel recursive algorithms for matrix multiplication,” Master’s thesis, University of California, Berkeley, 2013.
[22] S. Tomov, R. Nath, H. Ltaief, and J. Dongarra, “Dense
linear algebra solvers for multicore with GPU accelerators,” in
Parallel & Distributed Processing, Workshops and Phd Forum
(IPDPSW), 2010 IEEE International Symposium on. IEEE,
2010, pp. 1–8.
[23] A. Borodin and I. Munro, The computational complexity
of algebraic and numeric problems.
Elsevier Publishing
Company, 1975, vol. 1.
[24] S. M. Balle, P. C. Hansen, and N. Higham, “A Strassen-type
matrix inversion algorithm,” Advances in Parallel Algorithms,
pp. 22–30, 1994.
[25] L. S. Blackford, J. Choi, A. Cleary, E. D’Azeuedo, J. Demmel, I. Dhillon, S. Hammarling, G. Henry, A. Petitet, K. Stanley, D. Walker, and R. C. Whaley, ScaLAPACK User’s Guide,
J. J. Dongarra, Ed.
Philadelphia, PA, USA: Society for
Industrial and Applied Mathematics, 1997.

