Lecture 15 | External Sorting¶

外排序与数据库系统中的相关内容有交叉关系，当需要排序的数据过大，而无法被完全放在内存时，普通的排序算法无法被应用。此时需要使用外排序，简单来说就是在更大的尺度上进行类似归并的操作。

而正因为此，外部排序的过程与硬件设计有一定关系。

概述¶

外排序的基本思路就是将数据分为若干个小块，然后对每个小块进行排序，最后再将这些小块合并起来。而我们常说的归并排序，指的是递归地将两块合成一块，而所谓的 \(k\) 路（\(k\)-way）归并，就是将 \(k\) 块合成一块。

那么如何归并呢？我将从两个维度来简单阐述。

逻辑维度¶

外部排序所使用的归并排序从逻辑上来讲和普通的归并排序一致，总是将 \(k\) 个有序序列合并为 1 个有序序列。

而这里的“有序序列”，在外排序中被称为“run”，即每次归并我们另 \(k\) 个 run 变成一个 run。正着说就是：

从执行的顺序来说，内排序中的归并排序是一个自上而下不断 \(\frac{1}{k}\) 地划分，再自下而上不断归并的过程。相反，外排序由于其特性限制，其“归并段”并不是自上而下 \(\frac{1}{k}\) 划分出来的，而是根据硬件处理能力，直接划分好最小的归并段，然后直接自下而上归并。

而这样一个将 \(k \cdot c\) 个 run merge 成 \(c\) 个 run 的过程，我们称之为一个 pass。（在归并树上体现为一层。）

物理维度¶

关于物理维度，涉及到一些硬件知识，在 ADS 中为了方便说明会将其简化，有关 block 的概念将被抽象化为“数据单位”。

我们知道，内存的大小是有限的，划分给归并数据的内存也应当是有限的，我们用 \(M\) 来记它，即内存中一次只能处理 \(M\) 个单位的数据。

更细节的，我们应当更具物理大小来计算 \(M\)，例如一条数据的大小是 \(l \text{Bytes}\)，而内存的大小是 \(m \text{Bytes}\)，那么一个内存能够容纳的数据数量应当为 \(\lfloor \frac{m}{l} \rfloor\)。

但是既然要归并，我们就需要将 \(k\) 路的数据读入到内存中，最理想的情况下我们肯定希望这 \(k\) 路都能读入到内存中，但是显然这是不切实际的，我们最多公平地读入每一路的前 \(\lfloor \frac{M}{k} \rfloor\) 个数据——但这已经足够——对于 \(k\) 个有序序列的合并操作，其合并过程中也恰好只与最靠前的、未排序的一部分数据有关。

而这个过程也正是外排序能够进行的一个重要基础。

其中比较特别的步骤就是，最开始的排序，即第一个 pass。先前我们在#逻辑维度里提到了，外排序的第一个 pass 会直接划分好最小的归并段，而这个“最小归并段”的大小就是 \(M\)。用语言描述，就是最早的 run 的大小就是平均每一路能够在内存中处理的最大数据单位量。

然而问题出现了，根据我之前给出的定义，run 应当是有序的，但是从原始数据里读出来的“最小归并段”是无序的。但是对于最初的 run，它必然能够整段放到内存里（更进一步的，也只有最初的 run 能够完整地放到内存里），因此直接对其进行内排序即可。

具体分析¶

ADS 中相比上面介绍的部分，又引入了一个叫 tape 的概念，tape 的中文是磁带，而在这个框架中，我更倾向于把它当作一个抽象的概念。

相对应的，其实际过程与上面描述的方法可能有一些感受上的差别，如果只是了解思想的话上半部分已经足够（当然后面还有一些基于如下模型的优化讨论），但是毕竟还是面向考试，所以还是需要以 ADS 课件的方法再介绍一次。

朴素过程分析¶

我们以 2-way merge 为例，结合 ADS 课件中的配图来说明。

准备

图中 \(T_1\) 是一条 tape 的编号，我们可以理解为一个序列的物理地址，或更通俗的来说，可以当作一个数组，只不过它的实际数据是在硬盘中。换句话来说，这里的 tape 表示的都是硬盘中的数据。

这条 tape 中有 13 个元素，我们记其为 \(N = 13\)。而这条原始的 tape 被划分为了 5 段，每一段都有不超过 3 个元素，此时 \(M = 3\)。即有 \(\lceil \frac{N}{M} \rceil = 5\)。

Pass 1

现在我们要开始 merge 了。对于这段数据来说，这是意义重大的“人生第一次”，相比于其他归并都是从 2 个 tape 开始的 pass，这一次显得有些特殊。

