Impact of Knowledge on Election Time in Anonymous Networks

Proceedings of the 33rd ACM Symposium on Parallelism in Algorithms and Architectures, 2021

Leader election is one of the fundamental problems in distributed computing: a single node, called the leader, must be specified. This task can be formulated either in a weak way, where one node outputs 'leader' and all other nodes output 'non-leader', or in a strong way, where all nodes must also learn which node is the leader. If the nodes have distinct identifiers, then such an agreement means that all nodes have to output the identifier of the elected leader. For anonymous networks, the strong version of leader election requires that all nodes must be able to find a path to the leader, as this is the only way to identify it. In this paper, we study variants of deterministic leader election in arbitrary anonymous networks. Leader election is impossible in some anonymous networks, regardless of the allocated amount of time, even if nodes know the entire map of the network. This is due to possible symmetries in the network. However, even in networks in which it is p...

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.

2017

Leader election is a basic symmetry breaking problem in distributed computing. All nodes of a network have to agree on a single node, called the leader. If the nodes of the network have distinct labels, then agreeing on a single node means that all nodes have to output the label of the elected leader. If the nodes are anonymous, the task of leader election is formulated as follows: every node of the network must output a simple path starting at it, 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 anonymous trees. Our goal is to establish tradeoffs between the allocated time $\tau$ and the amount of information that has to be given {\em a priori} to the nodes of a network to enable leader election in time $\tau$. Following the framework of {\em algorithms with advice}, this information is provided to all nodes at the start by an oracle knowing the entire tree, in form of ...

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.

Distributed Computing, 2014

We study the problem of leader election among mobile agents operating in an arbitrary network modeled as an undirected graph. Nodes of the network are unlabeled and all agents are identical. Hence the only way to elect a leader among agents is by exploiting asymmetries in their initial positions in the graph. Agents do not know the graph or their positions in it, hence they must gain this knowledge by navigating in the graph and share it with other agents to accomplish leader election. This can be done using meetings of agents, which is difficult because of their asynchronous nature: an adversary has total control over the speed of agents. When can a leader be elected in this adversarial scenario and how to do it? We give a complete answer to this question by characterizing all initial configurations for which leader election is possible and by constructing an algorithm that accomplishes leader election for all configurations for which this can be done.

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.

2012

We study the time needed for deterministic leader election in the LOCAL model, where in every round a node can exchange any messages with its neighbors and perform any local computations. The topology of the network is unknown and nodes are unlabeled, but ports at each node have arbitrary fixed labelings which, together with the topology of the network, can create asymmetries to be exploited in leader election. We consider two versions of the leader election problem: strong LE in which exactly one leader has to be elected, if this is possible, while all nodes must terminate declaring that leader election is impossible otherwise, and weak LE, which differs from strong LE in that no requirement on the behavior of nodes is imposed, if leader election is impossible. We show that the time of leader election depends on three parameters of the network: its diameter D, its size n, and its level of symmetry λ, which, when leader election is feasible, is the smallest depth at which some node has a unique view of the network. It also depends on the knowledge by the nodes, or lack of it, of parameters D and n. Optimal time of weak LE is shown to be Θ(D + λ) if either D or n is known to the nodes. (If none of these parameters is known, even weak LE is impossible.) For strong LE, knowing only D is insufficient to perform it. If only n is known then optimal time is Θ(n), and if both n and D are known, then optimal time is Θ(D + λ).

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.

Algorithmica

Leader election is, together with consensus, one of the most central problems in distributed computing. 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. (2015) and a result of Dinitz and Solomon (2007), we show that the bit round complexity of ST T is optimal (up to a constant factor), which is a significant 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, and the pipelining technique we introduce to break the O(D log n) barrier is general. This research has been partially supported by ANR projects DESCARTES and ESTATE (resp. ANR-16-CE40-0023 and ANR-16-CE25-0009-03). A preliminary subset of this work appeared in the proceedings of DISC 2016 [12].

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).