Distributed Algorithms

Reliable Broadcast
Prof R. Guerraoui
Lpdwww.epfl.ch

© R. Guerraoui 1
 Broadcast

A
m deliver
B
m
broadcast
deliver

C
2
 Broadcast abstractions

P2

P3
P1 Best-effort broadcast
Reliable broadcast
Uniform broadcast

3
Modules of a process

indication

request (deliver)

indication

(deliver) (deliver)
indication indication

request (deliver) request (deliver)

4
 Intuition
Broadcast is useful for instance in applications
where some processes subscribe to events
published by other processes (e.g., stocks)

The subscribers might require some

reliability guarantees from the broadcast
service (we say sometimes quality of service
– QoS) that the underlying network does not
provide
5
 Overview
We shall consider three forms of reliability for
a broadcast primitive
(1) Best-effort broadcast
(2) (Regular) reliable broadcast
(3) Uniform (reliable) broadcast
We shall give first specifications and
then algorithms

6
 Best-effort broadcast (beb)

Events
Request: <bebBroadcast, m>
Indication: <bebDeliver, src, m>

• Properties: BEB1, BEB2, BEB3

7
Best-effort broadcast (beb)
Properties
BEB1. Validity: If pi and pj are correct,
then every message broadcast by pi is
eventually delivered by pj
BEB2. No duplication: No message is
delivered more than once
BEB3. No creation: No message is
delivered unless it was broadcast

8
 Best-effort broadcast
delivery
p1
m
delivery
p2

m
p3 delivery

9
 Best-effort broadcast
delivery
p1 crash
m1 m2 m2
delivery
p2 delivery

m1
p3 delivery

10
 Reliable broadcast (rb)

Events
Request: <rbBroadcast, m>
Indication: <rbDeliver, src, m>

• Properties: RB1, RB2, RB3, RB4

11
 Reliable broadcast (rb)
Properties
RB1 = BEB1.
RB2 = BEB2.
RB3 = BEB3.
RB4. Agreement: For any message m, if
any correct process delivers m, then every
correct process delivers m

12
 Reliable broadcast

p1 crash
m1 m2
delivery delivery
p2
m2
m1
p3 delivery delivery

13
 Reliable broadcast

p1 crash
delivery
m1 m2
p2
delivery
m1
p3 delivery

14
 Reliable broadcast
delivery delivery
p1 crash
m1 m2 m2
delivery delivery
p2 crash

m1
delivery
p3

15
 Uniform broadcast (urb)

Events
Request: <urbBroadcast, m>
Indication: <urbDeliver, src, m>

• Properties: URB1, URB2, URB3, URB4

16
 Uniform broadcast (urb)
Properties
URB1 = BEB1.
URB2 = BEB2.
URB3 = BEB3.
URB4. Uniform Agreement: For any
message m, if any process delivers m, then
every correct process delivers m

17
 Uniform reliable broadcast

delivery delivery
p1 crash
m1 m2
delivery delivery
p2 crash

m1 m2

p3 delivery delivery

18
 Uniform reliable broadcast
delivery
p1 crash
m1 m2
delivery
p2 crash

m1
delivery
p3

19
 Overview
We consider three forms of reliability for a
broadcast primitive
(1) Best-effort broadcast
(2) (Regular) reliable broadcast
(3) Uniform (reliable) broadcast
We give first specifications and then
algorithms

20
 Algorithm (beb)
Implements: BestEffortBroadcast (beb).
Uses: PerfectLinks (pp2p).
upon event < bebBroadcast, m> do
forall pi Î S do
trigger < pp2pSend, pi, m>;
upon event < pp2pDeliver, pi, m> do
trigger < bebDeliver, pi, m>;
21
 Algorithm (beb)
delivery
p1
m
delivery
p2

m
p3 delivery

22
 Algorithm (beb)
Proof (sketch)
BEB1. Validity: By the validity property of perfect
links and the very facts that (1) the sender sends the
message to all and (2) every correct process that
pp2pDelivers a message bebDelivers it
BEB2. No duplication: By the no duplication
property of perfect links
BEB3. No creation: By the no creation property of
perfect links