在第一轮中，面对全部都是无序的数据，我们将这 \(\lceil \frac{N}{M} \rceil = 5\) 个段均分到两条 tape 上（2-way），这里经历两个步骤：

1. 依次读取 \(T_1\) 中每一段数据（刚好占满内存），并对它们进行内排序；
2. 将排序完的段，追加写到 \(T_2\) 或 \(T_3\) 中（具体每一个 tape 写几条，会有专门策略做调整，目前先平分着放）；

于是，\(T_1\) 中的数据便被转移到了 \(T_2\) 和 \(T_3\)。为了重复利用 tape，此时的 \(T_1\) 被看作可以用的空磁盘了。

于是，完成了第一个 pass。

Pass 2

之后的 pass 则基本遵循同样的规则，不断取每一路的第一个 run 并 merge，并且将结果写到两个（k 个）闲置的 tape 上（和前面说过的一样，这里暂且将分配策略定为平分到每一个 tape 上）。

例如，我们要取 \(T_2\) 和 \(T_3\) 的第一段，执行归并操作，得到一个新的，有 6 个数据的 run，并写到闲置的 \(T_1\) 上；接下来取 \(T_2\) 和 \(T_3\) 的第二段，归并得到新的 run，此时我们发现，\(T_1\)、\(T_2\)、\(T_3\) 都不是闲置的，所以我们需要一个新的 tape，写到 \(T_4\) 上。

于是，完成了第二个 pass。

Pass 3

pass 3 和 pass 2 的过程基本一致。现在的 tape 状态是 \(\{T_2, T_3\}\) 闲置，我们取 \(T_1\) 和 \(T_4\) 的第一段，得到一个新的 run，包含 12 个元素；取 \(T_1\) 和 \(T_4\) 的第二段，得到一个新的 run，包含 1 个元素。这两段被分配到两条空闲 tape 上，即 \(T_2\) 和 \(T_3\)。

于是，完成了第三个 pass。

Pass 4

同样，pass 4 和前面两个 pass 的过程也是一致性的，不做过多解释，对于规模更大的数据也是一样，除了第一个 pass 比较特殊，其它 pass 都是一样的。最终得到只剩下一个 tape 中包含唯一的 run 时，排序就结束了。

至此，排序结束。

优化空间¶

可以优化的部分主要有这么几个：

• 一个 pass 意味着若干次 seek，所以减少 pass 可以是一个方向；
  • #pass-数量分析与优化
• merge 的过程中会多次读取 tape 中的数据，而对于计算机来说单次大量读取比多次小量读取更高效，如何优化数据读取也是一个方向；
  • #tape-数量分析与优化
• 如何更高效的在 \(k\)-way merge 过程中，归并 M 个分别来自 k 个序列的数据，即内排序的策略，也上优化的一个方向；
  • #k-路内排序优化
• 读入、内排序、输出，这三个事务目前是停机串行的，考虑将其并行化也是一个方向；
  • TODO

pass 数量分析与优化¶

