算法设计与分析--分布式算法内容整理

Chapter 1 导论
- 分布式系统定义
- 分布式系统 VS 并行处理
- 分布式系统的作用及困难
- 分布式计算的理论
- - 复杂性度量标准
  - 模型
  - 错误的种类
Chapter 2 消息传递系统中的基本算法
- 消息传递系统的形式化模型
- - 系统
  - - 异步系统
    - 同步系统
    - 异步 VS 同步
  - 复杂性度量
  - - 消息复杂度
    - 时间复杂度
    - 伪代码约定
  - 生成树上的广播和汇集
  - - 广播（Broadcast）
    - 汇集，敛播 convergecast

分布式系统–汪炀

Chapter 1 导论

分布式系统定义

定义1（课件）：一个分布式系统是一个能彼此通信的单个计算装置的集合（计算单元：硬——处理器；软——进程）。

定义2（分布式算法导论原书第2版）：分布式系统表示自主计算机、进程或者处理器互连的集合。（计算机、进程或处理器称为分布式系统中的节点。）

自主性是指节点必须至少配备自己专用的控制单元。

因此，单指令多数据模型（SIMD）的并行计算机不是分布式系统。SIMD 是使用一个指令流来处理多个数据流，这意味着所有的处理器在同一时刻都执行相同的指令（所有的处理器都由一个单一的控制单元来控制），但是是对不同的数据进行操作。SIMD 并行计算机是一种集中式系统，它由一个控制单元和多个从属单元组成，而不是由多个自治的节点组成。

分布式系统中的每个节点（无论是计算机、进程还是处理器）都有自己的控制单元，可以独立地执行任务。
互连性是指节点之间必须能够交换信息。

在分布式系统中，计算机、进程和处理器都可以被视为节点。

计算机：当节点是计算机时，自主性体现在每台计算机都有自己的控制单元，例如 CPU、内存和存储设备，可以独立完成任务。互连性体现在计算机之间通过网络进行通信，共享数据和资源。
进程：当节点是进程时，自主性体现在每个进程都有自己的地址空间和一组资源，可以独立执行任务。互连性体现在进程之间可以通过各种进程间通信机制（如管道、消息队列、共享内存等）进行通信。
处理器：当节点是处理器时，自主性体现在每个处理器都有自己的控制单元，可以独立执行指令。互连性体现在处理器之间可以通过总线或其他连接方式进行通信。

分布式系统 VS 并行处理

❖ 并行处理 的目标是使用 所有处理器 来 执行一个大任务；

在并行计算中，一个大任务被分解成 N 个较小的任务，这些任务被分配到 一台机器上的 N 个处理器 进行处理。这些处理器可以同时（在时间上并行）或在不同的位置（在空间上并行）执行这些任务。

例如，我国的 神威·太湖之光超级计算机 和 IBM 的 Summit 超级计算机 就是这样的系统。它们拥有数百万个处理器，可以同时处理大量的任务。这些系统通常运行并行操作系统，该操作系统能够管理和调度所有的处理器，以确保它们能够有效地工作。

❖ 而 分布式系统 中，每个处理器一般都有自己独立的任务，但由于各种原因（为共享资源，可用性和容错等），处理机之间需要协调彼此的动作。

在分布式计算中，N 个独立的节点协同工作，各自处理一部分任务。这些系统可能位于不同的地理位置，通过网络进行通信。每个系统完成其分配的任务后，结果需要汇总到一起进行最终的计算。（可以充分利用所有可用的计算资源，提高系统的性能和可靠性。由于任务是在多个独立的节点上并行执行的，因此即使其中一个系统发生故障，其他系统仍然可以继续执行任务。）

分布式操作系统负责管理和调度这些独立的节点，确保它们能够有效地协同工作。

分布式软件系统则是为特定的分布式处理任务设计的软件，它们通常包括各种工具和服务，以支持数据处理、通信、资源共享等功能。

一个典型的分布式系统的例子是 Google 的搜索引擎。

当用户在 Google 的搜索框中输入查询时，这个查询会被发送到 Google 的服务器集群。这个集群是由数以千计的服务器组成，它们分布在全球各地的数据中心。

在这个分布式系统中，每个服务器都是一个节点，它们各自负责处理一部分任务。例如，一些服务器可能负责处理用户的查询请求，另一些服务器可能负责从数据库中检索相关的网页，还有一些服务器可能负责对这些网页进行排序和过滤。

这些服务器之间需要通过网络进行通信，以便协调彼此的工作。例如，处理查询请求的服务器需要将查询结果发送到其他服务器进行排序和过滤，而这些服务器又需要将最终的搜索结果返回给用户。

Google 的搜索引擎之所以能够在几秒钟内返回数以亿计的搜索结果，就是因为它利用了分布式计算的优势。通过 将大任务分解成小任务，并将这些任务分配给多个服务器并行处理，Google 能够大大提高搜索速度和效率。

