3,682 research outputs found
An automated wrapper-based approach to the design of dependable software
The design of dependable software systems invariably comprises two main activities: (i) the design of dependability mechanisms, and (ii) the location of dependability mechanisms. It has been shown that these activities are intrinsically difficult. In this paper we propose an automated wrapper-based methodology to circumvent the problems associated with the design and location of dependability mechanisms. To achieve this we replicate important variables so that they can be used as part of standard, efficient dependability mechanisms. These well-understood mechanisms are then deployed in all relevant locations. To validate the proposed methodology we apply it to three complex software systems, evaluating the dependability enhancement and execution overhead in each case. The results generated demonstrate that the system failure rate of a wrapped software system can be several orders of magnitude lower than that of an unwrapped equivalent
Fast and compact self-stabilizing verification, computation, and fault detection of an MST
This paper demonstrates the usefulness of distributed local verification of
proofs, as a tool for the design of self-stabilizing algorithms.In particular,
it introduces a somewhat generalized notion of distributed local proofs, and
utilizes it for improving the time complexity significantly, while maintaining
space optimality. As a result, we show that optimizing the memory size carries
at most a small cost in terms of time, in the context of Minimum Spanning Tree
(MST). That is, we present algorithms that are both time and space efficient
for both constructing an MST and for verifying it.This involves several parts
that may be considered contributions in themselves.First, we generalize the
notion of local proofs, trading off the time complexity for memory efficiency.
This adds a dimension to the study of distributed local proofs, which has been
gaining attention recently. Specifically, we design a (self-stabilizing) proof
labeling scheme which is memory optimal (i.e., bits per node), and
whose time complexity is in synchronous networks, or time in asynchronous ones, where is the maximum degree of
nodes. This answers an open problem posed by Awerbuch and Varghese (FOCS 1991).
We also show that time is necessary, even in synchronous
networks. Another property is that if faults occurred, then, within the
requireddetection time above, they are detected by some node in the locality of each of the faults.Second, we show how to enhance a known
transformer that makes input/output algorithms self-stabilizing. It now takes
as input an efficient construction algorithm and an efficient self-stabilizing
proof labeling scheme, and produces an efficient self-stabilizing algorithm.
When used for MST, the transformer produces a memory optimal self-stabilizing
algorithm, whose time complexity, namely, , is significantly better even
than that of previous algorithms. (The time complexity of previous MST
algorithms that used memory bits per node was , and
the time for optimal space algorithms was .) Inherited from our proof
labelling scheme, our self-stabilising MST construction algorithm also has the
following two properties: (1) if faults occur after the construction ended,
then they are detected by some nodes within time in synchronous
networks, or within time in asynchronous ones, and (2) if
faults occurred, then, within the required detection time above, they are
detected within the locality of each of the faults. We also show
how to improve the above two properties, at the expense of some increase in the
memory
Model Driven Mutation Applied to Adaptative Systems Testing
Dynamically Adaptive Systems modify their behav- ior and structure in
response to changes in their surrounding environment and according to an
adaptation logic. Critical sys- tems increasingly incorporate dynamic
adaptation capabilities; examples include disaster relief and space exploration
systems. In this paper, we focus on mutation testing of the adaptation logic.
We propose a fault model for adaptation logics that classifies faults into
environmental completeness and adaptation correct- ness. Since there are
several adaptation logic languages relying on the same underlying concepts, the
fault model is expressed independently from specific adaptation languages.
Taking benefit from model-driven engineering technology, we express these
common concepts in a metamodel and define the operational semantics of mutation
operators at this level. Mutation is applied on model elements and model
transformations are used to propagate these changes to a given adaptation
policy in the chosen formalism. Preliminary results on an adaptive web server
highlight the difficulty of killing mutants for adaptive systems, and thus the
difficulty of generating efficient tests.Comment: IEEE International Conference on Software Testing, Verification and
Validation, Mutation Analysis Workshop (Mutation 2011), Berlin : Allemagne
(2011
Phase Clocks for Transient Fault Repair
Phase clocks are synchronization tools that implement a form of logical time
in distributed systems. For systems tolerating transient faults by self-repair
of damaged data, phase clocks can enable reasoning about the progress of
distributed repair procedures. This paper presents a phase clock algorithm
suited to the model of transient memory faults in asynchronous systems with
read/write registers. The algorithm is self-stabilizing and guarantees accuracy
of phase clocks within O(k) time following an initial state that is k-faulty.
Composition theorems show how the algorithm can be used for the timing of
distributed procedures that repair system outputs.Comment: 22 pages, LaTe
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
- …