并行算法设计与分析(2)

算法2.4
SIMD-EREW上求元素表序并行算法
引入指针数组next(k)，定义next(k)为k 的下一个元素，若为最后一个元素， 则next(k)=k
Begin
(1) for all k in L do in parallel // O(1)
(1.1) (1.2) P(k)=next(k); // P(k)表示k的后继
• 求森林根并行算法：算法2.5， p69-70, 时间t(n)=O(logn)
8 6 5 3 4 1 2 9 (a) 10 7 13
示例
初始时 P[1]=p[2]=5；p[3]=p[4]=p[5]=6；P[6]=p[7]=8；[8]=8 P[9]=10；p[10]=11；p[11]=12； p[12]=13；p[13]=13 s[i]=p[i]
12 11
第一次迭代后
第二次迭代后
8 6 5 4 1 2 9 (b) 11
13 1 7 12 2 3 10
8 7 9 6 5 4 10
13
3
12 11
(c)
2.3 分治策略
设计思想 将原问题划分成若干个类型相同的子问题分而治之，若子 问题仍然较大，则反复递归应用分治策略处理这些子问题， 直至子问题易求解为止。 2.3.1 （并行）分治策略求解问题步骤 – 将输入划分成若干个规模相等的子问题； – 同时(并行地)递归求解这些子问题； – 并行地归并子问题的解成为原问题的解。 分治策略的重点：如何归并子问题的解。 如果归并的开销太大，那么可以使用流水线方式的级联分 治策略进行归并。
并行算法设计与分析
第2章 并行算法的设计技术
本章主要内容
• • • • • • • 2.1 平衡树方法 2.2 倍增技术 2.3 分治策略 2.4 划分原理 2.5 流水线技术 2.6 加速级联策略 2.7 破对称技术
2.1 平衡树方法
设计思想
将树叶结点作为输入，中间结点作为处理结点，由叶向根 或 由根向叶逐 层并行处理。 并行处理过程相当于由底向上（自顶向下）动态生成一个逻辑平衡二叉树。
// O(1)
// 如果k的后继不等于k的后继之后继 // 距离倍增
(i) distance(k)= distance(k)+ distance(P(k)) (ii) P(k)=P(P(k)) // 指针跳跃 // O(1)
(2.2) for all k in L do on parallel rank(k)=distance(k) End 算法复杂度：t(n)=
c(n)=O(nlogn) ，代价非最优（原因：活跃处理器数目逐层减半）
2.1.2 前缀和的并行计算
前缀和问题定义：n个元素S={x1,x2,…,xn}， S的第i 个前缀和 Si=x1*x2*…*xi, 1≤i≤n， 这里*可以是＋或×。 （递归）前缀和串行算法： Si=Si-1*xi ，i=2~n, S1=x1, 计算时间 为 O(n) 。 前缀和并行算法的设计思想 令A[i]=xi, i=1~n, 引入辅助数组B[h,j]和C[h,j]，h=0~logn, j=1~n/2h B[0,j]保存第j 个前缀和的初始值， j=1~ n。 数组B记录由叶到根逐层正向并行遍历树中各结点的信息(并行 求“前缀子和”)。 数组C记录由根到叶逐层反向并行遍历树中各结点的信息(并行 播送“前缀子和”) 。 C[0,j]保存最终的第j个前缀和， j=1~ n。
n-1
2
-
算法2.7
SIMD-EREW上FFT并行算法
Procedure Para-FFT(x,y) // t(n), W(n) Begin (1) if n=2 then {y0=x0+x1; y1=x0-x1; return} // O(1), W1(n)=1 (2) for l=0 to n/2-1 do in parallel // O(1), W2(n)=2(n/2)=n (2.1) ul=xl + xn/2+l ; (2.2) vl=wl(xl - xn/2+l ); (3) Do in step (3.1), (3.2) in parallel // 并行分治、递归 (3.1) Para-FFT((u0,u1,..un/2-1 ), z(1)=(z0(1), z1(1),…, zn/2-1(1))); // t(n/2), W(n/2) (3.2) Para-FFT((v0,v1,..vn/2-1 ), z(2)=(z0(2), z1(2),…, zn/2-1(2))); // t(n/2), W(n/2) (4) For j=0 to n-1 do in parallel //并行归并；O(1), W3(n)=2n (4.1 ) if j=even then yj= zj/2(1) (4.2 ) if j=odd then yj= z(j-1)/2(2)
2.3.2 SIMD-SM上FFT并行算法
1、串行FFT递归算法
DFT离散傅里叶变换的定义
给定向量 A (a0 , a1,...,an1 )T ，DFT将A变换为 B (b0 , b1,...,bn1 )T，即
n 1
b j ak kj
写成矩阵形式为
k 0
0 j n 1
if P(k) != k then distance(k) =1 else distance(k) =0 // distance(k)为k的距离 // O(logn)
(2) repeat logn 次
(2.1) for all k in L do in parallel
if P(k)!=P(P(k)) then
2.2 倍增技术(指针跳跃技术，pointer jumping)
设计思想 对于规模为n的问题，每当递归（迭代）调用时，将所 要处理数据之间的距离（下标，规模）逐步加倍，经过 k=logn步后，即可完成距离(规模)为2k =n的所有数据的 计算（处理）。 倍增技术特别适合于处理链表或有向树之类的数据结构。 2.2.1 表序问题 设L为n个元素的线性表，求出L中每个元素k在L中的次第 号rank(k) （位序，秩）, rank(k) =L中“小于”k的元素数 目。
a (1) (2)
2 4 4 2 4 4 3 6 5 2 1 3 1 0 0 2 1
b
2
1
c
1
d
2
1Байду номын сангаас
e
1
f
2
1 1
g
0 0
(3)
(4)
2.2.2 求森林的根