此外，由于每个服务器都有自己独立的任务，即使其中一个服务器发生故障，其他服务器仍然可以继续执行任务。这就提高了系统的可靠性和容错能力。

分布式系统的作用及困难

分布式系统无处不在，其作用是：

①共享资源；

分布式系统中的资源共享主要体现在以下几个方面：

数据共享：在分布式系统中，数据可以在不同的节点之间共享。例如，一个节点可以将其数据库中的数据提供给其他节点，或者多个节点可以共同维护和更新一个共享的数据库。
设备共享：分布式系统中的节点可以共享物理设备，如打印机、硬盘等。例如，一个节点可以将其连接的打印机作为共享设备，供其他节点使用。
软件和服务共享：在分布式系统中，一个节点上运行的软件或服务可以被其他节点使用。例如，一个节点上运行的文件服务器可以为其他节点提供文件存储和访问服务。
处理能力共享：在分布式系统中，一个任务可以被分解成多个子任务，这些子任务可以在不同的节点上并行执行。这样，所有的节点都可以共享处理能力，提高系统的整体性能。

②改善性能：并行地解决问题；

③改善可用性：提高可靠性，以防某些成分发生故障；

【分布式系统面临的困难】

❖异质性：软硬件环境；

分布式系统通常由不同类型的硬件和软件组成，这些硬件和软件可能运行在不同的操作系统上，使用不同的数据格式和协议。这种异质性使得集成和协调各个系统成为一项挑战。

❖异步性：事件发生的绝对、甚至相对时间不可能总是精确地知道；

在分布式系统中，由于网络延迟和时钟偏差等因素，事件的发生时间可能无法精确地知道。这就需要设计一种机制来处理这种异步性，例如使用时间戳或者向量时钟来对事件进行排序。

❖局部性：每个计算实体只有全局情况的一个局部视图；

在分布式系统中，每个节点只能看到全局情况的一个局部视图，而无法获取整个系统的完整信息。这就需要设计一种机制来保证系统的一致性，例如使用分布式锁或者一致性协议来协调各个节点的操作。

❖故障：各计算实体会独立地出故障，影响其他计算实体的工作。

在分布式系统中，各个节点可能会独立地出现故障，这可能会影响其他节点的工作。因此，需要设计一种机制来处理故障，例如使用副本或者冗余来提高系统的可靠性和容错能力。

分布式计算的理论

【目标】针对分布式系统完成类似于顺序式计算中对算法的研究。

【具体】对各种分布式情况发生的问题进行抽象，精确地陈述这些问题，设计和分析有效算法解决这些问题，证明这些算法的最优性。

分布式计算模型需要定义：

❖计算实体之间如何通信：计算实体间 消息（msg）传递 还是 共享变量？

消息传递可以完成通信和同步。

如，在一个进程（发送方进程）执行发送操作，而另一进程（接收方进程）执行接收操作，就会发生通信。发送操作的变量包括接收方的地址和附加数据，形成了消息的内容。当执行完接受语句时，对于接收方才能用附加数据，这就实现了通信。只有当发送操作执行完后，接受操作才能完成，这就实现了同步。

共享存储只能进行通信，此外还需关注利用共享存储器进行通信的进程的同步。利用共享存储器进行通信，如，一个进程将值写入变量，另一进程读取该值。难以达到进程间的同步，因为读取变量可以在写入变量之前。利用同步原语，如信号量或管程，是可行的。

分布式系统中的进程通信，既可通过访问共享变量，又可通过消息传递来进行。
分布式系统中的消息可通过同步或者异步的方式传递。

❖哪些计时信息和行为是可用的？

❖容许哪些错误？

复杂性度量标准

❖时间，空间

❖通信成本：msg 的个数，共享变量的大小及个数

❖故障和非故障的数目

模型

这里主要考虑三种，基于通信介质和同步程度考虑。

① 异步共享存储模型：用于紧耦合机器，通常情况下各处理机的时钟信号不是来源于同一信号源；

② 异步 msg 传递模型：用于松散耦合机器及广域网；

③ 同步 msg 传递模型：这是一个理想的 msg 传递系统。该系统中，某些计时信息（如 msg 延迟上界）是已知的，系统的执行划分为轮执行，是异步系统的一种特例。

错误的种类

❖ 初始死进程：指在局部算法中没有执行过一步。

❖ Crash failure 崩溃错误（损毁模型）指处理机没有任何警告而在某点上停止操作。

❖ Byzantine failure 拜占庭错误：一个出错可引起任意的动作, 即执行了与局部算法不一致的任意步。拜占庭错误的进程发送的消息可能包含任意内容。

Chapter 2 消息传递系统中的基本算法

本章介绍无故障的 msg 传递系统，考虑两个主要的计时模型：同步及异步。

消息传递系统的形式化模型

系统

拓扑：无向图（结点——处理机；边 ——双向信道）

