分布式 | 复习总结

第2讲：基本模型与进程间通信

1. 考试内容：全局状态的记录

答：
全局状态包括各个进程的本地状态和信道状态。
$GS = \{ U_iLS_i^{x_i}, U_{j,k}SC_{j,k}^{y_j, z_k}\}$GS={Ui​LSixi​​,Uj,k​SCj,kyj​,zk​​}
全局状态的记录分两步：
1.各个进程记录各自的本地状态

• 在上式中，进程$p_j$pj​记录的状态是事件$y_j$yj​刚刚发生完的状态
• 在上式中，进程$p_k$pk​记录的状态是事件$z_k$zk​刚刚发生完的状态

2.确定哪些消息应该划入信道状态

• 进程$p_j$pj​在事件$y_j$yj​发生之前发送，但进程$p_k$pk​到事件$z_k$zk​发生为止还未收到的消息应该划入信道状态。

2. 考试内容：一致状态的判定

答：
全局状态$GS = \{ U_iLS_i^{x_i}, U_{j,k}SC_{j,k}^{y_j, z_k}\}$GS={Ui​LSixi​​,Uj,k​SCj,kyj​,zk​​}是一致的，当且仅当它满足以下条件：

即：一个进程在记录本地状态之后发送的消息，不能纳入全局状态包含的信道状态；该消息的接收操作，也不能纳入目标进程的本地状态。

3. 考试内容：通信原语的组合方式判定

答：
Send可以为：同步阻塞、同步非阻塞、异步阻塞、异步非阻塞
Recv可以为：同步阻塞、同步非阻塞

通信原语的组合方式判定：

第3讲：逻辑时钟与物理时钟同步

4. 考试内容：向量时间的推进计算

答：
向量时间的数据结构：
每个进程$p_i$pi​维护一个向量$vt_i[1..n]$vti​[1..n]，n为进程总数。

• 向量$vt_i[1..n]$vti​[1..n]表示进程$p_i$pi​视图中的全局时钟
• $vt_i[i]$vti​[i]表示进程$p_i$pi​的本地时钟
• $vt_i[j]$vti​[j]表示进程$p_i$pi​所知的有关进程$p_j$pj​的本地时钟的最近消息

向量时间的推进计算：
R1规则：

• 当进程$p_i$pi​发生一个内部事件时，更新时钟：$vt_i[i] = vt_i[i] + 1$vti​[i]=vti​[i]+1

R2规则：

• 消息发送：将全局时钟$vt_i[1..n]$vti​[1..n]附加到消息中
• 消息接收：假设接收到的消息携带逻辑时钟$vt_j[1..n]$vtj​[1..n]：
  • 第一步：$1≤ k ≤ n: vt_i[k] = max(vt_i[k], vt_j[k])$1≤k≤n:vti​[k]=max(vti​[k],vtj​[k])
  • 第二部：$vt_i[i] = vt_i[i] + 1$vti​[i]=vti​[i]+1

第4讲：全局快照算法

5*. 注意：可能的考试内容(Lai-Yang算法)

答：
由于在非FIFO中，先于Marker标志发送的消息，有可能后于Marker标志到达，因此Lai-Yang算法明确地将PAST消息和FUTURE消息分成两类，每个进程开始是白色的，记录快照时变成红色，进程变红时执行标记发送规则，促使其他进程也变红，红色进程发送红色消息，白色进程发送白色消息。

本地状态记录：

• 每个进程必须在接收到第一个红色消息之前记录本地状态。

通道状态记录：

• 每个白色进程记录它沿着每个通道发送和接收的白色消息
• 在一个通道上收到红色消息，则停止记录该通道的消息
• $SC_{i,j} = p_i$SCi,j​=pi​在通道$C_{i,j}$Ci,j​上发送的白色消息 $-$− $p_j$pj​在通道$C_{i,j}$Ci,j​上接收的白色消息

第5讲：基本图算法

6. 考试内容：简述算法流程(基于洪泛的异步单一启动者生成树算法)