例子中一共经过了 4 次 pass。如果我们记 \(max(\#run)\) 为 \(\#run\) 最多的 tape 的 \(\#run\)，则每一次 pass 会令 \(max(\#run)\) 缩小一半，直到 \(max(\#run)\) 变为 1，且只有它一条 tape 还有数据，标志着排序结束。

如果专注于 \(\#run\) 的变化，那么上面的模拟步骤大致是这么一个过程：

模拟到从这里其实已经可以看出来了，对于 2-way merge 来说，排除末段情况，从第二个 pass 开始，基本上每次都是从 2 路中各取 1 个 run，并合并为 1 个 run。换句话来说，每一个 pass 会让 \(total(\#run)\) 缩小为原来的 \(\frac{1}{2}\)。

那么，对于 \(k\)-way merge 来说，就是从第二个 pass 开始，每次从 \(k\) 路中各取 1 个 run，并合并为 1 个 run，每一个 pass 会让 \(total(\#run)\) 缩小为原来的 \(\frac{1}{k}\)。

因此，我们可以归纳得到如下计算式：

其中，\(k\) 表示归并路数，\(N\) 表示数据量，\(M\) 表示内存一次能处理的数据量。

那么，减少 pass 的方法也很直观了，只需要增加 \(k\) 即可，即采取更多路的归并，就能减少 pass。

然而，其中必然存在一个 trade-off 的关系，虽然 \(k\) 增加可以减少 \(\#pass\)，但是在接下来一节中我们会知道，\(k\) 过大会导致 tape 需求量增加，此外，\(k\) 的增加也会导致内排序的复杂度增加，也会增加 pass 内的 seek 次数。

当然，除了暴力的增加 \(k\) 以外，我们还可以通过使用替换选择(Replacement Selection)算法，来生成比 \(M\) 大的初始 run，以相对减少 pass 数量。

替换选择算法¶

替换选择(Replacement Selection) 在 hw15 中被布置为编程题，所以其实现过程可以结合那道题目来学习。

利用替换选择策略以后，每一次生成的 run 一定不小于 \(M\)（末端余数除外），于是相对来说 \(\#pass\) 就会减少。

tape 数量分析与优化¶

如果使用#朴素过程分析中的方法，那么我们使用 \(k\)-way merge 至少需要 \(2k\) 个 tape。

这其实很好理解，我们每一个 pass 需要 \(k\) 个 tape 来存放每一路的序列，而其结果要平分放复制到下一个 pass 所需要的 \(k\) 个 pass 中，所以至少需要 \(2k\) 个 tape 轮换着来存储数据。

而这不利于我们通过增加 \(k\) 来减少 \(\#pass\)，因此我们考虑某种策略来优化 tape 的使用。

在#朴素过程分析中我多次暗示，之后会对「将归并后的 run 平分到各 tape」这件事做优化。

我们可以考虑，不平均的将归并后的 run 分配到各个 tape 上，即总有一些 tape 比别的 tape 多一些 run。虽然在平分的策略中，也有可能会有多出来的 run，但是只会多一个（也就是将 \(x \mod k\) 的余数分配到其中几个 tape 上）。此时这些多出来的 run 可能就是单纯的从一个 tape 别复制到另外一个 tape 上，看起来是个非常没必要的操作，为什么不直接留下它，将当前 tape 拿到下一轮用呢？

但是由于平分策略下，这个情况的出现并不可控，而且总是会引起悬殊的 tape 间的数量差，所以我们考虑能不能主动利用这个性质。

实在想不到怎么过度了，而且急急急，所以直接上结论。

我们按照 Fibonacci 数列的项来分配每个 tape 的 \(\#run\)，此时每一个 pass 只需要一个有一个空闲的 tape 即可。

使用 Fibonacci 我们总可以滚动着将 \(\#run\) 的规模缩小。

当然，刚好能凑上 Fibonacci 的情况自然是少数，对于无法凑上 Fibonacci 的情况，我们可以将多余的部分均匀的分到较多若干 tape 上，以相对的利用 Fibonacci 数列的性质（联系思考题理解）。

k 路内排序优化¶

随着 \(k\) 的增加，我们不能再像两路归并那样直接输出较小的那个，而是需要维护数据结构来总是输出 k 个中最小的那个——我们用堆来维护每一个 run 在内存中的数据的队首元素（同时也是最小元素），每当堆顶元素被输出，就需要从对应的 run 中读入下一个元素。

霍夫曼树优化¶

当然，我们也可以不使用直接 \(k\) 路合并，而是采用两两归并的方法，也就是 wiki 中提到的迭代归并（注意，该条目中提到的归并并没有说明是外排序背景，但是可以迁移）。

假设我们现在有若干个 run，并且我们将要进行两两归并，那么我们可以根据每一个 run 的大小，根据霍夫曼树的规律来进行归并，即总是选最小的两个进行归并。

并行优化¶

这里并行的目标主要是使算法支持数据的读-用-写的流水线，也就是说我们要想办法让读不阻塞用，用不阻塞写。

先前我们需要先读入数据，然后进行排序，排序完了再写入磁盘，腾出内存空间以供下一次读入。那为什么会阻塞呢？因为我们没法读一个正在写的数据块，所以我们只需要在不同的数据块读和写就行了。对于 \(k\)-way 中的每一路，我们都提供两个 input buffer，一个用于写，一个用于排序。当排序 buffer 空了的时候，就和读满了的 input buffer 交换，无缝衔接继续输出。于此同时，刚刚被交换过去的 buffer 则可用于继续读入。

因此，如果我们执行 direct \(k\)-way merge，就需要 \(2k\) 个 input buffer（这里强调 direct 是因为，如果使用 iterative 的话，input buffer 只需要 4 个）。

而对于输出，我们只需要 2 个 output buffer 交替使用即可，一个用来接收来自排序算法的输出，一个用来将数据写入磁盘。

但是，并行优化的缺点就是占据了更多的内存空间——原先 \(k + 1\) 个 buffer 平分的用于处理数据的内存，现在需要被 \(2k + 2\) 个 buffer 平分，所以每一个 buffer 的大小会变小。进而导致每一次从 disk 中读取的数据变少，所以要读完数据所需要的读取次数就增加，即 seek 次数增加。

激励

评论