超级会员免费看
可靠的去中心化合作算法：DARE 分析
在分布式计算领域，多个处理器协同执行大量计算密集型任务时，处理器的可靠性和算法的效率是关键问题。本文将介绍一种名为 DARE（Decentralized Algorithm with Reliability Estimation）的算法，该算法旨在解决处理器可能出现故障和返回错误结果的问题，并分析其在不同对抗模型下的性能。
1. 系统模型与定义
- 系统模型 ：系统中有 n 个处理器，每个处理器有唯一的标识符。消息传递系统是同步且点对点可靠的，但广播不可靠。计算以轮为单位进行，每轮处理器可发送消息、接收消息、执行一个任务和进行一些本地计算。
- 任务 ：有 t 个任务，每个任务有唯一的标识符。任务具有相似性、独立性和幂等性，且 t ≥ n。
-
对抗模型
：处理器可能出现两种故障：崩溃和返回错误结果。定义了三种对抗模型：
- Model Fℓf ：对手受处理器数量的线性分数约束，即 |P - F| ≥ cn，其中 c ∈ (0, 1)。
- Model Ffp ：对手受分数多项式约束，即 |P - F| = Ω(na)，其中 a ∈ (0, 1)。
- Model Fpl ：对手受多对数约束，即 |P - F| = Ω(logc n)，其中 c ≥ 1。
- 效率度量 ：使用通信轮数、工作量和消息复杂度来评估算法。事件 E 以高概率发生（whp）表示 Pr[E] = 1 - O(n - α)，其中 α > 0。
2. DARE 算法描述
DARE 算法分为两个阶段：估计阶段和计算阶段。
-
估计阶段
：处理器使用算法 Aest 计算所有处理器正确计算任务结果的概率估计，并将计算错误结果的概率存储在数组 Ei[] 中。如果检测到处理器 j 崩溃，则将 Ei[j] 设置为 -1。
-
计算阶段
：每个处理器维护一些本地知识和状态变量，如结果数组 Ri[]、最终结果数组 Resultsi[] 等。算法通过一个循环进行，每个处理器初始为工作者，在每次迭代中，工作者随机选择一个任务执行，并将其结果数组发送给另一个随机选择的处理器。当工作者获得“足够”的任务知识时，它计算最终结果并成为启发者，通过多播将其知识发送给随机选择的处理器集合。循环在收到 km log n 个启发消息后终止。
以下是 DARE 算法的伪代码：
Procedure for processor i;
external n, t, km, kt /* n processors and t tasks; km, kt are constants */
Task[1..t] /* set of tasks */
Ei[1..n] init ⊥ /* estimates of pj for each j ∈ P */
Ri[1..t] init ∅n /* set of collected results */
Resultsi[1..t] init ⊥ /* array of results */
prof ctr init 0 /* number of profess messages received */
r init 0 /* round number */
ℓ init 0 /* number of profess messages to send */
worker init true /* initially each processor is a worker */
estimation phase
Use procedure Aest [5] to compute Estimatei[1..n]
/* Estimatei[q] = if q crashes then -1 else (ϵ, δ)-approximation of 1 - pq */
for each j ∈ P do /* Prob. of computing incorrectly */
Ei[j] ← if Estimatei[j] ̸= -1 then 1 - Estimatei[j] else -1
/* Here Ei[j] is rounded to the numerical precision Δ */
computation phase
while prof ctr < km log n do
Send:
1:
if worker then
2:
Let q be a randomly selected processor from P
3:
Send ⟨share, Ri[ ]⟩ to processor q
4:
else
5:
Let D be a set of 2ℓ log n randomly selected processors from P
6:
Send ⟨profess, Ri[ ]⟩ to processors in D
7:
ℓ ← ℓ + 1
Receive:
8:
Let M be the set of received messages
9:
prof ctr ← prof ctr + |{m : m ∈ M ∧ m.type = profess}| /* count msgs */
10:
for all j ∈ T do /* update knowledge */
11:
Ri[j] ← Ri[j] ∪ (∪m∈M m.R[j])
Compute:
12:
r ← r + 1
13:
if worker then
14:
Randomly select j ∈ T and compute the result vj for Task[j]
15:
Ri[j] ← Ri[j] ∪ {⟨vj, i, r⟩}
16:
for all j ∈ T do
17:
Let Q = {s : ⟨, s, ⟩ ∈ Ri[j]}
18:
S ← select(Q, Ri[j], Ei[ ], 2ζ)
19:
Let Kj = {⟨v, s, q⟩: ⟨v, s, q⟩ ∈ Ri[j] ∧ s ∈ S}
20:
if minj∈T {|Kj|} ≥ kt log n then /* sufficient results for all tasks */
21:
for all j ∈ T do
22:
Resultsi[j] ← u such that triples ⟨u, , ⟩ form a plurality in Kj
23:
worker ← false /* worker is enlightened */
end.
3. 计算阶段的详细步骤
计算阶段的每次迭代包括三个阶段：发送阶段、接收阶段和计算阶段。
-
发送阶段
：工作者随机选择一个目标处理器 q，并将其结果数组 Ri[] 以共享消息的形式发送给 q。启发者随机选择一个大小为 2ℓ log n 的处理器集合 D，并将其结果数组 Ri[] 以启发消息的形式发送给 D 中的处理器。
-
接收阶段
：处理器接收上一发送阶段发送给它的消息，增加启发消息计数器 prof ctr，并更新其结果数组 Ri[]。
-
计算阶段
：工作者随机选择一个任务 j 进行计算，并将结果添加到 Ri[j] 中。对于每个任务，工作者使用 select 过程选择一组处理器，计算这些处理器的结果集合 Kj。当每个任务的 Kj 大小至少为 kt log n 时，工作者计算最终结果并成为启发者。
4. select 过程
select 过程用于为每个任务选择一组处理器，使得这些处理器的平均错误概率小于 1/2 - ζ，并且计算的结果集合最大。该过程通过解决一个 0 - 1 背包问题来实现。
Procedure select(Q, Z, E[ ], η)
S1, S2 init ∅ /* subsets of selected processors */
1:
S1 ← {s | s ∈ Q ∧ E[s] ≤ 1/2 - η}
2:
Q′ ← Q \ S1
3:
Let ℓ = |Q′| and ⟨s1, ..., sℓ⟩ be some ordering of sk ∈ Q′
4:
Let w = ⟨E[s1] - 1/2 + η, ..., E[sℓ] - 1/2 + η⟩ /* the weight vector for sk ∈ Q′ */
5:
Let v = ⟨λ1, · · ·, λℓ⟩, where λk = |{τ | τ = ⟨, sk, ⟩ ∈ Z}|
/* λk is the number of results in Z calculated by processor sk ∈ Q′ */
6:
W ← ∑s∈S1(1/2 - η - E[s])
7:
S2 ← BinaryKnapSack(v, w, W)
8:
return S1 ∪ S2
5. 复杂度分析
在不同的对抗模型下分析 DARE 算法的复杂度。
-
估计阶段
：算法 Aest 在不同对抗模型下的时间、工作量和消息复杂度如下表所示：
| 对抗模型 | 时间复杂度 | 工作量复杂度 | 消息复杂度 |
| ---- | ---- | ---- | ---- |
| Model Fℓf | O(log n) | O(n log n) | O(n log2 n) |
| Model Ffp | O(n1 - a log n log log n) | O(n log n log log n) | O(n log2 n log log n) |
| Model Fpl | O(n) | O(n1 + a) | O(n1 + a) |
-
计算阶段
：通过一系列引理和定理证明了 select 过程的正确性和效率，并分析了算法在不同对抗模型下的轮数、工作量和消息复杂度。
- Model Fℓf ：算法在 Θ(log n) 轮内正确执行所有 n 个任务，工作量复杂度为 Θ(n log n)，消息复杂度为 O(n log2 n)。对于 t ≥ n 的任务，算法需要 Θ(t/n log n) 轮，工作量复杂度为 Θ(t log n)，消息复杂度为 O(n log2 n)。
- Model Ffp ：算法分为两个时期进行分析，最终在 O(n1 - a log n log log n) 轮内正确执行所有 n 个任务，工作量复杂度为 O(n log n log log n)，消息复杂度为 O(n log2 n log log n)。对于 t ≥ n 的任务，算法需要 O(t/na log n log log n) 轮，工作量复杂度为 O(t log n log log n)，消息复杂度为 O(n log2 n log log n)。
- Model Fpl ：算法也分为两个时期进行分析，最终在 O(n) 轮内正确执行所有 n 个任务，工作量复杂度为 O(n1 + a)，消息复杂度为 O(n1 + a)。对于 t ≥ n 的任务，算法需要 O(t) 轮，工作量复杂度为 O(t · na)，消息复杂度为 O(n1 + a)。
以下是 DARE 算法在不同对抗模型下的复杂度总结：
| 对抗模型 | 轮数复杂度 | 工作量复杂度 | 消息复杂度 |
| ---- | ---- | ---- | ---- |
| Model Fℓf | Θ(log n)（n 任务）
Θ(t/n log n)（t ≥ n 任务） | Θ(n log n)（n 任务）
Θ(t log n)（t ≥ n 任务） | O(n log2 n) |
| Model Ffp | O(n1 - a log n log log n)（n 任务）
O(t/na log n log log n)（t ≥ n 任务） | O(n log n log log n)（n 任务）
O(t log n log log n)（t ≥ n 任务） | O(n log2 n log log n) |
| Model Fpl | O(n)（n 任务）
O(t)（t ≥ n 任务） | O(n1 + a)（n 任务）
O(t · na)（t ≥ n 任务） | O(n1 + a) |
mermaid 格式流程图展示 DARE 算法的计算阶段流程：
graph TD;
A[开始] --> B[估计阶段];
B --> C[计算阶段];
C --> D{prof ctr < km log n};
D -- 是 --> E[发送阶段];
E --> F[接收阶段];
F --> G[计算阶段];
G --> D;
D -- 否 --> H[结束];
通过以上分析，DARE 算法在不同的对抗模型下都能以较高的效率和可靠性完成任务，为分布式计算中的处理器合作提供了一种有效的解决方案。
可靠的去中心化合作算法：DARE 分析
6. 引理证明与算法可靠性
在分析 DARE 算法的过程中，多个引理起到了关键作用，确保了算法的可靠性和效率。
-
引理 1
：当处理器 i 调用
select(Q, Z = Ri[j], E[ ] = Ei[ ], η = 2ζ)
时，它返回的集合 S 满足 $\frac{1}{|S|}\sum_{s\in S}\tilde{p_s} \leq \frac{1}{2} - 2\zeta$，并且从 Z 中由 S 中的处理器计算的结果子集是所有满足 $\frac{1}{|X|}\sum_{s\in X}\tilde{p_s} \leq \frac{1}{2} - 2\zeta$ 的子集 X 中最大的。证明过程将优化问题转化为 0 - 1 背包问题，通过合理的集合划分和推理，得出了该引理的正确性。
-
引理 2
：对于结果参数 Z 满足 $|Z| = O(\log n \cdot \log \log n)$ 的情况，
select
过程在每个任务上以高概率在本地多项式对数时间内返回。这保证了算法在计算过程中的时间效率。
-
引理 3
：
select
为任何任务 j 返回的子集 S 满足 $\frac{1}{|S|}\sum_{s\in S} p_i \leq \frac{1}{2} - \zeta$，以高概率成立。这表明估计值 $\tilde{p_i}$ 满足平均概率约束时，实际概率 $p_i$ 也能以高概率满足该约束，进一步证明了算法的可靠性。
-
引理 4
：设 r 是总
profess
消息数达到 $\Theta(n \log n)$ 的第一轮，那么到这一轮结束时，每个存活的处理器以高概率停止。这为算法的终止条件提供了理论依据。
-
引理 5
：一旦处理器 $v \in P - F$ 成为启发者，每个存活的处理器在额外的 $O(\log n)$ 轮内以高概率停止。这说明了启发者对算法终止的推动作用。
7. 不同对抗模型下的详细分析
7.1 Model Fℓf
在这个模型中，处理器崩溃数量受线性分数约束。
-
任务执行次数
：引理 6 表明，在算法的计算阶段，H 中的处理器在 $\Theta(\log n)$ 轮内以高概率对每个任务执行 $\Theta(\log n)$ 次。
-
启发者出现
：引理 7 指出，当 H 中的工作者对每个任务执行 $\Theta(\log n)$ 次后，在额外的 $\Theta(\log n)$ 轮内，H 中至少有一个工作者以高概率成为启发者。
-
算法性能总结
：定理 2 说明算法在 $\Theta(\log n)$ 轮内以高概率正确执行所有 n 个任务，并且每个存活的处理器都能知道结果。定理 3 给出了算法的复杂度，即 $\Theta(\log n)$ 轮，工作量复杂度为 $\Theta(n \log n)$，消息复杂度为 $O(n \log^2 n)$。对于 $t \geq n$ 的任务，定理 4 指出算法需要 $\Theta(\frac{t}{n} \log n)$ 轮，工作量复杂度为 $\Theta(t \log n)$，消息复杂度为 $O(n \log^2 n)$。
7.2 Model Ffp
该模型中 $|F| \leq n - n^a$，算法执行分为两个时期。
-
任务执行与启发者出现
：引理 8 表明，在 $O(n^{1 - a} \log n)$ 轮内，H 中的处理器以高概率对每个任务执行 $\Theta(\log n)$ 次。通过一系列引理（引理 9 - 11）的证明，得出在 $O(n^{1 - a} \log n \log \log n)$ 轮内，H 中至少有一个处理器以高概率成为启发者。
-
算法性能总结
：定理 5 说明算法在 $O(n^{1 - a} \log n \log \log n)$ 轮内以高概率正确执行所有 n 个任务。定理 6 给出了算法的复杂度，即 $O(n^{1 - a} \log n \log \log n)$ 轮，工作量复杂度为 $O(n \log n \log \log n)$，消息复杂度为 $O(n \log^2 n \log \log n)$。对于 $t \geq n$ 的任务，定理 7 指出算法需要 $O(\frac{t}{n^a} \log n \log \log n)$ 轮，工作量复杂度为 $O(t \log n \log \log n)$，消息复杂度为 $O(n \log^2 n \log \log n)$。
7.3 Model Fpl
此模型中 $|P - F| = \Omega(\log^c n)$，算法执行也分为两个时期。
-
任务执行与启发者出现
：引理 12 表明，在 $O(n)$ 轮内，H 中的处理器以高概率对每个任务执行 $\Theta(\log n)$ 次。引理 13 指出，当每个任务执行 $\Theta(\log n)$ 次后，H 中至少有一个工作者在 $O(n)$ 轮内以高概率成为启发者。
-
算法性能总结
：定理 8 说明算法在 $O(n)$ 轮内以高概率正确执行所有 n 个任务。定理 9 给出了算法的复杂度，即 $O(n)$ 轮，工作量复杂度为 $O(n^{1 + a})$，消息复杂度为 $O(n^{1 + a})$。对于 $t \geq n$ 的任务，定理 10 指出算法需要 $O(t)$ 轮，工作量复杂度为 $O(t \cdot n^a)$，消息复杂度为 $O(n^{1 + a})$。
8. 复杂度对比表格
为了更直观地对比不同对抗模型下算法的复杂度，我们给出以下表格：
| 对抗模型 | 轮数复杂度（n 任务） | 轮数复杂度（t ≥ n 任务） | 工作量复杂度（n 任务） | 工作量复杂度（t ≥ n 任务） | 消息复杂度 |
| ---- | ---- | ---- | ---- | ---- | ---- |
| Model Fℓf | Θ(log n) | Θ(t/n log n) | Θ(n log n) | Θ(t log n) | O(n log² n) |
| Model Ffp | O(n¹⁻ᵃ log n log log n) | O(t/nᵃ log n log log n) | O(n log n log log n) | O(t log n log log n) | O(n log² n log log n) |
| Model Fpl | O(n) | O(t) | O(n¹⁺ᵃ) | O(t · nᵃ) | O(n¹⁺ᵃ) |
9. 流程图：算法整体流程
graph LR;
A[开始] --> B[估计阶段];
B --> C[计算阶段];
C --> D{是否满足终止条件};
D -- 否 --> E[发送阶段];
E --> F[接收阶段];
F --> G[计算阶段];
G --> D;
D -- 是 --> H[结束];
10. 总结
DARE 算法通过估计阶段和计算阶段的协同工作，结合
select
过程对处理器的选择，在不同的对抗模型下都能以较高的效率和可靠性完成任务。不同对抗模型下的复杂度分析为算法在实际应用中的选择提供了重要参考。例如，在处理器崩溃受线性分数约束的 Model Fℓf 模型中，算法具有较好的时间和工作量复杂度；而在 Model Ffp 和 Model Fpl 模型中，虽然复杂度相对较高，但也能在合理的范围内完成任务。通过这些理论分析和证明，DARE 算法为分布式计算中的处理器合作提供了一种有效的解决方案，能够应对处理器可能出现的故障和错误结果问题。
扫一扫
31万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