答:
环境初始化，对于每个节点：

• $parent ⟸⊥$parent⟸⊥
• $Unrelated, Chirldren = \{\}$Unrelated,Chirldren={}
• $Neighbors = set \ of \ neighbors$Neighbors=set of neighbors
• 有三种消息类型：QUERY, ACCEPT, REJECT

算法执行，对于每个节点：

• 如果是指定根节点，则启动QUERY洪泛，且将根节点的parent设为它自己
• 收到由j发送的QUERY消息时，如果节点还没加入生成树，则确定加入生成树（parent ⟸ j; send ACCEPT to j）, 并向除j以外的邻居发送QUERY；否则，发送REJECT给j
• 收到由j发送的ACCEPT消息时，将j加入孩子节点
• 收到由j发送的REJECT消息时，将j加入无关节点
• 当所有邻居节点都处理完毕时，算法结束

第6讲：基本图算法（二）

7. 考试内容：简述算法流程（全源最短路算法：异步Floyd-Warshall）

答：
环境初始化，对于当前进程：

• 维护一个LEN[0…n]向量，LEN[i]代表当前节点所知的到i节点的最短距离
• 维护PARENT[0…n]向量，PARENT[i]表示到节点i的路程的第一跳
• 此外，还设置了neighbours,pivot和ngb

有三种消息类型：

• IN_TREE(pivot)
• NOT_IN_TREE(pivot)
• PIV_LEN（pivot，PIVOT_ROW[1…n]）

算法执行：

• 依次将每个节点设为pivot，对于每一轮：
  • 首先，给PAERNT[pivot]发送IN_TREE(pivot)消息，给其他邻居发送NOT_IN_TREE(pivot)，然后等待其他邻居的IN_TREE、NOT_IN_TREE消息
  • 接着就是获得PIV_LEN（如果自己不是pivot），传播PIV_LEN，以及根据PIV_LEN更新路径
    • 如果自己不是pivot，则等待PAERNT[pivot]发送PIV_LEN(pivot，PIVOT_ROW[1…n])
    • 如果自己是别人的PARENT[pivot]，也就是从某邻居那里接收到了IN_TREE(pivot)，则向该邻居传播PIV_LEN
    • 根据PIV_LEN更新路径，如果先经过pivot，再去某节点k，比原来去节点k的路径要短，则更新路径

第7讲：基本图算法（三）

8. 考试内容：简述算法流程(不依赖于生成树的受限洪泛算法)

环境初始化：

• SEQNO[1…n]，????????????????????[????]记录本进程看到的，由进程????发出的消息的最大编号
• neighbours

消息类型：

• UPDATE(M, i, SEQNO[i])

算法执行（假设要传递消息M）：

• 对于根节点i，首先将SEQNO[i]加1，然后向所有邻居发送UPDATE（M,i,SEQNO[i]）
• 当节点收到UPDATE(M, j, $seqno_j$seqnoj​)消息时，首先比较SEQNO，如果SEQNO[j]小于$seqno_j$seqnoj​，则处理M，SEQNO[j]更新为$seqno_j$seqnoj​，然后向所有邻居发送UPDATE（M, j, $seqno_j$seqnoj​）

9*. 可能的考试内容：最小生成树算法（分布式系统中的最小生成树算法（GHS算法））

以下步骤循环logn次：

• 在森林中，每棵树的根节点沿着树边向其子节点发送广播，要求它们找出自己权重最小的出边
• 收到广播消息的节点找出不属于同一棵子树的最小出边<localID, remoteID>
• 每个节点再通过聚播操作，将最小出边<localID, remoteID>上报给树根
• 树根从中选出权最小出边<localID, remoteID>，再次发送广播消息，将边<localID, remoteID>纳入生成树
• 最后，节点MAX（localID, remoteID）成为新的根，并沿树边发送广播消息通知其他节点

第8讲 P2P系统中的查询算法

10*. 可能的考试内容（Chord分布式哈希表