问题描述
一组有向树F中, 如果<i, j>是F中的一条弧，则p[i]=j(即j是i的双亲)；若i为根， 则p[i]=i。求每个结点j(j=1~n)的树根s[j].
End
复杂度分析: 步(1)时间：O(1)，步(2)：logn O(1)= O(logn)，步(3)：logn O(1)= O(logn)， t(n)= O(1)+ O(logn) +O(logn)= O(logn) ， p(n)=n/2 , c(n) = n/2 O(logn) =O(nlogn) 代价非最优（原因：活跃处理器数目逐层减半） W(n)=n+(n/21 + n/22 +… + n/2logn)+(n/2logn + … n/21 + n/20)=n+(n-1)+(2n-1)=3n-2=O(n)
这里 e 2i / n ,
i 1
b0 0 0 0 b 0 1 2 1 0 n 1 2 ( n 1) b n 1
a0 a1 ( n 1)( n 1) a n 1
算法2.2 SIMD-SM上非递归并行求前缀和高层描述算法
Begin //高层描述并行算法——不考虑可用处理器的数目 // 自顶向下反向遍历二叉树播送前缀子和 (1)for j=1 to n par-do //初始化 (3) for h=logn to 0 do // h为树层号 B[0,j]=A[j] for j=1 to n/2h par-do //n/2h 为h层结点数 (i) if j=even then // 该结点为其父结点右儿子 end for C[h,j]=C[h+1,j/2] //由叶到根生成高为logn的逻辑二叉树 end if // 正向遍历二叉树求前缀子和 (ii) if j=1 then //该结点为最左结点 C[h,1]=B[h,1] (2)for h=1 to logn do // h为树层号 end if for j=1 to n/2h par-do //n/2h 为h层结点数 (iii) if j=odd>1 then //该结点为其父结点左儿子 B[h,j]=B[h-1,2j-1]*B[h-1,2j] C[h,j]=C[h+1,(j-1)/2]*B[h,j] end if end for end for end for end for
a a
+
0
a 0+a n
2
+
1
a 1+a n
2
+1
. . .
. . . + 1 ω
n a2
DFT(n/2)
. . .
a a
n
2
-1
-1 +a n-1
n
2
a 0-a n
2
an
2
+1
ω (a 1-a n
2
+1 )
. . .
-
. . . ω
n
2
DFT(n/2)
-1 -an-1 )
-1
a
ω2
n
-1(a n
. . .
End.,
算法复杂度：t(n)=O(1)+O(1)+t(n/2)+O(1)=t(n/2)+O(1)=O(logn), p(n)=n/2. C(n)=n/2O(logn)=O(nlogn),代价最优, Sp(n)=O(nlogn)/O(logn)=O(n)，线性加速 W(n)= W1(n)+ W2(n)+ 2W(n/2) + W3(n) =1+ n+ 2W(n/2) +2n= 2W(n/2) +O(n) = 22W(n/22) +2O(n) = 23W(n/23) +3O(n) =O(nlogn)
0 n 1
串行直接计算DFT的算法需要O(nlogn) 时间
2、FFT递归并行算法思想：将20个规模为n的原问题的DFT划分为21个规模 为n/2的子问题的DFT；将21个规模为n/2的子问题DFT划分为22个规模为 n/22的子问题的DFT；依次类推；直到将2logn-1个规模为n/2logn-1=2的子问题 为止直接求解 。
2.1.1 并行求n个元素的最大值
算法2.1 SIMD-SM上求最大值算法 Begin // m=logn——逻辑二叉树的高度
for k=m-1 to 0 do // k为树的层号 for j=2k to 2k+1-1 par-do // k层上2k结点（处理器）并行求最大值 A[j]=max{A[2j], A[2j+1]} end for end for End 复杂度分析：t(n)=m×O(1) =O(m) =O(logn)，p(n)=n/2
// k的位序倍增，第 i 次确定2i个元素的位序，i=0~lgn-1
O(1) +logn( O(1)+O(1))= O(logn), p(n)=n,c(n)=O(nlogn)
并行求线性表中元素位序示例：n=7
(1) (2) (3) (4) p[a]=b, p[b]=c, p[c]=d, p[d]=e, p[e]=f, p[f]=g, p[g]=g r[a]=r[b]=r[c]=r[d]=r[e]=r[f]=1, r[g]=0 p[a]=c, p[b]=d, p[c]=e, p[d]=f, p[e]=p[f]=p[g]=g r[a]=r[b]=r[c]=r[d]=r[e]=2, r[f]=1, r[g]=0 p[a]=e, p[b]=f, p[c]=p[d]=p[e]=p[f]=p[g]=g r[a]=4, r[b]=4, r[c]=4, r[d]=3, r[e]=2, r[f]=1, r[g]=0 p[a]=p[b]=p[c]=p[d]=p[e]=p[f]=p[g]=g r[a]=6, r[b]=5, r[c]=4, r[d]=3, r[e]=2, r[f]=1, r[g]=0