Optimal Distributed t- Resilient Election in Complete Networks

IFAC-PapersOnLine

Leader election, a fundamental coordination problem in distributed systems, has been addressed in many different ways. Among these works, resilient leader election algorithms are of particular interest due to the ongoing emergence of open, complex distributed systems such as smart cities and the Internet of Things. However, previous algorithms with O(diameter) stabilization time complexity either assume some prior knowledge of the network or that very large messages can be sent. In this paper, we present a resilient leader election algorithm with O(diameter) stabilization time, small messages, and no prior knowledge of the network. This algorithm is based on aggregate computing, which provides a layered approach to algorithm development based on composition of resilient algorithmic "building blocks." With our algorithm, a key design parameter K defines important performance attributes: a larger K will delay the recovery from loss of current leader, while a small K may lead to multiple leaders, and the algorithm will stabilize with O(diameter) time complexity when K ≥ 2.

International Journal of Next-Generation Networks, 2013

Leader Election Algorithm , not only in distributed systems but in any communication network, is an essential matter for discussion. Tremendous amount of work are happening in the research community on this Election, because many network protocols are in need of a coordinator process for the smooth running of the system. These socalled Leader or Coordinator processes are responsible for the synchronization of the system. If there is no synchronization, then the entire system would become inconsistent which intern makes the system to lose its reliability. Since all the processes need to interact with the leader process, they all must agree upon who the present leader is. Furthermore, if the leader process crashes, the new leader process should take the charge as early as possible. New leader is one among the currently running processes with the highest process id. In this paper we have presented a modified version of ring algorithm. Our work involves substantial modifications of the existing ring election algorithm and the comparison of message complexity with the original algorithm. Simulation results show that our algorithmminimizes the number of messages being exchanged in electing the coordinator..

Lecture Notes in Computer Science, 2014

We propose a silent self-stabilizing leader election algorithm for bidirectional arbitrary connected identified networks. This algorithm is written in the locally shared memory model under the distributed unfair daemon. It requires no global knowledge on the network. Its stabilization time is in Θ(n 3) steps in the worst case, where n is the number of processes. Its memory requirement is asymptotically optimal, i.e., Θ(log n) bits per processes. Its round complexity is of the same order of magnitude-i.e., Θ(n) rounds-as the best existing algorithms designed with similar settings. To the best of our knowledge, this is the first self-stabilizing leader election algorithm for arbitrary identified networks that is proven to achieve a stabilization time polynomial in steps. By contrast, we show that the previous best existing algorithms designed with similar settings stabilize in a non polynomial number of steps in the worst case.

World Wide Web Conference Series, 1991

A distributed system is self-stabilizing if it can be started in any possible globalstate. Once started the system regains its consistency by itself, without any kindof outside intervention. The self-stabilization property makes the system tolerantto faults in which processors crash and then recover spontaneously in an arbitrarystate. When the intermediate period in between one recovery and the next crashis long

2017

We present the first self-stabilizing algorithm for leader election in arbitrary topologies whose space complexity is O(max{log Delta, log log n}) bits per node, where n is the network size and Delta its degree. This complexity is sub-logarithmic in n when Delta = n^o(1).

Proceedings of the 2013 ACM symposium on Principles of distributed computing, 2013