）

Chord的对象布局方法

• 对象的键值k被保存到满足以下条件的第一个节点：
• $succ(k) &gt;= k$succ(k)>=k

Chord的可扩展查找优化

• 每个节点保存多个后继节点：
• 节点i保存的数组为：$i.finger[x] = succ(i + 2^{(x-1)}), x = 1, 2, 3...$i.finger[x]=succ(i+2(x−1)),x=1,2,3...

节点i加入ID环

• 节点i与已存在于环中的节点j取得联系，节点j在环中确定i的位置
• i的前驱、后继节点分别更新其后继、前驱指针，使之指向i
• 节点i创建路由表$i.finger[x] = succ(i + 2^{(x-1)}), x = 1, 2, 3...$i.finger[x]=succ(i+2(x−1)),x=1,2,3...
• 其他所有节点都可能更新其路由表$k.finger[x] = succ(k + 2^{(x-1)}), x = 1, 2, 3...$k.finger[x]=succ(k+2(x−1)),x=1,2,3...

未标出的考点(Pastry前缀寻址网络)

第9讲：最大独立集与选举算法

11. 考试内容：简述算法流程（最大独立集

）
消息类型：

• RANDOM(random)
• SELECTED(pid，indicator)
• ELIMINATED(pid，indicator)

算法执行：

• 一个节点有两种情况可以纳入独立集：

  • 该节点没有邻居，纳入独立集，exit()
  • 该节点的生成的随机数在所有邻居中是最小的，发送SLECTED(i，true)，exit()

• 如果这一轮没有纳入独立集，则向邻居发送SLECTED(i，false)，并等待其他邻居的SELECTED消息

• 如果收到SLECTED(j，true)，则表示邻居被纳入独立集，自己要被删除，于是向未被纳入独立集的其他邻居发送ELIMINATED(i，true)

• 否则，向邻居发送ELIMINATED(i，false)，如果收到ELIMINATED(j，true)，则将j从邻居中删除

第10讲 Gossip协议与事务提交

12. 潜在的考试点：Gossip协议的优势分析

Gossip的性能分析：

• 假定在每一轮中，每个感染节点传播b个未感染节点，可简单认为$β = b/n$β=b/n，再令$t=c*logn$t=c∗logn，于是得到：$y_t = (n + 1) - 1 / n^{cb-2}$yt​=(n+1)−1/ncb−2
• 由此可知，Gossip具有以下优势：
  • 低延迟：仅仅需要O(logn)轮的消息传递
  • 鲁棒性：只有$1 / n^{cb-2}$1/ncb−2个节点不会收到消息
  • 轻量级：每个节点只需传递bclogn次消息
  • 容错性：50%的丢包率，等价于使用b/2代替b进行分析；50%的节点故障等价于使用b/2代替b，n/2代替n进行分析。

Gossip的优势：

• 可扩展性：
  • 仅仅需要O(logn)轮的消息传递
  • 每个节点只需传递固定数量的消息，与网络中的节点数目无关
  • 节点无需等待消息的ack，允许消息传送失败
  • 系统很容易扩展到数百万个进程
• 容错性：
  • 网络中任何节点的故障都不会影响Gossip协议的运行
• 健壮性：
  • 集群中的所有节点都是对等的，任何节点出现故障都不会阻止其他节点继续发送消息，任何节点都可以随时加入或离开
• 最终一致性：
  • Gossip协议实现信息指数级的快速传播，但不能应用于强一致性的场景

第11讲：因果序保证算法

13. 潜在的考试点：Raynal-Schiper-Toueg算法

消息发送事件：

• Pi向Pj发送发送（M，SENT）
• SENT[i, j] = SENT[i, j] + 1

消息接收事件(Pj收到(M, ST))：

• 对于每一进程x，如果都满足以下条件，则将M交付给Pj：

  • DELIV[x] >= ST[x]

• 对于所有的i，j，SENT[i,j] = max(SENT[i,j], ST[i,j])

