Distributed Computing 2. Leader Election – ring network Shmuel Zaks ©

message passing asynchronous ? Leader election

 motivation  who starts?  Leader election, maximum finding, spanning tree (Leader election)

 Unidirectional ring  Bidirectional rings  Complete networks  General networks (Leader election)

Unidirectional ring phases, unique execution (Leader election)

Bidirectional ring (Leader election) sense of direction L R L L L L L L L R R R R R R R

Bidirectional ring (Leader election) no sense of direction R R L L L L L L L R R L R R R R

Sense of Direction : For each process p in a bidirectional ring, its left and right neighbors are termed left(p) and right(p) respectively. If right(left(p)) = p for every p, then there is a sense of direction (otherwise – no sense of direction)

LeLann’s algorithm state := candidate; send (my_id); receive (nid); while nid ≠ my_id do if nid > my_id then state:=no_leader; send (nid); receive (nid); od; if state=candidate then state:=leader.

(LeLann’s algorithm) messages: 64 time: 8 My_id nid 1 5

Theorem: LeLann’s algorithm terminates, and exactly one processor is in state= leader. Message complexity: O(n 2 ) (worst and average) Time complexity: O(n) (LeLann’s algorithm)

Chang and Roberts algorithm state := candidate; send (my_id); receive (nid); while nid ≠ my_id do if nid > my_id then state:=no_leader; send (nid); receive (nid); od; if state=candidate then state:=leader.

or: state := candidate; send (my_id); while state ≠ leader do receive (nid); if nid > my_id then send (nid); od; if nid = my_id then state:=leader. (Chang and Roberts’ algorithm)

messages: = 20 time: 8

Theorem: Chang and Roberts’s algorithm terminates, and exactly one processor is in state= leader. Message complexity: O(n 2 ) (worst) Time complexity: O(n) (Chang and Roberts’ algorithm)

Theorem: The average message complexity of Chang and Roberts’s algorithm is O(n log n). assume all rings equally probably (for the proof – assume ids are 1,2,…, n) (Chang and Roberts’ algorithm)

K i P(i,k) – probability that id i makes exactly k steps (Chang and Roberts’ algorithm)

or: Consider all rings Each id makes 1 step – times Identity of P i : makes 2 nd step iff it is largest among Pi, Pi+1, which happens times Identity of Pi: makes 3 rd step iff it is largest among Pi, Pi+1,Pi+2, which happens times, etc … (Chang and Roberts’ algorithm)

Bidirectional rings messages: ? time: ?

Phases 1,2,… processors start phase k no. of phases messages time = O(n) Hirschberg and Sinclair’s algorithm

messages: ? time: ? Franklin’s algorithm

messages: ? (Franklin’s algorithm) messages: 16messages: 32messages: 48

no. of phases messages time = O(n) (Franklin’s algorithm) Exercise: what is the expected number of active processors after the first phase?

Peterson’s 1 st Algorithms This algorithm is a modification of Franklin’s algorithm for unidirectional ring. The basic idea is, during a phase, each active process receives the temporary identifier of its nearest active neighbor and that neighbor’s nearest active neighbor’s temporary identifier, then applies Franklin’s strategy. DKRP

Each node maintains four variables: state { candidate, relay, leader} tid – temporary identity ntid – first id received nntid – second id received (Peterson’s 1 st Algorithms)

state := candidate ; tid := id ; while state  relay do begin [start phase] send( tid ); receive( ntid ); if ntid = id then state := leader ; if tid > ntid then send( tid ); else send( ntid ); receive( nntid ); if nntid = id then state := leader ; if ntid  max( tid, nntid ) then tid := ntid else state := relay ; end; (now state = relay )

while state  leader do begin receive( tid ); if tid = id then state := leader ; send( tid ); end (now state = relay )

tid ntid nntid tid:=id; candidate [start phase] : send(tid); receive(ntid); phase 1a

tid ntid nntid candidate: if tid > ntid then send(tid); else send(ntid); receive(nntid); phase 1b

tid ntid nntid candidate: if ntid  max(tid, nntid) then tid:=ntid else state := relay; phase 1c

tid ntid nntid phase 2a candidate [start phase] : send(tid); receive(ntid); relay: …

tid ntid nntid phase 2b candidate: if tid > ntid then send(tid); else send(ntid); receive(nntid); relay: …

tid ntid nntid phase 2c candidate: if ntid  max(tid, nntid) then tid:=ntid else state := relay; relay: … 8

tid ntid nntid phase 3a candidate [start phase] : send(tid); receive(ntid); relay: … 8 8 8

Exercises: 1. why send max{tid,ntid}? 2. what happens if n=2? 3. what happens if n=1?