算法：由系统中每个处理器上的局部程序构成。

形式地：一个系统或一个算法是由 $n$ 个处理器 $p_0$ ， $p_1$ ，… $p_{n-1}$ 构成，每个处理器 $p_i$ 可以模型化为一个具有状态集 $Q_i$ 的状态机。

术语 “配置” 用于表示整个分布式系统的属性，术语 “事件” 和 “状态” 用于表示进程的属性。

【概念1–状态】（进程的局部状态）由 $p_i$ 的变量， $p_i$ 的 msgs 构成。

$p_i$ 的每个状态由 $2 r$ 个 msg 集构成：

❖ $outbuf_i[l](1≤l≤r)$ ： $p_i$ 经第 $l$ 条关联的信道发送给邻居，但尚未传到邻居的 $m s g$ 。outbuf 是存储那些 已经被发送方发送但还未被接收方接收的消息的缓冲区。

❖ $inbuf_i[l](1≤l≤r)$ ：在 $p_i$ 的第 $l$ 条信道上已传递到 $p_i$ ，但尚未经 $p_i$ 内部计算步骤处理的 msg。inbuf 是存储那些 已经被接收方接收但还未被接收方处理的消息的缓冲区。

【概念2–初始状态】

$Q_i$ 包含一个特殊的 初始状态子集：每个 $inbuf_i[l]$ 必须为空，但 $outbuf_i[l]$ 未必为空。

inbuf_i[l] 必须为空：这是因为在系统开始运行时，还没有任何消息被传递到处理器，所以输入缓冲区必须是空的。

因为 消息的接收是一个动态的过程，需要在系统运行过程中进行。即使在异步通信模型中，一个处理器也不能预先知道它将会接收到什么消息，或者何时会接收到消息。因此，它不能预先在 inbuf 中放置任何消息。
outbuf_i[l] 可能不为空：这是因为在系统开始运行时，可能已经有一些消息准备好要发送出去，但还没有被发送。这些消息会被存储在输出缓冲区中，等待被发送。

因为 消息的发送可以在系统开始运行之前就进行准备。

在分布式系统的初始状态下，outbuf（输出缓冲区）不为空的情况可能有以下几种：

预加载消息：在某些分布式系统或算法中，可能会在系统开始运行之前预先在 outbuf 中加载一些消息。这些消息可能是系统启动所需的配置信息，或者是为了优化性能而预先计算的结果。

恢复从先前的状态：如果分布式系统从先前的状态恢复（例如，系统崩溃后的恢复），那么 outbuf 可能包含未发送的消息。这些消息是系统在崩溃前尝试发送但未成功发送的消息。

inbuf 中的消息表示已经被传递到处理器但尚未被处理的消息。当系统崩溃时，所有未处理的消息都会丢失，因为它们存储在内存中，而内存在系统崩溃时不会保留数据。

outbuf 中的消息可能会在系统恢复后仍然存在。这是因为这些消息通常会被写入持久化存储（如硬盘），以便在系统恢复后可以继续发送。

【概念3–转换函数】

转换函数：处理器 $p_i$ 的转换函数（实际上是一个局部程序）

❖ 输入： $p_i$ 可访问的状态；

❖ 输出：对每个信道 $l$ ，至多产生一个 $m s g$ 输出；

❖ 转换函数使 输入缓冲区（ $1 \leq l \leq r$ ）清空。

【概念4–配置】

配置是分布式系统在某点上整个算法的全局状态。

在分布式系统中，“配置” 通常指的是 系统在某一时刻的全局状态，包括 所有处理器的状态 以及 它们之间的通信状态。

例如，如果我们有一个由三个处理器组成的分布式系统，那么该系统的一个配置可能包括每个处理器的当前执行到哪一步、每个处理器存储了哪些数据、每个处理器正在发送或接收哪些消息等信息。

因此，当说 “配置是分布式系统在某点上整个算法的全局状态” 时，实际上是在描述 分布式系统在某一时刻的整体情况。

$向量=(q_0 , q_1 ,…q_{n-1} )$ ， $q_i$ 是 $p_i$ 的一个状态；

一个配置里的 $o u t b u f$ 变量的状态表示在通信信道上传输的信息，由 del 事件模拟传输；

一个初始的配置是 $向量=(q_0 , q_1 ,…q_{n-1} )$ ，其中每个 $q_i$ 是 $p_i$ 的初始状态，即每个处理器处于初始状态。

【概念5–事件】

系统里所发生的事情均被模型化为事件，对于 msg 传递系统，有两种：

comp(i)——计算事件，代表处理器 $p_i$ 的一个计算步骤。这可能包括读取或写入数据、执行算法或其他计算任务。
del(i,j,m)——传递事件，表示 msg $m$ 从 $p_i$ 传送到 $p_j$ 。这描述了系统中的通信过程，即一个处理器向另一个处理器发送消息。

