The complexity of leader election in diameter-two networks

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.

SIAM Journal on Computing, 1991

This paper addresses the problem of distributively electing a leader in both synchronous and asynchronous complete networks. We present O(n log n) messages synchronous and asynchronous algorithms. The time complexity of the synchronous algorithm is O(log n), while that of the asynchronous algorithm is O(n). In the synchronous case, we prove a lower bound of (n log n) on the message complexity. We also prove that any message-optimal synchronous algorithm requires (log n) time. In proving these bounds we do not restrict the type of operations performed by nodes. The bounds thus apply to general algorithms and not just to comparison based algorithms.

Proceedings of the fourth annual ACM symposium on Principles of distributed computing - PODC '85, 1985

Algorithms for election in asynchronous general networks and in synchronous rings are presented. The algorithms are message-optimal, and their time behavior is significantly improved over currently available algorithms. In asynchronous general networks we, present a O([W]+nlogn)-messages, O(n log n)-time algorithm, where n is the number of nodes, and IE] is the number of links in the network. For synchronous rings, we propose two algorithms. The first works in O(n)-messages, and O(n2n+lTI 2) time, where IT[ is the cardinality of the set of the node identifiers. The second works in O(n log*n) messages and O(o~-l(log*n)[ T[),time, where oF10 is the functional inverse of log. By contrast, the time behavior of previously known algorithms is exponential in ]T], for fixed n. 1. Introduction Most distributed algorithms strive for message economy, usually at the expense of running time. This may be justified for algorithms whose timely termination is not of great consequence. But for many algorithms, especially those that are part of the network control, time might be at a premium. One such algorithm is the election algorithm. This algorithm could for example be 1"This research was supported by an IBM Faculty Development Award.

Theoretical Computer Science, 2006

Itai and Rodeh showed that, on the average, the communication of a leader election algorithm takes no more than LN bits, where L ≃ 2.441716 and N denotes the size of the ring. We give a precise asymptotic analysis of the average number of rounds M (n) required by the algorithm, proving for example that M (∞) := lim n→∞ M (n) = 2.441715879. . ., where n is the number of starting candidates in the election. Accurate asymptotic expressions of the second moment M (2) (n) of the discrete random variable at hand, its probability distribution, and the generalization to all moments are given. Corresponding asymptotic expansions (n → ∞) are provided for sufficiently large j, where j counts the number of rounds. Our numerical results show that all computations perfectly fit the observed values. Finally, we investigate the generalization to probability t/n, where t is a non negative real parameter. The real function M (∞, t) := lim n→∞ M (n, t) is shown to admit one unique minimum M (∞, t *) on the real segment (0, 2). Furthermore, the variations of M (∞, t) on the whole real line are also studied in detail.

Algorithmica, 2018

Leader election is one of the basic problems in distributed computing. This is a symmetry breaking problem: all nodes of a network must agree on a single node, called the leader. If the nodes of the network have distinct labels, then such an agreement means that all nodes have to output the label of the elected leader. For anonymous networks, the task of leader election is formulated as follows: every node v of the network must output a simple path, which is coded as a sequence of port numbers, such that all these paths end at a common node, the leader. In this paper, we study deterministic leader election in arbitrary anonymous networks. It is well known that leader election is impossible in some networks, regardless of the allocated amount of time, even if nodes know the map of the network. This is due to possible symmetries in it. However, even in networks in which it is possible to elect a leader knowing the map, the task may be still impossible without any knowledge, regardless of the allocated time. On the other hand, for any network in which leader election is possible knowing the map, there is a minimum time, called the election index, in which this can be done. Informally, the election index of a network is the minimum depth at which views of all nodes are distinct. Our aim is to establish tradeoffs between the allocated time τ and the amount of information that has to be given a priori to the nodes to enable leader election in time τ in all networks for which leader election in this time is at all possible. Following the framework of algorithms with advice, this information (a single binary string) is provided to all nodes at the start by an oracle knowing the entire network. The length of this string is called the size of advice. For a given time τ allocated to leader election, we give upper and lower bounds on the minimum size of advice sufficient to perform leader election in time τ. We focus on the two sides of the time spectrum. For the smallest possible time, which is the election index of the network, we show that the minimum size of advice is linear in the size n of the network, up to polylogarithmic factors. On the other hand, we consider large values of time: larger than the diameter D by a summand, respectively, linear, polynomial, and exponential in the election index; for these values, we prove tight bounds on the minimum size of advice, up to multiplicative constants. We also show that constant advice is not sufficient for leader election in all graphs, regardless of the allocated time.

Journal of Computer and System Sciences, 2001

In the leader election problem, n players wish to elect a random leader. The difficulty is that some coalition of players may conspire to elect one of its own members. We adopt the perfect information model: all communication is by broadcast, and the bad players have unlimited computational power. Within a round, they may also wait to see the inputs of the good players. A protocol is called resilient if a good leader is elected with probability bounded away from 0. We give a simple, constructive leader election protocol that is resilient against coalitions of size βn, for any β < 1=2. Our protocol takes log n + O(1) rounds, each player sending at most log n bits per round. For any constant k, our protocol can be modified to take k rounds and be resilient against coalitions of size εn=(log (k) n) 3 , where ε is a small enough constant and log (k) denotes the logarithm iterated k times. This is constructive for k 3.

The leader election task calls for all nodes of a network to agree on a single node. If the nodes of the network are anonymous, the task of leader election is formulated as follows: every node $v$ of the network must output a simple path, coded as a sequence of port numbers, such that all these paths end at a common node, the leader. In this paper, we study deterministic leader election in anonymous trees. Our aim is to establish tradeoffs between the allocated time $\tau$ and the amount of information that has to be given $\textit{a priori}$ to the nodes to enable leader election in time $\tau$ in all trees for which leader election in this time is at all possible. Following the framework of $\textit{algorithms with advice}$, this information (a single binary string) is provided to all nodes at the start by an oracle knowing the entire tree. The length of this string is called the $\textit{size of advice}$. For an allocated time $\tau$, we give upper and lower bounds on the minimum...

Journal of Parallel and Distributed Computing, 2020

We present a self-stabilizing leader election algorithm for general networks, with space-complexity O(log ∆+log log n) bits per node in n-node networks with maximum degree ∆. This space complexity is sub-logarithmic in n as long as ∆ = n o(1). The best space-complexity known so far for general networks was O(log n) bits per node, and algorithms with sub-logarithmic space-complexities were known for the ring only. To our knowledge, our algorithm is the first algorithm for self-stabilizing leader election to break the Ω(log n) bound for silent algorithms in general networks. Breaking this bound was obtained via the design of a (non-silent) self-stabilizing algorithm using sophisticated tools such as solving the distance-2 coloring problem in a silent self-stabilizing manner, with space-complexity O(log ∆ + log log n) bits per node. Solving this latter coloring problem allows us to implement a sublogarithmic encoding of spanning trees-storing the IDs of the neighbors requires Ω(log n) bits per node, while we encode spanning trees using O(log ∆+log log n) bits per node. Moreover, we show how to construct such compactly encoded spanning trees without relying on variables encoding distances or number of nodes, as these two types of variables would also require Ω(log n) bits per node.

Lecture Notes in Computer Science, 2011

We consider the message complexity of achieving consensus in synchronous anonymous message passing systems. Unlabeled processors (nodes) communicate through links of a network. In each round every processor can exchange messages with all neighbors and the duration of each transmission is one round. An adversary wakes up some subset of processors at possibly different times and assigns them arbitrary numerical input values. All other processors are dormant and do not have input values. Any message wakes up a dormant processor. The goal of consensus is to wake up all processors and have them agree on one of the input values. We seek deterministic consensus algorithms using as few messages as possible. As opposed to most of the literature on consensus, the difficulty of our scenario are not faults (we assume that the network is fault-free) but the arbitrary network topology combined with the anonymity of nodes. For unknown n-node networks we show a consensus algorithm using O(n 2 ) messages; this complexity is optimal for this class. We show that if the network is known, then the complexity of consensus decreases significantly. Our main contribution is an algorithm that uses O(n 3/2 log 2 n) messages on any n-node network and we show that some networks require Ω(n log n) messages to achieve consensus. We also observe that availability of distinct labels of nodes helps to improve complexity of consensus for known networks but has no effect for the class of unknown networks. Indeed, even with labeled nodes, Ω(n 2 ) messages are sometimes necessary if the network is unknown but for known labeled networks consensus can be always achieved with O(n) messages.

Information Processing Letters, 2011

We propose a probabilistic network model, called asynchronous bounded expected delay (ABE), which requires a known bound on the expected message delay. In ABE networks all asynchronous executions are possible, but executions with extremely long delays are less probable. Thus, the ABE model captures asynchrony that occurs in sensor networks and ad-hoc networks. At the example of an election algorithm, we show that the minimal assumptions of ABE networks are sufficient for the development of efficient algorithms. For anonymous, unidirectional ABE rings of known size n we devise a probabilistic election algorithm having average message and time complexity O(n). .

We start with a set of n players. With some probability $P(n, k)$, we kill $n−k$ players; the other ones stay alive, and we repeat with them. What is the distribution of the number $X_n$ of phases (or rounds) before getting only one player? We present a probabilistic analysis of this algorithm under some conditions on the probability distributions $P(n, k)$, including stochastic monotonicity and the assumption that roughly a fixed proportion $\alpha$ of the players survive in each round. We prove a kind of convergence in distribution for $\lceilX_n−\log_{1/\alpha}(n)\rceil$; as in many other similar problems there are oscillations and no true limit distribution, but suitable subsequences converge, and there is an absolutely continuous random variable $Z$ such that $d(Xn, \lceilZ+\log_{1/\alpha}(n)\rceil) \to 0$, where d is either the total variation distance or the Wasserstein distance. Applications of the general result include the leader election algorithm where players are elimin...

2012

The leader election problem consists in selecting a process (called leader) in a group of processes. Several leader election algorithms have been proposed in the past for ring networks, tree networks, fully connected networks or regular networks (such as tori and hypercubes). As far as ring networks are concerned, it has been shown that the number of messages that processes have to exchange to elect a leader is Ω(n log n). The algorithm proposed by Higham and Przytycka is the best leader algorithm known so far for ring networks in terms of message complexity, which is 1.271 n log n + O(n). This algorithm uses round numbers and assumes that all processes start with the same round number. More precisely, when round numbers are not initially equal, the algorithm has runs that do not terminate. This paper presents an algorithm, based on Higham-Przytycka's technique, which allows processes to start with different round numbers. This extension is motivated by fault-tolerance with respect to initial values. While the algorithm always terminates, its message complexity is optimal, i.e., O(n log n), when the processes start with the same round number and increases up to O(n 2) when all processes start with different round number values. We call graceful degradation this additional property that combines fault-tolerance (with respect to initial values) and efficiency.

We present an efficient randomized algorithm for leader election in large-scale distributed systems. The proposed algorithm is optimal in message complexity (O(n) for a set of n total processes), has round complexity logarithmic in the number of processes in the system, and provides high probabilistic guarantees on the election of a unique leader. The algorithm relies on a balls and bins abstraction and works in two phases. The main novelty of the work is in the first phase where the number of contending processes is reduced in a controlled manner. Probabilistic quorums are used to determine a winner in the second phase. We discuss, in detail, the synchronous version of the algorithm, provide extensions to an asynchronous version and examine the impact of failures.

We consider the problem of electing a leader among nodes in a highly dynamic network where the adversary has unbounded capacity to insert and remove nodes (including the leader) from the network and change connectivity at will. We present a randomized algorithm that (re)elects a leader in O(D log n) rounds with high probability, where D is a bound on the dynamic diameter of the network and n is the maximum number of nodes in the network at any point in time. We assume a model of broadcast-based communication where a node can send only 1 message of O(log n) bits per round and is not aware of the receivers in advance. Thus, our results also apply to mobile wireless adhoc networks, improving over the optimal (for deterministic algorithms) O(Dn) solution presented at FOMC 2011. We show that our algorithm is optimal by proving that any randomized Las Vegas algorithm takes at least Ω(D log n) rounds to elect a leader with high probability, which shows that our algorithm yields the best possible (up to constants) termination time.

arXiv (Cornell University), 2020

Leader election is a fundamental task in distributed computing. It is a symmetry breaking problem, calling for one node of the network to become the leader, and for all other nodes to become non-leaders. We consider leader election in anonymous radio networks modeled as simple undirected connected graphs. Nodes communicate in synchronous rounds. In each round, a node can either transmit a message to all its neighbours, or stay silent and listen. A node v hears a message from a neighbour w in a given round if v listens in this round and if w is its only neighbour transmitting in this round. If v listens in a round in which more than one neighbour transmits then v hears noise that is different from any message and different from silence. We assume that nodes are identical (anonymous) and execute the same deterministic algorithm. Under this scenario, symmetry can be broken only in one way: by different wake-up times of the nodes. In which situations is it possible to break symmetry and elect a leader using time as symmetry breaker? In order to answer this question, we consider configurations. A configuration is the underlying graph with nodes tagged by non-negative integers with the following meaning. A node can either wake up spontaneously in the round shown on its tag, according to some global clock, or can be woken up hearing a message sent by one of its already awoken neighbours. The local clock of a node starts at its wakeup and nodes do not have access to the global clock determining their tags. A configuration is feasible if there exists a distributed algorithm that elects a leader for this configuration. Our main result is a complete algorithmic characterization of feasible configurations. More precisely, we design a centralized decision algorithm, working in polynomial time, whose input is a configuration and which decides if the configuration is feasible. Using this algorithm we also provide a dedicated deterministic distributed leader election algorithm for each feasible configuration that elects a leader for this configuration in time O(n 2 σ), where n is the number of nodes and σ is the difference between the largest and smallest tag of the configuration. We then ask the question if there exists a universal deterministic distributed algorithm electing a leader for all feasible configurations. The answer turns out to be no, and we show that such a universal algorithm cannot exist even for the class of 4-node feasible configurations. We also prove that a distributed version of our decision algorithm cannot exist.