distributed computing on topics of: leader election + byzantine algorithms)
TRANSCRIPT
Distributed Computing On Topics of: Leader election + Byzantine algorithms)
SLIDES BY OSAMA ASKOURA
EECS 6117
Distributed Computing Set 2
Leader Election in rings
Slide
2
We define leader election:
By the end of algorithm’s execution, only one
node identifies as “leader”
All other nodes identify as “follower”
Leader Election in anonymous rings is
impossible.
Leader Election in
Model
Ring Topology
Synchronous
Non Anonymous Processes
Anonymous ring Non-Anonymous ring
#1
#3 #9
#7 #5
#2
#3
#4
Leader Election in non-anonymous rings
Slide
2
Leader election algorithm 1:
• send id CCW;
• Forward msgs until you receive own id back;
• If ( my id was smallest seen before own id
comes back )
• Then I’m “leader”
• Else
• Not leader “follower”
Total # messages = n2
Model
Ring Topology
Synchronous
Non Anonymous Processes
Non-Anonymous ring
#1
#3 #9
#7 #5
#2
#3
#4
Slide
2
Leader election algorithm 2:
• Candidate = true;
• loop
• send id CCW and CW (bi-directional)
• If received id < own id
• Candidate = false
• Exit loop (“follower”)
• If got own id back
• I’m “leader”
• Exit loop
Total # messages = 2n log(n)
Model
Ring Topology
Synchronous
Non Anonymous Processes
Bi-directional msgs
Non-Anonymous ring
#1
#3 #9
#7 #5
#2
#8
#4
Leader election algorithm 2:
Proof that total # messages = 2n log(n):
• Every cycle each node sends 2 msgs 2n messages
• Every cycle you eliminate half log(n) cycles
• Total = 2n log(n)
Model
Ring Topology
Synchronous
Non Anonymous Processes
Bi-directional msgs
Non-Anonymous ring
#1
#3 #9
#7 #5
#2
#8
#4
#1
#3 #9
#7 #5
#2
#8
#4
#1
#9
#7 #5
#2
#8
#3
#4
#1
#9
#7 #5
#2
#8
#3
#4
#1
#9
#7 #5
#2
#8
#3
#4
Slide
2
Leader election algorithm 3:
• Wait until CLOCK = n * id
• Declare yourself leader
• Send everybody telling you are leader
Total # messages = n
But what if id’s are very large numbers or IP addresses?
• Time complexity grows big
• Cannot compare IP to CLOCK Model
Ring Topology
Synchronous
Non Anonymous Processes
#1
#3 #9
#7 #5
#2
#8
#4
Slide
2
CLAIM:
Every Leader Election algorithm in this model uses Ω( n log(n) )
messages
PROOF (Contradiction):
Suppose, exists algorithm that uses < n log(n) messages
Let A be that L.E algorithm
Transform A into A’ so that in A’ every process outputs minimum
id’s
So, A’ is
1. Elect leader;
2. Leader sends message around round to find smallest id
3. Leader sends smallest id to all
Model
Ring Topology
Synchronous
Non Anonymous Processes
#1
#3 #9
#7 #5
#2
#8
#4
Slide
2
If A uses A(n) messages, then A’ uses A(n) + 2n messages
We will show that A(n) + 2n ≥ c. n log(n)
i.e. A(n) ≥ c. log(n)
Base n = 1: at least 0 messages
m(n) :
m(1) = 0
m(n) = 2 m(n) + 𝒏
𝟐
Two rings proof Model
Ring Topology
Synchronous
Non Anonymous Processes
#1
#3 #9
#7 #5
#2
#8
#4
Byzantine Agreement
in complete graphs
We look at the problem where a group of processes or nodes
need to agree on an output. In Byzantine agreements, some
nodes are allowed to be malicious. i.e. stay alive but not
follow their algorithm.
This problem arises in distributed systems with sensors
that can be faulty; such as airplane systems
Byzantine
Process
Correct
Processes
Agreement Property
All outputs of correct processes are same
Validity Property
If all inputs are “v”, then all outputs of correct processes are “v”
Byzantine
Process
Correct
Processes
Examples for Agreement with n=2 #failures = 0
Solution: each process send their input to each other; output
AND of the inputs (ensures both output same value)
Model
Non Anonymous Processes ( Proc IDs)
Message Passing System
Complete Network
Synchronous
No cryptography (used in reality to
avoid byzantine/malicious nodes)
Examples for Agreement with n=2 #failures = 1 (up to 1 failure: we don’t know if any will fail)
Solution Attempt:
output whatever your input is; No communication in between.
- This satisfies validity property (if all input was v; all output is v)
- But doesn’t satisfy agreement property. How?:
So if n=2 & f =1, it’s impossible to solve
Model
Non Anonymous Processes ( Proc IDs)
Message Passing System
Complete Network
Synchronous
No cryptography (used in reality to
avoid byzantine/malicious nodes)
v1
v1
v1
v1
1
1
0
0
Examples for Agreement with n=3 #failures = 1 (up to 1 failure: we don’t know if any will fail)
Solution Attempt:
Round 1: send to your neighbors your input
Round 2: ask other nodes what others sent them?
Problem: Bad guy can send inconsistent answers to bias their
decisions and violate agreement or validity property.
n = 3 and f = 1 is impossible
Model
Non Anonymous Processes ( Proc IDs)
Message Passing System
Complete Network
Synchronous
No cryptography (used in reality to
avoid byzantine/malicious nodes)
1 1
0 1
0 0
0
1 Byzantine:
sends
inconsistent
values to each
0 1
0 1
0 1
0
1 Byzantine:
sends
inconsistent
values to each
Round 1 Round 2
Byzantine Agreement in n = 4, f =1 is possible.
Byzantine Agreement is possible if n > 3f
Proving impossibility for n ≤ 3f
Claim: it’s impossible for n ≤ 3f
Proof (by contradiction):
assume it’s possible for n ≤ 3f i.e. exists algorithm A, that
solve it, then we can show that n=3, f=1 is solvable by A
If there is an algorithm for n=3, f=1 take it and run it on 6
nodes as follows:
Then processes a & b can’t tell difference if P3’ and P3
send you same as
P3’
P3
a
b
Algorithm for Byzantine Agreement if n > 4f: for i=1 to f+1
round 1: send preference to everyone
round 2: if i=my_id then
send majority value received in prev round
Lemma 1: if all correct processes have same preference v at
start of phase P, they have preference v at end of phase P.
Proof: In round 1, all correct processes send v (≥ n-f v’s sent)
n-f > f + 𝑛
2 ≡
𝑛
2 > 2f ≡ n > 4f
Therefore, satisfying validity property follows from Lemma 1
Algorithm for Byzantine Agreement if n > 4f:
Lemma 2: if process i is correct, then all correct processes have
same preference at end of phase P.
Proof: Any 2 correct proc that update to leader’s value choose
same preference (since leader is correct)
Any 2 that chooses value because they get > f+ 𝑛
2 copies must
choose same value. (since > 𝑛
2 copies caused from correct
processes + cannot be each of 2 different values )
Proof (continued): if any proc gets > f + 𝑛
2 copies of v then:
• > 𝑛
2 v’s came from correct processes
• Leader gets > 𝑛
2 copies of v
• Leader sends v
• all correct processes choose v
Thus satisfying agreement property follows from Lemma 2
Since we proved that our algorithm satisfies validity and
agreement, we prove that our algorithm is correct.
Byzantine Agreement
in incomplete graphs
Byzantine agreement works in complete graphs (model
below) if n > 3f
But for incomplete graphs, an extra condition holds.
Why?
Model
Non Anonymous Processes ( Proc IDs)
Message Passing System
Complete Network
Synchronous
No cryptography (used in reality to
avoid byzantine/malicious nodes)
A
C
B
D
Nodes B or C can fail, but NOT both
If this happens, the agreement is not
solvable.
Byzantine agreement works in complete graphs (model
below) if n > 3f
But for incomplete graphs, an extra condition holds.
Why?
Model
Non Anonymous Processes ( Proc IDs)
Message Passing System
Complete Network
Synchronous
No cryptography (used in reality to
avoid byzantine/malicious nodes)
A
C
B
D
Nodes B or C can fail, but NOT both (so n > 3f)
BUT
If this happens, the agreement
is not solvable: as A and D can only
communicate reliably one non-byzantine
process. However, the byzantine process
can reach all other 3.
Generality:
Byzantine Agreement is solvable in any arbitrary graph
if and only if:
n > 3f AND connectivity > 2f
When we say model A is as strong as model B, we need to
prove any of:
1. All executions in A are also executions in B
2. Problems solvable in B are subset of problems
solvable in A • i.e. any problem the can be solved in B; can also be solved in A.
(Corollary: If a problem is impossible in A; it’s also impossible in B)
3. Show that A simulates B ( ᴟ transformation that
converts any algorithm for B into algorithm for A) • Strong simulates weak
B
executions
A
executions
Slide
18
EECS 6117 notes FW15-16, Instructor: Eric Ruppert
Hagit Attiya and Jennifer Welch. Distributed Computing: Fundamentals, Simulations and Advanced
Topics, 2nd edition. Wiley, 2004.
Nancy A. Lynch. Distributed Algorithms. Morgan Kaufmann, 1996.
References