【概念6–执行】

系统在时间上的行为被模型化为一个执行，它是一个 由配置和事件交错的序列。

说执行是由 “配置“ 和 ”事件“ 交错的序列时，实际上是在描述 系统如何从一个全局状态（配置）转变到另一个全局状态。这个转变是通过一系列的事件（如消息传递或计算步骤）来实现的。每个事件都会改变系统的配置，从而推动系统向前发展。

该序列须满足各种条件，主要分为两类：

①Safety 条件： (安全性) 表示某个性质在每次执行中每个可到达的配置里都必须成立。

例如：“在 leader 选举中，除了 $p_{max}$ 外，没有哪个结点宣称自己是 leader”。

②liveness 条件： (活跃性) 表示某个性质在每次执行中的某些可达配置里必须成立。必须成立一定次数的条件(可能是无数次)。

例如：条件：“ $p_1$ 最终须终止” ，要求 $p_1$ 的终止至少发生一次；“leader 选举， $p_{max}$ 最终宣布自己是 leader”。

对特定系统，满足所有要求的安全性条件的序列 称为一个执行；
若一个执行也 满足所有要求的活跃性条件，则称为 容许(合法的)(admissible)执行。

在分布式系统中，一个执行被称为"容许的执行"，必须满足以下两个条件：

满足所有的安全性条件：这意味着在执行过程中，系统必须始终保持一些基本的性质或约束，以确保系统的正确和稳定运行。

满足所有的活跃性条件：这意味着在执行过程中，系统必须能够最终达到一些期望的状态或结果，以确保系统的响应性和有效性。

假设有一个由两个处理器 $p_0$ 和 $p_1$ 组成的分布式系统，它们通过一个信道进行通信。

安全性：在这个例子中，一个可能的安全性条件是 “在任何时候， $p_0$ 和 $p_1$ 都不能同时拥有消息 $m$ ”。这个条件确保了系统的一致性，因为它防止了同一消息被多次处理。

活跃性：在这个例子中，一个可能的活跃性条件是 “ $p_1$ 最终必须接收到消息 $m$ ”。这个条件确保了系统的响应性，因为它要求消息最终必须被接收和处理。

执行：一个可能的执行是这样的：首先， $p_0$ 执行一个计算步骤（comp(0)），然后它发送一个消息 $m$ 给 $p_1$ （这可以表示为 del(0,1,m)）。然后， $p_1$ 接收这个消息，并执行一个计算步骤（comp(1)）。这个序列满足所有的安全性条件，因此它是一个执行。

容许的执行：在上述执行的基础上，如果添加一个活跃性条件，例如 “ $p_1$ 最终必须接收到消息 $m$ ”，那么只有当 $p_1$ 确实接收到消息 $m$ 时，这个执行才被认为是容许的。

异步系统

【概念1–异步】

异步： $m s g$ 传递的时间 和一个处理器的两个相继步骤之间的时间 无固定上界。

例如，Internet 中，email 虽然常常是几秒种到达，但也可能要数天到达。

当然 $m s g$ 延迟有上界，但它可能很大，且随时间而改变。

因此异步算法设计时，须使之独立于特殊的计时参数，不能依赖于该上界。

在异步系统中，消息传递 时间没有固定上界：

网络延迟：在分布式系统中，各个节点通过网络进行通信。网络的状态（如带宽、拥塞等）会影响消息的传递时间。这些因素是不可预测的，因此消息的传递时间也就没有固定的上界。
处理器速度：不同的处理器处理速度可能会有差异，这也会影响到消息的处理和传递时间。
系统负载：如果系统负载较高，可能会导致消息处理和传递的延迟。
故障恢复：在分布式系统中，节点可能会出现故障。当故障节点恢复后，可能需要一段时间来处理积压的消息。

在异步系统中，一个处理器的两个相继步骤之间 的时间没有固定上界：

处理器的工作负载：处理器可能需要处理来自多个源的任务，这些任务可能会在任何时间到达。因此，处理器可能在完成一个步骤后，需要花费一些时间来处理其他任务，然后再执行下一个步骤。
处理器的性能：不同的处理器可能具有不同的性能特性，例如处理速度、内存大小等。这些因素会影响处理器完成任务的速度。
系统中断和故障：处理器可能会遇到各种中断和故障，例如硬件故障、软件错误等。这些中断和故障可能会导致处理器暂停当前的任务，转而去处理这些问题。

这意味着，消息可能在任意长时间到达，处理器也可能任意长时间完成任务。

因此，异步系统需要 能够处理任何可能的延迟，并且 在消息到达或任务完成时能够正确地响应。

【概念2–执行片断】

一个异步 msg 传递系统的一个 执行片断 $α$ 是一个有限或无限的序列： $C_0$ , $Φ_1$ , $C_1$ , $Φ_2$ , $C_2$ , $Φ_3$ , … , （ $C_0$ 不一定是初始配置）

