26、多线程算法缓存缺失分析的再探讨

多线程算法缓存缺失分析的再探讨

在多线程算法的执行过程中，缓存缺失问题一直是影响性能的关键因素之一。本文将深入探讨相关算法的缓存缺失分析，介绍一些重要的算法和概念，并给出相应的缓存缺失边界。

1. 重要算法介绍

• 矩阵乘法算法
  • 8 路递归矩阵乘法（8 - way recursion Matrix Multiply） ：这是一个 2 型分层分治并行（HBP）算法。输入为两个 $n×n$ 矩阵，并行进行 8 次递归调用，处理 $n/2×n/2$ 大小的子问题，之后进行 4 次矩阵加法（BP 计算）。这里 $c = 1$，$v(n^2) = 8$，$r(n^2) = n^2/4$。
  • 深度 - n 矩阵乘法（Depth - n - MM） ：同样是 2 型 HBP 算法，$c = 2$，$v(n^2) = 4$，$r(n^2) = n^2/4$。
• 快速傅里叶变换算法（FFT） ：将输入视为方阵，先进行转置，然后对大小为 $\sqrt{n}$ 的独立并行子问题进行两次递归 FFT 计算，最后对结果进行矩阵转置。该算法的顺序缓存复杂度为 $Q = O(\frac{n}{B} \log_M n)$。Type 2 HBP 算法 FFT 在输入长度为 $n$ 时，会对 $\sqrt{n}$ 个大小为 $\sqrt{n}$ 的子问题进行 $c = 2$ 次 FFT 调用，在每次递归调用集合前后进行常数次数的矩阵转置（BP 计算），且 $f(r) = \sqrt{r}$。

2. 线性空间边界与变量访问约束

• 线性空间边界 ：对于线性空间有界的计算，能获得更强的边界。线性空间有界意味着计算使用的空间与输入和输出数据的大小呈线性关系（或更小），并且在 HBP 计算中，该线性空间边界适用于所有递归任务。本文分析的所有算法都是线性空间有界的。
• 变量访问约束 ：为了控制篡夺发生时的缓存缺失，对局部变量的访问进行了限制。在向上遍历树的节点 $v’$ 处的计算可以访问全局变量以及在向下遍历树的对应节点 $v$ 或 $v$ 的父节点中声明的局部变量，其他则不可访问。

3. 自然任务的定义

自然任务有以下两种情况：
1. 由定义 3 中的规则 1 - 4 构建的任务。
2. 可能被窃取的任务：从分叉树的节点 $w$ 开始，到对应合并树的相应节点结束，并包含所有中间计算的任务 $\tau_w$。

4. 工作窃取细节

在分叉节点，总是将右子任务放在任务队列的底部，使其可被窃取。这确保在 BP 计算中，任务内核 $\tau_K$ 始终包含 $\tau$ 中连续的叶子部分，从而最小化缓存缺失。对于 HBP 计算，类似的要求适用于每个有序的并行递归任务集合。窃取操作在任务队列（双端队列）的顶部进行。

5. 缓存缺失的界定

• 数据局部性的定义 ：为了帮助界定非恒定大小块的缓存缺失成本，定义了数据局部性的概念。如果 $r$ 个数据字包含在 $O(\frac{r}{B} + f(r))$ 个块中，则称这些数据为 $f$ - 缓存友好。本文考虑的算法中任务 $\tau$ 访问的数据要么是 $O(1)$ - 友好，要么是 $O(\sqrt{|\tau|})$ - 友好。同时，将分析限制在行为良好的函数 $f$（正则 $f$），即非递减的多项式有界函数。
• 深度 - n 矩阵乘法的缓存缺失分析 ：在最终递归调用中，可能会窃取叶子节点任务 $\tau_v$。如果执行 $\tau_v$ 的处理器 $P’$ 篡夺了剩余的计算，$P’$ 将在向上遍历树的路径上进行处理，可能会执行 $\log n$ 个节点。这些节点需要同步并可能终止递归调用，这需要访问父任务 $\tau$ 的执行栈 $E_{\tau}$ 上存储的变量，从而导致 $\Theta(\frac{\log n}{B})$ 次缓存缺失。一般来说，执行 $x \geq \log n$ 工作的任务可能会产生 $\Theta(\frac{x}{B\sqrt{M}} + \frac{\log n}{B})$ 次缓存缺失。

