Self-stabilizing Leader Election Algorithm 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.

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.

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.

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.

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.

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.

ANALYSIS OF THE AVERAGE EXECUTION TIME FOR A SELF-STABILIZING LEADER ELECTION ALGORITHM

This paper focuses on the self-stabilizing leader election algorithm of Xu and Srimani [10] that finds a leader in a tree graph. The worst case execution time for this algorithm is O(N4), where N is the number of nodes in the tree. We show that the average execution time for this algorithm, assuming two different scenarios, is much lower than O(N4). In the first scenario, the algorithm assumes an equiprobable daemon and it only privileges a single node at a time. The average execution time for this case is O(N2). For the second case, the algorithm can privilege multiple nodes at a time. We eliminate the daemon from this algorithm by making random choices to avoid interference between neighboring nodes. The execution time for this case is O(N). We also show that for specific tree graphs, these results reduce even more.

A Self-Stabilizing Leader Election Algorithm in Highly Dynamic Ad Hoc Mobile Networks

The classical definition of a self-stabilizing algorithm assumes generally that there are no faults in the system long enough for the algorithm to stabilize. Such an assumption cannot be applied to ad hoc mobile networks characterized by their highly dynamic topology. In this paper, we propose a self-stabilizing leader election algorithm that can tolerate multiple concurrent topological changes. By introducing the time-interval-based computation concept, the algorithm ensures that a network partition can within a finite time converge to a legitimate state even if topological changes occur during the convergence time. Our simulation results show that our algorithm can ensure that each node has a leader over 99 percent of the time. We also give an upper bound on the frequency at which network components merge to guarantee the convergence.

SELF-STABILIZING ANONYMOUS LEADER ELECTION IN A TREE

We propose a new self-stabilizing anonymous leader election algorithm in a tree graph. We show the correctness of the protocol and show that the protocol terminates in O(n4) time starting from any arbitrary initial state. The protocol can elect either a leaf node or a non leaf node (starting from the same initial state) depending on the behavior of the daemon. The protocol generalizes the result in [1] and at the same time is much simpler and terminates in polynomial number of moves.

A Self-Stabilizing Leader Election Algorithm for Tree Graphs

We propose a self-stabilizing algorithm (protocol) for leader election in a tree graph. We show the correctness of the proposed algorithm by using a new technique involving induction.