这里 $C_k$ 是一个配置， $Φ_k$ 是一个事件。

若 $α$ 是有限的，则它须结束于某个配置，且须满足下述条件：

❖ 若 $Φ_k =del(i,j,m)$ ，则 $m$ 必是 $C_{k-1}$ 里的 $outbuf_i [l]$ 的一个元素，这里 $l$ 是 $p_i$ 的信道 ${p_i, p_j\}$ 的标号；从 $C_{k-1}$ 到 $C_k$ 的唯一变化是将 $m$ 从 $C_{k-1}$ 里的 $outbuf_i [l]$ 中删去，并将其加入到 $C_k$ 里的 $inbuf_j [h]$ 中， $h$ 是 $p_j$ 的信道 ${p_i,p_j \}$ 的标号。

即：传递事件 将 $m s g$ 从 发送者的 $o u t b u f$ 移至 接收者的 $inb u f$ 。

❖ 若 $Φ_k =comp(i)$ ，则从 $C_{k-1}$ 到 $C_k$ 的变化是：

①改变状态：转换函数在 $p_i$ 的可访问状态（在配置 $C_{k-1}$ 里）上进行操作，清空 $inbuf_i [l], (1≤l≤r)$

②发送 $m s g$ ：将转换函数指定的消息集合加到 $C_k$ 里的变量 $outbuf_i$ 上。（Note：发送 send，传递 delivery 之区别）： $p_i$ 以当前状态(在 $C_{k-1}$ 中)为基础按转换函数改变状态并发出 $m s g$ 。

在分布式系统中，“发送（send）” 和 “传递（delivery）” 是两个关键的概念，它们描述了 消息在系统中的移动过程：

发送（send）：发送事件 是指 处理器 $p_i$ 生成一个消息并将其放入其输出缓冲区 outbuf_i 中。这个过程通常发生在处理器执行计算步骤（comp(i)）时，此时处理器可能会根据其当前状态和转换函数来 生成新的消息。这些消息被添加到 outbuf_i 中，等待被发送到其他处理器。
传递（delivery）：传递事件 是指一个消息 从发送者的输出缓冲区 outbuf_i 被移动到接收者的输入缓冲区 inbuf_j 中。这个过程表示消息已经被成功地 从一个处理器传递到另一个处理器。

“发送” 是指生成消息并准备发送它（ $p_i$ 生成的新消息，然后放到 $p_i$ 自己的 $o u t b u f$ 中等待发送出去），而 “传递” 是指消息已经被成功地从发送者传送到接收者（从 $p_i$ 的 $o u t b u f$ 到 $p_j$ 的 $inb u f$ ）。

【概念3–执行】

一个执行是一个执行片断 $C_0 , Φ_1 , C_1 , Φ_2 , … $，但是 * *$ C_0$ 是一个初始配置**。

区别于 执行片段的 $C_0$ 未必是初始配置。可以理解为执行片段可以不是从头开始，但是执行一定是从头开始。

执行是描述系统从初始状态开始的行为，执行片段是描述系统在任何给定配置开始的行为（执行片段可以从系统的任何状态开始）。可以将执行看作是一种特殊的执行片段，它始终从系统的初始状态开始。

【概念4–调度】

一个调度（或调度片段）总是和执行（或执行片断）联系在一起的，它是执行中的事件序列： $Φ_1 , Φ2 , …$ 。

并非每个事件序列都是调度。

非调度：如果规定 “处理器 $p_1$ 不能在接收到消息 $m$ 之前执行计算步骤”，那么以下的事件序列就不是一个有效的调度：
comp(0)：处理器 $p_0$ 执行一个计算步骤。
comp(1)：处理器 $p_1$ 执行一个计算步骤。
del(0,1,m)：消息 $m$ 从处理器 $p_0$ 传送到处理器 $p_1$ 。

调度：根据同样的规则，以下的事件序列就是一个有效的调度：
comp(0)：处理器 $p_0$ 执行一个计算步骤。
del(0,1,m)：消息 $m$ 从处理器 $p_0$ 传送到处理器 $p_1$ 。
comp(1)：处理器 $p_1$ 执行一个计算步骤。

在有效的调度中，处理器 $p_1$ 是在接收到消息 $m$ 之后才执行计算步骤的，它满足规则，该事件序列才是调度。

对于处理器 $p_0$ ，我们没有类似的规则。因此，处理器 $p_0$ 可以在任何时候执行计算步骤，包括在发送消息 $m$ 之前。

在分布式系统中，处理器 $p_0$ 可以在不接收消息的情况下执行计算步骤。因为处理器的计算步骤通常包括执行算法、处理数据、生成新的消息等，这些操作并不一定需要接收到新的消息。

例如，处理器 $p_0$ 可能正在执行一个排序算法，它可以在不接收新数据的情况下继续对已有数据进行排序。