6. 我们的方法

我们的方法确定给定大小的自然任务的最坏情况数量的边界，并表明给定算法的缓存缺失成本由 $\Theta(S)$ 加上 $O(S)$ 个不相交自然任务的成本界定。对于大小为 $2M$ 或更大的任务 $\tau$，即使没有窃取，也会产生相同的缓存缺失成本（常数因子除外），除了一个 $O(f|\tau|)$ 项。对于较小的任务，产生的成本是任务大小的函数，结合给定大小任务数量的边界，可得出缓存缺失成本与窃取任务数量的函数关系。具体来说，我们分三部分证明边界：
1. 假设没有篡夺的边界。
2. 篡夺后向上遍历的成本边界。
3. 篡夺后重新访问数据的成本边界（除了 2 中的成本）。

对于 BP 计算，第 3 部分不会出现，第 1 部分由引理 2 处理，第 2 部分由引理 3 处理。对于 HBP 计算，论证更复杂。

以下是一个简单的流程图，展示工作窃取的基本流程：

graph TD;
    A[分叉节点] --> B[右子任务放入队列底部];
    B --> C{是否有窃取};
    C -- 是 --> D[顶部窃取任务];
    C -- 否 --> E[继续正常执行];

7. BP 计算的分析

• 相关定义
  • 用 $C(\tau)$ 表示从空缓存开始顺序执行 $\tau$ 的最坏情况缓存缺失成本。
  • $T_w$ 表示以节点 $w$ 为根的向下遍历树的子树。
  • 如果节点 $w$ 的右子节点未被窃取，则称 $w$ 为无窃取节点；如果 $T_x$ 的所有节点都是无窃取节点，则称 $T_x$ 为无窃取树。
  • 如果在每次窃取结束的合并处，当前执行任务内核 $\tau_K$ 的处理器 $C$ 继续执行 $\tau_K$，则称 $\tau_K$ 的执行是无篡夺的。
• 引理 2 ：设 $\tau_K$ 是任务内核，缓存友好函数 $f$ 是正则的。假设 $\tau$ 在形成 $\tau_K$ 时发生 $S \geq 1$ 次窃取，且 $\tau_K$ 的执行是无篡夺的，那么存在一个完全包含在 $\tau_K$ 中的自然任务 $\tau_u$，使得从空缓存开始执行 $\tau_K$ 会产生 $O(S + C(\tau_u))$ 次缓存缺失。
• 引理 3 ：设 $\tau_K$ 是任务内核，缓存友好函数 $f$ 是正则的。假设 $\tau$ 在形成 $\tau_K$ 时发生 $S \geq 1$ 次窃取，那么存在一个完全包含在 $\tau_K$ 中的自然任务 $\tau_u$，使得从空栈开始执行 $\tau_K$ 会产生 $O(C(\tau_u) + S)$ 次缓存缺失。
• 定理 2 ：设 $A$ 是 BP 算法，其缓存友好函数 $f$ 是正则的。考虑 $A$ 的一次执行，发生 $S \geq 1$ 次窃取，那么存在一个由 $s = S + 1$ 个不相交自然任务组成的集合 $C = {\nu_1, \nu_2, \cdots, \nu_s}$，使得 $A$ 的执行最多产生 $O(S + \sum_{i} C(\nu_i))$ 次缓存缺失。

以下是一个表格总结 BP 计算分析中的重要概念：
| 概念 | 定义 |
| ---- | ---- |
| $C(\tau)$ | 从空缓存开始顺序执行 $\tau$ 的最坏情况缓存缺失成本 |
| $T_w$ | 以节点 $w$ 为根的向下遍历树的子树 |
| 无窃取节点 | 右子节点未被窃取的节点 |
| 无窃取树 | 所有节点都是无窃取节点的树 |
| 无篡夺执行 | 在每次窃取结束的合并处，当前执行任务内核 $\tau_K$ 的处理器 $C$ 继续执行 $\tau_K$ |

8. HBP 算法的扩展

