Self-stabilizing Leader Election Research Articles

Proof of Karma (PoK): A Novel Consensus Mechanism for Consortium Blockchain

In blockchain-based systems, participants can be malicious. Therefore, this work first characterizes several properties expected in systems where the honest behaviour of involved parties plays significant role in the success. Considering these properties, a new consensus mechanism, Proof of Karma (PoK), is proposed based on karma (actions) of nodes. PoK incorporates a self-stabilizing leader election algorithm based on karma score to ensure consistency in the system. In PoK, both new and existing nodes get a fair chance to earn profit by becoming a leader and adding a valid block to the blockchain. PoK gives incentives and imposes penalties to encourage and discourage the nodes' honest and malicious actions. PoK is analyzed with respect to the CAP theorem. The work provides security analysis to demonstrate the resistance of PoK against various blockchain specific attacks and karma specific attacks. Several experiments are also performed to assess the performance of PoK and compare it with the baseline model. The results show the feasibility, effectiveness, usability and scalability of PoK. PoK is also compared based on the characterized properties with various existing consensus mechanisms that consider malicious actions of nodes. PoK achieves consensus finality, decentralization and fairness, outperforming existing works.

Self-stabilizing systems in spite of high dynamics

We initiate research on self-stabilization in highly dynamic identified message-passing systems where dynamics is modeled using time-varying graphs (TVGs). More precisely, we address the self-stabilizing leader election problem in three wide classes of TVGs: the class TCB(Δ) of TVGs with temporal diameter bounded by Δ, the class TCQ(Δ) of TVGs with temporal diameter quasi-bounded by Δ, and the class TCR of TVGs with recurrent connectivity only, where TCB(Δ)⊆TCQ(Δ)⊆TCR. We first study conditions under which our problem can be solved. We introduce the notion of size-ambiguity to show that the assumption on the knowledge of the number n of processes is central. Our results reveal that, despite the existence of unique process identifiers, any deterministic self-stabilizing leader election algorithm working on the class TCQ(Δ) or TCR cannot be size-ambiguous, justifying why our solutions for those classes assume the exact knowledge of n. We then present three self-stabilizing leader election algorithms for Classes TCB(Δ), TCQ(Δ), and TCR, respectively. Our algorithm for TCB(Δ) stabilizes in at most 3Δ rounds. However, we show that stabilization time cannot be bounded for the leader election problem in TCQ(Δ) and TCR. Nevertheless, we circumvent this issue by showing that our solutions are speculative in the sense that their stabilization time in TCB(Δ) (⊆TCQ(Δ)⊆TCR) is O(Δ) rounds.

Optimal Space Lower Bound for Deterministic Self-Stabilizing Leader Election Algorithms

Given a boolean predicate $\Pi$ on labeled networks (e.g., proper coloring, leader election, etc.), a self-stabilizing algorithm for $\Pi$ is a distributed algorithm that can start from any initial configuration of the network (i.e., every node has an arbitrary value assigned to each of its variables), and eventually converge to a configuration satisfying $\Pi$. It is known that leader election does not have a deterministic self-stabilizing algorithm using a constant-size register at each node, i.e., for some networks, some of their nodes must have registers whose sizes grow with the size $n$ of the networks. On the other hand, it is also known that leader election can be solved by a deterministic self-stabilizing algorithm using registers of $O(\log \log n)$ bits per node in any $n$-node bounded-degree network. We show that this latter space complexity is optimal. Specifically, we prove that every deterministic self-stabilizing algorithm solving leader election must use $\Omega(\log \log n)$-bit per node registers in some $n$-node networks. In addition, we show that our lower bounds go beyond leader election, and apply to all problems that cannot be solved by anonymous algorithms.

Time-Optimal Self-Stabilizing Leader Election on Rings in Population Protocols

We propose a self-stabilizing leader election protocol on directed rings in the model of population protocols. Given an upper bound $N$ on the population size $n$, the proposed protocol elects a unique leader within $O(nN)$ expected steps starting from any configuration and uses $O(N)$ states. This convergence time is optimal if a given upper bound $N$ is asymptotically tight, i.e., $N=O(n)$.

Self-Stabilizing Population Protocols With Global Knowledge