或者，处理器 $p_0$ 可能正在生成一个新的消息，准备发送给其他处理器。

若局部程序是确定的，则执行（或执行片断）就由初始配置 $C_0$ 和调度（或调度片断） $σ$ 唯一确定，可表示为 $\mathbf{exec}(C_0 , σ)$ 。

【概念5–容许的执行】

异步系统中，若某个处理器有 无限个计算事件，每个发送的 $m s g$ 都最终被传递，则执行称为容许的。

Note：无限个计算事件是指 处理器没有出错，可以执行无限次的计算步骤。

这并不意味着处理器的程序必须包含一个无限循环，而是指 处理器可以持续地接收和处理新的任务或消息。
也不意味着处理器必须一直忙碌，而是指处理器 有能力在任何时候接收和处理新的任务或消息。

在异步系统中，尽管可能 存在各种延迟和故障，但 只要每个发送的消息最终都被传递，并且 每个处理器都可以执行无限个计算事件（即持续地接收和处理新的任务或消息），那么就认为这个系统的执行是被允许的。

异步系统中的 “无限个计算事件” 和 “每个发送的消息都最终被传递” 这两个概念，都是为了 描述在面临各种不确定性（如网络延迟、处理器负载等）时，系统仍能保持正常运行的能力。

非形式地说：一个算法终止是指在某点后转换函数不改变处理器的状态。

算法已经达到了预期的结果，或者已经确定无法达到预期的结果。

若该算法已经完成了其任务，并且无论执行多少次计算，处理器的状态都不会发生改变。

【概念6–容许的调度】

容许的调度：若它是一个容许执行的调度，即容许的执行中的事件序列。

同步系统

在同步模型中，处理器按 锁步骤（lock-step）执行：

执行被划分为轮，每轮里，

① 每个处理器 能够 发送一个 $m s g$ 到每个邻居，这些 $m s g$ 被传递。

② 每个处理器 一接到 $m s g$ 就进行计算。

虽然特殊的分布系统里一般达不到，但这种模型对于设计算法非常方便，因为无需和更多的不确定性打交道。

当按此模型设计算法后，能够很容易模拟得到异步算法。

【概念1–轮】

在 同步系统 中，配置和事件序列 可以划分成 不相交的轮，每轮由 一个传递事件（将 $o u t b u f$ 的消息传送到信道上使 $o u t b u f$ 变空），后 跟一个计算事件（处理所有传递的 $m s g$ ）组成。

【概念2–容许的执行】

指 系统能够无限地执行操作。

因为轮的结构，所以

每个处理器可以执行无限数目的计算步（处理器没有出错，并且可以继续接收和处理新的任务或消息）；
每个被发送的 $m s g$ 最终被传递。

在同步系统中，消息传递通常是按照预定的顺序进行的，每个处理器都会在其轮次到来时接收和处理消息。

如果一个处理器在其轮次到来时由于网络延迟或故障等原因无法接收到消息，那么这个消息就会在这一轮中无法被传递。

同步系统通常也有机制来确保系统的正常运行。例如，它可能会使用重试机制来处理网络延迟问题，或者使用冗余和备份机制来处理故障问题。

异步 VS 同步

在一个 无错的同步系统 中，一个算法的执行 只取决于初始配置；
但在一个 异步系统 中，对于 相同的初始配置及无错假定，因为 处理器步骤间隔及消息延迟均不确定，故 同一算法可能有不同的执行。

在同步系统中，由于 所有处理器都按照预定的顺序（或“轮次”）进行操作，并且 消息传递的时间是确定的，因此给定初始配置和无错假设，一个算法的执行结果是确定的。换句话说，同一算法在同步系统中，对于相同的初始配置，总是会有相同的执行结果。

而在异步系统中，由于处理器步骤间隔和消息延迟都是不确定的，因此即使初始配置和无错假设相同，同一算法也可能有不同的执行结果。

例如，处理器 $A$ 可能在处理器 $B$ 完成其操作之前就已经开始了下一个操作，或者由于网络延迟，处理器 $A$ 发送的消息可能在预期之后才被处理器 $B$ 接收。这些因素都可能导致算法的执行结果与预期不同。

总的来说，同步系统和异步系统的 主要区别在于它们处理时间不确定性的方式：

同步系统假设所有操作都可以在预定的时间内完成，而异步系统则允许操作的完成时间有所不同。

举个例子，假设有一个分布式系统，其中包含多个节点，这些节点通过网络进行通信。一个节点（节点 $A$ ）向另一个节点（节点 $B$ ）发送了一个请求消息。

在 同步系统 中，节点 $A$ 会等待并 期望在一定时间内收到节点 $B$ 的回复。
然而，在 异步系统 中，节点 $A$ 不会等待回复，它会 继续执行其他任务，直到它在某个时刻收到来自节点 $B$ 的回复。

