Distributed Algorithms. The Leader Election Problem. 1.2 The Network Model. Applications. 1 The Problem and the Model. Lesson two Leader Election

Transcription

1 The Problem and the Model Distributed Algorithms Lesson two Leader Election. The problem What is a leader A leader is a member that all other nodes acknowledge as being distinguished to perform some special task. The Leader Election Problem Choosing a leader from a set of candidates, initially a node n i is only aware of its own identification and a totally order is defined on the set of all identifications. P P P P P P Applications Token ring One and only one leader Others. The Network Model Complete Network

2 The Network Model (Cont.) Synchronous Network There is a global clock. In every even pulse, every node sends a message, In every odd pulse, every node receives all messages sent to it in last pulse, performs some local computation to process these messages, and then it may (not ) send a message to another node. The Network Model (Cont.) Undirected graph (bi-directional channels) FIFO No Error The Basic Ideas and the Algorithm. The Basic Ideas Naive solution: Every node sends its identification to all other nodes at pulse 0 Every node receives all identifications of other nodes, and then computes the maximum identification at pulse. The leader is decided as the node with the maximum identification. The approach is simple, and its time complexity is O(). However, its message complexity is O( V ), where V is the set of nodes. In order to reduce the message complexity: Outline of the algorithm A candidate sends capture message(s) A node replies an ack to only one candidate (may receiving more captures but only reply to one) A candidate will send more captures if it received enough acks

3

4 . The Formal Description of the Algorithm See P and P of Introduction to distributed Algorithms Outline Variable: Initialization for all nodes (.) pulse s = 0, Initialization for initial actively (.) pulse s = odd, receiving messages, comparing of identifications and deciding whether it sends an ack or not. (.) pulse s = even, to proceed further, if receiving enough ack messages.. The Correctness of the Algorithm The attempt to capture more nodes in (.) is conditioned upon having received as many ack s as needed for the last attempt. In (.) n i decides whether to change its owner or not depending on the comparison of identifiers received and the owner s. The Correctness (Cont.) After all log n + pulses have elapsed. Every n i s owner is the node with greatest identification. From every node s point of view, the elected leader is the same. The Correctness (Cont.) Because of the total order, the node with the greatest id must have captured all nodes after log n + pulses, and All others must have sent ack message to the node and changed their owner to the node.. The Complexity of the Algorithm The time complexity is O(log n) since it requires log n + pulses. The message complexity is O(n log n) The bit message complexity is O(n (log n))

5 The Message Complexity Theorem.: For k log n -, the maximum number of nodes to reach pulse s = k as candidates in Algorithm S_Elect_Leader_C is n/k- At pulse s = k, a node must have captured k- nodes to be still a candidate. Every node can be captured by only one node (has only one owner). Every node captures at least k- nodes. There are n nodes in total. Thus, at most n/ k- nodes are still candidates. Any of the n nodes may only be captured by at most one candidate at any odd pulse. Corollary.: Algorithm S_Elect_Leader_C employs at most n log n -n capture messages and at most n log n ack messages. By (.), a node sends at most one ack per odd pulse, so that the total number of ack s is no more than n log n. The initial number of candidates is at most n, so by (.) at pulse s = 0 at most n capture s are sent. For k log n -, by (.) at pulse s = k a candidate sends at most k capture's. by Theorem., the number of candidates at this pulse in no larger than n/k- And then the total number of capture s is at most n + n/k- k n + n( log n - ) = n log n -n The message complexity of the algorithm is O(n log n) The bit message complexity of the algorithm is O(n (log n)), since a capture message carries a node s identification. Summary Leader Election Traditional distributed problem (algorithm) Many applications The techniques for reducing messages To whom and when to send messages Local decision Extensions