In the population protocol model, many problems cannot be solved in a self-stabilizing manner. However, global knowledge, such as the number of nodes in a network, sometimes enables the design of a self-stabilizing protocol for such problems. For example, it is known that we can solve the self-stabilizing leader election in complete graphs if and only if every node knows the exact number of nodes. In this article, we investigate the effect of global knowledge on the possibility of self-stabilizing population protocols in arbitrary graphs. Specifically, we clarify the solvability of the leader election problem, the ranking problem, the degree recognition problem, and the neighbor recognition problem by self-stabilizing population protocols with knowledge of the number of nodes and/or the number of edges in a network.

Compact self-stabilizing leader election for general networks

We present a self-stabilizing leader election algorithm for general networks, with space-complexity O(logΔ+loglogn) bits per node in n-node networks with maximum degree Δ. This space complexity is sub-logarithmic in n as long as Δ=no(1). The best space-complexity known so far for general networks was O(logn) 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 Ω(logn) 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Δ+loglogn) bits per node. Solving this latter coloring problem allows us to implement a sub-logarithmic encoding of spanning trees — storing the IDs of the neighbors requires Ω(logn) bits per node, while we encode spanning trees using O(logΔ+loglogn) 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 Ω(logn) bits per node.

Loosely-stabilizing leader election with polylogarithmic convergence time

A loosely-stabilizing leader election protocol with polylogarithmic convergence time in the population protocol model is presented in this paper. In the population protocol model, which is a common abstract model of mobile sensor networks, it is known to be impossible to design a self-stabilizing leader election protocol unless the exact number of agents is known a priori. Thus, in our prior work, we introduced concept of loose-stabilization, which is weaker than self-stabilization but has similar advantage in practice. Following this work, several loosely-stabilizing leader election protocols have been given. Loosely-stabilizing leader election guarantees that, starting from an arbitrary configuration, the system reaches a safe configuration with a single leader within a short time, and keeps the unique leader for a long time thereafter. The convergence times of all existing loosely-stabilizing protocols, i.e., the expected times to reach a safe configuration, are polynomial in n where n is the number of nodes, while their holding times, i.e., the expected times to keep the unique leader after reaching a safe configuration, are exponential in n. In this paper, a loosely-stabilizing protocol with polylogarithmic convergence time is presented. Its holding time is not exponential, rather an arbitrarily large polynomial function of n.

Loosely-Stabilizing Leader Election for Arbitrary Graphs in Population Protocol Model

In the population protocol model [Angluin et al. 2006], it is impossible to design a self-stabilizing leader election protocol without any knowledge of the exact number of nodes in the system. The notion of loose-stabilization, which relaxes the closure requirement of self -stabilization, was introduced in 2009 to circumvent this impossibility. The notion can be described as follows: a loosely-stabilizing protocol guarantees that, starting from any initial configuration, a system reaches a safe configuration eventually, and after that, the system maintains its specification (e.g., the unique leader) not forever, but for a sufficiently long time. The previous work of the authors presented a loosely-stabilizing protocol that solves the leader election on complete graphs using only a given upper bound $N$N on the number of nodes $n$n in the system, instead of the exact value of $n$n. In this paper, we propose two loosely-stabilizing protocols that solve leader election for arbitrary graphs. One is a deterministic protocol that uses the unique identifiers of nodes while the other is a probabilistic protocol that works on anonymous networks. Given an upper bound $N$N on the number of nodes, both protocols maintain a unique leader for $\Omega (Ne^{2N})$Ω(Ne2N) expected steps (holding time) after entering a safe configuration. The first algorithm enters a safe configuration within $O(mN \, \log n)$O(mNlogn) expected steps (convergence time) while the second one does this within $O(mN^2\,\log N)$O(mN2logN) expected steps, where $m$m is the number of edges in the graph. Both protocols require only $O(\log N)$O(logN) bits for each node's memory. A novel concept, called the same speed timer is introduced, by which all nodes of the system can count down their timers at the same speed. This concept allows to achieve fast convergence time of both algorithms. To design the second protocol, we design a self-stabilizing two-hop coloring protocol, which is interesting in its own right. This protocol uses only $O(\log N)$O(logN) memory space per node. We establish a lower bound. Any loosely-stabilizing leader election protocol with expected exponential holding time requires $\Omega (mN)$Ω(mN) expected convergence time. This lower bound shows a near-optimality of the first algorithm.

Self-Stabilizing Weak Leader Election in Anonymous Trees Using Constant Memory per Edge

