192 research outputs found
Two snap-stabilizing point-to-point communication protocols in message-switched networks
A snap-stabilizing protocol, starting from any configuration, always behaves
according to its specification. In this paper, we present a snap-stabilizing
protocol to solve the message forwarding problem in a message-switched network.
In this problem, we must manage resources of the system to deliver messages to
any processor of the network. In this purpose, we use information given by a
routing algorithm. By the context of stabilization (in particular, the system
starts in an arbitrary configuration), this information can be corrupted. So,
the existence of a snap-stabilizing protocol for the message forwarding problem
implies that we can ask the system to begin forwarding messages even if routing
information are initially corrupted. In this paper, we propose two
snap-stabilizing algorithms (in the state model) for the following
specification of the problem: - Any message can be generated in a finite time.
- Any emitted message is delivered to its destination once and only once in a
finite time. This implies that our protocol can deliver any emitted message
regardless of the state of routing tables in the initial configuration. These
two algorithms are based on the previous work of [MS78]. Each algorithm needs a
particular method to be transform into a snap-stabilizing one but both of them
do not introduce a significant overcost in memory or in time with respect to
algorithms of [MS78]
Bounding the Impact of Unbounded Attacks in Stabilization
Self-stabilization is a versatile approach to fault-tolerance since it
permits a distributed system to recover from any transient fault that
arbitrarily corrupts the contents of all memories in the system. Byzantine
tolerance is an attractive feature of distributed systems that permits to cope
with arbitrary malicious behaviors. Combining these two properties proved
difficult: it is impossible to contain the spatial impact of Byzantine nodes in
a self-stabilizing context for global tasks such as tree orientation and tree
construction. We present and illustrate a new concept of Byzantine containment
in stabilization. Our property, called Strong Stabilization enables to contain
the impact of Byzantine nodes if they actually perform too many Byzantine
actions. We derive impossibility results for strong stabilization and present
strongly stabilizing protocols for tree orientation and tree construction that
are optimal with respect to the number of Byzantine nodes that can be tolerated
in a self-stabilizing context
Gracefully Degrading Gathering in Dynamic Rings
Gracefully degrading algorithms [Biely \etal, TCS 2018] are designed to
circumvent impossibility results in dynamic systems by adapting themselves to
the dynamics. Indeed, such an algorithm solves a given problem under some
dynamics and, moreover, guarantees that a weaker (but related) problem is
solved under a higher dynamics under which the original problem is impossible
to solve. The underlying intuition is to solve the problem whenever possible
but to provide some kind of quality of service if the dynamics become
(unpredictably) higher.In this paper, we apply for the first time this approach
to robot networks. We focus on the fundamental problem of gathering a squad of
autonomous robots on an unknown location of a dynamic ring. In this goal, we
introduce a set of weaker variants of this problem. Motivated by a set of
impossibility results related to the dynamics of the ring, we propose a
gracefully degrading gathering algorithm
Self-Stabilization, Byzantine Containment, and Maximizable Metrics: Necessary Conditions
Self-stabilization is a versatile approach to fault-tolerance since it
permits a distributed system to recover from any transient fault that
arbitrarily corrupts the contents of all memories in the system. Byzantine
tolerance is an attractive feature of distributed systems that permits to cope
with arbitrary malicious behaviors. We consider the well known problem of
constructing a maximum metric tree in this context. Combining these two
properties leads to some impossibility results. In this paper, we provide two
necessary conditions to construct maximum metric tree in presence of transients
and (permanent) Byzantine faults
Dynamic FTSS in Asynchronous Systems: the Case of Unison
Distributed fault-tolerance can mask the effect of a limited number of
permanent faults, while self-stabilization provides forward recovery after an
arbitrary number of transient fault hit the system. FTSS protocols combine the
best of both worlds since they are simultaneously fault-tolerant and
self-stabilizing. To date, FTSS solutions either consider static (i.e. fixed
point) tasks, or assume synchronous scheduling of the system components. In
this paper, we present the first study of dynamic tasks in asynchronous
systems, considering the unison problem as a benchmark. Unison can be seen as a
local clock synchronization problem as neighbors must maintain digital clocks
at most one time unit away from each other, and increment their own clock value
infinitely often. We present many impossibility results for this difficult
problem and propose a FTSS solution when the problem is solvable that exhibits
optimal fault containment
Robustness: a New Form of Heredity Motivated by Dynamic Networks
We investigate a special case of hereditary property in graphs, referred to
as {\em robustness}. A property (or structure) is called robust in a graph
if it is inherited by all the connected spanning subgraphs of . We motivate
this definition using two different settings of dynamic networks. The first
corresponds to networks of low dynamicity, where some links may be permanently
removed so long as the network remains connected. The second corresponds to
highly-dynamic networks, where communication links appear and disappear
arbitrarily often, subject only to the requirement that the entities are
temporally connected in a recurrent fashion ({\it i.e.} they can always reach
each other through temporal paths). Each context induces a different
interpretation of the notion of robustness.
We start by motivating the definition and discussing the two interpretations,
after what we consider the notion independently from its interpretation, taking
as our focus the robustness of {\em maximal independent sets} (MIS). A graph
may or may not admit a robust MIS. We characterize the set of graphs \forallMIS
in which {\em all} MISs are robust. Then, we turn our attention to the graphs
that {\em admit} a robust MIS (\existsMIS). This class has a more complex
structure; we give a partial characterization in terms of elementary graph
properties, then a complete characterization by means of a (polynomial time)
decision algorithm that accepts if and only if a robust MIS exists. This
algorithm can be adapted to construct such a solution if one exists
Stabilizing data-link over non-FIFO channels with optimal fault-resilience
Self-stabilizing systems have the ability to converge to a correct behavior
when started in any configuration. Most of the work done so far in the
self-stabilization area assumed either communication via shared memory or via
FIFO channels. This paper is the first to lay the bases for the design of
self-stabilizing message passing algorithms over unreliable non-FIFO channels.
We propose a fault-send-deliver optimal stabilizing data-link layer that
emulates a reliable FIFO communication channel over unreliable capacity bounded
non-FIFO channels
A Taxonomy of Daemons in Self-stabilization
We survey existing scheduling hypotheses made in the literature in
self-stabilization, commonly referred to under the notion of daemon. We show
that four main characteristics (distribution, fairness, boundedness, and
enabledness) are enough to encapsulate the various differences presented in
existing work. Our naming scheme makes it easy to compare daemons of particular
classes, and to extend existing possibility or impossibility results to new
daemons. We further examine existing daemon transformer schemes and provide the
exact transformed characteristics of those transformers in our taxonomy.Comment: 26 page
The Weakest Failure Detector for Eventual Consistency
In its classical form, a consistent replicated service requires all replicas
to witness the same evolution of the service state. Assuming a message-passing
environment with a majority of correct processes, the necessary and sufficient
information about failures for implementing a general state machine replication
scheme ensuring consistency is captured by the {\Omega} failure detector. This
paper shows that in such a message-passing environment, {\Omega} is also the
weakest failure detector to implement an eventually consistent replicated
service, where replicas are expected to agree on the evolution of the service
state only after some (a priori unknown) time. In fact, we show that {\Omega}
is the weakest to implement eventual consistency in any message-passing
environment, i.e., under any assumption on when and where failures might occur.
Ensuring (strong) consistency in any environment requires, in addition to
{\Omega}, the quorum failure detector {\Sigma}. Our paper thus captures, for
the first time, an exact computational difference be- tween building a
replicated state machine that ensures consistency and one that only ensures
eventual consistency
- âŠ