跳过1简介部分 1 简介 随着高性能计算从串行进一步转向并行，计算线性代数面临着重大挑战。 经典算法的设计目的是最小化浮点运算的数量，并且在现代通信绑定体系结构上并不总是能够获得最佳性能。 在秩揭示矩阵分解领域，障碍尤其明显。 基于列向量QR分解或Krylov方法的传统技术往往使高效并行化具有挑战性，因为它们最自然地被视为一系列矩阵-向量运算。
在本文中，我们描述了用于计算所谓的等级揭示UTV分解的随机化算法的有效实现技术[ 24 ] ( 随机UTV 从现在开始）共享和分布式内存体系结构。 给定输入矩阵 A类 大小为 \（m\次n\），目标 随机UTV 就是计算因子分解 (1) \（开始{方程式}\开始{数组}{ccccccccc}A&=&U&T&V^{*}，\\m\次n&m\次m&m\次数n&n\次n\结束{数组{end{方程式{}\） 其中中间因素 T型 为上三角形（或在以下情况下为上梯形 \（m）和左右因子 \（U、V\）是正交的。 从以下意义上说，因子分解具有等级揭示性 (2) \（\begin{方程式}\Vert A-U（：，1:k）T（1:k，：）V^*\Vert\approx\inf\lbrace\Vert A-B\Vert:B\text{has rank}k\rbrace。 \结束{方程式}\） 在因式分解中 随机UTV ，中间矩阵 T型 通常在对角线上方有模量很小的元素，这意味着 T型 成为奇异值的优秀近似 A类 这种类型的因式分解对于解决低秩近似、确定基本子空间近似的基等任务非常有用 A类 ，在最小二乘意义下求解病态或超/欠定线性系统，并估计 A类 .
随机算法 随机UTV 我们描述并实现了以下特性，这些特性在许多环境中都优于经典的等级揭示因子分解，如列向量QR（CPQR）和奇异值分解（SVD）。
在算法中使用随机化是无风险的，因为计算出的矩阵 U型 , T型 、和 V（V） 必然满足( 1 )，达到机器精度。 算法中的随机性只影响到接近最优值的程度( 1 )是在揭示数字等级。 理论分析和广泛的数值实验都很好地支持了它以很高的概率揭示出的秩几乎与奇异值分解（SVD）一样好，远优于传统的CPQR； 我们向感兴趣的读者推荐[ 24 ]，尤其是图 6 – 10 .
它将其大多数操作转换为矩阵-矩阵乘法，这在并行计算环境中非常有效。 它在[ 24 ]直接阻塞的实现 随机UTV 在对称多处理（SMP）系统中，执行速度甚至超过CPQR的高度优化实现。 在这份手稿中，我们提出了一个改进了[ 24 ]对于SMP，并获得了分布式内存体系结构的类似结果。
分解是以增量方式构建的，一旦满足指定的容差，就可以停止分解。 准确地说，如果执行在顶部停止 k个 行，共行 T型 已建造，仅 \（O（mnk）\）次失败将被花费。
在本文中，我们提供了两种有效的实现来计算 随机UTV 因子分解：第一个是共享内存机器，第二个是分布式内存机器。 关于共享内存体系结构，之前的工作[ 24 ]提出了一种分块算法，其中基于并行BLAS实现，并遵循fork-join并行执行模型，在每个任务的基础上提取并行度。 在这里，我们提出了一种新的分块算法[ 31 ]，其中顺序任务动态添加到有向非循环图（DAG）中，并通过运行时任务调度程序执行( 利比亚火焰 的超级矩阵[ 7 ]). 这种方法通过减轻fork-join模型中固有同步点的影响来提高性能，并在其他线性代数实现中显示了其潜力[ 8 ]. 此外，考虑到现代SVD实现（例如，在“英特尔MKL”中）在性能方面的最新改进，我们将展示基于运行时的实现 随机UTV 在性能方面仍与他们不相上下。 关于我们的第二个提议，这是第一次发布内存版本的 随机UTV 出现在文献中。 性能结果表明，与最先进的分布式内存实现相比，具有极好的可扩展性。
与最新技术相比，本文的主要贡献如下。
(1)
我们提出了一种新的分块算法来计算 随机UTV 在无编程成本的情况下实现性能最大化的因式分解。
(2)
我们已将解决方案与现有的基于任务的软件基础架构集成( 利比亚火焰 SuperMatrix），基于以下任务提供现成的实现 随机UTV .
(3)
在共享内存体系结构上，我们提供了与基于并行BLAS的解决方案相比的最佳块大小的详细研究，并报告了社区可能感兴趣的它们之间的定性和定量差异。 同样，我们对两台高度并行的共享内存机器进行了详细的性能和可伸缩性研究。
(4)
性能结果显示了 按块算法 与 阻塞算法 在我们的目标测试台上，在 \（1.73倍）和 \（2.54倍）。 与专有的MKL SVD实现相比，其加速还显示出显著的性能提升，改进幅度高达 \（3.65倍），一般来说，在所有涉及较大矩阵的情况下( \（不超过4，\！000\）
(5)
在分布式内存体系结构上，与ScaLAPACK SVD、ScaLABACK CPQR和PLiC CPQR的执行时间比较表明，从 \（2.8\次）至 \（6.6\times\），以及在测试平台上的出色可扩展性。
(6)
在分布式内存体系结构上，我们提供了关于几个节点上的块大小、网格大小、每个进程的线程等的详细性能研究。
文章结构如下：第节 2 介绍了我们的记法，并简要回顾了相关概念。 在节中 三 ，让读者熟悉 随机UTV 最近在中描述的算法[ 24 ]. 小节 4 和 5 描述构成本文主要贡献的共享和分布式内存实现。 在节中 6 ，我们给出了数值结果，将我们的实现与竞争因子分解的高度优化实现进行了比较。 章节 7 总结了主要发现，并概述了进一步改进和扩展的一些可能性。
跳过2PREIMINARIES部分 2 序言 我们使用符号 \（A\in\mathbb｛R｝^｛m\times n｝\）指定 A类 是一个 \（m\times n）矩阵，带实项。 安 正交的 矩阵是一个方形矩阵，其列向量都有单位范数，并且是成对正交的。 \（\sigma-i（A）\）表示 我 -的第个奇异值 A类 、和 \（显示样式{\inf（A）=\min _i\lbrace\sigma _i（A）\rbrace}\）。 默认规范 \（\Vert\cdot\Vert\）是光谱范数。 我们还使用标准的矩阵索引符号 \（A（c:d，e:f）\）表示的子矩阵 A类 由中的条目组成 c（c） -th到 d日 -第行 e（电子） -th到 （f） -第个列。
2.1 奇异值分解（SVD） 让 \（A\in\mathbb{R}^{m\次n}）和 \（p=\分钟（m，n）\）。 这是众所周知的[ 17 , 34 , 37 ]任何矩阵 A类 接受表单的SVD \（开始{方程式*}\开始{数组}{ccccc}A&=&U&\Sigma&V^*，\\m\次n&m\次m&m\次数n&n\次n\结束{数组{方程式*}\） 哪里 U型 和 V（V） 是正交的，并且 \（\Sigma\）是对角线。 我们也可以说 经济的 的SVD A类 ，由提供 \（\ begin｛equipment*｝\ begin｛array｝｛ccccccc｝A&=&U&&\ Sigma&V^*，\\m\ times n&&m\ times p&p\ times p&p\ times n\end｛array｝\ end｛equipment*｝\） 在这种情况下 U型 和 V（V） 不一定是正交的（因为它们不是正方形），但它们的列保持正交。 对角线元素 \（\西格玛\）是 奇异值 \（\lbrace\sigma{i}\rbrace_{i=1}^{p}\）的 A类 。这些是为了 \（\sigma_1\ge\ sigma_2\ge\cdots\ge\ simma_{p-1}\ge\ sigma_p\ge0）。 立柱 \（u_i）和 \第（v_i）页，共页 U型 和 V（V） 被称为 左边 和 右奇异向量 分别为 A类 .
SVD的一个关键事实是它提供了理论上的最优秩- k个 近似值 A类 具体来说，Eckart-Young-Mirsky定理[ 14 , 28 ]给出矩阵SVD的状态 A类 如前所述 \（1），我们有 \（\begin{等式*}\Vert A-U（：，1:k）\Sigma（1:k，1:1k）（V（：，1:2k））^*\Vert=\inf\lbrace\Vert A-B\Vert:B\text{has rank}k\rbrace。 \结束{方程式*}\） 这个结果的一个推论是，由前导 k个 的左右奇异向量 A类 提供最佳排名- k个 列和行空间的近似值 A类 例如，如果 对 是左奇异向量跨越的子空间上的正交投影 A类 ，然后 \（PA=U（：，1:k）\西格玛（1:k，1:k； 因此， \（\Vert A-PA\Vert=\inf\lbrace\Vert A-B\Vert:B\text{具有等级}k\rbrace\）。
2.2 QR分解 给定矩阵 \（A\in\mathbb{R}^{m\次n}\），让 \（p=\分钟（m，n）\）。 QR分解 A类 由提供 \（开始{方程式*}\开始{数组}{cccc}A&=&Q&R，\\m\次n&&m\次m&m\次数n\结束{数组{end{方程式*}\） 哪里 问 是正交的，并且 R（右） 为上三角形。 如果 \（m\gt n\），则任何QR都可以简化为“经济”QR \（开始{等式*}\开始{数组}{cccc}A&=&Q&R。\\m\乘以n&m\乘以n和n\乘以n\结束{数组{end{等号*}\）
计算QR因子分解的标准算法依赖于Householder反射器( HQR公司 ). HQR算法的详细讨论可以在[ 17 , 34 , 37 ]. 计算矩阵的因子分解 A类 , 第页 必须计算并应用户主转换，其中每个户主反射器具有以下结构： \（H=I-\tau v v ^*\）。 的输出 HQR公司 是上三角矩阵 R（右） QR分解的单位下三角矩阵 \（V\in\mathbb{R}^{m\乘以p}）和一个向量 \（t\in\mathbb｛R｝^p\）。 矩阵 V（V） 存储“Householder矢量” \（v_i）和向量 t吨 存储 \（tau _i）值。 户主向量 \（v_i）和标量值 \（tau_i）可用于廉价构建或应用 问 或 \（Q^*\）（参见第节 2.3 ). 在本文中，我们批判性地利用了以下事实： \（m\gt n\），领先 第页 列，共列 问 构造柱空间的正交基 A类 .
2.3 契约 年 住户反射器集合的表示 让 b条 , \（0\lt b\le p\）是一个整数，我们称之为块大小，让 \（A\in\mathbb{R}^{m\timesn}），然后让 \（H_i，\；i=1，\ldots，b\）是Householder变换。 作为房主转换 \（H_i=i-\tau_i v_i v_ i^*\），它在矩阵中的一个有效应用 A类 只需一个矩阵-向量积和一个秩-1更新即可完成，而不需要矩阵-矩阵积。 显然，如果 b条 住户转型 \（H_i）被一个接一个地应用，计算需要 \（\mathcal{O}（bmn）\）整体失败。 然而，这两种操作（产品和等级1更新）都是基于矩阵-向量的； 因此，它们在现代建筑上无法产生高性能。
如果 b条 必须应用户主转换，产品 \（H=H_bH_{b-1}\cdots H_2H_1）可以表示为 \（\开始｛方程*｝H=I-W S W ^*，\结束｛方程*｝\） 哪里 \（W\in\mathbb{R}^{m\乘以b}\）是下梯形 \（S\in\mathbb{R}^{b\乘以b}）是上三角形。 Householder矩阵乘积的这种重新表述被称为紧致矩阵 年 表示[ 33 ]. 如果房主转型 \（H_i）已知，矩阵 W公司 和 S公司 紧凑型的 年 计算成本低。 矩阵 W公司 只包含Householder向量 \（v_i）和矩阵 S公司 可以从Householder矢量中廉价计算 \（v_i\）（或 W公司 )和 \（tau _i）值。
此表达式可用于构建产品 哈 : \（开始{方程式*}HA=A-W S W ^*A.结束{方程式*}） 此公式的计算成本大致相同。 然而，在这种情况下，只使用矩阵-矩阵运算（一次 S公司 ）。 由于在现代体系结构上，矩阵-矩阵运算通常比矩阵-向量运算效率更高，因此这种方法将产生更高的性能。 回想一下，由于存在高速缓存和更大的浮点到内存访问比率，矩阵-矩阵操作中一个浮点（浮点操作）的平均时间成本通常比矩阵-向量操作中一次浮点的平均成本小得多（几倍）。
跳过3THE UTV FACTORIZATION部分 三 UTV因子化 在本节中，我们将讨论等级揭示UTV矩阵分解，确定其在计算线性代数中的用途，并回顾其计算的有效算法。 在节中 3.1 ，我们回顾了经典的UTV矩阵分解，总结了其相对于其他标准分解（如列向量QR和SVD）的优点。 在节中 3.2 ，我们总结了最近的工作[ 24 ]这就提出了一种随机分块算法来计算这个因子分解。
3.1 经典UTV因子分解 让 \（A\in\mathbb{R}^{m\timesn}\）并设置 \（p=\分钟（m，n）\）。 UTV分解 A类 是形式的任何因子分解 (3) \（开始{方程式}\开始{数组}{ccccccccc}A&=&U&T&V^{*}，\\m\次n&m\次m&m\次数n&n\次n\结束{数组{end{方程式{}\） 哪里 T型 是三角形的 U型 和 V（V） 都是正交的。 在本文中，我们采用 T型 成为 上面的 三角形，当 \（m\gen）。 通常需要计算 揭示等级 UTV（RRUTV）分解。 对于任何 \（1\le k\le p\），考虑 T型 (4) \（\开始{方程式}T \右箭头\左（\开始}数组}{c|c}T_{11}和T_{12}\\hline T_{21}&T_{22}结束{数组}\右），\结束{方程式{） 哪里 \（T_{11}\）是 \（k\乘以k\）。 我们非正式地说，UTV因子分解具有等级揭示性，如果
(1)
\（\ inf（T_{11}）\近似\σ_k（A）\），
(2)
\（\垂直T_{22}\垂直\近似\σ_{k+1}（A）\）。
UTV分解中因子的灵活性使其比其他规范形式（如CPQR和SVD）具有某些优势（请注意，这些都是UTV分解的特殊情况）。 由于CPQR中的右因子被限制为置换矩阵，因此UTV有更多的自由度来提供更好的低秩和子空间近似。 此外，由于UTV没有SVD对中间因子的对角线限制，因此UTV的计算成本更低，并且具有更有效的更新和降级方法（例如，请参阅[ 三 , 15 , 29 , 35 , 36 ]).
3.2 这个 随机UTV 算法 在[ 24 ]，一个名为 随机UTV 提出用于计算RRUTV因子分解。 随机UTV 设计用于很好地并行化，增强RRUTV作为CPQR和SVD的竞争对手在各种问题类型中的生存能力。 它产生的低阶近似在最优性方面与SVD相当，而其计算速度与CPQR相似。 事实上，正如我们将要演示的那样，我们的randUTV新实现通常非常重要 更快 计算CPQR的最先进算法。 与构建SVD和RRUTV的经典方法不同， 随机UTV 按块处理输入矩阵 b条 连续列。 随机UTV 分享了CPQR的优点，因为因子分解是增量计算的，并且可能会提前停止，从而导致 \（\mathcal{O}（mnk）\），其中 k个 是计算的因子分解的秩。
结构背后的驱动理念 随机UTV 算法是构建中间因子 T型 使用向右的方法，即在每次迭代中 T型 （一个块列）同时获得，并且只获得 T型 已访问。 为了进行说明，请考虑一个输入矩阵 \（A\in\mathbb{R}^{m\timesn}\）并让 \（p=\分钟（m，n）。\） 块大小参数 b条 具有 \必须在之前选择（1\le b\le p\） 随机UTV 开始。 为了简单起见，假设 b条 划分 第页 均匀地。 算法从初始化开始 \（T^{（0）}{：=}A\）。 然后，大部分工作在一个需要 \（p/b\）步骤。 在 我 -第th步（从0开始），一个新的矩阵 \（T^{（i+1）}\）是用 \（开始{方程式*}T^{（i+1）}{：=} 对于一些正交矩阵 \（U^{（i）}\）和 \（V^{（i）}\）。 \（U^{（i）}\）和 \（V^{（i）}）的选择如下：
领先者 \（i+1）b\）列 \（T^{（i+1）}\）是带 \尺寸为（i+1\）的对角块 \（b\乘以b\）。
在方程式中使用分区( 4 )定义 \（T^{（i+1）}_{11}\）和 \（T^{（i+1）}_{22}\），我们有这个 \（\inf（T^{（i+1）}_{11}）\approxix\sigma_k（A）\）和 \（\垂直T^{（i+1）}_{22}\垂直\近似\σ_{k+1}（A）\） \（1\le k\le（i+1）b\）。
\（T^{（i+1）}_{11}（k，k）\近似\σ_k（A）\） \（1\le k\le（i+1）b\）。
稀疏模式示例 T型 随着算法的发展，如图所示 1 可以看出，每次迭代后，矩阵其余部分（右下部分）的大部分“质量”或“范数”都会移动到当前对角线块：矩阵右下部分元素的大部分“重量”都会移到当前块列， 当前块列的对角线下的元素被置零，当前对角线块被对角线化。
图1。 对于randUTV，如果（n=12，b=3），计算了前三个（T^{（i）}）之后的稀疏模式。 randUTV继续，直到整个\（T^{（i）}\）是上三角形。 空白表示无效元素，点的大小表示元素绝对值的近似值。
一次 \（T^{（i）}\）是上三角形， U型 和 V（V） 然后可以按以下方式构建： \（\开始{等式*}V{：=}V^{（0）}V ^{； U{：=}U^{（0）}U^}。 \结束{方程式*}\）
实际上，两者都是 \（V^{（i）}\）和 \（U^｛（i）｝\）分两个阶段构建，并应用于 \（T^{（i）}）在算法中的不同点。 此后，我们将这些矩阵称为 \（V^{（i）}_{\alpha}\）， \（U^{（i）}_{\alpha}\）和 \（V^{（i）}_{\β}\）， \（U^{（i）}_{\beta}\）分别用于第一阶段和第二阶段。 首先， \使用（V^{（i）}{\alpha}）将矩阵其余部分（右下部分）的大部分“质量”移动到当前块列。 然后， \使用（U^{（i）}{\alpha}\）使主对角线以下的所有元素无效（将主对角线上当前块列的所有“质量”移动到对角线块），然后 \（V^{（i）}{β}）和 \使用（U^{（i）}{\beta}\）对角化当前对角线块。 此外，只有一个 T型 矩阵被存储，其内容被新的覆盖 \（T^{（i+1）}\）。 类似地，如果矩阵 U型 和 V（V） 只需要形成一个矩阵 U型 和一个矩阵 V（V） 将被存储。 因此 随机UTV 如下所示：
(1)
初始化 \（T{：=}A，\，V{：=}I，\，U{：=1}I）。
(2)
对于 \（i=0，\ldots，b/p-1）：
（i）
生成 \（V^{（i）}_\alpha\）。
（ii）
更新 T型 和 V（V） : \（T\leftarrow TV^{（i）}_\alpha，\，V\leftarrow V^{（i）{_\alfa\）。
（iii）
生成 \（U^{（i）}_\alpha\）。
（iv）
更新 T型 和 U型 : \（T\leftarrow（U^{（i）}_\alpha）^*T，\，U\leftarrow U（i^}_\alpha\）。
（v）
生成 \（V^{（i）}_\beta\）和 \（U^｛（i）｝_\beta\）同时进行。
（vi）
更新 T型 , V（V） 、和 U型 : \（左箭头（U^{（i）}_\beta）^*TV^{， \（V\左箭头V^{（i）}_\beta\）， \（U\leftarrow U U^｛（i）｝_\beta\）。
使用FLAME方法/符号编写的完整算法如图所示 2 。给定一个 \（m\次n\）矩阵 A类 ，该算法计算其UTV分解 \（A=UTV^{*}\）。 两个输入参数 内置_U 和 建筑_V 是布尔变量，指示正交矩阵 U型 和 V（V） 必须构建。 其他输入参数 q个 和 b条 分别是幂迭代过程的步骤数和块大小。 在该算法中 非ivoted_QR 函数计算输入参数的非透视QR因式分解，并返回以下三个结果：上三角因子 R（右） 、带有Householder向量的矩阵和上三角因子 S公司 紧凑型的 年 代表。 这个 SVD公司 函数计算输入参数的SVD分解，并返回以下三个结果：第一个输出和两个正交矩阵对角线中的奇异值 U型 和 V（V） .
图2。 使用FLAME方法/符号编写的randUTV算法。 在该算法中，unpivoted_QR函数返回三个结果：上三角因子R、带有Householder向量的矩阵和紧致WY表示的上三角因子T。 SVD函数还返回三个结果：对角矩阵和正交矩阵U和V。
接下来，四个变换的计算 \（V^{（i）}_{\alpha}\）， \（U^{（i）}_{\alpha}\）， \（V^{（i）}{β}），以及 \对前面提到的（U^{（i）}{\beta}）进行了详细描述。 在每种情况下，我们都指出了每个变换与上述算法中计算它的部分之间的对应关系。
3.2.1 建筑物 \（V^{（i）}{\alpha}\）。 构造该变换并应用于最大化最终因式分解的秩揭示特性。 具体来说，在步骤中考虑以下分区 我 两个矩阵的 T型 和 \（V ^｛（i）｝_\alpha\）： \（\开始{等式*}T\右箭头\左（\开始}数组}{c|c}T_{TL}&T_{TR}\\hline T_{BL}&T_{BR}\结束{数组}\右），\；\； V^{（i）}_\alpha\rightarrow\left（\begin{array}{cIc}i&0\\hline 0&（V^{（i）{_\alfa）_{BR}\end{arrays}\right），\end{equation*}\） 其中每个分区的左上（TL）块是 \（i+1）b\乘以（i+1 T型 表示已计算的部分。 然后， \（V^{（i）}_\alpha\）是这样构造的： b条 列，共列 \（（V^{（i）}_\alpha）{BR}\）构成前导的正交近似基础 b条 的右奇异向量 \（T_{BR}\）。 最近开发了一种用于这种构造的有效方法（例如，参见[ 20 , 25 , 26 , 27 , 32 ])使用随机矩阵理论中的思想。 \（V^{（i）}_\alpha\）的构造如下：
(1)
绘制一个薄的高斯随机矩阵 \（G^{（i）}\在\mathbb{R}^{。
(2)
计算 \某些小整数的（Y^{（i）}{：=}\左（（T_{BR}）^*T_{BR{\右）^q（T_{BR}） q个 .
(3)
对 \（Y^{（i）}\）以获得正交 \（Q^{（i）}）和上三角 \（R^{（i）}\）这样 \（Y^{（i）}=Q^{。
(4)
设置 \（（V^{（i）}_\alpha）{BR}{：=}Q^{。
参数 q个 通常称为“幂迭代”参数，它决定了 \（（V^{（i）}_\alpha）{BR}\）。 因此，提高 q个 改进了结果因式分解的秩揭示特性，但也增加了计算成本。 自提出以来 q个 过高也会导致数值溢出，实际上它被选为较小值( \（q=0,1,2）为典型值）。 有关更多详细信息，请参阅[ 20 ].
变换的计算和应用 \（V^{（i）}_{\alpha}\）在 随机UTV 图中给出的算法 2 。此步骤由五个句子或行组成，标记为1到5。 第1句和第2句执行“权力迭代”过程。 句子3计算正交矩阵 \（V ^｛（i）｝_｛\alpha｝\）。 第4句和第5句将此转换应用于输出矩阵 T型 和 V（V） 分别为。 出于转换应用效率的原因， \（V^｛（i）｝_｛\alpha｝\）不是显式计算的。 相反 非ivoted_QR 回报系数 \（W_V\）和 \（S_V\），以便 \（V^{（i）}{\alpha}=i-W_V S_V W_V^*\），因为这两个因素允许应用 \（V^{（i）}{\alpha}）非常有效。
3.2.2 建筑物 \（U^{（i）}_{\alpha}\）。 构造并应用该变换以满足RRUTV的秩揭示和上三角要求。 在步骤中考虑以下分区 我 两个矩阵的 T型 和 \（U^{（i）}_\alpha\）： \（\开始{等式*}T\右箭头\左（\开始}数组}{c|c}T_{TL}&T_{TR}\\hline T_{BL}&T_{BR}\结束{数组}\右），\；\； U^{（i）}_\alpha\rightarrow\left（\begin{array}{c|c}i&0\\hline 0&（U^{（i）{_\alfa）_{BR}\end{arrays}\right），\；\； T_{BR}\rightarrow\left（\begin{array}{c|c}T_{1}&T_{2}\end{arrays}\right），\end{equation*}\） 其中每个分区的左上方块（带有后缀TL的块）是 \（i b\次i b\）。 可以看出，前两个表达式与前一步的表达式类似。 最后一个表达式是对第一个表达式的细化，以便 \（T_{1}\）具有 b条 柱。
获取 \（（U^{（i）}_\alpha）{BR}\）这样 \（（（（U^{（i）}_\alpha）{BR}）^*T_{1}\）是上三角，我们可以计算 \（T_{1}\）以获得 \（W^{（i）}，S^{ \（T_{1}=W^{（i）}S^{。 接下来，观察一下 \（U^{（i）}_\alpha\）发生时，前导的范围 b条 列，共列 \（T_{BR}\）与前导的大致相同 b条 的左奇异向量 \（T_{BR}\）。 因此 \非透视QR因式分解的（W^{（i）}）也构成了前导的正交近似基础 b条 的左奇异向量 \（T_{BR}\）。 因此， \从等级揭示的角度来看，（W^{（i）}）是矩阵的近似最优选择。 因此，我们让 \（（U^{（i）}_\alpha）{BR}{：=}W^{。
此计算在 随机UTV 图中给出的算法 2 。这一步包括三个句子，标记为6到8。 第6句计算的是 \（T_{1}\）。 第7句和第8句将这种转换应用于输出矩阵 T型 和 U型 分别为。 如前所述，出于转换应用效率的原因 \（U^{（i）}_{\alpha}\），它不是显式计算的。 这个 非象牙色_QR 回报系数 \（W_U\）和 \（S_U\），以便 \（U^{（i）}_{\alpha}=i-W_U S_U W_U^*\）。
3.2.3 建筑物 \（V^{（i）}{β}）和 \（U^{（i）}_{\beta}\）。 这两种转换在 T型 以较低的计算成本，使其更接近对角线，从而减少 \（|T（k，k）-\σ_k（A）|\） \（k=1，\ldots，（i+1）b\）。 它们是通过计算左上角块的SVD来同时计算的 \维度的（T_{BR}\） \（b\乘以b\）（称为 \（T_{11}\））以获得 \（U^{（i）}_{S}，V^{ \（T_{11}=U^{（i）}_{S}D^{。 然后，我们设置 \（开始{等式*}V^{（i）}_\beta{：=}\left（开始{array}{c|c|c}i&0&0\\hline 0&V^{（i）{{S}&0\\ hline 0＆0&i\结束{arrays}\right），\，U^{0\\hline 0&0&i\end{数组}\right）。 \结束{方程式*}\） 在更新步骤之后， \（右箭头（U^{（i）}_\beta）^*TV^{ \（T_{11}\）是对角线。
该计算在 随机UTV 图中给出的算法 2 。这一步包括五个句子，标记为9到13。 第9句计算的SVD \（T_{11}\）。 第10句和第11句将这些转换应用于输出矩阵 T型 句子12和13将这些变换应用于输出矩阵 U型 和 V（V） 分别为。
3.2.4 计算成本。 当未生成正交矩阵且 q个 应用幂迭代的步骤 随机UTV 因子分解 \（m乘n）矩阵，使用图中给出的算法 2 如下所示（请参见[ 24 ])以下为： \（开始｛方程*｝（5+2q）m n^2-（3+2q）\frac｛n^3｝｛3｝。 \结束{方程式*}\）
由于 \（m次n）矩阵为 \（2 mn^2-2 n^3/3，\） 随机UTV 平方矩阵算法 \（q=0）， \（q=1），以及 \（q=2）分别是QR分解的计算成本的3倍、4倍和5倍。
3.2.5 具有精度比较的数值示例。 让我们展示一个简短的数字示例 随机UTV 算法有效。 要处理的矩阵是 \（6乘6）矩阵构建为第一个的随机置换 锰 正数。 对于这个示例，我们使用了块大小 \（b=2）和 \（q=2）。 为了减少显示的数据量，示例中的矩阵只显示了两个十进制数字。 考虑初始化为的输入矩阵 \（开始{方程式*}A=\左（开始{array}{rrrrrr}13&33&5&15&30&32\\2&26&7&24&23&6\\18&28&9&36&29\\22&16&25&35&21&14\\8&10&3&31&4&20\\1&17&27&11&34&12\\end{array{右）结束{方程式}）
应用第一次迭代的步骤1（右变换）后，矩阵 T型 成为 \（\begin{方程式*}T=\left（\being{array}{rr|rrrr} -55.68和-15.37&-4.32&-1.24&-6.99&5.17\\-40.00&-0.84&0.66&13.01&1.26&9.89\\ hline-59.40&-9.50&-5.50&-0.21&1.97\\-52.04&21.87&1.34&-4.74&-0.18&-3.99 \\-31.61&14.34&-9.94&9.29&-6.95&10.60 \\-43.36&-3.34&18.42&-3.67&13.62&-3.27 \\ end{数组}右）结束方程式*}\）
观察矩阵的大部分“质量”是如何移动到第一个块列（前两列），尤其是第一列。 在应用第一次迭代的步骤2（左三角化）之后，矩阵 T型 成为 \（开始方程式*}T=左（开始数组}{rr|rrrr}117.54&0.06&-0.12&0.06&-0.09&0.05\\0.00&-31.97&1.77&-3.30&1.27&0.45\\hline 0.00&0.00&4.07&-3.66&2.35&-1.19\\0.00&0.00&2.71&-17.03&0.68&3.27\\0.00&-0.10&1.32&-6.47&15.36\\0.00&0.00&19.48&-3.59&15.33&-4.38\\结束数组} \右）\结束{方程式*}\）
再次注意第一个块列中的所有“质量”是如何移动到对角线的上三角形部分的 \（b\乘以b\）块和右上部分“质量”的重要部分已移动到矩阵的右下部分。应用第一次迭代的步骤3（对角块的奇异值分解）后，矩阵 T型 成为 \（开始{方程式*}T=左（开始{数组}{rr|rrrr}117.54&0.00&-0.12&0.06&-0.09&0.05\\0.00&31.97&1.77&-3.30&1.27&0.45\\hline 0.00&0.00&-4.07&-3.16&2.35&-1.19\\0.00&0.00&2.71&-17.03&0.68&3.27\\0.00&.00&9.10&1.32&-6.47&15.36\\0.00&19.48&-3.59&15.33&-4.38\\结束{数组} \右）\结束{方程式*}\）
对角线块已对角线化。 以上三个步骤构成了第一个迭代。 为了计算 随机UTV 原始矩阵的因子分解 A类 .
表 1 比较了一个小例子（ \（6乘以6）上述矩阵）。 表中的每一列显示了计算因子分解后获得的因子的对角线： \SVD的（\Sigma\）（奇异值） R（右） 对于QR和CPQR，以及对角线 T型 对于 随机UTV ( \（b=2）在这种情况下）。 QR因子分解不是一个等级揭示工具； 它只是作为参考。 CPQR显示了一条对角线，其值与SVD的绝对值类似（但已知其可能会失败的特殊矩阵）。 另一方面 随机UTV 更接近奇异值。
跳过4高效共享内存randUTV实现部分 4 高效共享内存 随机UTV 实施 由于共享内存多核/多处理器体系结构在现代计算中无处不在，因此它是高效设计的 随机UTV 第节中介绍的算法 3.2 .
现代体系结构（从unicore处理器到SMP到GPU）的有效实现必须强烈地基于矩阵矩阵操作，因为矩阵矩阵操作中的浮点运算与内存访问的比率为 \（\mathcal{O}（n）\）( \（\mathcal{O}（n^3）\）失败到 \（mathcal{O}（n^2）内存访问），远高于向量-向量和矩阵-向量操作。 这种增加的比率在现代计算机上提供了更高的性能，因为当前的处理器和GPU每次存储器访问可以执行多次触发器。
通常有两种方法可以重新制定算法以使用矩阵-矩阵运算： 阻塞算法 和 按块计算的算法 。分块算法同时执行标量算法的多次迭代，从而在其主循环的每次迭代中计算所需结果的多个列（或行）。 该设计决策允许根据矩阵-矩阵运算（3级BLAS）进行大多数计算。 请参见图 三 对于块分解的图形表示（文本对应于QR分解，但LU分解类似）。 另一方面，逐块算法将标量算法应用于方形块，而不是标量。 通过处理方块，可以大量使用矩阵-矩阵运算（3级BLAS）。 请参见图 4 对于通过用于计算因子分解的块的算法的图形表示（文本对应于QR，但LU将是类似的）。
图3。 图为计算QR分解的阻塞算法执行的第一个任务。 符号\（\bullet\）表示当前任务的未修改元素，\（\star\）表示当前task的修改元素，以及\（\circ\）表示无效元素（之所以显示这些元素，是因为它们存储了有关Householder转换的信息，这些转换稍后将用于应用它们）。 连续的线围绕着当前任务中涉及的块。
图4。 由计算QR因式分解的算法块执行的第一个任务的图示。 符号\（\bullet\）表示当前任务的未修改元素，\（\star\）表示当前工作的修改元素，以及\（\circ\）表示目前任务的无效元素（之所以显示这些符号，是因为它们存储了有关稍后将用于应用它们的Householder转换的信息）。 连续的线围绕着当前任务中涉及的块。
的主要优势 随机UTV 前面描述的算法在并行计算环境中的效率主要是因为它可以 此 路 不通 很容易。 也就是说，它驱动输入矩阵的多列 A类 在其主循环的每次迭代中转换为上三角形式。 这种设计允许根据三级BLAS（矩阵-矩阵运算）进行大多数运算，更具体地说，在 xgemm公司 操作（矩阵-矩阵乘积）。 由于三级BLAS的供应商提供和开源多线程实现效率很高，接近峰值速度， 随机UTV 应产生高性能。 Martinsson等人[ 24 ]提供了对 随机UTV 该算法比竞争的等级揭示因子分解（如SVD和CPQR）更快， 尽管 随机UTV 比他们两个都有更高的失败次数 。与许多线性代数代码中的情况一样，这阻止了 随机UTV 将所有并行性保留在BLAS库中。
在节中 4.1 我们讨论了一种称为algorithms-by-blocks的方案，用于在多核或多核架构上设计更高效的算法。 章节 4.2 探索分块算法在 随机UTV .章节 4.3 和 4.4 让读者熟悉用于实现分块算法的软件和用于分别调度各种矩阵操作的运行时系统。
4.1 分块算法：概述 将所有并行性引入BLAS库的多线程实现中可以使编程变得更加容易，但它的性能受到限制，不仅仅局限于几个内核[ 31 ]，这可能会成为一个严重的限制。 大多数用于计算因子分解的高性能分块算法（如Cholesky、LU和QR）在每次迭代中都涉及至少一个任务，这些任务处理的数据很少（因此是非并行的），其结果在当前迭代的以下操作中是必需的。 这些串行任务通常涉及处理至少具有一个小维度的块 b条 ，其中 b条 通常选择为32或64，通常比矩阵维数小得多。 例如，在块Cholesky因式分解中，这个性能受限的任务是计算对角块的Cholesky因式分解。 在块QR和LU因式分解中，这个性能限制部分是当前块列的一部分因式分解的计算（参见图中的步骤1 三 ). 因此，由于这些串行任务形成了一个同步点，因此在这些计算期间，系统中除一个内核外，其余所有内核都处于空闲状态。 对于总共四个或五个内核，时间损失最小。 然而，随着可用内核数量的增加，效率方面的浪费也越来越大。 这个 随机UTV 分解也受到这个问题的影响，因为每次迭代都包含三个这种类型的任务：矩阵的QR分解 Y（Y） ，的当前块列的QR分解 T型 ，和对角线块的SVD T型 .
这导致我们寻求一种除阻塞之外的技术来获得更高的性能，尽管我们不会放弃在3级BLAS中铸造大多数操作的策略。 关键在于改变将多个低级别BLAS触发器聚合为单个三级BLAS操作的方法。 块算法通过提高算法主循环的粒度来实现这一点。 在 随机UTV 例如，输入的多列通常在主循环的一次迭代中处理。 一次处理一列需要在每次迭代中进行矩阵-向量运算（第2级BLAS），但一次处理多列会将其聚合为更高效的矩阵-矩阵运算（第3级PLAS）。
另一种方法称为逐块算法，它是提高 数据 使用此方法，可以将算法设计为一次只处理输入的标量元素。 然后，通过将每个标量设想为子矩阵或大小块，将算法转换为3级BLAS \（b\乘以b\）。 每一个标量运算都会变成一个矩阵-矩阵运算，算法中的运算在最精细的层次上通常只对几个（在一到四之间，但通常是两个或三个）进行运算 \（b\乘以b\）块。 对几个块的每个操作称为任务。 这种安排在排序操作时比阻塞更具灵活性，消除了阻塞方法中同步点造成的瓶颈。 对于共享内存架构上的线性代数问题，逐块算法方法相对于基于块算法的方法所获得的性能优势通常是显著的[ 7 , 31 ].
4.2 分块算法 随机UTV 按块计算的算法 随机UTV ，我们将致电 品牌UTV_AB ，执行与原始操作基本相同的操作。 因此，其结构与前面描述的相同（见图 2 )和未显示。 关键区别在于，这种定义在方形块上运行的较小任务（与阻塞算法相比）的新理念可以在完成顺序上提供更大的灵活性。
如前所述，按块的算法必须提高数据的粒度。 因此，块大小 b条 必须选择（实际上，块大小在 \（b=256）工作良好）。 为了简单起见，假设 b条 将两者分开 米 和 n个 均匀地。 回想一下 随机UTV , T型 使用初始化 \（T{：=}A \）。 考虑矩阵的以下分区 T型 : \（开始{等式*}T\rightarrow\left（开始{array}{c|c|c| c}B_{11}和B_{12}和\cdots&B_{1N}\\hline B_{21}和B_{22}和\ cdots＆B_{2N}\\ hline\vdots&\vdots和\ddots&\ vdots\\hline B_方程式*}\） 其中每个子矩阵或块 \（B_{ij}\）是 \（b\乘以b\）， \（N=N/b\），以及 \（M=M/b\）。 注意矩阵的其余部分( G公司 , Y（Y） , U型 、和 V（V） )也必须相应地进行分区。 在这个分区中，我们没有使用字母 T型 用于上述区块，以避免与区块混淆 \的（T_{ij}\） 随机UTV 算法。 在该算法中， \（T_{11}\）是 \（b\乘以b\）正在处理的斜块， \（T_{22}\）是要处理的矩阵的右下部分， \（T_｛00｝\）是已经处理的矩阵的左上部分，依此类推。因此，它们的维度（除了 \（T_{11}\）取决于算法的当前迭代。 相反，所有 \（B_｛ij｝\）块具有尺寸 \（b\乘以b\）。
一旦定义了块，我们必须根据这些块重新定义算法的所有操作。 块或子矩阵 \（B_{ij}）（以及其他矩阵的那些）在算法中被视为数据的基本单位，因此每个操作都仅用这些术语表示。 因此，所有涉及 随机UTV 算法（见图 2 )必须分解成在这些方块上操作的小任务。
例如 随机UTV 算法是矩阵的生成 G公司 带有随机正常条目。 由于此操作只能用方块表示，因此对于第一次迭代，此操作将包括以下任务： 生成随机（_R）( \（G_1\）） , 生成随机（_R）( \（G_2） , ... 生成随机（_R）( \（G_N\）） ，其中例程 生成随机（_R） 填充其参数（一个正方形的维度块 \（b\乘以b\））具有随机正态项。
算法中计算成本最高的两个部分如下。 第一个是矩阵的计算 Y（Y） （功率迭代循环），在步骤1中执行。 第二个是列块的因式分解和相应矩阵的更新，这在步骤1（因式分解 Y（Y） )和步骤2中（因子分解 \（\左（{T_{11}\顶在T_{21}}\右））。 接下来我们对其进行评论。
4.2.1 矩阵的计算 Y（Y） . 矩阵的计算 Y（Y） 在幂迭代循环中如下： \（\begin{等式*}Y{：=}（（T_{BR}）^*T_{BR{）^q（T_{BR}）#*G=\左（\left（\being{array}{c|c}T_{11}&T_{12}\\hline T_{21}&T_{22}\ end{array}\\right）^*\左22}\end{数组}\right）\right ^*G.\end（方程式*）
虽然它的计算成本很高，但它只包含一系列高效的矩阵乘积。
此操作将分为几个任务，以便每个任务计算两个方块的乘积 T型 和积累成一块 Y（Y） 在简化的情况下，其中 \（q=0），我们有 \两个区块的（M\乘以N\）乘积。 例如，在第一次迭代中，任务列表如下（回忆一下该矩阵 T型 被分成方块 \（B_{ij}\）： \（开始{等式*}开始{数组}{lcl}Y_1&=&Y_1+B_{11}^*G_1，\\Y_1&=&Y_1+B_{21}^*G2，\\Y_1&=&Y_1+B_{31}^*G _3，\\&\vdots&\end{array}\end{equation*}\）
在这种情况下，可以并行执行的最大任务数取决于 Y（Y） 因为在同一个区块行上有两次聚集 Y（Y） 不能同时执行。 在算法的第一次迭代中，块行数为 M（M） 当产品涉及 \（T_{BR}\）和 N个 当产品涉及 \（T_{BR}^*\）。 随着算法的发展，每次迭代的并行度都会减少一个单位，这可能是此操作中并行度的限制因素，特别是在小矩阵和最后一次迭代中。
4.2.2 增量QR分解。 计算成本第二高的部分 随机UTV 算法是块列的因式分解和相应矩阵的后续更新。 如图所示，第1步 随机UTV 需要分解 Y（Y） ，而步骤2需要分解 \（\左（{T_{11}\顶在T_{21}}\右）\）。
这些块列的传统QR分解并没有将此操作分解为在方形块上操作的小任务。 由于计算 随机UTV 要求在工程内部进行QR分解 \（b\乘以b\）块，我们采用了另一种算法，通常称为增量QR分解，该算法基于在向输入矩阵添加更多行时更新QR分解的思想。例如，请参见[ 19 , 30 , 31 ]有关QR分解方法的详细信息。 我们将此算法称为 QR_AB公司 。我们只考虑 QR_AB公司 这使得第一列块成为上三角形，因为这就是所需的全部 随机UTV_AB 通过这种方式，可以将此操作概念化为在具有大量任务的迭代中发生，每个任务都在几个方块上运行。
图 4 显示了一个 \块大小的（9乘9）矩阵 \（b=3）。 在该图中，连续线显示了 \当前任务中涉及的一个或多个块（3乘以3）， \（\bullet\）表示当前任务未修改的元素， \（\star\）表示当前任务修改的元素，并且 \（\circ\）表示当前任务取消的元素。 显示无效的元素是因为，像往常一样，它们存储有关Householder转换的信息，这些转换稍后将用于应用这些转换。 第一个任务名为 计算密度QR ，消灭领先的致密块体 \（A_{00}\）通过使用QR分解。 第二个任务消灭方块 \（A_{10}\）。 此任务称为 计算_td_QR ，其中 td（时域） 代表三角形，因为两个参数的形状： \（A_{00}\）是三角形的，而 \（A{10}\）是致密的。 类似地，第三个任务消灭块 \（A_{20}\）。 在这三项任务成功执行后，主对角线以下的所有元素都被消除，矩阵的其余部分必须相应更新。
第四项任务，称为 应用_left_Qt_of_dense_QR ，应用在第一个任务中获得的Householder转换（并存储在 \（A_{00}\））到块 \（A_{01}\）。 第五个任务对执行相同的操作 \（A_{02}\）。 第六项任务， 应用_左_Qt_of_td_QR ，将第二个任务中获得的转换应用于块 \（A_｛01｝\）和 \（A_{11}\）。 第七个任务对执行相同的操作 \（A_｛02｝\）和 \（A_{12}\）。 类似地，第八和第九个任务与前两个任务在第一和第三行块上应用相同的处理。 通过利用每次迭代的因式分解中的零 QR_AB公司 与传统的屏蔽非隔离QR相比，其成本基本上没有更多的失败。 算法在中有更详细的描述[ 7 , 30 , 31 ].
为了在并行环境中执行前面的增量QR分解时获得高性能，运行时系统应该尽早同时执行尽可能多的任务。 注意，在这个尺寸的小例子中 \（9乘以9），第四和第五个任务可以在第一个任务之后执行，因为它们只需要访问（读取） \（A_{00}\）。 然而，由于 \（A{00}）被第二个和第三个任务更新，运行时系统不允许提前执行第四个和第五个任务（在执行第二和第三任务的同时）。 因此， \（A_{00}\）成为错误的瓶颈或数据依赖。 解决这个瓶颈并提高并行性的一种方法是使用一个辅助方形块来复制 \（A_{00}\）就在第一个任务执行之后。 事实上，这个拷贝是一个额外的任务（但速度要快得多）。 在这种情况下，原始的第四个和第五个任务可以在复制之后执行，同时计算第二个和第三个任务（它们正在更新 \（A_{00}\））。 通常，通过使用两个维度的辅助块 \（b\乘以b\）（一个用于因子分解 Y（Y） 另一个用于对当前块列进行因子分解 A类 )块列的消除和第一个块行的更新可以同时执行。
可以并行执行的最大任务数取决于从右侧应用变换时要更新的块行数和从左侧应用变换时更新的列块数。 例如，在图 4 ，可以并行执行的最大任务数是两个：执行任务1后，任务2和任务3可以并行执行，依此类推。在算法的第一次迭代中，块行数为 M（M） 从右侧更新或 N个 从左侧更新时。 随着算法的发展，每次迭代的并行度都会减少一个单位，这可能是一个限制因素，特别是在小矩阵、最后一次迭代以及未构建正交矩阵的情况下。 在后一种情况下，由于矩阵块，可以并行执行的最大任务数更大 T型 可以与块同时更新 U型 和/或 V（V） .
4.2.3 的变体 品牌UTV_AB 算法。 接下来，我们描述了对之前算法的一些改进。 考虑到前面的评论，我们实施并评估了 随机UTV_AB 算法。
变体 v00版本 ：这是对基本 随机UTV_AB 前面描述的算法。
变体 第01版 ：两个尺寸辅助块 \在计算增量QR分解时，使用了（b\乘以b\）来消除数据依赖性和瓶颈，并增加并行性。 此改进也适用于下一个变体。
变体 第02版 ：在每次迭代中，对角线块的奇异值分解的计算都向上移动，以便能够尽快解锁尽可能多的任务，从而提高并行度。 一旦当前块列， \（\左侧（{T_{11}\顶部T_{21}}\右侧）\） \（\左侧（{T_{12}\顶部T_{22}}\右侧）\）被更新（可能还有矩阵 U型 和 V（V） )，计算的SVD \可以计算（T_{11}\）以最小化 分叉连接 影响并激活尽可能多的任务。
变体 第03版 ：此实现提高了矩阵计算的并行度 Y（Y） 在每次迭代中，通过使用与 Y（Y） （另一个尺寸与 G公司 ). 回想一下，这个幂迭代由一系列矩阵-矩阵乘积组成，其中第二个矩阵是块列。 第二个矩阵的形状明显限制了并行性，因为多个任务（块-块产品）必须累加到同一块 Y（Y） .
所采用的技术是将每个矩阵矩阵乘积重写为相同数量的块乘积，但使用辅助矩阵在不同的左侧进行累加 \（Y{：=}T G\）重写为： \（\开始{方程式*}Y{：=}T G=（T_E，T_O）\左（\！\！\开始{array} {c} G_E（希腊） \\G_O\结束{数组}\！\！ \右）=T_E G_E+T_O G_O，结束{方程式*} 哪里 \（T_E\）包含偶数块列 T型 , \（T_O\）包含的奇数块列 T型 , \（G_E\）包含的偶数块行 G公司 、和 \（G_O\）包含的奇数块行 G公司 .
此表达式计算为 \（开始{eqnarray*}Y&{：=}&T_E\，G_E\\Z&{；=}&T_O\，G_O\\Y&{:=}&Z+Y.结束{eqnarray*{）
在这个序列中，在算法的第一次迭代中，第一行允许执行最多 M（M） 任务同时执行，而第二行允许最多执行 M（M） 同时执行更多任务。 这样，可以同时执行的任务数量是原来数量的两倍，唯一的缺点是最多可达 M（M） 积累的额外任务( \（Y{：=}Z+Y\）），这是非常简单和快速的。
变体 版本04 ：此实现增加了左右两侧QR更新的并行性。
当计算一个块的密集QR分解或两个块的三角密度QR分解时（见图 4 )，可以并行执行的最大任务数取决于要使用该块分解更新的块数。 要更新的块数越多，并行度越大。
增加这种并行性的一种方法是将前面描述的增量QR分解应用于 Y（Y） ，而同时增量QR因子分解应用于 Y（Y） 因此，任务的最大数量是原始数量的两倍，唯一的缺点是在末尾，第二个块行必须被清空（带有附加任务）。 尽管第二块行是上三角形的，但为了简化编程，使用了通常的三角形密集QR因子分解。
例如，在第一次迭代开始时 Y（Y） 已计算， \（Y_0\）和 \（Y_1）同时三角化。 然后 A类 可以通过以下转换进行更新 \（Y_0\）同时作为 A类 使用的转换进行更新 \（Y_1\），从而使可用任务的数量加倍。 然后， \（Y_2）和 \（Y_3\）必须置零，同时更新相应的块，依此类推。最后，块 \（Y_1\）应根据 \（Y_0\）中包含原始算法中未包含的其他任务。
此方法是对中提出的一种避免通信的QR分解的修改[ 16 , 22 ]，适用于Householder变换，非常适合于方阵。
变体 第05版 ：此实现可以通过在主内存中使用分层存储来提高性能。 每个矩阵不是按列主顺序存储数据，而是按块大小的块列主顺序进行存储 b条 （与算法块大小相同）。
4.3 实现分块算法的FLAME抽象 实现算法块的一个重要障碍是可编程性问题。 使用调用LAPACK的传统方法[ 1 ]和BLAS[ 23 ]对于计算步骤库，跟踪索引很快变得复杂且容易出错。 FLAME（形式线性代数方法环境）项目[ 18 , 21 ]是解决这个问题的一个方法。 FLAME是一个用于设计线性代数算法的框架，它偏离了传统的基于索引的循环方法。 相反，输入矩阵作为子矩阵的集合进行交互，其循环基于输入的重新分区。 FLAME API[ 5 ]对于C语言，将这些思想编码，使API的用户能够在高抽象级别上编码线性代数算法的高性能实现。 此外，FLAME框架的方法论及其在 利比亚火焰 图书馆[ 38 ]使其自然适合与算法块一起使用。 因此 品牌UTV_AB 看起来与图中给出的算法的书面版本几乎相同 2 因为所有的改变都是在每个操作内部执行的。
4.4 按块执行算法 名为SuperMatrix的运行时系统[ 7 ]是 利比亚火焰 并被用于公开和利用中的任务级并行 品牌UTV_AB 任何程序的执行都分为两个阶段：分析阶段和执行阶段。
(1)
在分析阶段，运行时不是按顺序执行代码，而是构建一个任务列表，记录与每个操作关联的依赖项信息，并将其放入队列中。 运行库为构建的队列示例 品牌UTV_AB 对于这种情况 \（A\in\mathbb{R}^{n\timesn}\），块大小为 \（b=n/2\）如图所示 5 .
在块大小b为\（n/2\）的简化情况下，运行时在randUTV算法的分析器阶段排队的操作列表。 In列指定所需的输入数据。 In/Out列指定操作完成后将更改的所需数据。 按块执行randUTV算法包括两个阶段。 在第一个阶段（分析），运行时构建记录依赖项的任务列表。 在第二个阶段（调度/分派阶段），运行时动态调度和执行队列中的任务。 任务可以按照任何顺序完成，而不违反表中编码的数据依赖性。
(2)
在执行阶段，队列中的任务被动态调度和执行。 每个任务在其输入数据可用时立即执行，核心可以自由完成工作，但任务之间保持顺序一致。
图 6 显示了一个实际的DAG，该DAG说明了任务之间的数据依赖关系，以便完成执行。 从代码的角度来看，主要的FLAME公式（见图 2 )保持不变，用任务创建替换对BLAS/LAPACK代码的实际调用，包括每任务的输入/输出数据，并将其添加到DAG中。 从那时起，调度/调度阶段对开发人员来说是透明的。
图6。 在块大小为\（b=n/2\）的简化情况下，在调度阶段向运行时任务调度程序公开的完整有向非循环图。 每个任务使用的颜色遵循图中使用的约定 5 .
跳过5高效分布式内存randUTV实现部分 5 高效分布式内存 随机UTV 实施 分布式内存计算体系结构通常用于解决大型问题，因为它们在单个系统上扩展内存和处理能力。 在本节中，我们将讨论 随机UTV 用于分布式内存体系结构。 在节中 5.1 ，我们讨论了用于实施和评估我们的新规范的基础设施。 在节中 5.2 ，我们描述了 随机UTV 在分布式内存体系结构中。
5.1 ScaLAPACK概述 ScaLAPACK软件库[ 6 , 9 , 11 ]由于它提供了在分布式内存体系结构上实现线性代数应用程序的广泛功能，因此在所提供的实现中使用了。 此库为分布式内存环境提供了LAPACK的大部分功能。 它使用基于对象的API向开发人员隐藏了大部分通信细节，每个矩阵的对象信息都传递给库例程。 这种设计选择增强了库的可编程性，使代码的编写与标准LAPACK实现类似。 然而，由于它是在Fortran-77中实现的，它的面向对象性并不完美，编程工作量也较大。
除了实现新的线性代数代码的广泛功能外，ScaLAPACK还提供了高效的SVD和2级BLAS CPQR。 PLiC库中的3级BLAS CPQR[ 4 ]采用了同样基于ScaLAPACK的。 这些因子分解的可用性是评估和比较我们新的分布式内存的关键 随机UTV 代码。 ScaLAPACK的另一个优点是它通常包含在MKL中，这提高了它的可移植性并简化了它的下载和安装。
ScaLAPACK被设计为可移植到各种计算分布式内存体系结构，并且只依赖于三个外部库。 第一个是顺序LAPACK[ 1 ]. 第二个是序列BLAS（基本线性代数子程序）[ 12 , 13 , 23 ]，为涉及向量和矩阵的最常见操作提供规范。 第三个是BLACS（基本线性代数通信子程序），顾名思义，它是通用矩阵和向量通信任务的规范[ 2 ]. PBLAS库是ScaLAPACK中的一个关键模块。 它包含为在分布式内存环境中使用而重写的大多数BLAS例程。 此库是使用顺序BLAS库和BLACS库的组合编写的。
所有ScaLAPACK例程都采用所谓的“块循环分布”方案[ 10 ]. 块循环分布方案包括四个参数。 前两个， \（m_b\）和 \（b，\）定义块大小，即用作进程之间通信的基本单元的子矩阵的尺寸。 尽管有这种灵活性，但几乎所有的线性代数主例程通常都使用 \（m_b=n_b\），以便简化。 最后两个参数，通常称为 对 和 问 ，确定逻辑流程网格的形状。
5.2 实施 随机UTV 在分布式内存体系结构中 在本节中，我们将描述 随机UTV 分布式内存体系结构上的算法。
自算法 2 BLAS-3操作非常丰富，而且这种操作在分布式内存体系结构中也非常有效，我们在分布式内存实现中使用了相同的算法。
的分布式内存实现 随机UTV 使用标准分块算法[ 24 ]而不是逐块算法方法（如第节所述 4.2 )评估公平比较，因为唯一可用的SVD和CPQR分解也采用了阻塞算法方法。 使用ScaLAPACK库实现 随机UTV 算法允许进行更公平的比较，因为所有评估例程的基本构造块（矩阵-矩阵乘积、Householder变换等）基本相同。
与共享内存体系结构上的逐块算法不同，逐块算法在分布式内存体系结构中存在一些问题。 DAG允许在其操作数准备好后立即执行任何任务，但要提高集体通信的效率，需要更协调的方法。 尽管在一些高性能的分布式内存库中，通过使用特殊语言可以避免这种情况，但它们并没有提供SVD和CPQR分解，与我们的 随机UTV .
与其他一些因子分解（QR、SVD等）一样，在应用时 随机UTV 到一个矩阵 \（m\gg n\），最好先执行非透视QR因式分解，然后执行 随机UTV 对得到的方形三角形因子进行因式分解。
中计算成本最高的两个部分 随机UTV 算法如下：矩阵的计算 Y（Y） （在步骤1中），以及矩阵更新 T型 , U型 、和 V（V） 使用QR因子分解的Householder变换（在步骤1和2中）。
5.2.1 矩阵的计算 Y（Y） . 即使是为了 \（q=0\），矩阵的计算 Y（Y） 是该算法中最昂贵的部分之一。 由于此操作基本上是分布式数据上的一系列矩阵乘积，因此此操作通常非常有效，其速度由所使用的ScaLAPACK库决定。 构建矩阵 Y（Y） ，一系列矩阵-矩阵乘积（例程 pdgemm公司 必须使用ScaLAPACK）。
5.2.2 QR分解和更新。 中另一个最昂贵的部分 随机UTV 算法是在对一些块列进行QR分解后更新相应的矩阵。 矩阵 Y（Y） 和块 \（\left（{T_{11}\top T_{21}}\right）\）必须分别在步骤1和步骤2中分解。
自矩阵 Y（Y） 是块列，用于分解它并更新的相应部分 T型 和 V（V） ，例程 pdgeqr2 （将因子分解 Y（Y） ), pdlarft公司 （计算系数 \（S_V\）），以及 pdlarfb公司 （更新矩阵 T型 和 V（V） )已被聘用。 显然，最昂贵的部分是使用 pdlarfb公司 矩阵例程 T型 和 V（V） 从因子分解后的右边 Y（Y） 。由于此更新需要以下产品 \（A（I-W_V S_V W_V ^*）=A-A W_V S-V W_V^*），有效通用( pdgemm公司 )和三角形( pdtrmm公司 )矩阵-矩阵乘积通常用于 pdlarfb公司 例程，这保证了高性能。
的因子分解 \（\left（{T_{11}\top T_{21}}\right））和相应的更新是类似的。 在这种情况下， T型 从左侧更新 U型 从右侧更新。 和以前一样，这些更新只需要高效的通用( pdgemm公司 )和三角形( pdtrmm公司 )矩阵-矩阵乘积。
另一方面，在分布式内存机器上，我们实现并评估了另一种使用增量QR分解计算QR分解和更新矩阵的方法。 这种增量QR分解类似于共享内存机器任务调度中使用的方法（但没有任务调度，因为ScaLAPACK不允许这样做）。 在我们的增量QR因子分解和更新方法中，每个块迭代有两个阶段。 第一阶段是计算对角块的稠密QR，然后对其余相应矩阵进行更新。 第二阶段是通过将“质量”移动到对角线块并进行相应的更新，从而消除对角线下的所有方形块。 第二个阶段是所谓的三角形QR分解，因为顶部块已经是三角形（对角线块），而底部块是稠密的（要消除的块）。
5.2.3 其他操作。 Two computationally cheaper operations in each iteration of the随机UTV 算法是对角块的奇异值分解及其相应的更新（在步骤3中）和矩阵的生成 G公司 （在步骤1中）。 在每次迭代中对角线块的奇异值分解的计算， \（T_{11}\）非常快，因为不需要通信。 要计算它，例程 dgesvd公司 来自LAPACK的。 然后，矩阵的更新 T型 , U型 、和 V（V） 需要使用输出矩阵 \（U_S\）和 \此SVD的（V_S\）。 这些更新需要替换产品（结果也是一个操作数），例如 \（A:=A B\）。 因此，除了 pdgemm公司 例行程序。 然而，这部分的总成本要小得多，因为 T型 , U型 、和 V（V） （某些块行和块列）必须更新。
前面讨论的另一个操作是矩阵的生成 G公司 ，以并行方式执行，避免了任何性能瓶颈。 与均匀随机数生成器不同的是，LAPACK和ScaLAPACK不包括正规随机数生成器，而正规随机数发生器在每次迭代中都是形成领先的正交近似基础的关键 b条 的右奇异向量 \（T_{22}\）（在步骤1中）。 因此，采用Box-Mueller变换方法将均匀变量转换为正态变量。
总之，很明显，一般的矩阵矩阵乘法( pdgemm公司 )在实施过程中形成主导成本 随机UTV 。由于此操作属于3级BLAS，并且可以在此类体系结构上非常有效地实施 随机UTV 可以预期是非常有效的。
跳过6性能分析部分 6 性能分析 在本节中，我们将研究用于计算 随机UTV 因子分解，并将其与计算SVD和CPQR因子分解的高度优化方法的速度进行比较。 在所有实验中，都处理了双精度实矩阵。
为了公平地比较评估的不同实现，由于SVD、CPQR和 随机UTV 分解需要非常不同的失败次数（占主导地位 \渐近触发器计数中的（n^3）项是非常不同的）。 由于实验中评估的矩阵维数范围很大，因此绝对计算时间也没有显示出来，因为它们差异很大。 因此，缩放计算时间（绝对计算时间除以 \通常使用（n^3）。 因此，缩放的计算时间越短，性能越好。 由于所有被评估的实现都具有渐近复杂性 \（O（n^{3}）\）应用于 \（n次n次）矩阵，这些图更好地显示了计算速度（如时间到解决方案）。 这些缩放时间乘以一个常数（通常 \（10^{10}\）以使垂直轴中的图形更具可读性。
另一方面，一些曲线显示速度加快。 加速比通常计算为串行（单核）实现获得的时间与并行实现（多核）获得的时间的商。 因此，这个概念传达了并行实现的速度是串行实现的速度的多少倍。 因此，加速比越高，并行实现的性能越好。 在检查实现的可伸缩性时，此度量通常非常有用。 请注意，在这种类型的图中，每个实现都在一个核心上与自身进行比较。
其他一些图显示了缩放速度。 在这些图中，选择其中一种方法作为速度为1的参考，并相应缩放其他方法。 因此，这个概念传达了与参考文献1中所选方法相比，某个方法的速度快了多少倍。 因此，速度越高，性能越好。
算法的准确性和揭示目标矩阵秩的能力这一重要问题在[ 27 ]. 总之，秩揭示性质远远超过了标准QR分解的性质，在某些情况下，它们可以接近理论上最优SVD的性质。 我们建议读者参考[ 27 ]进行彻底的讨论。
6.1 准确性 我们计算了所有新的共享和分布式内存实现的以下残差，以计算 随机UTV 因式分解： \（\垂直A-U T V ^*\垂直_F\）， \（\垂直I-U^*U\垂直_F\）， \（垂直I-V^*V\垂直_F\），以及 \（\Vert\textrm{svd}（A）-\textrm{svd\（T）\Vert_F\），其中 \（\textrm｛svd｝（X）\）是一个奇异值为 X 命令。 在对许多矩阵维度和块大小进行的所有实验中 随机UTV 与我们在其他因子分解中计算的类似残差类似，如SVD、CPQR和QR。
6.2 共享内存体系结构的计算速度 6.2.1 实验装置。 我们在共享内存体系结构的实验中使用了以下计算机：
马尔孔 ：它采用两个Intel Xeon CPU E5-2695 v3（2.30 GHz），28核，共128 GB RAM。 在这台计算机中，所谓的 涡轮增压 在我们的实验中，两个CPU的模式被关闭。
它的操作系统是GNU/Linux（内核版本2.6.32-504.el6.x86_64）。 使用GCC编译器（版本6.3.0 20170516）。 英特尔数学内核库（MKL）2018.0.1版针对英特尔（R）64体系结构的产品构建20171007被采用，因为此库中的LAPACK例程通常比Netlib存储库中的LAPACK例行程序提供更高的性能。
米米尔 ：它采用两个Intel Xeon金牌CPU 6254（3.10 GHz），36核，总内存791 GB。 这个 最大涡轮频率 CPU的频率为4.00 GHz。
它的操作系统是GNU/Linux（内核版本5.0.0-32-generic）。 使用了Intel C编译器（版本19.0.5.281 20190815）。 采用针对英特尔（R）64体系结构的英特尔数学内核库（MKL）2019.0.5版产品构建20190808，原因与前面给出的相同。
马卡鲁 ：它采用两个Intel Xeon金牌CPU 6138（2.00 GHz），共有40个内核和92 GB RAM。 这个 最大涡轮频率 CPU的频率为3.70 GHz。
它的操作系统是GNU/Linux（内核版本4.19.0-13-amd64）。 使用了Intel C编译器（版本18.0.1 20171018）。 采用适用于英特尔（R）64体系结构的英特尔数学内核库（MKL）版本2018.0.1产品内部版本20171007的原因与前面给出的相同。
除非另有明确说明，否则所有实验均使用计算机中的所有核心，并从一次运行中提取。 当使用MKL的LAPACK例程时，采用了由该软件确定的最佳块大小。 在一些实验中，除了MKL的LAPACK例程外，我们还评估了Netlib的LAPACK 3.4.0例程。 在这种情况下 Netlib（网络图书馆） 使用术语。 在使用Netlib的LAPACK例程时，使用了几种块大小，并报告了最佳结果。 为了进行公平比较，Netlib中的这些例程链接到MKL中的BLAS库。
实验中使用的所有矩阵都是随机生成的。 类似的结果 随机UTV 是在其他类型的矩阵上获得的，因为 随机UTV 算法的性能不依赖于被分解的矩阵。
实验中考虑了以下实现：
MKL SVD公司 ：例行程序 dgesvd公司 使用MKL LAPACK实现计算奇异值分解。
Netlib SVD ：与前一个相同，但使用了从参考Netlib LAPACK计算SVD的代码。
MKL SDD ：例行程序 国防部国防部长办公室 使用MKL计算奇异值分解。 与前一个SVD不同，此SVD使用分而治之的方法。 此代码通常更快，但在构建正交矩阵时需要更大的辅助工作空间。
Netlib SDD ：与前一个相同，但使用了Netlibs LAPACK中使用分治方法计算SVD的代码。
MKL CPQR公司 ：例行程序 边缘qp3 使用MKL的LAPACK计算列抽样QR因子分解。
品牌UTV_PBLAS ( 随机UTV 使用并行BLAS）：这是计算 随机UTV 依赖并行BLAS来利用系统中所有核心的因子分解。 为了进行公平的比较，MKL的并行BLAS实现与这些代码一起使用。 我们的实现是用编码的 利比亚火焰 [ 38 , 39 ]（版本11104）。
品牌UTV_AB ( 随机UTV 使用algorithm-by-block）：这些是我们计算 随机UTV 通过调度所有要并行计算的任务，然后使用串行MKLBLAS执行这些任务来进行因子分解。 我们的实现也通过 利比亚火焰 .
MKL-QR公司 ：例行程序 边缘qrf 使用MKL LAPACK实现计算QR因子分解。 尽管此例程没有显示等级，但在一些实验中，它被作为以前实现的性能参考。
对于每个实验，显示了两个曲线图：
左图显示了未计算正交矩阵时的性能。 在这种情况下，只计算奇异值SVD，只计算上三角因子 R（右） 计算CPQR和QR，仅计算上三角因子 T型 是为 随机UTV 在后一种情况下，图的算法 2 使用参数调用 内置_U 和 构建_V 设置为false。
右图显示了除奇异值（SVD）、上三角矩阵外显式形成所有正交矩阵时的性能 R（右） （CPQR），或上三角矩阵 T型 ( 随机UTV ). 在这种情况下，矩阵 U型 和 V（V） 计算SVD矩阵 问 计算CPQR和QR，以及矩阵 U型 和 V（V） 为计算 随机UTV 在后一种情况下，图的算法 2 用两个参数调用 内置_U 和 建筑_V 设置为true。 右边的图稍微倾向于CPQR和QR，因为只形成了一个正交矩阵。
6.2.2 块大小影响 随机UTV . 图 7 显示了两种实现为计算 随机UTV 因式分解( 品牌UTV_PBLAS 和基本 品牌UTV_AB 版本01 )关于处理维数矩阵时的几个块大小 \（20，000乘以20，000）。 这两个图的目的是确定最佳块大小，并说明适当块大小选择对总体性能的影响。 其他因子分解（SVD和CPQR）未显示，因为在这些情况下，最佳块大小是由Intel软件确定的。 最佳块大小约为160和320 品牌UTV_PBLAS 和 品牌UTV_AB 第01版 分别为。 这是许多任务并行实现的常见观察结果，因为较小的块大小有利于任务并行，而较大的块大小通常显示出更好的每任务性能。 与往常一样，这些最佳大小略微依赖于矩阵维数：矩阵维数越大，块的大小就越小。
图7。 在makalu中，randUTV实现的缩放时间与维数为（20，000乘以20，000）的矩阵上的块大小。
6.2.3 最新SVD因子分解的性能。 图 8 比较了计算SVD分解的四种实现的缩放时间： MKL SVD公司 , MKL SDD , Netlib SVD 、和 Netlib SDD 性能与矩阵维数有关。 Netlib的例程使用了与上图相似的块大小，并报告了最佳结果。 当没有计算正交矩阵时，传统的SVD和分治SVD对于这种矩阵类型都具有相似的性能。 在这种情况下，MKL例程的速度大约是Netlib例程的14倍。 此外，当矩阵的维数大于 \（n=3，\！000\）。 这是因为计算SVD的常用算法（Netlib使用的算法）包含较高比率的BLAS-1和BLAS-2操作，通常是内存限制的，这使得整个算法对内存带宽更敏感。 维度矩阵 \（n=3，\！000\）需要大约69 MB，而L3缓存大小为 马尔孔 为70 MB（2 \（\次\）每个插槽35 MB）。 维度矩阵 \（n=4，\！000\）（当性能下降时）需要122 MB，这比 马尔孔 Netlib的CPQR和MKL CPQR（见下一图）也会出现同样的性能下降，因为在有效的BLAS-3操作中，底层算法也只执行一半的浮点运算。 在计算正交矩阵时，传统的奇异值分解要比分治奇异值分解慢得多。 在这种情况下 MKL SVD公司 例行程序的速度是 Netlib SVD 、和 MKL SDD 例程的速度是 Netlib SDD 。请注意，用于计算SVD的MKL代码比参考Netlib代码快一个数量级以上，显示了优化后的英特尔实现所取得的卓越性能。
图8。 Netlib和MKL库的SVD实现的缩放时间与矩阵维。
6.2.4 的性能 随机UTV 变体。 图 9 比较了 品牌UTV_AB 在第节中 4.2.3 关于矩阵维数 \（q=0）（顶部图）和 \（q=2）（底图）。 像往常一样，测试了一系列块大小，并报告了最佳块大小的性能。 基本变体的性能( v00版本 )被选为每个矩阵大小的参考。 除了第节中描述的变体之外 4.2.3 ，报告了另外两种变体。 这个 第06版 variant同时结合了 第01版 , 第02版 , 第03版 、和 第04版 变体； 这个 版本07 variant同时结合了 第01版 , 版本02 , 第03版 , 第04版 、和 第05版 变体。 当已经有许多任务要处理时，为了避免增加并行度（附加任务）的开销，只有当要处理的行或列块少于核心时，这两种变体才会增加并行度。 由于使用了40个核心，通常块大小约为320，因此该阈值约为 \( 13,\!000 \). 1 观察如何 版本01 变型明显优于基本型 v00版本 变体。 相比之下 第02版 与 第01版 变体。 在另一边 第03版 和 第04版 对于中小型矩阵（当维数小于约12000或14000时），相对于 第01版 变体。 当构建正交矩阵时，这种改进较小，因为在这些情况下存在更多潜在的任务并行性。 当矩阵维数大于40（被测机器中的核数）乘以最佳块大小时，由于存在大量并行性，增加并行性不会带来任何收益，也会带来性能损失，而增加并行性的开销会降低性能。 可以看出 第06版 和 第07版 当没有建立正交矩阵时，变量要大得多。 在这种情况下，速度通常会快30%到50%； 在某些情况下，速度快80%。 除非另有明确说明，否则接下来的实验显示了 第07版 变体。
图9。 makalu中randUTV_AB实现的缩放速度与矩阵维数。 在所有绘图中，v00变体的性能对于每个矩阵大小为1。 第一行显示\（q=0\）的结果，而第二行显示\的结果（q=2\）。
图 10 比较两种实现的缩放时间 随机UTV ( 品牌UTV_PBLAS 和 品牌UTV_AB )关于矩阵维数。 同样，只报告最佳块大小的性能结果。 当没有建立正交矩阵时， 品牌UTV_AB 在2.7之间( \（q=0\））和3.4( \（q=2）倍的速度 品牌UTV_PBLAS 对于最大矩阵尺寸； 当建立正交矩阵时， 品牌UTV_AB 在2.2之间( \（q=0）和2.7( \（q=2）倍的速度 品牌UTV_PBLAS 用于最大的矩阵大小。
图10。 makalu中randUTV实现的缩放时间与矩阵维。
6.2.5 的性能 随机UTV 与最新SVD因子分解进行比较。 图 11 显示了最佳实现相对于矩阵维度的缩放时间。 在这种情况下， 品牌UTV_AB 通常在未构建正交矩阵时速度更快，而在构建正交矩阵后，这种性能改进更为明显。 实际上 品牌UTV_AB , MKL SVD公司， 和 MKL SDD 与 MKL CPQR公司 ，这是一种需要更少浮点运算的因子分解。
图11。 缩放时间与矩阵维度，以实现最佳实施。 顶行显示了28个岩芯的marbore结果，中间行显示了36个岩芯mimir的结果，底行显示了40个岩芯makalu的结果。
表 2 总结了 随机UTV_AB 以及其他等级揭示因子分解标准化为其在最大矩阵维上的执行时间，数据如图所示 11 。当建立正交矩阵和 \（q=0），但当没有建立正交矩阵时增益仍然存在，并且 \（q=2）。
表2。 三台机器中最大矩阵上randUTV_AB与其他等级因子分解的性能比
6.2.6 可扩展性和效率分析。 图 12 显示了三台机器上的最佳实现所获得的加速比。 顶行显示的结果 马尔孔 关于维数矩阵 \( 14,\!000 \) \（\次\） \（14，\！000\），中间一行显示 米米尔 关于维数矩阵 \( 18,\!000 \) \（\次\） \（18，\！000\）（所有最佳实现都可以在其中运行的最大维度），最下面一行显示 马卡鲁 关于维数矩阵 \（20，000乘以20，000）。 回想一下，在这个图中，每个实现都在一个内核上与自身进行比较。
图12。 最佳实施的速度与核心数量。 顶行显示了最多有28个岩心和\（m=n=14，\！000\）的marbore的结果，中间一行显示了最多有36个岩心和\（m=n=18，\！000\）的mimir的结果，而底行显示了最多有40个岩心和\（m=n=20，\！000\）的马卡鲁的结果。
可扩展性 品牌UTV_AB 总是类似于甚至优于高效的非透视QR分解的可扩展性，并且它不依赖于是否构建了正交矩阵。 请注意，每当使用更多内核时，它总是会增长。 相比之下，SVD分解在一种情况下表现得很好（即使有轻微的超高速）：当使用18个或更少的核构建正交矩阵时 米米尔 在所有其他情况下，当没有构建正交矩阵时，加速比通常是适中的，当核心数从一半增加到全部时，可伸缩性甚至会下降（加速比增长不大）。 总而言之 品牌UTV_AB 与QR因子分解类似（甚至更好），并且比其他实现高出很多。
本研究的另一个目标是衡量实施的效率。 并行环境中的效率有多种定义。 最流行的定义之一是加速比除以核心数。 根据这个定义，最大效率为1，表示系统中进行有用工作的部分 13 显示了三台机器上的最佳实现所获得的效率。 顶行显示的结果 马尔孔 关于维数矩阵 \（14，000乘以14，000），中间一行显示 米米尔 关于维数矩阵 \（18，000乘以18，000）（可以运行所有最佳实现的最大维度），而底行显示了 马卡鲁 关于维数矩阵 \（20，000乘以20，000）。 回想一下，同样在这个图中，每个实现都在一个核心上与自身进行比较。 可以看出，在所有情况下 品牌UTV_AB 要么是最高的，要么是第二高的。 随机UTV_AB 在两种体系结构中使用最大核数时，是唯一一个效率接近或高于50%（加速比高于核数的一半）的因子分解，而所有其他因子分解的效率通常较低。 相比之下，SVD分解的效率通常较低，除了 米米尔 当建立正交矩阵时。 CPQR分解的效率甚至更低。
图13。 最佳实现的效率与核心数量。 顶行显示了多达28个岩芯和（m=n=14，\！000\）的marbore结果，中间行显示了最多36个岩芯的mimir结果和（m=n=18，\！000 \），底行显示了最高40个岩芯makalu和（m=20，\！0000 \）的结果。
评估新产品效率的另一种方法 随机UTV_AB 共享内存体系结构上的代码将其时间与QR分解的时间进行比较。 回想一下 随机UTV 的算法 \（q=0）， \（q=1），以及 \当没有建立正交矩阵时，（q=2）的计算量分别是QR分解的3倍、4倍和5倍。 分解维数矩阵时 \（30，\！000\）在 马卡鲁 并且没有建立正交矩阵 品牌UTV_AB 对于 \（q=0）， \（q=1），以及 \（q=2），QR分解时间分别为3.14、4.24、5.40。 可以看出，这些数字非常接近3、4和5的理论商数。 因此，对于 \（q=2\） 随机UTV 与MKL库中的QR因式分解相比，效率仅低约8%（5.40 vs.5），众所周知，该库非常有效。
6.2.7 详细性能分析。 图 14 报告任务执行跟踪（通过 Extrae/Paraver公司 框架 2 )上的 马卡鲁 ，用于 \（n=8，\！192\）和 \（b=320\）在40芯上运行。 注意，在我们的实验中，本例中的最大潜在任务并行度大约为( \（8，\！192/320\约26\））。 这将最终限制那些不会自动增加任务并行度的变体的性能。
图14。 使用40个线程，在makalu上使用\（n=8，\！192\）和\（b=320\）对randUTV的两种不同的algorithm-by-block变体进行详细的执行跟踪。 从左到右：v05不带正交矩阵，v07不带正交阵，v05带正交矩阵和v07带正交矩阵。 顶部的图显示了数据流任务的执行，使用与图中相同的颜色约定 5 ; 底部的图报告了每次执行的瞬时核心占用。
实验包括四次连续执行- 第05版 和 第07版 没有或有正交矩阵的构造。 顶部轨迹说明了按照图中的颜色约定执行任务 5 ; 蓝色的图表示瞬时堆芯占用。 从对痕迹的观察中可以提取出一些警告：
首先，观察执行时间从 第07版 实现与它们的 第05版 同行。
当不计算正交矩阵时，这种改进更加明显，因为在这些情况下并行性更加稀少； 因此，我们在暴露额外任务并行性方面的技术改进更加明显。
总而言之，如前几节所述，观察到的性能改进的主要来源是任务并行度的增加（因此，核心占用）。 这种现象可以在占用图中观察到，占用图清楚地报告了整个计算过程中的额外占用 第07版 与他们相比 第05版 同行。
图 15 包含与图中报告的实验相同的核心职业直方图 14 在图中，低百分比意味着内核在大多数时间处于空闲状态。 注意以下方面的定性和定量差异 第05版 和 第07版 ：虽然第一个出现了26左右的峰值核心占用（回想一下前面计算的潜在任务并行性） 第07版 增加了这种潜在的并行性，并且在计算正交矩阵的情况下，使用40个核显示出很大的时间百分比（约42%）（当不计算正交矩阵时，该百分比也显著增大）。
图15。 randUTV算法块的两个不同变体的核心占用直方图，在makalu上使用40个线程，分别为\（n=8，\！192\）和\（b=320\）。。 低百分比意味着内核大部分时间处于空闲状态。
最后，表 三 列出了在同一轮实验中用于每种任务类型的时间百分比。 请注意，所有实现都很繁重 xgemm公司 基础，以及如何额外 xgemm公司 任务在所有情况下都以变体形式生成 第07版 与他们相比 第05版 对应的，产生更高的性能。
表3。 randUTV变量v05和v07的每种任务类型的详细时间百分比分布，在makalu上使用40个线程，使用\（n=8，\！192\）和\（b=320\）
6.2.8 共享内存体系结构的总结。 总之， 品牌UTV_AB 当需要正交矩阵且矩阵不太小时，就原始速度而言，是竞争因子分解方法的明显赢家( \（第4章，第000章）。 在可扩展性方面， 品牌UTV_AB 表现也优于竞争对手。 此外，算法块实现比阻塞的PBLAS版本有明显的加速。 虽然SVD的准确性要高得多，但事实是 品牌UTV_AB 可以与竞争 MKL SVD公司 考虑到英特尔通常在其软件上投入的巨大努力，在速度方面是显著的。 事实证明 MKL CPQR公司 都被这两个 MKL SVD公司 和 品牌UTV_AB 每一次失败的代价都比 MKL CPQR公司 。的可扩展性结果 随机UTV_AB 它出色的计时性能显示了它在共享内存计算中作为一种高性能工具的潜力。
6.3 分布式内存体系结构的计算速度 本小节中报告的分布式存储器体系结构的实验在两台计算机上进行：
ua公司 ：HP计算机集群。 集群的每个节点包含两个2.8 GHz的Intel Xeon CPU X5560处理器，共有12个内核和48 GB RAM。 这些节点与Infiniband 4X QDR网络相连。该网络能够支持40 Gb/s的信令速率，每个方向的峰值数据速率为32 Gb/s。
它的操作系统是GNU/Linux（版本3.10.0-514.21.1.el7.x86_64）。 英特尔的 ifort公司 使用了编译器（版本12.0.0 20101006）。 LAPACK和ScaLAPACK例程取自英特尔数学内核库（MKL）10.3.0产品内部版本20100927，适用于英特尔（R）64体系结构，因为此库通常比Netlib存储库中的LAPACK和ScaLAPACK代码提供更高的性能。
skx公司 ：具有天湖架构的节点 踩踏2 超级计算机。 集群的每个节点包含两个2.1 GHz的Intel Xeon CPU Platinum 8160处理器，共有48个内核和192 GB RAM。 这些节点通过一个具有胖树拓扑结构的100 Gb/s Intel Omni-Path（OPA）网络进行连接。
它的操作系统是GNU/Linux（版本3.10.0-957.5.1.el7.x86_64）。 英特尔的 ifort公司 使用了编译器（版本18.0.2）。 LAPACK和ScaLAPACK例程也取自“英特尔数学内核库”（MKL）2018.0.2版针对英特尔64体系结构的产品构建20180127。
大多数实验都是在第一台计算机上进行的，因为第二台计算机的可用小时数有限。 除非另有明确说明，否则以下绘图显示第一台计算机的结果。
这些实验中使用的所有矩阵都是随机生成的，因为它们可以更快地生成，而且集群正被其他用户大量加载。
在本小节的实验中评估了以下实现：
ScaLAPACK SVD公司 ：调用的例程 pdgesvd公司 使用MKL的ScaLAPACK计算SVD。
ScaLAPACK CPQR软件 ：调用的例程 pdgeqpf公司 使用MKL的ScaLAPACK计算CPQR因子分解。
PLiC CPQR ：调用的例程 pdgeqp3 来自PLiC库（用于控制的并行库）[ 4 ]用于使用BLAS-3计算CPQR因式分解。 为了进行公平比较，此源代码链接到了MKL的ScaLAPACK库。
随机UTV ：用于计算 随机UTV 基于ScaLAPACK基础设施和库的因子分解。 为了进行公平比较，此源代码链接到了MKL的ScaLAPACK库。
ScaLAPACK二维码 ：调用的例程 边缘qrf 来自MKL的ScaLAPACK用于计算QR因子分解。 虽然这个程序没有显示等级，但它被包括在一些实验中，作为其他实验的参考。
与前一小节共享内存体系结构一样，每个实验都会显示两个曲线图。 左图显示了未计算正交矩阵时的性能（代码仅计算SVD（上三角矩阵）的奇异值 R（右） 对于CPQR和QR分解，以及上三角矩阵 T型 对于 随机UTV 因式分解）。 右图显示了除这些外，所有正交矩阵都显式形成时的性能（矩阵 U型 和 V（V） 对于SVD和 随机UTV 和矩阵 问 用于QR和CPQR）。 回想一下，由于只构建了一个正交矩阵，所以右边的图稍微倾向于CPQR和QR。
第一项任务是评估QR分解以及我们在分布式内存机器上实现的增量QR分解。 我们评估了几个节点、几个网格配置、块大小和矩阵大小。 在所有情况下，ScaLAPACK中的QR分解明显优于我们的增量QR分解。 例如，在计算维数矩阵的QR分解时 \（25，600乘以25，600），ScaLAPACK中QR分解的速度( pdgeqrf公司 )是370 GFlops/s，而增量QR分解的速度是250 GFlops/s.由于这个性能差距，我们没有实现完整的 随机UTV 基于增量QR分解。 以下图表报告了使用常规QR分解时的结果和性能。
图 16 显示了使用96个排列为 \维度矩阵上的（6乘16）网格 \（25，600乘以25，600）。 可以看出，大多数实现在小块大小（如32和64）上的性能稍好，唯一的例外是PLiC CPQR，当没有构建正交矩阵时，它在大块大小上的性能略好。
图16。 96个排列成（6乘以16）网格的芯上的缩放时间与块大小。
图 17 显示了维矩阵上许多拓扑的所有实现的性能 \（20，480乘以20，480\）。 第一行显示了一个节点（12个核）的结果，第二行显示了两个节点（24个核）上的结果，而第三行显示了四个节点（48个核）下的结果，并且第四行显示了八个节点（96个核）中的结果。 可以看出，最好的拓扑通常是 \（p\times q），带 第页 略小于 q个 .
图17。 维数为\（20，\！480\乘以20，\？480\）的矩阵上的几个拓扑的缩放时间。
图 18 显示了两个不同数量的磁芯的性能与矩阵维数的关系：48个磁芯排列如下 \（4乘以12）（顶行）和96芯排列为 \（6乘以16）（最下面一行）。 显而易见， 随机UTV 通常比其他等级揭示因子分解快得多。 正如预期， 随机UTV 比QR分解慢； 一个非秩揭示因子分解作为参考。 在大中型矩阵上，ScaLAPACK CPQR的性能远低于 随机UTV ，而PLiC CPQR的性能与 随机UTV 然而，回想一下，CPQR的精度通常比 随机UTV .
图18。 两个不同数量的核心上的缩放时间与矩阵维数。 顶行显示了48个岩芯的结果，排列为（4乘以12）； 底部一行显示了96个排列为（6乘以16）的芯的结果。
表 4 总结了分布式存储器的速度比 随机UTV 以及其他两个最佳等级揭示因子分解（其他因子分解的时间除以 随机UTV )关于最大矩阵维度，数据如图所示 18 和图 21 。在本表中，单元格中的值2.00表示 品牌UTV_AB 速度是原来的两倍。 当建立正交矩阵和 \（q=0）； 当建立正交矩阵和 \（q=2）。
表4。 在两台机器的某些配置中，最大矩阵上分布式内存randUTV与其他秩级因子分解的速度之比
在分布式内存应用程序中，传统方法为每个内核创建一个进程。 然而，在某些情况下，创建更少的进程，然后每个进程对应的线程数可以提高性能。 显然，进程数与每个进程的线程数的乘积必须等于内核总数。 这种方法的优点是创建更少的进程可以降低通信成本，而通信成本通常是分布式内存应用程序的主要瓶颈。 在线性代数应用程序中，通过使用共享内存并行LAPACK和BLAS库，可以很容易地为每个进程创建和使用多个线程。 然而，必须非常小心地确保将进程正确固定到核心，否则性能会显著下降。 这是通过使用 -通用I_MPI_PIN_DOMAIN套接字 执行时标记 mpirun运行 / mpiexec公司 实验中使用的机器中的命令。
图 19 显示了维数矩阵分解的缩放时间 \( 25,\!600 \) \（\次\） \（25，\！600）。 这些图包括一组完整拓扑的结果，以隔离线程数量增加的影响。 与往常一样，左侧三个图显示未构建正交矩阵时的性能，右侧三个图则显示构建正交矩阵后的性能。 当每个核心创建一个进程（96个进程），然后每个进程创建一个线程时，顶行显示性能( \（96次1=96次）。 第二行显示了每两个内核创建一个进程（48个进程），然后每个进程创建两个线程时的性能( \（48乘以2=96））。 第三行显示每三个核心创建一个进程（32个进程），然后每个进程创建三个线程时的性能( \（32乘以3=96））。 可以看出，SVD仅在创建正交矩阵时才提高性能，而 随机UTV 提高了这两种情况下的性能（有或没有正交矩阵）。
图19。 维数为（25，600乘以25，600）的矩阵上几个拓扑的缩放时间。
表 5 显示了具有96个核的多个拓扑的最佳定时（以秒为单位），以便可以实现更精细的详细比较。 被分解的矩阵有 \（25，600乘以25，600）。 可以看出，当构建正交矩阵时，SVD的性能提高了13%，而 随机UTV 具有 \（q=2）在这两种情况下，性能都提高了20%。 当每个进程使用两个线程时，性能通常会提高，但在每个进程使用超过两个线程的情况下，性能会保持相似或下降。
表5。 考虑每个进程多个线程数的维矩阵（25，600乘以25，600）上96个核的几种拓扑的秒最佳定时
图 20 显示了所有维矩阵实现所获得的加速比 \（20，480乘以20，480\）。 回想一下，在这个图中，每个实现都在一个内核上与自身进行比较。 已为以下数量的核心选择了最佳拓扑： \12芯（3乘以4）， \24芯（6乘以4）， \48芯（4乘以12），以及 \96芯（6乘以16）。 当没有建立正交矩阵时 随机UTV 最大芯数（96）在47.1之间( \（q=0\））和43.3( \（q=2\））。 构建正交矩阵时 随机UTV 最大的芯数（96）在49.3之间( \（q=0）和44.7( \（q=2\））。 在这两种情况下，效率都接近50%。 当没有建立正交矩阵时 随机UTV 略低于QR分解； 当建立正交矩阵时 随机UTV 略高于QR分解。 在这两种情况下 随机UTV 远高于SVD和CPQR分解得到的结果，显示了这种分解的巨大可扩展性潜力。
图20。 速度与维度矩阵（20，480乘以20，480\）上所有实现的核心数之比。
正如之前在共享内存体系结构上所做的那样，评估新内存效率的另一种方法 随机UTV 分布式内存体系结构上的代码是将它们的时间和QR分解的时间进行比较。 如前所述，当未构建正交矩阵时 随机UTV 的算法 \（q=0）， \（q=1），以及 \（q=2）分别是QR分解的计算成本的3倍、4倍和5倍。 分解维数矩阵时 \（25，\！600），96芯 ua公司 组织为 \（6次16次）网格，不建立正交矩阵 随机UTV 对于 \（q=0）， \（q=1），以及 \（q=2），QR分解的时间分别为3.58、5.18和6.62。 另一方面，当分解维数矩阵时 \（40，\！960\），768芯 skx公司 组织为 \（24乘32）个网格，不建立正交矩阵 随机UTV 对于 \（q=0）， \（q=1），以及 \（q=2），QR分解的时间分别为3.65、4.55和5.56。 可以看出，这些商非常接近（在第二种情况下更接近）理论商3、4和5。 因此，在 skx公司 对于 \（q=2\） 随机UTV 仅比来自MKL ScaLAPACK库的QR因子分解低11.8%。
图 21 显示了16个节点上的性能与矩阵维 skx公司 （共768芯，布置为 \（24\乘以32\）逻辑网格）。 本实验的目标是评估比以前实验数量多得多的内核，以及具有更现代化硬件和软件的更高性能平台。 可以看出 随机UTV 比ScaLAPACK码的要高得多。 当建立正交矩阵时，PLiC CPQR更接近于 随机UTV ，ScaLAPACK SVD显示矩阵大小之间的性能下降 \（20，\！480\）和 \( 25,\!600 \).
图21。 在768个skx核（排列为24乘以32）上的缩放时间与矩阵尺寸。
总之， 随机UTV 比可用的SVD分布式内存实现快得多。 它还与测试的最佳CPQR实现相匹配。 随机UTV 众所周知，排名远优于CPQR[ 24 ]. 它还为矩阵的行空间和（数字）零空间提供了正交基。这意味着只要匹配CPQR的速度就可以在不增加额外计算成本的情况下获得大量信息。 此外， 随机UTV 在需要正交矩阵的情况下，比CPQR更快。 我们最后发现 随机UTV 是在分布式内存中进行秩揭示因子分解的竞争实现之上迈出的一大步。
跳过7结论部分 7 结论 我们描述了 随机UTV 计算秩揭示因子分解矩阵的算法，分别针对共享内存和分布式内存体系结构。
关于共享内存，新的实现提出了一个 按块算法 它构建在运行时任务调度程序之上( libflame公司 的SuperMatrix）实现了数据流执行模型。 该模型基于DAG，减少了同步点的数量，提高了大规模并行体系结构的性能。 事实上，与最先进的专有库相比，多达40个内核的性能结果显示出优异的性能和可扩展性。
我们还提出了一种分布式内存算法，用于 随机UTV 该提案利用了经典的分块算法而不是逐块算法，并大量使用了ScaLAPACK。 性能结果表明，与其他最先进的实现相比，它具有竞争性的性能和出色的可扩展性。
在本文中，我们专门讨论了具有共享内存和同构分布式内存体系结构的多核CPU的情况。 我们预计 随机UTV 在诸如基于GPU的架构（由一个或多个节点组成）的更严格的通信约束环境中将更加明显。 针对此类环境，提出了改进方法的变化，作为未来的工作。
跳过补充材料部分
[1] 安德森E。 , 白Z。 , 比肖夫C。 , 布莱克福德L.S。 , 德梅尔·J。 , Dongarra Jack J。 , 克罗兹·J·杜 , 哈马林S。 , 格林鲍姆A。 , 麦肯尼A。 、和 索伦森D。 . 1999 . LAPACK用户指南（第三版） . 暹罗 , 宾夕法尼亚州费城 . 谷歌学者 交叉引用 [2] 安德森·埃德 , 本佐尼A。 , 东加拉·J·。 , 莫尔顿S。 , 奥斯特罗乔夫S。 , 图兰乔·伯纳德 、和 盖恩·罗伯特·范德 . 1991 . 基本线性代数通信子程序 .英寸 第六届分布式内存计算会议论文集 IEEE标准， 287 – 290 . 谷歌学者 [3] 巴洛·杰西·L。 . 2002 . ULV分解的修改和维护 .英寸 应用数学与科学计算 . 施普林格 , 31 – 62 . 谷歌学者 交叉引用 [4] 本纳·彼得 , 金塔纳-奥蒂安里克。 、和 金塔娜·奥尔蒂·格雷戈里奥 . 2008 . 在并行计算机上求解线性二次型最优控制问题 . 优化方法和软件 23 , 6 ( 2008 ), 879 – 909 . 内政部： 谷歌学者 数字图书馆 [5] 保罗·比伦蒂内西 , 金塔纳-奥蒂安里克。 、和 盖恩·罗伯特A。 . 2005 . 用代码表示线性代数算法：FLAME应用程序接口 . ACM数学软件汇刊 31 , 1 ( 2005 ), 27 – 59 . 谷歌学者 数字图书馆 [6] 布莱克福德·L·苏珊 , Choi Jaeyong先生 , 克利里·安迪 , 达泽维多·爱德华多 , 德梅尔·詹姆斯 , Dhillon Inderjit公司 , 东加拉杰克 , 哈马林·斯文 , 亨利·格雷格 , 佩蒂特·安托万 ，等 . 1997 . ScaLAPACK用户指南 . 暹罗 . 谷歌学者 数字图书馆 [7] 陈恩妮（Chan Ernie） , 金塔纳·奥蒂·恩里克（Quintana-Orti Enrique S.）。 , 金塔纳·奥蒂·格雷戈里奥 、和 盖恩·罗伯特·范德 . 2007 . SMP和多核架构矩阵操作的超矩阵无序调度 .英寸 第19届ACM并行算法和体系结构研讨会论文集 .ACM时， 116 – 125 . 谷歌学者 数字图书馆 [8] 陈恩妮（Chan Ernie） , 泽·菲尔德·G·凡 , 保罗双年展 , 金塔纳·奥蒂·恩里克（Quintana-Orti Enrique S.）。 , 金塔娜·奥尔蒂·格雷戈里奥 、和 盖恩·罗伯特·范德 . 2008 . SuperMatrix：一个用于逐块算法的多线程运行时调度系统 .英寸 第13届ACM SIGPLAN并行编程原理与实践研讨会论文集（PPoPP'08） . ACM公司 , 纽约州纽约市 , 123 – 132 . 内政部： 谷歌学者 数字图书馆 [9] 崔在英 , 德梅尔·詹姆斯 , Dhillon Inderjiit公司 , 东加拉杰克 , 奥斯特鲁乔夫·苏珊 , 佩蒂特·安托万 , 斯坦利·肯 , 沃克·戴维 、和 惠利·克林顿 . 1996 . ScaLAPACK：用于分布式内存计算机的便携式线性代数库？ 设计问题和性能 . 计算机物理通信 97 , 1–2 ( 1996 ), 1 – 15 . 谷歌学者 交叉引用 [10] Choi Jaeyong先生 , Dongarra Jack J。 , 奥斯特鲁乔夫·L·苏珊 , 佩蒂特·安托万P。 , 沃克·大卫·W·。 、和 惠利·R·克林特 . 1996 . ScaLAPACK LU、QR和Cholesky因子分解例程的设计和实现 . 科学规划 5 , 三 ( 1996 ), 173 – 184 . 谷歌学者 数字图书馆 [11] Choi Jaeyong先生 , Dongarra Jack J。 , 波佐·罗尔丹 、和 沃克·大卫·W·。 . 1992 . ScaLAPACK：用于分布式内存并发计算机的可扩展线性代数库 .英寸 第四届大规模并行计算前沿研讨会 IEEE标准， 120 – 127 . 谷歌学者 [12] Dongarra Jack J。 , 克鲁斯·杰梅·杜 , 哈马林·斯文 、和 达夫·伊恩·S。 . 1990 . 算法679：一组三级基本线性代数子程序：模型实现和测试程序 . ACM数学软件汇刊 16 , 1 ( 1990 ), 18 – 28 . 谷歌学者 数字图书馆 [13] Dongarra杰克J。 , 克罗斯·杰里米·杜 , 哈马林·斯文 、和 汉森·理查德·J。 . 1988 . 算法656：一组扩展的基本线性代数子程序：模型实现和测试程序 . ACM数学软件汇刊 14 , 1 ( 1988 ), 18 – 32 . 谷歌学者 数字图书馆 [14] 埃卡特·卡尔 和 Young Gale公司 . 1936 . 一个矩阵与另一个低阶矩阵的近似 . 心理测量学 1 , 三 ( 1936 ), 211 – 218 . 谷歌学者 交叉引用 [15] 埃尔巴·哈桑 , 巴洛·杰西·L。 、和 张振岳 . 2002 . 一种改进的基于Gram–Schmidt的ULV分解降代技术及其在递归TLS问题中的应用 . 计算统计与数据分析 41 , 1 ( 2002 ), 195 – 209 . 谷歌学者 数字图书馆 [16] 金塔纳·A.M.维达尔和G。 . 1992 . 共享内存多处理机上QR分解的并行算法 .英寸 1992年欧洲并行计算研讨会论文集，并行计算：从理论到实践 , Joosen E.Milgrom W。 （编辑）。 IOS出版社 , 72 – 75 . 谷歌学者 [17] Golub基因H。 和 贷款Charles F.Van . 1996 . 矩阵计算 （第三版） . 约翰霍普金斯大学出版社 , 马里兰州巴尔的摩 . 谷歌学者 数字图书馆 [18] 枪手John A。 , 古斯塔夫森·弗雷德·G。 , 亨利·格雷格·M。 、和 盖恩·罗伯特·范德 . 2001 . 形式化线性代数方法环境 . ACM数学软件汇刊 27 , 4 ( 2001 ), 422 – 455 . 谷歌学者 数字图书馆 [19] 冈特·布莱恩·C。 和 盖恩·罗伯特·范德 . 2005 . QR分解的并行核外计算和更新 . ACM数学软件汇刊 31 , 1 ( 2005 ), 60 – 78 . 谷歌学者 数字图书馆 [20] 哈尔科·内森 , Martinsson Per-Gunnar公司 、和 奖杯Joel A。 . 2011 . 寻找随机结构：构造近似矩阵分解的概率算法 . SIAM审查 53 , 2 ( 2011 ), 217 – 288 . 谷歌学者 数字图书馆 [21] Igual Francisco D。 , 陈厄尼 , 金塔纳-奥蒂安里克。 , 金塔纳·奥蒂格雷戈里奥 , 盖恩·罗伯特·范德 、和 泽·菲尔德·G·凡 . 2012 . FLAME方法：从密集线性代数算法到高性能多加速器实现 . 并行与分布式计算杂志 72 , 9 ( 2012 ), 1134 – 1143 . 谷歌学者 数字图书馆 [22] Quintana A.M.Vidal、J.M.BadíA和G。 . 1994 . Transputer网络上的高效并行QR分解 .英寸 Transputers’94，先进研究和工业应用论文集 . IOS出版社 , 247 – 265 . 谷歌学者 [23] 劳森·查克·L。 , 汉森·理查德·J。 , 金凯·大卫·R。 、和 克罗夫·弗雷德·T。 . 1979 . Fortran使用的基本线性代数子程序 . ACM数学软件汇刊 5 , 三 ( 1979 ), 308 – 323 . 谷歌学者 数字图书馆 [24] Martinsson私人有限公司。 , 金塔纳州。 、和 Heavner N.公司。 . 2019 . RandUTV：用于计算排名显示UTV因子分解的分块随机算法 . ACM数学软件汇刊 45 , 1 ，文章 第4条 ( 三月 2019 )，共26页。 内政部： 谷歌学者 数字图书馆 [25] Martinsson Per-Gunnar公司 , 罗赫林·弗拉基米尔 、和 Tygert标记 . 2006 . 矩阵逼近的一种随机化算法 . 技术报告。 耶鲁大学CS研究报告YALEU/DCS/RR-1361。 耶鲁大学计算机科学系，康涅狄格州纽黑文。 谷歌学者 [26] Martinsson Per-Gunnar公司 , 罗赫林·弗拉基米尔 、和 泰格特标记 . 2011 . 矩阵分解的随机算法 . 应用和计算谐波分析 30 , 1 ( 2011 ), 47 – 68 . 内政部： 谷歌学者 [27] Martinsson Per-Gunnar公司 和 奖杯乔尔 . 2020 . 随机数值线性代数：基础与算法 . ( 2020 ). . 谷歌学者 [28] 米尔斯基·利昂 . 1960 . 对称规范函数与酉不变范数 . 数学季刊 11 , 1 ( 1960 ), 50 – 59 . 谷歌学者 交叉引用 [29] 海森公园 和 埃尔登·拉斯 . 1995 . 降低等级揭示URV分解的时间 . SIAM SIAM矩阵分析与应用杂志 16 , 1 ( 1995 ), 138 – 155 . 谷歌学者 数字图书馆 [30] 金塔纳·奥蒂格雷戈里奥 , Igual Francisco D。 , 玛奎斯梅赛德斯 , 金塔纳-奥蒂安里克。 、和 盖恩·罗伯特·范德 . 2012 . 一个运行时系统，用于在多线程架构上逐块编程核心外矩阵算法 . ACM数学软件汇刊 38 , 4 ( 2012 ), 25 . 谷歌学者 数字图书馆 [31] 金塔纳·奥蒂格雷戈里奥 , 金塔纳-奥蒂安里克。 , 盖恩·罗伯特·范德 , 泽·菲尔德·G·凡 、和 陈恩妮（Chan Ernie） . 2009 . 线程级并行的逐块编程矩阵算法 . 数学软件交易 36 , 三 ，文章 14 ( 七月 2009 )，共26页。 内政部： 谷歌学者 数字图书馆 [32] 罗赫林·弗拉基米尔 , 斯拉姆·阿瑟 、和 Tygert标记 . 2009 . 一种用于主成分分析的随机算法 . SIAM矩阵分析与应用杂志 31 , 三 ( 2009 ), 1100 – 1124 . 谷歌学者 数字图书馆 [33] 施赖伯·罗伯特 和 贷款Charles Van . 1989 . Householder变换乘积的高效存储WY表示 . SIAM科学与统计计算杂志 10 , 1 ( 1989 ), 53 – 57 . 谷歌学者 数字图书馆 [34] 斯图尔特·G·W。 . 1998 . 矩阵算法第1卷：基本分解 . 宾夕法尼亚州费城SIAM . 谷歌学者 交叉引用 [35] 斯图尔特·G·W。 . 1992 . 一种用于子空间跟踪的更新算法 . IEEE信号处理汇刊 40 , 6 ( 六月 1992 ), 1535 – 1541 . 内政部： 谷歌学者 数字图书馆 [36] 斯图尔特·吉尔伯特·W。 . 1993 . 更新等级揭示ULV分解 . SIAM矩阵分析与应用杂志 14 , 2 ( 1993 ), 494 – 499 . 谷歌学者 数字图书馆 [37] 特雷费滕·劳埃德。 和 III大卫·鲍 . 1997 . 数值线性代数 ，音量 50 . 宾夕法尼亚州费城SIAM . 谷歌学者 交叉引用 [38] 泽·菲尔德·G·凡 . 2012 . 利比亚火焰 ：完整参考 www.lulu.com。2022年4月6日检索自 http://www.cs.utexas.edu/users/flame/web/FLAMEPublications.html . 谷歌学者 [39] 泽·菲尔德·G·凡 , 陈恩妮（Chan Ernie） , 盖恩·罗伯特·范德 , 金塔纳-奥蒂安里克。 、和 金塔纳·奥蒂格雷戈里奥 . 2009 . 用于密集矩阵计算的libflame库 . IEEE科学与工程计算 11 , 6 ( 2009 ), 56 – 62 . 谷歌学者 交叉引用 