We propose a deterministic silent self-stabilizing algorithm for the weak leader election problem in anonymous trees. Our algorithm is designed in the message passing model, and requires only O(1) bits of memory per edge. It does not necessitate the a priori knowledge of any global parameter on the network. Finally, its stabilization time is at most [Formula: see text] time units, where 𝒟 is the diameter of the network, X is an upper bound on the time to execute some recurrent code by processes, and Imax is the maximal number of messages initially in a link.

Self-Stabilizing Leader Election in Dynamic Networks

Two silent self-stabilizing asynchronous distributed algorithms are given for the leader election problem in a dynamic network with unique IDs. A leader is elected for each connected component of the network. A BFS DAG, rooted at the leader, is constructed in each component. The construction takes O(Diam) rounds, where Diam is the maximum diameter of any component. Both algorithms are self-stabilizing, silent, and work under the unfair daemon, but use one unbounded integer variable. Algorithm DLE selects an arbitrary process to be the leader of each component. Algorithm DLEND (Distributed Leader Election No Dithering) has the incumbency property and the no dithering property. If the configuration is legitimate and a topological fault occurs, each component will elect, if possible, an incumbent to be its leader, i.e., a process which was a leader before the fault. Furthermore, during this computation, no process will change its choice of leader more than once.

Compact deterministic self-stabilizing leader election on a ring: the exponential advantage of being talkative

This paper focuses on compact deterministic self-stabilizing solutions for the leader election problem. When the solution is required to be silent (i.e., when the state of each process remains fixed from some point in time during any execution), there exists a lower bound of \(\varOmega (\log n)\) bits of memory per participating node , where n denotes the number of nodes in the system. This lower bound holds even in rings. We present a new deterministic (non-silent) self-stabilizing protocol for n-node rings that uses only \(O(\log \log n)\) memory bits per node, and stabilizes in \(O(n\log ^2 n)\) rounds. Our protocol has several attractive features that make it suitable for practical purposes. First, it assumes an execution model that is used by existing compilers for real networks. Second, the size of the ring (or any upper bound on this size) does not need to be known by any node. Third, the node identifiers can be of various sizes. Finally, no synchrony assumption, besides weak fairness, is assumed. Our result shows that, perhaps surprisingly, silence can be traded for an exponential decrease in memory space without significantly increasing stabilization time or introducing restrictive assumptions.

Constructing self-stabilizing oscillators in population protocols

We consider the population protocol (PP) model used to represent a collection of finite-state mobile agents that interact with each other to accomplish a common task. Motivated by the well-known BZ reaction, we address the problem of autonomously generating an oscillatory execution from any initial configuration (i.e., in a self-stabilizing manner). For deterministic PPs under a deterministic scheduler, we show that the self-stabilizing leader election (SS-LE) problem and the self-stabilizing oscillation (SS-OS) problem are equivalent, in the sense that an SS-OS protocol is constructible from a given SS-LE protocol, and vice versa, which unfortunately implies that (1) resorting to a leader is inevitable (although we seek a decentralized solution), (2) n states are necessary to create oscillations of amplitude n, where n is the number of agents (although we seek a memory-efficient solution). Aiming at reducing the space complexity, we present some deterministic oscillatory PPs under a uniform random scheduler.

Self-stabilizing leader election in polynomial steps

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 Θ(n3) 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.

On space complexity of self-stabilizing leader election in mediated population protocol

Chatzigiannakis et al. (Lect Notes Comput Sci 5734:56–76, 2009) extended the Population Protocol (PP) of Angluin et al. (2004) and introduced the Mediated Population Protocol (MPP) by introducing an extra memory on every agent-to-agent communication link (i.e., edge), in order to model more powerful networks of mobile agents with limited resources. For a general distributed system of autonomous agents, Leader Election (LE) plays a key role in their efficient coordination. A Self-Stabilizing (SS) protocol has ideal properties required for distributed systems of huge numbers of not highly reliable agents typically modeled by PP or MPP; it does not require any initialization and tolerates a finite number of transient failures. Cai et al. (2009) showed that for a system of \(n\) agents, any PP for SS-LE requires at least \(n\) agent-states, and gave a PP with \(n\) agent-states for SS-LE. In this paper, we show, for a system of \(n\) agents, any MPP for SS-LE with 2 edge-states (i.e., 1 bit memory) on every edge requires at least \((1/2) \lg {n}\) agent-states, and give an MPP for SS-LE with \((2/3)n\) agent-states and 2 edge-states on every edge. Furthermore, we show that a constant number of edge-states on every edge do not help in designing an MPP for SS-LE with a constant number of agent-states, and that there is no MPP for SS-LE with 2 agent-states, regardless of the number of edge-states; the edge-state is not a complete alternative of the agent-state, although it can help in reducing the number of agent-states, when solving SS-LE.