• DELIV[j] = DELIV[j] + 1

第13讲：终止检测算法

14. 注意：潜在的考试点(基于快照的终止检测算法

)

主要思路：

• 在一个程序的所有进程中，一定有一个进程是最后结束的，但是由于没有全局信息，因此，每个进程从活跃变为空闲时，就把自己当成最后结束的进程，向其他进程发送消息，收集全局快照
• 收集全局快照的过程中，如果遇到还没结束的进程，就宣告全局快照收集失败
• 最后结束的进程能够成功收集程序终止的全局快照

15. 注意：潜在的考试点(基于生成树的终止检测算法

)
基本思想：

• 所有节点根据关联关系组成图，在图中生成一棵树
• 数根向节点发送广播消息
• 收到广播消息的节点，一旦变成空闲，向父节点报告
• 每个内部节点收到所有子节点的空闲报告，且自己也空闲的时候，向父节点发送报告
• 根节点收到所有子节点报告后，程序终止

改进：

• 所有节点根据关联关系组成图，在图中生成一棵树
• 数根向节点发送广播消息
• 收到广播消息的节点，将自己染成白色，如果节点向其他发送消息，则将自己染成黑色。节点一旦变成空闲，向父节点报告
• 每个内部节点收到所有子节点的空闲报告，且自己也空闲的时候，向父节点发送报告
• 根节点收到黑色消息，重新发起广播；根节点收到所有子节点白色报告后，程序终止

第14讲：分布式互斥算法

16. 注意：潜在的考试点（Lamport分布式互斥算法）

请求临界区：

• 进程Pi向其他进程发送$REQUEST(t_i, i)$REQUEST(ti​,i)消息，并将$REQUEST(t_i, i)$REQUEST(ti​,i)按时间戳顺序放入QUEUE
• 进程Pi收到$REQUEST(t_j, j)$REQUEST(tj​,j)，发送REPLY给Pj，并将$REQUEST(t_j, j)$REQUEST(tj​,j)按时间戳顺序放入QUEUE

执行临界区：满足以下两个条件，进入临界区：

• 进程Pi从其他所有进程收到时间戳大于$(t_i, i)$(ti​,i)的REPLY
• 进程Pi的请求处于本地QUEUE的队首

释放临界区：

• 从本地QUEUE删除自己的请求，并向其他进程广播一个带时间戳的消息
• 收到释放消息的进程，将对应请求从本地QUEUE中删除

17. 注意：潜在的考试点（Ricart-Agrawala分布式互斥算法）

请求临界区：

• 进程Pi向其他进程发送$REQUEST(t_i, i)$REQUEST(ti​,i)消息
• 进程Pj收到$REQUEST(t_i, i)$REQUEST(ti​,i)
  • 如果Pj没有请求临界区，也没有执行临界区，则立即返回REPLY
  • 如果Pj正在请求临界区，但时间戳大于$(t_i, i)$(ti​,i)，则立即返回REPLY
  • 否则，延迟发送REPLY，并设置RDj[i] = 1

执行临界区：

• 收到所有进程的REPLY后，可以进入临界区

释放临界区：

• 发送所有延迟的REPLY

18. 注意：潜在的考试点（Singhal自适应分布式互斥算法

）
变量：

• 请求集合R
• 通知集合I

请求临界区：

• Pi向集合R中的所有进程发送REQUEST消息
• Pj收到REQUEST：
  • 如果Pj没有请求临界区，也没有执行临界区，则立即返回REPLY，且将Pi加入R
  • 如果Pj正在请求临界区，但Pj的优先级低，则立即返回REPLY，并且如果Pi不在R中，则将Pi加入R，并向Pi发送REQUEST
  • 否则，延迟发送REPLY，并将Pi加入I

执行临界区：

• 收到R中所有进程的REPLY后，可以进入临界区，且每收到一个REPLY，就将相应进程从R中删除

释放临界区：

• 向I中的所有进程发送REPLY，将已发送REPLY的进程从I移动到R