94 MIMD共享存储模型的并行算法.docx
《94 MIMD共享存储模型的并行算法.docx》由会员分享，可在线阅读，更多相关《94 MIMD共享存储模型的并行算法.docx（31页珍藏版）》请在冰豆网上搜索。
94MIMD共享存储模型的并行算法
9.4MIMD共享存储模型的并行算法
（一）异步枚举排序算法
枚举排序（EnumerationSort）是一种最简单的排序算法，通常也称为秩排序（RankSort）。
对于基于枚举比较原理的异步排序算法，为了排序n个数的序列S=（x1,x2,…,xn），算法要生成n个进程。
进程i（1≤i≤n）将xi与S中其余元素进行比较，并且使用局部变量k及下所有小于xi的元素的数目。
当所有的比较都完成时，就将xi置入排序序列中的k+1的位置上，因此每个进程都可能彼此独立地执行，而无通信的要求。
令X是存在共享存储器中长度为n的数组，开始时放入被排序的序列，当算法结束时，结果置于共享存储器中的T数组内，变量i,j,k是算法生成的每个进程的局部变量[1007]。
该并行算法的描述如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
算法9.4.1MIMD-CREW模型上的异步枚举排序算法
输入：
S=（x1,x2,…,xn）置于共享存储器的X数组中
输出：
已排序的序列置于共享存储器的T数组中
ENUERSORT
{
for（i=1;i<=n;i++）
{
CreateProcessi;
}
Processi:
k=0;
for（j=1;j<=n;j++）
{
if（X（i）>X（j））
{
kk+1;
}
elseif（（X（i）==X（j）&&i>j））
{
kk+1;
}
}
T（k+1）=X（i）;
}
在该并行算法中有，由于每个处理器至多确定数组X中的
个元素的位置，而每确定一个元素的位置需O（n）时间，因此对X进行排序需
×O（n）时间。
例9_8设S=（8,6,6,9,7），p（n）=2。
创建进程的过程中，假定由P1生成5个进程，此后所有的进程均等待开始。
假定使用“先进先出”的调度策略。
进程1和2分别由P1和P2执行，它们同时计算元素8和6的次第，然后将其分别置于T数组的相应位置上，如图9_19（a）所示。
欲知下一进程有哪一个处理器启动执行，需研究进程1和2的执行时间。
假定比较操作和赋值操作大致用相同的时间，当执行X（i）>X（j）,X（i）=X（j）和i>j以及k=0,k=k+1和T（k+1）=X（i）时，进程1和2分别需要14和17各时间步，如图9_19（b）所示。
所以进程3应由P1启动执行，之后3个时间步P2启动执行进程4。
这两个进程负责将元素6和9分别置于数组T的相应位置上，此时进程3需要18个时间步，进程4需要13个时间步，所以进程4比进程3早结束。
下一进程5由P2启动。
之后当进程3执行完后，因无等待的进程，所以P1变为空闲。
当进程5执行15个时间步后，元素7便放到数组T的相应位置上。
算法总共需要45个时间步。
（a）数组T的变化过程
（b）进度调度
图9_19异步枚举排序数组变化及进程调度
（二）单源点最短路径并行算法
假设一有向图各边赋于非负整数，某条路径的长度就是沿该路径所有边权之和。
最短路径问题，就是对每一点对i和j，丘照期间任何最短长度的路径。
单源点最短路径，即在一个图中寻找从一个指定顶点到所有其他定点的最短路径。
（a）单处理机上的Moore算法。
在Moore算法中，设源点为s∈V。
从s到其他各顶点的最短路径长度用一维数组dist存储。
首先置dist（s）=0,dist（v）=∞，其中v≠s，且v∈V。
算法使用了一个队列queue。
开始执行时队列中仅含有源点s；以后每次只要队列非空，就将排头顶点u从队列中移去，令其作为本次搜索的顶点，然后检查u的所有射出边（u,v）∈E：
若dist（u）+w（u,v）如此重复进行，直到整个待搜索队列空时，算法就终止。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
算法9.4.2_1SISD机器上的单源点最短路径算法
输入：
有向加权图G（V,E）的权矩阵
输出：
从源s到其余顶点i（i≠s）的最短路径dist（i）,i∈V
SISDSHORTESTPATH
{
（1）for（i=1;i<=n;i++）/*初始化*/
{
INITIALIZE（i）;
}
（2）将s插入队列queue中;
（3）while（队列非空）{SEARCH;}
}
StatusSEARCH
{
（3.1）dequeuevertexu;/*从队列中删去顶点u*/
（3.2）for（eachedge（u,v）∈E）
{
new_distdist（u）+w（u,v）;
if（new_dist{
dist（v）new_dist;
}
if（visnotinthequeue）
{
enqueuevertexv;
}
}
}
StatusINITIALIZE
{
（1.1）dist（s）0;
（1.2）dist（v）∞;（v≠s,v∈V）
（1.3）queue0;
}
（b）Moore算法的并行化
Deo等人基于MIMD紧耦合共享存储模型实现了Moore算法的并行化。
直观上讲，算法9.4.2_1有两处可并行化的地方：
一是SEARCH的第（3.2）步；二是主算法的第（3）步。
前者，任何一个顶点均可能有多条射出边，它们都可并行地被检查；后者，在任何时候都可能有多个顶点在队列中，因此有可能每次检查多个顶点的射出边。
由于后者可产生较大的加速，而且当G是个稀疏图时，并行度受定点射出变得影响，所以选用后者。
首先，队列用源点初始化。
然后创建了许多异步进程，每个进程都从队列中删除一个顶点，检查其射出边，将已发现有更短路径的顶点加入到队列。
算法的第
（1）步采用预调度方法很容易并行化。
而第（3）步的while循环需作适当的修改，以能反映并执行SEARCH过程时一些异步进程的存在。
显然，当一个进程发现队列为空时，就停止执行是不合适的。
因而必须采用两个变量联合使用的办法，以决定什么时候无工作可做：
第一个是数组变量waiting，它记住哪一个进程正处于等待状态；第二个是布尔变量halt，仅当队列为空和所有进程处于等待状态时为真。
INITIALIZE过程置数组waiting中的第一个元素为假。
SEARCH过程也必须作适当的修改。
因为队列的插入、删除操作不是原子操作，所以执行上述操作时必须给队列上锁：
其次，在一个进程将刚找到的v路径new_dist与当前的最短路径dist（v）比较之前，变量dist（v）也必须上锁，否则两个进程有可能同时修改它；最后，若一个进程发现队列为空时，则置waiting中的相应元素为真。
若进程1处于等待状态，则它要检查每个进程是否都处在等待状态，如果是，则halt置为真，而进程1检查每个进程是否处于等待状态时，队列也必须上锁。
该并行算法的描述如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
算法9.4.2MIMD-SM模型上单源点最短路径算法
输入：
有向加权图G的权矩阵W
输出：
从源s到其余顶点i（i≠s）的最短路径dist（i）,i∈V
MIMDSHORTESTPATH
{
parfor（i=1;i<=p;i++）/*p为进程数*/
{
for（j=i;j<=n;j=j+p）/*初始化*/
{
INITIALIZE（j）;
}
}
enqueues;/*s入队*/
halt=FALSE;
parfor（i=1;i<=p;i++）
{
while（nothalt）
{
SEARCH（i）;
}
}
}
StatusSEARCH（i）
{
lockthequeue;/*队列上锁*/
if（queueisempty）/*队列空时，等待进程为真*/
{
waiting（i）TRUE;
if（i==1）/*进程1等待时，其它进程均须等待*/
{
halt=waiting
（2）∧waiting（3）∧…∧waiting（p）;
}
unlockthequeue;/*队列开锁*/
}
else
{
dequeueu;/*从队列中删除u*/
waiting（i）FALSE;
unlockthequeue;/*队列开锁*/
for（everyedge（u,v）inGraph）/*检查每条射出边*/
{
new_distdist（u）+w（u,v）;
lock（dist（v））/*dist（v）上锁*/
if（new_dist{
dist（v）new_dist;/*更新new_dist*/
unlock（dist（v））;/*dist（v）开锁*/
if（v
queue）
{
lockthequeue;/*队列上锁*/
enqueuev;/*v入队*/
unlockthequeue;/*队列开锁*/
}
}
else{unlock（dist（v））;}/*dist（v）开锁*/
}
}
}
（二）最小生成树并行算法
一个无向连通图G的生成树是指满足如下条件的G的子图T：
（1）G和T具有相同的顶点数；
（2）在T中有足够的边能连接G所有的顶点，但不出现回路。
最小生成树，即最小代价生成树（MinimumCostSpanningTree），它是加权连通无向图的所有生成树中权值最小的生成树。
（a）Sollin顺序求MST算法
算法开始时，图的n个孤立顶点视为一片森林，而每个顶点均视为一棵树；算法共迭代logn次，每次迭代时，森林中的每棵树，同时决定其最小的邻边，并将它们加入到森林中（即合并各棵树）；此过程重复到森林中只剩下一棵树。
因为森林中树的数目，每次都以2的倍数减少，所以迭代至多需要
次就可找到MST；而每次迭代时，找顶点的最小邻边至多执行O（n2）次比较。
因此Sollin的顺序算法的复杂度为O（n2logn）。
函数FIND（v）找顶点v所在的树的名字，UNION（v,u）合并包括顶点v和u的两棵树。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
算法9.4.3_1SISD机器上的SollinMST算法
输入：
无向图G的加权矩阵W
输出：
G的最小生成树T（树以边的形式存储）
SOLLIN-MST
{
（1）for（i=1;i<=n;i++）/*初始化*/
{
vertexiisinitiallyinseti;
}
（2）T0;/*T就是MST*/
（3）while（|T|{
（3.1）for（eachtreei）/*每棵树i找不在同一树中的最小边权*/
{
closest（i）∞;
}
（3.2）for（each（v,u）∈E）
{
if（FIND（v）≠FIND（u））/*v和u属于不同的连通片*/
{
if（w（v,u）{
closest（FIND（v））w（v,u）;
edge（FIND（v））（v,u）;
}
}
}
（3.3）for（eachtreei）
{
（3.3.1）（v,u）edge（i）;
（3.3.2）if（FIND（v）≠FIND（u））
{
（3.3.2.1）TT∪{（v,u）};/*加入新的树边*/
（3.3.2.2）UNION（v,u）;/*合并成较大的树*/
}
}
}
}
（b）Quinn的并行化算法
在共享存储的MIMD机系统上，Sollin算法可按如下思路并行化：
首先，应设法对第（3）步while循环进行并行化，但遗憾的是因循环之间存在着先后制约关系，即在第k+1次循环之前，第k次循环的子树必须同一个有最小权值的边关联的另一棵子树归并，所以while语句的并行化是有限的。
其次，考虑循环体内的并行化。
算法的第（3.1）步通过适当的预调度可以使其并行化，设第t次循环时已有nt棵子树：
若nt>p，则把nt棵子树较均匀的分配到p个处理器中，每个处理器约有
棵子树；否则，这nt棵子树就分配给nt个处理器。
算法的第（3.2）步并行化的最有效做法是：
首先，每个处理器检查它内部的顶点的边，然后再检查不在同一处理器上树之间的边。
算法的第（3.3）步并行化稍微复杂些。
图9_20示出了此情况，假定一个处理器企图将树B与其最近的树A进行归并，变量edge（A）有一条权值为k的边（vA,uA），变量edge（B）也有一条权值为k的边（vB,uB）。
然而假定两处理器都在实行UNION之前执行了第（ii）步的测试，则（vA,uA）和（vB,uB）都将加入到树T中，结果形成一个环，显然这是错的。
因此，欲使第（3.3）步并行化，必须在执行第（3.3.2）步之前上锁，执行完第（3.3.2.2）步后再开锁。
每次仅允许一个处理器进入临界区。
为了避免死锁的产生，当有多个请求上锁的进程申请临界区时，仅仅让标号最小的子树上锁。
在MIMD-SM模型上，所法所需的时间为
，处理器数为O（p）[1007]。
图9_20并行化Sollin算法所引起的复杂情况
i.Gauss-Seidel算法
Gauss-Seidel算法是求解Ax=b的一种算法。
先将系数矩阵A分解为A=E+D+F，其中D、E和F均为n×n的矩阵，它们的元素分别定义如下：
，
，
这样，Ax=（D+E+F）x=b，从而Dx=b-Ex-Fx。
给定初始值x0，则第k次迭代为
对于某一k和给定的误差允许值c，如果下式成立，则认为迭代时收敛的。
Gauss-Seidel异步并行算法，设有N个处理器（N≤n），算法生成n个进程，每一个进程计算x的一个分量。
这些进程由N个处理器异步的执行。
令
代表初值，oldi代表旧值，newi代表当前值，c为精度[1007]。
该并行算法的描述如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
算法9.4.4MIMD-CREW模型上的Gauss-Seidel算法
输入：
An×n，向量b，初值
（i=1,…,n），精度c（0输出：
满足精度要求的x的近似解
GUASS-SEIDEL
{
for（i=1;i<=n;i++）
{
oldi
;
newi
;
CreateProcessi;/*生成i个进程*/
}
Processi:
do
{
oldinewi;
newi
;
}while（!
（
））
xinewi;
}
例9_9使用算法9.4.4求解下述方程：
设有2个处理器（N=2），取初值
=1/2,
=3/2,c=0.02。
①设置old1=1/2,new1=1/2，生成进程process1；
设置old2=3/2,new2=3/2，生成进程process2。
②process1：
设置old1=1/2；计算new1=（1/2）（3-3/2）=3/4；
process2：
设置old2=3/2；计算new2=（1/2）（4-1/2）=7/4。
③重复计算如下：
new1=5/8，new2=13/8；
new1=11/16，new2=27/16；
new1=21/32，new2=53/32；
new1=43/64，new2=107/64；
new1=85/128，new2=213/128。
因为|43/64-85/128|+|107/64-213/128|<0.02，所以迭代结束。
ii.牛顿求根并行算法
牛顿求根法，设f（x）在（a,b）上连续，且f’（x）≠0,f”（x）≠0,f（a）·f（b）<0，则方程f（x）=0的根z的近似值可用如下迭代公式计算，直到误差|xn+1-xn|xn+1=xn-f（xn）/f’（xn）
并取初始值如下：
牛顿方法的几何解释如图9_21所示（假定f”（x）>0）。
下一次迭代值xn+1就是曲线f（x）在xn处的切线与x轴的交点。
f（x）
zx3x2x1x0x
图9_21牛顿方法几何解释
MIMD机器上的牛顿求根算法，将包含f（x）的零点z的区间（a,b）（设a各分点取为z的近似值。
计算由N个进程组成，每一进程开始用各分点值进行牛顿法求根。
各进程并发异步的执行。
一旦某一进程收敛，它就向共享存储单元ROOT写它所求得的值。
开始时根ROOT被置成∞，一旦ROOT值被某一进程修改，所有进程将随之结束。
如果两个进程同时收敛，就会造成写冲突，于是按最小号码的进程优先的策略来裁决，其它进程都被拒绝。
如果在预定的迭代数目r之内某一进程不收敛，则它就被挂起[1007]。
该并行算法的描述如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
算法9.4.5MIMD-CREW模型上的牛顿求根算法
输入：
f（x），f’（x），（a,b），精度c，最大容许迭代次数r
输出：
返回答案在ROOT中
ROOT
{
s（b-a）/（N+1）;
for（k=1;k<=N;k++）
{
createprocessk;/*生成进程*/
}
ROOT∞;
Processk:
xolda+ks;
iteration0;
while（iteration{
iteration++;
xnewxold-f（xold）/f’（xold）;
if（|xnew-xold|{
ROOTxnew;
}
xoldxnew;
}
}
在牛顿求根并行算法中，令N为可用处理器数，如果N足够大，则有一个起始点可充分接近z。
如果f（x）,f’（x）,f”（x）在区间（a,b）内连续有界，那么其中有一个处理器将会在O（logm）时间内收敛，其中m为所希望的精度的位数。
例9_10令f（x）=x3-4x-5。
因此f’（x）=3x2-4。
在区间（-3,3）存在着f（x）的零点，令N=5，区间被6等分，各分点的值依次为-2,-1,0,1,2。
算法生成5个进程，令e=9-10，假定5个处理器同时执行5个进程。
在此情况下，进程5最先收敛到根，其值ROOT=2.456678。
b）MIMD异步通信模型的并行算法
i.快速排序并行算法
快速排序（QuickSort）是一种最基本的排序算法，它的基本思想是，在当前无序序列R[1,n]中取一个记录作为比较的基准，用此基准将当前的无序序列R[1,n]划分成两个无序序列R[1,i-1]和R[i,n]（1≤i≤n），且R[1,i-1]中记录的所有关键字均小于等于基准的关键字，R[i,n]中记录的所有关键字均大于等于基准的关键字；当R[1,i-1]和R[i,n]非空时，分别对他们重复上述的划分过程。
对每次划分过后所得到的两个序列分别使用两个处理器完成递归排序。
例如对一个长为n的序列，首先划分得到两个长为n/2的序列，将其交给两个处理器分别处理；而后进一步划分得到4个长为n/4的序列，在分别交给4个处理器处理；如此递归下去最终得到排序号的序列[1001]。
该并行算法的描述如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
算法9.5.1快速排序并行算法
输入：
无序数组data[1,n]，使用的处理器个数2m
输出：
有序数组data[1,n]
SORT
{
para_quicksort（data,1,n,m,0）;
}
para_quicksort（data,i,j,m,id）
{
if（（j-i）≤k||m==0）
{
Pid:
quicksort（data,i,j）;
}
else
{
Pid:
r=partition（data,i,j）;
Pidsenddata[r+q,m-1]toPid+2m-1;
para_quicksort（data,I,r-1,m-1,id）;
para_quicksort（data,r+1,j,m-1,id+2m-1）;
Pid+2m-1senddata[r+1,m-1]toPid;
}
}
在最优的情况下该并行算法形成一个高度为logn的排序树，其计算复杂度为O（n），通信复杂度为O（n）；在最坏情况下其计算复杂度降为O（n2）；正常情况下该算法的计算复杂度为O（n）。
ii.二维网孔上的矩阵转置并行算法
网孔上的矩阵转置并行算法思路是，实现矩阵转置时，若处理器个数为p，且它们的编号依次是0,1,…,p-1，则将n阶矩阵A分成p个大小为m×m的子块，m=
。
p个字块组成一个
×
的子块阵列。
记其中第i行第j列的子块为Aij，它含有A的第（i-1）m+1至第im行中的第（j-1）m+1至第jm列的所有元素。
对每一处理器按行主方式赋以二维下标，记编号为i的处理器的而为下标为（v,u），其中v=
，u=imod
，将A的子块存入下标为（v,u）表示的对应处理器中。
这样，转置过程分两步进行：
第一步，子块转置，具体过程如图9_22所示；第二步，处理器内部局部转置。
图9_22子块转置
为了避免对应子块交换数据时处理器发生死锁，可令下三角子块先向与之对应的上三角子块发送数据，然后从上三角子块接收数据；上三角子块先将数据存放在缓冲区buffer中，然后从与之对应的下三角子块接收数据；最后再将缓冲区中的数据发送给下三角子块[1001]。
该并行算法的描述如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
算法9.5.2矩阵转置并行算法
输入：
矩阵An×n
输出：
矩阵An×n的转置矩阵ATn×n
transposedmatrix
{
/*对所有处理器my_rank（my_rank=0,…,p-1）*/
vmy_rank/sqrt（p）;/*计算子块的行号*/
umy_rankmodsqrt（p）;/*计算
升级会员 