RANDOMIZED SELF-STABILIZING LEADER ELECTION IN PREFERENCE-BASED ANONYMOUS TREES

The performance of processors in a distributed system can be measured by parameters such as bandwidth, storage capacity, work capability, reliability, power limitations, years of usage, among others. Each processor defines its preference based on these parameters. The preference represents an indicator of the quality of service that a processor can provide. An algorithm that follows a preference-based approach uses the preference of the processors to make decisions. In this paper we introduce a randomized self-stabilizing leader election algorithm for preference-based anonymous trees. Our algorithm assures that the processor with the highest preference in the system is always selected as the leader; moreover, it is able to solve symmetric configurations where each preference is the same. We prove that our algorithm has an optimal average time complexity and we also performed simulations to illustrate the average performance of the algorithm.

Loosely-stabilizing leader election in a population protocol model

A self-stabilizing protocol guarantees that starting from any arbitrary initial configuration, a system eventually comes to satisfy its specification and keeps the specification forever. Although self-stabilizing protocols show excellent fault-tolerance against any transient faults (e.g. memory crash), designing self-stabilizing protocols is difficult and, what is worse, might be impossible due to the severe requirements. To circumvent the difficulty and impossibility, we introduce a novel notion of loose-stabilization, that relaxes the closure requirement of self-stabilization; starting from any arbitrary configuration, a system comes to satisfy its specification in a relatively short time, and it keeps the specification not forever but for a long time. To show the effectiveness and feasibility of this new concept, we present a probabilistic loosely-stabilizing leader election protocol in the Probabilistic Population Protocol (PPP) model of complete networks. Starting from any configuration, the protocol elects a unique leader within O(nNlogn) expected steps and keeps the unique leader for Ω(NeN) expected steps, where n is the network size (not known to the protocol) and N is a known upper bound of n. This result proves that introduction of the loose-stabilization circumvents the already-known impossibility result; the self-stabilizing leader election problem in the PPP model of complete networks cannot be solved without the knowledge of the exact network size.

An [formula omitted]-time self-stabilizing leader election algorithm

A self-stabilizing asynchronous distributed leader election algorithm is presented. The algorithm works for any connected unoriented (bidirectional) network with unique IDs. The solution also constructs a BFS tree of the network rooted at the elected leader. The proposed solution is silent and works under the unfair daemon. The algorithm stabilizes in O ( n ) rounds, where n is the number of processes in the network.

How to Prove Impossibility Under Global Fairness: On Space Complexity of Self-Stabilizing Leader Election on a Population Protocol Model

A population protocol is one of distributed computing models for passively-mobile systems, where a number of agents change their states by pairwise interactions between two agents. In this paper, we investigate the solvability of the self-stabilizing leader election in population protocols without any kind of oracles. We identify the necessary and sufficient conditions to solve the self-stabilizing leader election in population protocols from the aspects of local memory complexity and fairness assumptions. This paper shows that under the assumption of global fairness, no protocol using only n−1 states can solve the self-stabilizing leader election in complete interaction graphs, where n is the number of agents in the system. To prove this impossibility, we introduce a novel proof technique, called closed-set argument. In addition, we propose a self-stabilizing leader election protocol using n states that works even under the unfairness assumption. This protocol requires the exact knowledge about the number of agents in the system. We also show that such knowledge is necessary to construct any self-stabilizing leader election protocol.

A note on leader election in directed split-stars and directed alternating group graphs

A leader node is defined to be any node of the network unambiguously identified by some characteristics. In this paper, we first present a distributed algorithm for finding a leader node of a directed split-star. Moreover, an efficient self-stabilizing leader election algorithm that converges with linear rounds is proposed for directed split-stars. Actually, the distributed algorithm and the self-stabilizing algorithm are also applicable to the problem of directed alternating group graphs. As far as we know, no self-stabilizing leader election algorithm was known for the two graphs.

Self-stabilizing leader election in optimal space under an arbitrary scheduler

A silent self-stabilizing asynchronous distributed algorithm, SSLE, is given for the leader election problem in a connected unoriented (bidirectional) network with unique IDs. SSLE also constructs a BFS tree on the network rooted at that leader. SSLE uses O(logn) space per process and stabilizes in O(n) rounds, against the unfair daemon, where n is the number of processes in the network.