5-consensus_zy 容错一致性

How many processors total are needed to solve consensus when f = 1 ? Suppose n = 2. If p0 has input 0 and p1 has 1, someone has to change, but not both. What if one processor is faulty? How can the other one know? Suppose n = 3. If p0 has input 0, p1 has input 1, and p2 is faulty, then a tie-breaker is needed, but p2 can act maliciously. Theorem (5.7): Any consensus algorithm for 1 Byzantine failure must have at least 4 processors.
2
Consensus Problem
Every processor has an input. Termination: Eventually every nonfaulty processor must decide on a value. Agreement: All decisions by nonfaulty processors must be the same. Validity: If all inputs are the same, then the decision of a nonfaulty processor must equal the common input.
6
Consensus Algorithm for Crash Failures
Code for each processor:
v := my at each if I wait v := input round 1 through f+1: have not yet sent v then send v to all to receive messages for this round minimum among all received values and current value of v if this is round f+1 then decide on v
Fault-Tolerant Consensus
Synchronous Systems with Crash Failures Synchronous Systems with Byzantine Failures
1
Processor Failures in Message Passing
Crash: at some point the processor stops taking steps
4
Modeling Crash Failures
Modify failure-free definitions of admissible execution to accommodate crash failures: All but a set of at most f processors (the faulty ones) taken an infinite number of steps.
Continue for f + 1 rounds
15
Calculating the Decision
In round f + 1, each processor uses the values in its tree to compute its decision. Recursively compute the "resolved" value for the root of the tree, resolve(λ), based on the "resolved" values for the other tree nodes:
at the processor's final step, it might succeed in sending only a subset of the messages it is supposed to send
Byzantine: processor changes state arbitrarily and sends messages with arbitrary content
Number of processors n > f f + 1 rounds at most n2 •|V| messages, each of size log|V| bits, where V is the input set.
10
Consensus with Byzantine Failures
q1
round 1
q2
round 2
…
qf
round f
qf+1
round f+1
pj pi
There are f + 1 faulty processors in this chain, a contradiction.
9
Performance of Crash Consensus Algorithm
7
Correctness of Crash Consensus Algorithm
Termination: By the code, finish in round f+1. Validity: Holds since processors do not introduce spurious messages: if all inputs are the same, then that is the only value ever in circulation.
11
Exponential Tree Algorithm
This algorithm uses
f + 1 rounds (optimal) n = 3f + 1 processors (optimal) exponential size messages (sub-optimal)
Each processor keeps a tree data structure in its local state Values are filled in the tree during the f + 1 rounds At the end, the values in the tree are used to calculate the decision.
13
Example of Local Tree
The tree when n = 4 and f = 1 :
14
Filling in the Tree Nodes
Initially store your input in the root (level 0) Round 1:
send level 0 of your tree to all store value x received from each pj in tree node labeled j (level 1); use a default if necessary "pj told me that pj 's input was x"
value in tree node labeled π if it is a leaf
resolve(π) =
majority{resolve(π ') : π' is a child of π} otherwise (use a default if tied)
16
Example of Resolving Values
3
Overview of Consensus Results
Impossible in asynchronous case. Even if we only want to tolerate a single crash failure. True both for message passing and shared read-write memory.
5
Modeling Byzfy failure-free definitions of admissible execution to accommodate Byzantine failures: A set of at most f processors (the faulty ones) can send messages with arbitrary content and change state arbitrarily (i.e., not according to their transition functions).
In synchronous case: once a faulty processor fails to take a step in a round, it takes no more steps.
In a faulty processor's last step, an arbitrary subset of the processor's outgoing messages make it into the channels.
8
Correctness of Crash Consensus Algorithm
Agreement:
Suppose in contradiction pj decides on a smaller value, x, than does pi. Then x was hidden from pi by a chain of faulty processors: