算法导论第 3 版之多线程算法（二）

来源：互联网发布：java syslog发送编辑：程序博客网时间：2024/06/06 20:37

用于学习和交流，欢迎指正。

多线程算法(二）

——算法导论第3版新增第27章

ThomasH. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein

邓辉译

原文：http://software.intel.com/sites/products/documentation/cilk/book_chapter.pdf

本书中的主要算法都是顺序算法，适合于运行在每次只能执行一条指令的单处理器计算机上。在本章中，我们要把算法模型转向并行算法，它们可以运行在能够同时执行多条指令的多处理器计算机中。我们将着重探索优雅的动态多线程算法模型，该模型既有助于算法的设计和分析，同时也易于进行高效的实现。

性能度量

我们可以使用两个度量：“work”和“span”，来衡量多线程算法的理论效率。work指的是在一个处理器上完成全部的计算所需要的总时间。也就是说，work是所有strand执行时间的总和。如果计算dag中每个strand都花费单位时间，那么其work就是dag中顶点的数目。span是在沿dag中任意路径执行strand所花费的最长时间。同样，如果dag中每个strand都花费单位时间，那么其span就等于dag中最长路径（也就是关键路径）上顶点的数目。（在24.2节中讲过，可以在Θ(V+E)时间内找到dag G=(V,E)的一条关键路径）。例如，图27.2中的计算dag共有17个顶点，其中8个在关键路径上，因此，如果每个strand花费单位时间的话，那么其work是17个单位时间，其span为8个单位时间。

多线程计算的实际运行时间不仅依赖于其work和span，还和可用处理器的数目以及调度器向处理器分配strand的策略有关。我们用下标P来表示一个在P个处理器上的多线程计算的运行时间。比如，我们用T_P来表示算法在P个处理器上的运行时间。work就是在一个处理器上的运行时间，也就是T₁。span就是每个strand具有自己独立处理器时的运行时间（也就是说，如果可用的处理器数目是无限的），用T_∞来表示。

work和span提供了在P个处理器上运行的多线程计算花费时间T_P的下界：

l 在一个单位时间中，具有P个处理器的理想并行计算机最多能够完成P个单位工作，因此在T_P时间内，能够完成最多PT_P数量的工作。由于总的工作为T₁，因此我们有：PT_P ≥ T₁。两边同除以P得到work法则（work law）：

T_P ≥ T₁/P. (27.2)

l 具有P个处理器的理想并行计算机肯定无法快过具有无限数量处理器的机器。换种说法，具有无限数量处理器的机器可以通过仅使用P个处理器的方法来仿真具有P个处理器的机器。因此，得到span法则（spaw law）：

T_P ≥ T_∞. (27.3)

我们用比率T₁/ T_P来定义在P个处理器上一个计算的加速因子（speedup），它表示该计算在P个处理器上比在1个处理器上快多少倍。根据work法则，T_P ≥ T₁/P，意味着T₁/T_P≤P。因此，在P个处理器上的加速因子最多为P。当加速因子和处理器的数目成线性关系时，也就是说，当T₁/T_P=ΘP时，该计算具有线性加速的性质，当T₁/T_P=P时，称其为完全的线性加速。

我们把work和span的比率T₁/T_∞定义为多线程计算的parallelism（并行度）。可以从三个角度来理解parallelism。作为一个比率，parallelism表示了对于关键路径上的每一步，能够并行执行的平均工作量。作为一个上限，parallelism给出了在具有任何数量处理器的机器上，能达到的最大可能加速。最后，也是最重要的，在达成完全线性加速的可能性上，parallelism提供了一个在限制。具体地说，就是一旦处理器的数目超过了parallelism，那么计算就不可能达成完全线性加速。为了说明最后一点，我们假设P > T₁/T_∞，根据span法则，加速因子满足T₁/T_P≤T₁/T_∞<P。此外，如果理想并行计算机的处理器数目P大大超过了parallelism（也就是说，如果P >> T₁/T_∞），那么T₁/T_P<<P，这样，加速因子就远小于处理器的数目。换句话说，处理器的数目超过parallelism越多，就越无法达成完全加速。

例如，我们来看看图27.2中P-FIB(4)的计算过程，并假设每个strand花费单位时间。由于work T₁=17，span T_∞=8，因此parallelism T₁/T_∞=17/8=2.125。从而，无论我们用多少处理器来执行该计算，都无法获得2倍以上的加速因子。不过，对于更大一些的输入来说，P-FIB(n)会呈现出更大的parallelism。

我们把在一台具有P个处理器的理想并行计算机上执行多线程算法的并行slackness（闲置因子）定义为：(T₁/T_∞)/P = T₁/(PT_∞)，也就是计算的parallelism超过机器处理器数目的倍数因子。因此，如果slackness小于1，那么就不能达成完全的线性加速，因为T₁/(PT_∞)<1，根据span法则，在P个处理器上的加速因子满足T₁/T_P≤T₁/T_∞<P。事实上，随着slackness从1降低到0，计算的加速因子就越来越远离完全线性加速。如果slackness大于1，那么单个处理器上工作量就成为限制约束。我们将看到，随着slackness从1开始增加，一个好的调度器可以越来越接近于完全线性加速。

调度

好的性能并不仅仅来自于对work和span的最小化，还必须能够高效地把strands调度到并行计算机的处理器上。我们的多线程编程模型中没有提供指定哪些strands运行在哪些处理器上的方法。而是依赖于并发平台的调度器来把动态展开的计算映射到单独的处理器上。事实上，调度器只把strands映射到静态线程，由操作系统来把线程调度到处理器上，不过这个额外的间接层次并不是理解调度原理所必需的。我们可以就认为是由并发平台的调度器直接把strands映射到处理器的。

多线程调度器必须能够在事先不知道strands何时被spawn以及何时完成的情况下进行计算的调度——它必须在线（on-line）操作。此外，一个好的调度器是以分散的（distributed）形式运转的，其中实现调度器的线程互相协作以均衡计算负载。好的在线、分散式调度器确实存在，不过对它们进行分析是非常困难的。

因此，为了简化分析工作，我们将研究一个在线、集中式（centralized）调度器，在任意时刻，它都知道计算的全局状态。我们将特别分析贪婪式调度器，它们会在每个执行步骤中把尽可能多的strands分配给处理器。如果在一个执行步骤中有至少P个strands可以执行，那么就称这个步骤为完全步骤，贪婪调度器会把就绪strands中的任意P个分配给处理器。否则，如果就绪的strands少于P个，则称这个步骤为不完全步骤，调度器会把每个strand分配给独立的处理器。

根据work法则，在P个处理器上可以达到的最快运行时间为T_P= T₁/P，根据span法则，最好的情况是T_P=T_∞。下面的定理表明，因为贪婪式调度器可以以这两个下界之和为其上界，所以其可被证明是一个好的调度器。

定理27.1

在一台具有P个处理器的理想并行计算机上，对于一个wrok为T₁，span为T_∞的多线程计算，贪婪调度器执行该计算的时间为：

T_P≤T₁/P + T_∞. (27.4)

证明：首先来考虑完全步骤。在每个完全步骤中，P个处理器完成的工作总量为P。我们采用反证法，假设完全步骤的数目严格大于└T₁/P┘，那么完全步骤所完成的工作总量至少为：

P*(└T₁/P┘+1) = P└T₁/P┘ +Ｐ

　　　　　　　 =　 T₁－（T₁mod P）+ P (根据等式3.8得出)

> T₁(根据不等式3.9得出)。

因此，P个处理器所完成的工作比所需要的还多，矛盾，所以完全步骤的数目最多为└T₁/P┘。

现在，考虑一个不完全步骤。我们用G来表示整个计算的dag，不失一般性，假设每个strand都花费单位时间。（我们可以把超过单位时间的strand用一串单位时间strand来替代）。令G’为在该不完全步骤开始时G已经执行的部分构成的子图，令G”为在该不完全步骤完成后G中还没有执行的部分构成的子图。dag中最长的路径一定起始于入度（in-degree）为0的顶点。由于贪婪调度器中的一个不完全步骤会把G’中所有入度为0的strands全部执行，因此G”的最长路径长度一定不G’中的最长路径小1。换句话说，一个不完全步骤会把还没有执行的dag的span减1。所以，非完全步骤的数目最多为T_∞。

由于每个步骤要么是完全的，要么是不完全的，因此定理得证。

下面是定理27.1的推论，说明了贪婪式调度器总是具有好的调度性能。

推论27.2

在一台具有P个处理器的理想并行计算机上，任何由贪婪式调度器调度的多线程计算的运行时间T_P，不会超过最优时间的2倍。

证明：令T_P^*为在具有P个处理器的机器上，一个最优调度器产生的运行时间，令T₁和T_∞为该计算的work和span。根据work法则和span法则（不等式27.2和27.3），得出：

T_P^*≥max(T₁/P, T_∞)，根据定理27.1，有：

T_P≤ T₁/P + T_∞

≤ 2*max(T₁/P, T_∞)

≤ 2* T_P^*

下一个推论告诉我们，对于任何多线程计算来所，随着slackness的增长，贪婪式调度器都可以达到接近完全的线性加速。

推论27.3

令T_P为在一台具有P个处理器的理想并行计算机上，贪婪式调度器调度一个多线程计算的运行时间，令T₁和T_∞为该计算的work和span。那么如果P << T₁/T_∞，就有T_P≈T₁/P（或者相等），也就是具有大约为P的加速因子。

证明：假设P<< T₁/T_∞，那么就有T_∞<< T₁/P，因此根据定理27.1，有T_P≤T₁/P + T_∞。根据work法则（27.2）得到T_P≥T₁/P，因此得出T_P≈T₁/P（或者相等），加速因子为：T₁/T_P≈P。

符号<<表示“远小于”，但是“远小于”意味着多少呢？作为经验之谈，当slackness至少为10时（也就是说，parallelism是处理器数目的10倍），通常就足以得到很高的加速因子。贪婪调度器的上界不等式（27.4）中的span项小于单处理器work项的10%，这对于绝大多数实际应用情况而言已经足够好了。例如，如果一个计算仅在10个或者1000个处理器上运行，那么去说1,000,000的parallelism比10,000更好是没有意义的，即使它们之间有100倍的差异。正如问题27-2所表明的那样，有时通过降低计算的最大并行度，所得到的算法要好于关注其他问题所得到算法，并且还能在相当数目的处理器上伸缩良好。

多线程算法分析

现在，我们已经拥有了分析多线程算法的所有工具，并且对于在不同数目处理器上的运行时间也有了个不错的边界。对于work的分析相对简单，因为只不过就是分析一个普通的串行算法的运行时间（也就是多线程算法的串行化版本），对此，我们早已熟悉，这正是本书大部分内容所讲的东西！对span的分析会更有趣一些，一旦掌握了其中的诀窍，通常也不难。我们将以P-FIB程序为例来研究一些基本概念。

分析P-FIB(n)的work T₁(n)没什么难度，因为我们已经做过了。原始的FIB过程就是P-FIB的串行化版本，因此T₁(n)=T(n)= Θ(Φⁿ)（基于等式27.1）。

图27.3中展示了如何去分析span。如果两个子计算被串行合并在一起，那么其组合的span等于二者span之和，如果它们被并行合并在一起，那么其组合的span等于二者span中较大的那一个。对于P-FIB(n)来说，第3行中spawn的P-FIB(n-1)和第4行中spawn的P-FIB(n-2)并行运行。因此，我们可以把P-FIB(n)的span表示为如下递归式：

T_∞ (n) = max(T_∞(n-1), T_∞ (n-2)) +Θ(1)

= T_∞(n-1) +Θ(1),

结果为：T_∞(n) = Θ(n)。

P-FIB(n)的parallelism为T₁ (n)/ T_∞ (n) =Θ(Φⁿ/n)，其随着n增长的速度极快。因此，对P-FIB(n)来说，即使在最大的并行计算机上，一个中等大小的n值就足以获得接近完全的线性加速，因为该过程具有相当大的并行slackness。

并行循环

有许多算法，其包含的循环中的所有迭代都可以并行执行。我们将看到，可以实用spawn和sync关键字来并行化这种循环，不过如果能够直接指明这种循环的迭代可以并发执行的话，会更加方便一些。我们通过使用parallel并发关键字来在伪码中提供该功能，它位于for循环语句的for关键字之前。

我们以一个n×n的矩阵A=（a_ij）乘以一个n元向量x=（x_j）为例进行说明。相乘的结果为一个n元向量y=（y_i），如下：

y_i = ∑ⁿ_j=1a_ij x_j，

i=1，2，…,n。我们可以通过并行地计算y的所有项来进行矩阵-向量的乘法操作，如下：

MAT-VEC(A,x)

1 n = A.rows

2 令y为一个新的长度为n的向量

3 parallel for i = 1 to n

4 y_i = 0

5 parallel for i = 1 to n

6 for j = 1 to n

7 y_i = y_i + a_ij x_j

8 return y

在这段代码中，第3行和第5行中的parallel for关键字表示着这两个循环中的迭代都可以并发执行。编译器可以把parallel for循环实现为基于嵌套并行的分治式子例程。例如，第5到7行中的parallel for循环可以被实现为对MAT-VEC-MAIN-LOOP(A,x,y,n,l,n)的调用，子例程MAT-VEC-MAIN-LOOP是编译器生成的辅助子例程，如下：

MAT-VEC-MAIN-LOOP(A, x, y, n, i, i’)

1 if i == i’

2 forj = 1 to n

3 y_i = y_i + a_ij x_j

4 else mid = └(i+i’)/2┘

5 spawn MAT-VEC-MAIN-LOOP(A, x, y, n, i,mid)

6 MAT-VEC-MAIN-LOOP(A, x, y, n, mid+1, i’)

7 sync

该代码递归地spawn循环中的前半部分迭代，使其和后半部分迭代并行执行，然后执行一条sync语句，创建了一棵二叉树式的执行过程，其中叶子为单独的循环迭代，如图27.4所示。

现在来计算对于n×n矩阵，MAT-VEC的work T₁(n)，也就是计算其串行化版本的运行时间，这个串行化版本可以通过把parallel for循环替换成普通的for循环得到。由此，我们得到T₁(n)= Θ(n²)，因为第5到7行的两重嵌套循环所产生的平方级运行时间占支配地位。在这个分析中，我们忽略掉了实现并行循环的递归spawn的开销。事实上，和其串行化版本相比，递归spawn的开销确实增加了并行循环的工作量，不过并不是渐进关系的。原因如下，因为递归过程实例树是一颗满二叉树，所以内部节点的个数正好比叶子的个数少1（见练习B.5-3）。每个内部节点分割迭代范围时所耗费的都是常数时间，并且每个叶子都对应循环中的一个迭代，其至少耗费常数时间（在本例中是Θ(n)）。因此，我们可以把递归spawn的开销分摊到迭代的工作中，对全部工作来说，至多增加了一个常数倍数因此。

在实际实现中，动态多线程并发平台时常会在一个叶子中执行多个迭代，从而使得递归产生的叶子的粒度变粗，这个过程可以是自动地，也可以由程序员来控制，因此减少了递归spawn的开销。付出的代价是降低了并行度，不过，如果计算具有局够大的并行slackness，那么还是可以达成接近完全的线性加速的。

在分析并行循环的span时，也必须得考虑到递归spawn的开销。由于递归调用的深度和迭代的次数成对数关系，因此对于一个具有n次迭代，其第i个迭代的span为iter_∞ (i)的并行循环来说，其span为：

T_∞(n)= Θ(lgn)+ max₁_≤i≤niter_∞ (i)。

例如，对于以一个n×n矩阵为参数的MAT-VEC来说，第3、4行中的并行初始化循环的span为Θ(lgn)，因为和每个迭代中的常数工作时间相比，递归spawn占支配地位。第5到7行中的双重嵌套循环的span为Θ(n)，因为外层parallel for循环的每个迭代都包含着内层（串行）for循环的n个迭代。伪码中剩余部分的span为常数，因此整个过程的span由双重嵌套循环支配，也就是Θ(n)。由于过程的work为Θ(n²)，所以parallelism为Θ(n²)/ Θ(n) =Θ(n)。（练习27.1-6会让读者提供一个具有更高并行度的实现）。

算法导论第 3 版之多线程算法（二）

性能度量

调度

多线程算法分析

并行循环

条件竞争（待续）