Electing a leader is a fundamental task in distributed computing. In its implicit version, only the leader must know who is the elected leader. This paper focuses on studying the message and time complexity of randomized implicit leader election in synchronous distributed networks. Surprisingly, the most "obvious" complexity bounds have not been proven for randomized algorithms. In particular, the seemingly obvious lower bounds of Ω(m) messages, where m is the number of edges in the network, and Ω(D) time, where D is the network diameter, are non-trivial to show for randomized (Monte Carlo) algorithms. (Recent results, showing that even Ω(n), where n is the number of nodes in the network, is not a lower bound on the messages in complete networks, make the above bounds somewhat less obvious). To the best of our knowledge, these basic lower bounds have not been established even for deterministic algorithms, except for the restricted case of comparison algorithms, where it was also required that nodes may not wake up spontaneously and that D and n were not known. We establish these fundamental lower bounds in this paper for the general case, even for randomized Monte Carlo algorithms. Our lower bounds are universal in the sense that they hold for all universal algorithms (namely, algorithms that work for all graphs), apply to every D, m, and n, and hold even if D, m, and n are known, all the nodes wake up simultaneously, and the algorithms can make any use of node's identities. To show that these bounds are tight, we present an O(m) messages algorithm. An O(D) time leader election algorithm is known. A slight adaptation of * A preliminary version of this article appeared in the proceedings of the 32nd ACM Symposium on Principles of Distributed Computing (PODC) 2013, pages 100-109.

Lecture Notes in Computer Science, 2016

This paper presents a distributed algorithm, called ST T , for electing deterministically a leader in an arbitrary network, assuming processors have unique identifiers of size O(log n), where n is the number of processors. It elects a leader in O(D + log n) rounds, where D is the diameter of the network, with messages of size O(1). Thus it has a bit round complexity of O(D + log n). This substantially improves upon the best known algorithm whose bit round complexity is O(D log n). In fact, using the lower bound by Kutten et al. [13] and a result of Dinitz and Solomon [8], we show that the bit round complexity of ST T is optimal (up to a constant factor), which is a step forward in understanding the interplay between time and message optimality for the election problem. Our algorithm requires no knowledge on the graph such as n or D.

In this paper, I have proposed an election algorithm that can be used in distributed systems to elect a coordinator. This is a betterment of an already existing Election algorithm (also known as Bully Algorithm) proposed by Hector Garcia-Monila (1982).The proposed algorithm is an efficient approach than Bully Algorithm.

Computers, 2012

In distributed computing systems, if an elected leader node fails, the other nodes of the system need to elect another leader. The bully algorithm is a classical approach for electing a leader in a synchronous distributed computing system. This paper presents an enhancement of the bully algorithm, requiring less time complexity and minimum message passing. This significant gain has been achieved by introducing node sets and tie breaker time. The latter provides a possible solution to simultaneous elections initiated by different nodes. In comparison with the classical algorithm and its existing modifications, this proposal generates minimum messages, stops redundant elections, and maintains fault-tolerant behaviour of the system.

Journal of Systems and Software, 2011

This work addresses the leader election problem in partially synchronous distributed systems where processes can crash and recover. More precisely, it focuses on implementing the Omega failure detector class, which provides a leader election functionality, in the crash-recovery failure model. The concepts of communication efficiency and near-efficiency for an algorithm implementing Omega are defined. Depending on the use or not of stable storage, the property satisfied by unstable processes, i.e., those that crash and recover infinitely often, varies. Two algorithms implementing Omega are presented. In the first algorithm, which is communication-efficient and uses stable storage, eventually and permanently unstable processes agree on the leader with correct processes. In the second algorithm, which is nearcommunication-efficient and does not use stable storage, processes start their execution with no leader in order to avoid the disagreement among unstable processes, that will agree on the leader with correct processes after receiving a first message from the leader.

International Conference on Computer Engineering and Technology (ICCET), 2010

An important challenge confronted in distributed systems is the adoption of suitable and efficient algorithms for coordinator election. The main role of an elected coordinator is to manage the use of a shared resource in an optimal manner. Among all the algorithms reported in the literature, the Bully and Ring algorithms have gained more popularity. In this paper, we describe novel approaches towards improving the Bully and Ring algorithms and also propose the heap tree mechanism for electing the coordinator. The higher efficiency and better performance of our presented algorithms with respect to the existing algorithms is validated through extensive simulation results.

2013

In this paper, I have proposed an election algorithm that can be used in distributed systems to elect a coordinator. This is a betterment of an already existing Election algorithm (also known as Bully Algorithm) proposed by Hector Garcia-Monila (1982).The proposed algorithm is an efficient approach than Bully Algorithm.

