12,262 research outputs found
New protocols for the election of a leader in a ring
AbstractIn this paper we investigate the impact of time for the election of a leader in a distributed environment. We propose a new protocol schema that can be specialized to obtain several protocols with different communication-time characteristics when the network is ring-shaped and the communications between processors are synchronous
An improved leader election algorithm for distributed systems
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.
Compact Deterministic Self-Stabilizing Leader Election: The Exponential Advantage of Being Talkative
This paper focuses on compact deterministic self-stabilizing solutions for
the leader election problem. When the protocol is required to be \emph{silent}
(i.e., when communication content remains fixed from some point in time during
any execution), there exists a lower bound of Omega(\log n) bits of memory per
node participating to the leader election (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, the communication model fits with the model used by
existing compilers for real networks. Second, the size of the ring (or any
upper bound on this size) needs not to be known by any node. Third, the node
identifiers can be of various sizes. Finally, no synchrony assumption, besides
a weakly fair scheduler, is assumed. Therefore, our result shows that, perhaps
surprisingly, trading silence for exponential improvement in term of memory
space does not come at a high cost regarding stabilization time or minimal
assumptions
Memory lower bounds for deterministic self-stabilization
In the context of self-stabilization, a \emph{silent} algorithm guarantees
that the register of every node does not change once the algorithm has
stabilized. At the end of the 90's, Dolev et al. [Acta Inf. '99] showed that,
for finding the centers of a graph, for electing a leader, or for constructing
a spanning tree, every silent algorithm must use a memory of
bits per register in -node networks. Similarly, Korman et al. [Dist. Comp.
'07] proved, using the notion of proof-labeling-scheme, that, for constructing
a minimum-weight spanning trees (MST), every silent algorithm must use a memory
of bits per register. It follows that requiring the algorithm
to be silent has a cost in terms of memory space, while, in the context of
self-stabilization, where every node constantly checks the states of its
neighbors, the silence property can be of limited practical interest. In fact,
it is known that relaxing this requirement results in algorithms with smaller
space-complexity.
In this paper, we are aiming at measuring how much gain in terms of memory
can be expected by using arbitrary self-stabilizing algorithms, not necessarily
silent. To our knowledge, the only known lower bound on the memory requirement
for general algorithms, also established at the end of the 90's, is due to
Beauquier et al.~[PODC '99] who proved that registers of constant size are not
sufficient for leader election algorithms. We improve this result by
establishing a tight lower bound of bits per
register for self-stabilizing algorithms solving -coloring or
constructing a spanning tree in networks of maximum degree~. The lower
bound bits per register also holds for leader election
Leader Election in Anonymous Rings: Franklin Goes Probabilistic
We present a probabilistic leader election algorithm for anonymous, bidirectional, asynchronous rings. It is based on an algorithm from Franklin, augmented with random identity selection, hop counters to detect identity clashes, and round numbers modulo 2. As a result, the algorithm is finite-state, so that various model checking techniques can be employed to verify its correctness, that is, eventually a unique leader is elected with probability one. We also sketch a formal correctness proof of the algorithm for rings with arbitrary size
Automated Synthesis of Distributed Self-Stabilizing Protocols
In this paper, we introduce an SMT-based method that automatically
synthesizes a distributed self-stabilizing protocol from a given high-level
specification and network topology. Unlike existing approaches, where synthesis
algorithms require the explicit description of the set of legitimate states,
our technique only needs the temporal behavior of the protocol. We extend our
approach to synthesize ideal-stabilizing protocols, where every state is
legitimate. We also extend our technique to synthesize monotonic-stabilizing
protocols, where during recovery, each process can execute an most once one
action. Our proposed methods are fully implemented and we report successful
synthesis of well-known protocols such as Dijkstra's token ring, a
self-stabilizing version of Raymond's mutual exclusion algorithm,
ideal-stabilizing leader election and local mutual exclusion, as well as
monotonic-stabilizing maximal independent set and distributed Grundy coloring
- …