Parallel Architecture Lecture6

并行算法设计的例子

以计算矩阵乘法为例，普通的串行算法的复杂度为$O(n^3)$，通过一些高级算法例如Strassen算法等可以把复杂度降到$O(n^x),2<x<3$​。

void matrixMultiply(int n, int m, int p, int A[n][m], int B[m][p], int C[n][p]) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < p; j++) {
            C[i][j] = 0;
            for (int k = 0; k < m; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

简单分块算法

流程

类比单个元素的计算，结果矩阵中对应的一个子矩阵也可以用两个矩阵的对应行列组成的矩阵相乘得到，这样就可以局部计算结果矩阵中的子矩阵：

分块算法首先把矩阵分块，有几块就用几个处理器，$P_{ij}$要存：$A_{ij},B_{ij},C_{ij}$。

计算阶段，每个处理器都把自己存的$A_{ij}$告诉同一行的其他处理器；每个处理器都把自己存的$B_{ij}$告诉同一列的其他处理器。

之后，每个$P_{ij}$按公式

$$C_{ij}=\sum _{k=0}^{\sqrt{p}-1}{A}_{ik}\cdot B_{kj}$$

算出$C_{ij}$放入结果矩阵。

复杂度

空间复杂度$O(n^3)$，时间复杂度$O(n)$。

因为每个处理器只需要跑一轮循环即可，但要存3个矩阵的信息。

Question

它的时间复杂度是什么？（算上通信开销应该不是$O(n)$）

Cannon算法

流程

初始化

先像上面一样把各个矩阵块分配给处理器：

只有颜色相同的才能相乘（其实就是上边提到的$A_{ik}\cdot B_{kj}$，中间位得一样乘出来才有意义）。

重排

$A_{ij}$向左循环移动$i$步；$B_{ij}$向上循环移动$j$步。

这样其实就是为了把所有能乘的$A_{ik}\cdot B_{kj}$放到一起，而且乘完要在相应位置。比如$A_{23}\cdot B_{31}=C_{21}$，所以$A_{23}$和$B_{31}$要刚好在第2行第一列。

描述

① 对准：

所有块 $A_{i,j},(0\le i,j\le \sqrt{p}-1)$ 向左循环移动$i$步；

所有块 $B_{i,j},(0\le i,j\le \sqrt{p}-1)$ 向上循环移动$j$步；

② 所有处理器 $P_{i,j}$ 做执行 $A_{i,j}$ 和 $B_{i,j}$ 的乘-加运算；

③ 移位：

$A$ 的每个块向左循环移动一步；

$B$ 的每个块向上循环移动一步；

④ 转②执行 $\sqrt{p}-1$​ 次；

例

以处理器$P_{12}$为例，第一次移位后：

计算完执行 ③：

i

可以看出，这个处理器上算的所有小矩阵，头尾的数都是12，比如$A_{13}\cdot B_{32},A_{10}\cdot B_{02}$，未来肯定还要算$A_{11}\cdot B_{12},A_{12}\cdot B_{22}$ 。也就是说每个处理器最后都要算完这$n$个和自己有关的矩阵。

后面两次位移：

伪代码

输入: $A_{n\times n}$, $B_{n\times n}$ ；输出: $C_{n\times n}$​

Cannon Algorithm

Begin for $k=0$ to $\sqrt{p}-1$ do  for all $P_{i,j}$ par-do    if $i>k$ then //大于$k$是为了避免重复移动    $A_{i,j}\leftarrow A_{i,(j+1)\text{mod}\sqrt{p}}$ //对$A$循环移位   endif   if $j>k$ then    $B_{i,j}\leftarrow B_{(i+1)\text{mod}\sqrt{p},j}$ //对$B$循环移位   endif  endfor endfor for all $P_{i,j}$ par-do $C_{i,j}=0$ endfor for $k=0$ to $\sqrt{p}-1$ do  for all $P_{i,j}$ par-do   $C_{i,j}\leftarrow C_{i,j}+A_{i,j}\cdot B_{i,j}$ //先计算   $A_{i,j}\leftarrow A_{i,(j+1)\text{mod}\sqrt{p}}$ //算完$A$左移   $B_{i,j}\leftarrow B_{(i+1)\text{mod}\sqrt{p},j}$  endfor endfor

复杂度

$p$是处理器数量，$n$是矩阵维度（边长）。

算法有 $\sqrt{p}$ 次循环，在每次循环，有 $(n/\sqrt{p})\times (n/\sqrt{p})$ 的矩阵乘法：$\mathrm{\Theta }(n^3/\sqrt{p^3})$​。

i

这里主要是对计算阶段说的。

计算阶段复杂度：$\mathrm{\Theta }(n^3/p)$；

在每个循环中，每个处理器发送和接收两个大小为 $(n/\sqrt{p})\times (n/\sqrt{p})$​ 的数据块（其实就是位移阶段，每一次位移都涉及一次收发）。

每个处理器的通信复杂度：

$$(n/\sqrt{p})\times (n/\sqrt{p})\times \sqrt{p}=\mathrm{\Theta }(n^2/\sqrt{p})$$

并行开销：$\mathrm{\Theta }(n^3/p)$​。

DNS

结果矩阵有几个元素就用几个处理器，总共用$n^3$个处理器，时间复杂度可以降到$O(logn)$​。

TODO

细节待补充。