International Journal of Advanced Technology and Engineering Exploration

Electing a reliable coordinator is a crucial task in peer-to-peer distributed network. The peer-to-peer distributed network comprises number of peer entities. These member entities elect the coordinator entity by consensus [1-3]. Different consensus algorithms exist for electing an entity as a coordinator and those are generally termed as coordinator election algorithms. The majority of the existing election algorithms focus on improving the performance measures in particular communication cost [4-6]. As the entities in the system are networked and use message passing technique for communication and execution of distributed election algorithm, electing a reliable entity as a coordinator is a challenge. The unreliable communication channel used in message passing makes the election algorithm vulnerable to security attacks [7, 8] The unauthorized access may result in a security and privacy attack which includes the impersonation and denial of voting attack [9, 10]. *Author for correspondence Unauthorized modifications result in the modification of the election messages and attack on the integrity of the election. In a blockchain-based application, the behavior of any protocol comprises basic steps where a client issues a transaction, a coordinator election protocol determines a coordinator to marshal the transaction and commit on an ordering proposed by the coordinator [11-13]. In such critical blockchainbased applications it is important to implement coordinator election protocol safely. The objective of this work is to select competent candidates for the election process and safely elect a reliable candidate as a coordinator. To achieve this, the authors have proposed a novel algorithm for coordinator election. Consider a distributed network with n nodes where all entities have a unique identity assigned to them as P 1 , P 2 , P 3 ... P n. Each node has a set of attributes associated with it. These nodal attributes for all member nodes are stored in a group view G v at every node. A secure and reliable coordinator election algorithm (SRCEA) is proposed out of which the first

IEEE Transactions on Parallel and Distributed Systems, 1997

A distributed system is self-stabilizing if it can be started in any possible global state. Once started the system regains its consistency by itself, without any kind of outside intervention. The self-stabilization property makes the system tolerant to faults in which processors exhibit a faulty behavior for a while and then recover spontaneously in an arbitrary state. When the intermediate period in between one recovery and the next faulty period is long enough, the system stabilizes. A distributed system is uniform if all processors with the same number of neighbors are identical. A distributed system is dynamic if it can tolerate addition or deletion of processors and links without reinitialization. In this work, we study uniform dynamic self-stabilizing protocols for leader election under readwrite atomicity. Our protocols use randomization to break symmetry. The leader election protocol stabilizes in O n D 'log a f time when the number of the processors is unknown and O D' a f, otherwise. Here D denotes the maximal degree of a node, ' denotes the diameter of the graph and n denotes the number of processors in the graph. We introduce self-stabilizing protocols for synchronization that are used as building blocks by the leader-election algorithm. We conclude this work by presenting a simple, uniform, self-stabilizing ranking protocol.

Achieving processor cooperation in the presence of faults is a major problem in distributed systems. Popular paradigms such as Byzantine agreement have been studied principally in the context of a complete network. Indeed, Dolev [J. Algorithms, 3 (1982), pp. 14-30] and Hadzilacos [Issues of Fault Tolerance in Concurrent Computations, Ph.D. thesis, Harvard University, Cambridge, MA, 1984] have shown that fl(t) connectivity is necessary if the requirement is that all nonfaulty processors decide unanlmously, where is the number of faults to be tolerated. We believe that in forseeable technologies the number of faults will grow with the size of the network while the degree will remain practically fixed. We therefore raise the question whether it is possible to avoid the connectivity requirements by slightly lowering our expectations. In many practical situations we may be willing to "lose" some correct processors and settle for cooperation between the vast majority of the processors. Thus motivated, we present a general simulation technique by which vertices (processors) in almost any network of bounded degree can simulate an algorithm designed for the complete network. The simulation has the property that although some correct processors may be cut off from the majority of the network by faulty processors, the vast majority of the correct processors will be able to communicate among themselves undisturbed by the (arbitrary) behavior of the faulty nodes.