上述对 BP 计算的分析可以扩展到类型 $t \geq 1$ 的 HBP 算法，从而得到定理 1。其证明基于为自然 HBP 任务 $\tau$ 展示一个类似于引理 2 的边界，现在这个边界的形式为 $O(s \cdot t \cdot \log B + \sum_{i \in C} C(\nu_i))$，其中 $s$ 是 $\tau$ 发生的窃取次数，$C = O(s \cdot t)$（这里将 $t$ 视为常数）。

证明采用归纳法，构建块是 BP 计算和发生窃取的分叉树。然后按照 HBP 计算的结构，将这些单元分层组合成自然任务。假设 HBP 计算对有序的并行递归任务集合进行了 $c \geq 1$ 次调用，那么每次组合都需要向 $C$ 中添加额外的 $O(c)$ 个任务，要么合并两组窃取，要么增加结果单元的类型，从而得到定理 1 中所述的边界。当计算是线性空间有界时，分析会更精确，将 $s \cdot t \cdot \log B$ 项减少到 $s \cdot t$。

以下是 HBP 算法扩展分析的流程示意：

graph TD;
    A[BP 计算和分叉树] --> B[分层组合成自然任务];
    B --> C{是否有新的调用};
    C -- 是 --> D[添加 O(c) 个任务到 C];
    C -- 否 --> E[得到最终边界];
    D --> E;

9. FFT 算法的分析

对 FFT 算法进行分析，该算法在执行过程中会发生缓存缺失。当 FFT 算法经历 $S$ 次窃取时，会产生 $O(\frac{n}{B} \log_M n + S \cdot B + \frac{n}{B} \frac{\log n}{\log[(n \log n)/S]})$ 次缓存缺失。

证明过程如下：
1. 应用定理 1，每个任务 $\nu_i$ 在执行时比作为算法顺序执行的一部分时多产生 $|\nu_i|/B + f(|ν_i|)$ 次缓存缺失。由于顺序执行产生 $O(\frac{n}{B} \log_M n)$ 次缓存缺失，所以 $\sum_{i} C(\nu_i) = O(\frac{n}{B} \log_M n + \sum_{i} \frac{|\nu_i|}{B} + f(|ν_i|))$。
2. 对于 FFT，$f(r) = O(\sqrt{r})$。如果 $|ν_i| < B^2$，则 $f(|ν_i|) = O(B)$；如果 $|ν_i| \geq B^2$，则 $f(|ν_i|) = O(\frac{|ν_i|}{B})$。因此，$\sum_{i} f(|ν_i|) = O(S \cdot B + \sum_{i} \frac{|\nu_i|}{B})$。
3. 剩下的是界定 $\sum_{\nu_i \in C} \frac{|\nu_i|}{B}$ 项。总大小为 $r$ 或更大的任务的大小为 $O(n \log_r n)$，且有 $\Theta(\frac{n}{r} \log_r n)$ 个这样的任务。选择 $r$ 使得 $S = \Theta(\frac{n}{r} \log_r n)$，则 $r \log r = \Theta(n \log n/S)$，所以 $\log r = \Theta(\log([n \log n/S]))$。因此，$\max_{C} \sum_{\nu_i \in C} \frac{|\nu_i|}{B} = O(\frac{n}{B} \log_r n) = O(\frac{n}{B} \frac{\log n}{\log[(n \log n)/S]})$。

对于 $n \geq p \log \log n \cdot (M^{\epsilon} + B^2 \log M)$（对于任何固定的 $\epsilon > 0$），FFT 算法能实现线性（最优）加速，这改进了之前的边界。

以下是 FFT 算法缓存缺失分析的步骤总结：
1. 应用定理 1 得到 $\sum_{i} C(\nu_i)$ 的初步表达式。
2. 根据 $f(r)$ 的性质化简 $\sum_{i} f(|ν_i|)$。
3. 界定 $\sum_{\nu_i \in C} \frac{|\nu_i|}{B}$ 项。
4. 得出最终的缓存缺失表达式和加速条件。

综上所述，通过对多线程算法中矩阵乘法、FFT 等算法的缓存缺失分析，以及对 HBP 算法的扩展研究，我们可以更好地理解和优化这些算法在多线程环境下的性能，减少缓存缺失带来的性能损失，提高算法的执行效率。