23
 Algorithm (beb)

p1 crash
delivery
m1 m2 m2
p2
delivery delivery
m1
delivery
p3

24
 Algorithm (rb)
Implements: ReliableBroadcast (rb).
Uses:
BestEffortBroadcast (beb).
PerfectFailureDetector (P).
upon event < Init > do
delivered := Æ;
correct := S;
forall pi Î S do from[pi] := Æ;

25
 Algorithm (rb – cont’d)

upon event < rbBroadcast, m> do

delivered := delivered U {m};
trigger < rbDeliver, self, m>;
trigger < bebBroadcast, [Data,self,m]>;

26
 Algorithm (rb – cont’d)

upon event < crash, pi > do

correct := correct \ {pi};
forall [pj,m] Î from[pi] do
trigger < bebBroadcast,[Data,pj,m]>;

27
 Algorithm (rb – cont’d)
upon event < bebDeliver, pi, [Data,pj,m]> do
if m Ï delivered then
delivered := delivered U {m};
trigger < rbDeliver, pj, m>;
if pi Ï correct then
trigger < bebBroadcast,[Data,pj,m]>;
else
from[pi] := from[pi] U {[pj,m]};

28
 Algorithm (rb)
p1
delivery
m

p2
delivery

m
p3 delivery

29
 Algorithm (rb)
p1
crash
m
m
p2
delivery m
m
p3
delivery

30
 Algorithm (rb)
Proof (sketch)
RB1. RB2. RB3: as for the 1st algorithm
RB4. Agreement: Assume some correct process
pi rbDelivers a message m rbBroadcast by some
process pk. If pk is correct, then by property
BEB1, all correct processes bebDeliver and then
rebDeliver m. If pk crashes, then by the
completeness property of P, pi detects the crash
and bebBroadcasts m to all. Since pi is correct,
then by property BEB1, all correct processes
bebDeliver and then rebDeliver m.
31
 Algorithm (urb)

Implements: uniformBroadcast (urb).

Uses:
BestEffortBroadcast (beb).
PerfectFailureDetector (P).
upon event < Init > do
correct := S;
delivered := forward := Æ;
ack[Message] := Æ;

32
 Algorithm (urb – cont’d)
upon event < crash, pi > do
correct := correct \ {pi};

upon event < urbBroadcast, m> do

forward := forward U {[self,m]};
trigger < bebBroadcast, [Data,self,m]>;

33
 Algorithm (urb – cont’d)

upon event <bebDeliver, pi, [Data,pj,m]> do

ack[m] := ack[m] U {pi};
if [pj,m] Ï forward then
forward := forward U {[pj,m]};
trigger < bebBroadcast,[Data,pj,m]>;

34
 Algorithm (urb – cont’d)

upon event (for any [pj,m] Î forward)

<correct Í ack[m]> and <m Ï delivered> do
delivered := delivered U {m};
trigger < urbDeliver, pj, m>;
35
 Algorithm (urb)
delivery
p1
m m m
delivery
p2

m m
m
p3 delivery

36
 Algorithm (urb)
delivery
p1
m m
crash
p2

suspicion
m
p3 m delivery

37
 Algorithm (urb)
Proof (sketch)
URB2. URB3: follow from BEB2 and BEB3
Lemma: If a correct process pi bebDelivers a
message m, then pi eventually urbDelivers m.
Any process that bebDelivers m bebBroadcasts m.
By the completeness property of the failure
detector and property BEB1, there is a time at
which pi bebDelivers m from every correct process
and hence urbDelivers m.

38
 Algorithm (urb)
Proof (sketch)
URB1. Validity: If a correct process pi
urbBroadcasts a message m, then pi eventually
bebBroadcasts and bebDelivers m: by our lemma,
pi urbDelivers m.
URB4. Agreement: Assume some process pi
urbDelivers a message m. By the algorithm and
the completeness and accuracy properties of the
failure detector, every correct process bebDelivers
m. By our lemma, every correct process will
urbDeliver m.
39