异步系统模型的一个优点是它可以 更好地处理网络延迟和故障。例如，如果节点 $B$ 暂时无法响应，节点 $A$ 可以继续执行其他任务，而不是无限期地等待。

然而，这也带来了 额外的复杂性，因为 需要处理消息可能在任何时间到达的情况。

复杂性度量

【概念–终止】

终止：假定每个处理器的状态集包括终止状态子集，每个的 $p_i$ 的转换函数对终止状态只能映射到终止状态。

当所有处理机均处于终止状态且没有 $m s g$ 在传输时，称 系统（算法）已终止。

【分布式算法的性能】

❖ 时间复杂度

❖ 空间复杂度

❖ 性能衡量：最坏性能、期望性能

❖ 消息复杂度

消息复杂度

算法的 $m s g$ 复杂性（最坏情况）：算法在所有容许的执行上发送 $m s g$ 总数的最大值（同步和异步系统）。

消息复杂度度量：消息总数 or 消息中总的位数长度。

消息总数：这是在执行一个算法或操作过程中，系统需要发送和接收的 消息的总数。这个指标反映了 系统的通信负载，即系统在 执行一个操作 时需要进行 多少次通信。
消息中总的位数长度：这是在执行一个算法或操作过程中，系统需要发送和接收的 所有消息中的位数的总和。这个指标反映了 系统的数据传输负载，即系统在 执行一个操作 时需要 传输多少数据。

如下例（每一个格子表示一位，每一组格子表示一个消息）：

在这里插入图片描述

那么算法 $A$ 与算法 $B$ ：

消息总数：4/4

消息位数总长度（位复杂度）：14/8

时间复杂度

【同步系统】

最大轮数，即算法的任何容许执行直到终止的最大轮数。

【异步系统】

假设：

①节点计算任何有限数目事件的时间为0；

②一条消息发送和接收之间的时间至多为1个时间单位；

定义为：所有计时容许执行中直到终止的最大时间。

【消息的延迟】

❖ 发送 $m s g$ 的计算事件和处理该 $m s g$ 的计算事件之间所逝去的时间；

❖ 它主要由 $m s g$ 在发送者的 $o u t b u f$ 中的等待时间和在接收者的 $inb u f$ 中的等待时间所构成。

【异步算法的时间复杂性】

定义中，每个 $m s g$ 延时至多为 $1$ ，但实际中，至多 $1$ 个时间单位会很难计算，因此修改假设：

① 一条消息发送和接收之间时间恰好为 $1$ 个时间单位；

② 一条消息发送和接收之间时间介于 $α$ 和 $1$ 之间（ $0 < α < 1$ ）

③ 假设消息传递的延迟满足某种概率分布，并由此来计算

伪代码约定

实际描述算法有两种方法：

① 叙述性：对于简单问题；

② 伪码形式：对于复杂问题。

【同步算法】逐轮描述。

【异步算法】对每个处理器，用 中断驱动 来描述异步算法。

中断驱动的异步算法，利用中断机制来处理消息和事件，而不是依赖于同步的时钟或者轮询的方式。

用中断驱动描述异步算法，就是要 说明每个处理器如何在收到中断信号时，执行相应的操作，更新自己的状态，并发送消息给其他处理器。

例如，下面是一个用中断驱动描述的异步广播算法：

Code for Pi 
Begin
	while (receiving no message) do 
		(1) if i = r then // 此节点为根节点
			(1.1) send <m> to all children 
			(1.2) terminate 
		end if 
	end while 
	while (receiving <m> from Pj) do 
		(2) send <m> to all children 
		(3) terminate 
	end while 
end

这个算法的目的是让根节点 $r$ 发送一个消息 $m$ 给所有其他节点。每个节点都有一个 $p a re n t$ 变量和一个 $c hi l d re n$ 集合，表示它在一棵生成树上的位置。当一个节点收到来自其 $p a re n t$ 的消息 $m$ 时，它就将消息转发给所有 $c hi l d re n$ ，并终止自己的执行。这样，所有节点都能最终收到消息 $m$ 。

这个算法中，每个节点都是被动地等待中断信号，即收到消息 $m$ 。当收到消息 $m$ 时，它就执行相应的操作，并发送消息给其他节点。这样，每个节点都能及时地响应事件，并与其他节点保持一致。

在形式模型中，**每个计算事件 $1$ 次处理所有输入缓冲区中的 $* * m s g s$ 。

而在算法中，一般须描述 每个 $m s g$ 是如何逐个处理的。

异步算法也可在同步系统中工作，因为同步系统是异步系统的一个特例。

生成树上的广播和汇集

信息收集（敛播/汇集）及分发(广播)是许多分布式算法的基础。故通过介绍这两个算法来说明模型、伪码、正确性证明及复杂性度量等概念。

由于 分布式系统中，每个节点并不知道全局拓扑状态，但某些算法需要在特定的结构下才能达到最优。

例如：广播/敛播在树结构下才能达到消息复杂度最优，因此 构造生成树是必要的，且是其他算法的基础。

【概念–生成树】

一个无向连通图 $G$ 的生成树（Spanning Tree）是指满足下列条件的 $G$ 的子图 $T$ ：

① $G$ 和 $T$ 具有相同的顶点数；

② 在 $T$ 中 有足够的边能够连接 $G$ 的所有顶点 且 不出现回路。

【概念–最小生成树】

如果图的每一条边都指定有一个权，那么 所有的边权最小 的生成树，称为最小代价生成树（Minimum Cost Spanning Tree, MCST），简称 最小生成树（MST）。

广播（Broadcast）

假定网络的生成树已给定。

某处理器 $p_r$ 希望将消息 $M$ 发送至其余处理器。假定生成树的根为 $p_r$ ，每个处理器有一个信道连接其双亲（ $p_r$ 除外），有若干个信道连接其孩子。

在这里插入图片描述

(a) 根 $p_r$ 发送 $M$ 给所有孩子。

(b) 当某节点收到父节点的 $M$ 时，发送 $M$ 到自己的所有孩子。

【伪码算法】 $A l g 2.1$ $B ro a d c a s t$

pr: if(i=r): //发动者;假设初始化时M已在传输状态
1. upon receiving no msg: //pr发送M后执行终止
2.     terminate; //将terminated置为true。
pi(i≠r,0≤i ≤ n-1):
3. upon receiving M from parent:
4.     send M to all children;
5.     terminate;

每个处理器 $p_i$ 包含状态：

变量 $parent_i$ ：表示处理器 $p_i$ 双亲节点的标号或为 $ni l$ （若 $i = r$ ）
变量 $children_i$ ： $p_i$ 的孩子节点标号的集合
布尔变量 $terminated_i$ ：表示 $p_i$ 是否处于终止状态

该算法对同步及异步系统均正确，且在两模型中， $m s g$ 和时间复杂度相同。

【 $M s g$ 复杂度】

无论在同步还是异步模型中， $m s g$ $M$ 在生成树的每条边上恰好发送一次。

因此， $m s g$ 复杂性为 $n - 1$ ，即 $O (n)$ 。

时间复杂度为 $h$ ，即 $O (h)$ ，其中 $h$ 为生成树的高度。

Code for Pi 
Begin
	while (receiving no message) do 
		(1) if i = r then // 此节点为根节点
			(1.1) send <m> to all children 
			(1.2) terminate 
		end if 
	end while 
	while (receiving <m> from Pj) do 
		(2) send <m> to all children 
		(3) terminate 
	end while 
end

说明：本算法中 $Whi l e$ 并不代表循环，而是代表满足条件时，节点所做的动作。

【时间复杂性】

① 同步模型：时间由轮来度量。

$L e mma 2.1$ 在同步模型中，在广播算法的每个容许执行里，树中每个距离 $p_r$ 为 $t$ 的处理器在第 $t$ 轮里接收消息 $M$ 。

pf：对距离 $t$ 使用归纳法。

归纳基础： $t = 1$ ， $p_r$ 的每个孩子在第1轮里接收来自于 $p_r$ 的消息 $M$ ；

归纳假设：假设树上每个距 $p_r$ 为 $t - 1 \geq 1$ 的处理器在第 $t - 1$ 轮里已收到 $M$ 。

归纳步骤：设 $p_i$ 到 $p_r$ 距离为 $t$ ，设 $p_j$ 是 $p_i$ 的双亲，因 $p_j$ 到 $p_r$ 的距离为 $t - 1$ ，由归纳假设，在第 $t - 1$ 轮 $p_j$ 收到 $M$ 。由算法描述知，在第 $t$ 轮里 $p_i$ 收到来自于 $p_j$ 的消息。

$T h 2.2$ 当生成树高度为 $d$ 时，存在一个消息复杂度为 $n - 1$ ，时间复杂度为 $d$ 的同步广播算法。

② 异步模型

$L e mma 2.3$ 在异步模型的广播算法的每个容许执行里，树中每个距离 $p_r$ 为 $t$ 的处理器至多在时刻 $t$ 接收消息 $M$ 。

pf：对距离 $t$ 做归纳。

对 $t = 1$ ，初始时， $M$ 处在从 $p_r$ 到所有距离为1的处理器 $p_i$ 的传输之中，由异步模型的时间复杂性定义知， $p_i$ 至多在时刻1收到 $M$ 。

$p_i$ ∈ {距 $p_r$ 为 $t$ 的处理器}，设 $p_j$ 是 $p_i$ 的双亲，则 $p_j$ 与 $p_r$ 的距离为 $t - 1$ ，由归纳假设知， $p_j$ 至多在时刻 $t - 1$ 收到 $M$ ，由算法描述知， $p_j$ 发送给 $p_i$ 的 $M$ 至多在 $t$ 时刻到达。