1,586 research outputs found
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
Separation of Circulating Tokens
Self-stabilizing distributed control is often modeled by token abstractions.
A system with a single token may implement mutual exclusion; a system with
multiple tokens may ensure that immediate neighbors do not simultaneously enjoy
a privilege. For a cyber-physical system, tokens may represent physical objects
whose movement is controlled. The problem studied in this paper is to ensure
that a synchronous system with m circulating tokens has at least d distance
between tokens. This problem is first considered in a ring where d is given
whilst m and the ring size n are unknown. The protocol solving this problem can
be uniform, with all processes running the same program, or it can be
non-uniform, with some processes acting only as token relays. The protocol for
this first problem is simple, and can be expressed with Petri net formalism. A
second problem is to maximize d when m is given, and n is unknown. For the
second problem, the paper presents a non-uniform protocol with a single
corrective process.Comment: 22 pages, 7 figures, epsf and pstricks in LaTe
Self-Stabilizing Repeated Balls-into-Bins
We study the following synchronous process that we call "repeated
balls-into-bins". The process is started by assigning balls to bins in
an arbitrary way. In every subsequent round, from each non-empty bin one ball
is chosen according to some fixed strategy (random, FIFO, etc), and re-assigned
to one of the bins uniformly at random.
We define a configuration "legitimate" if its maximum load is
. We prove that, starting from any configuration, the
process will converge to a legitimate configuration in linear time and then it
will only take on legitimate configurations over a period of length bounded by
any polynomial in , with high probability (w.h.p.). This implies that the
process is self-stabilizing and that every ball traverses all bins in
rounds, w.h.p
Bounds for self-stabilization in unidirectional networks
A distributed algorithm is self-stabilizing if after faults and attacks hit
the system and place it in some arbitrary global state, the systems recovers
from this catastrophic situation without external intervention in finite time.
Unidirectional networks preclude many common techniques in self-stabilization
from being used, such as preserving local predicates. In this paper, we
investigate the intrinsic complexity of achieving self-stabilization in
unidirectional networks, and focus on the classical vertex coloring problem.
When deterministic solutions are considered, we prove a lower bound of
states per process (where is the network size) and a recovery time of at
least actions in total. We present a deterministic algorithm with
matching upper bounds that performs in arbitrary graphs. When probabilistic
solutions are considered, we observe that at least states per
process and a recovery time of actions in total are required (where
denotes the maximal degree of the underlying simple undirected graph).
We present a probabilistically self-stabilizing algorithm that uses
states per process, where is a parameter of the
algorithm. When , the algorithm recovers in expected
actions. When may grow arbitrarily, the algorithm
recovers in expected O(n) actions in total. Thus, our algorithm can be made
optimal with respect to space or time complexity
Self-stabilizing cluster routing in Manet using link-cluster architecture
We design a self-stabilizing cluster routing algorithm based on the link-cluster architecture of wireless ad hoc networks. The network is divided into clusters. Each cluster has a single special node, called a clusterhead that contains the routing information about inter and intra-cluster communication. A cluster is comprised of all nodes that choose the corresponding clusterhead as their leader. The algorithm consists of two main tasks. First, the set of special nodes (clusterheads) is elected such that it models the link-cluster architecture: any node belongs to a single cluster, it is within two hops of the clusterhead, it knows the direct neighbor on the shortest path towards the clusterhead, and there exist no two adjacent clusterheads. Second, the routing tables are maintained by the clusterheads to store information about nodes both within and outside the cluster. There are two advantages of maintaining routing tables only in the clusterheads. First, as no two neighboring nodes are clusterheads (as per the link-cluster architecture), there is no need to check the consistency of the routing tables. Second, since all other nodes have significantly less work (they only forward messages), they use much less power than the clusterheads. Therefore, if a clusterhead runs out of power, a neighboring node (that is not a clusterhead) can accept the role of a clusterhead. (Abstract shortened by UMI.)
- …