P max – processor holding max_id Phase 1,2,… t p - number of non-relay processors starting phase p. Lemma: During the execution of the algorithm, a candidate processor that becomes relay will never be in a candidate state. Lemma: For every p, if t p ≥ 3 then t p+1 ≤ t p / 2.

Lemma: if t p ≥ 3 then at the start of phase p: for p>1: The tid of a candidate is equal to the tid of the preceeding candidate in the previous phase. (corollary: for every p: each identity resides as the tid of at most one candidate processor.) If the id of P i resides in P k, then all processors P i,P i+1, …, P k-1 are relays. max_id resides as a tid of some processor. Lemma: if t p = 2 or t p = 1 then the algorithm terminates, with the processor holding max_id as a leader.

Theorem: Peterson’s 1st algorithm always determines a unique processor – the one holding the largest identity - as a leader. Message complexity ≤ 2n log n Time complexity ≤ 2n-1 Exercise: show examples for worst cases and for best cases in terms of time and in terms of messages.

Peterson’s 2 nd Algorithm improvement of Peterson’s 1 st algorithm Instead of comparing its id with both neighbors in the same time, a process first compares itself with its left neighbor, then its right neighbor.

Each node maintains four variables: state { candidate, relay, leader} tid – temporary identity ntid – id received (Peterson’s 2 nd Algorithms)

state := candidate ; tid := id ; while state  relay do begin [compare to left, odd phase] send( tid ); receive( ntid ); if ntid = id then state := leader ; if tid < ntid then state := relay ; end; begin [compare to right, even phase] send( tid ); receive( ntid ); if ntid = id then state := leader ; if tid > ntid then state := relay else tid := ntid ; end; (now state = relay )

while state  leader do begin receive( tid ); if tid = id then state := leader ; send( tid ); end (now state = relay )

tid ntid begin [compare left] send(tid); receive(ntid); if ntid = id then state :=leader; if tid < ntid then state := relay; end; phase 1a

tid ntid phase 1b begin [compare right] send(tid); receive(ntid); if ntid = id then state :=leader; if tid > ntid then state := relay else tid := ntid ; end; relay: …

tid ntid phase 2a begin [compare left] send(tid); receive(ntid); if ntid = id then state :=leader; if tid < ntid then state := relay; end; relay: …

Theorem: Peterson’s 2nd algorithm always determines a unique processor as a leader. Message complexity ≤ 1.44… n log n Exercise: show an example where a processor whose id is not the largest is elected as a leader.

phases p, p-1, … 1 (last phase) t k – no. of processors that remain candidates after phase k = no. of processors that start phase k-1. t p+1 = n t 1 = 1 t 2 ≥ 2

Lemma: t k ≤ no. of processors that became relay during phase k+1 Proof: We show that for each processor that remained active after phase k there is a processor that became relay during phase k+1 (the previous phase)

beginning of phase k+1 end of phase k end of phase k+1 = beginning of phase k p p p Case a: k is odd

P survived phase k: end of phase k end of phase k+1 = beginning of phase k p p q q ? Hence p > q Case a: k is odd

If in the beginning of phase k+1 all of these were already relays … end of phase k+1 = beginning of phase k p q then p would have become relay, contradiction. Case a: k is odd

Lemma: t k ≤ no. of processors that became relay during phase k+1 Corollary: t k ≤ t k+2 - t k+1 t k + t k+1 ≤ t k+2 t k ≥ Fibonacci k+1 =

n = t p+1 ≥ Fibonacci p+2 = message complexity ≤ np ≤ 1.44… n log n no. of phases = p ≤ 1.44… log n

References E. Chang and R. Roberts, An improved algorithm for decentralized extrema-finding in circular configurations of processes, Communications of the ACM}, 22, 5, 1979, pp

References D. Dolev, M. Klawe and M. Rodeh, An O(n log n) unidirectional distributed algorithm for extrema finding in a circle, Journal of Algorithms, 3, 1982, pp

References W. R. Franklin, On an improved algorithm for decentralized extrema finding in circular configurations of processors, Communication of the ACM, 25, 1982, pp

References D. S. Hirschberg and J. B. Sinclair, Decentralized extrema-finding in circular configuration of processors, Communications of the ACM, 23, 1980, pp

References G. LeLann, Distributed systems - towards a formal approach, Information Processing Letters, 1977, pp

References G. L. Peterson An O(nlogn) unidirectional algorithm for the circular extrema problem. ACM Trans. Program. Lang. Syst. 4,4 (Oct. 1982),

References N. Santoro, Sense of direction, topological awareness and communication complexity, SIGACT News, 16, 2, Summer 1984, pp