3,287 research outputs found
Checkpoint-based rollback recovery in session programming
To react to unforeseen circumstances or amend abnormal situations in
communication-centric systems, programmers are in charge of "undoing" the
interactions which led to an undesired state. To assist this task,
session-based languages can be endowed with reversibility mechanisms. In this
paper we propose a language enriched with programming facilities to commit
session interactions, to roll back the computation to a previous commit point,
and to abort the session. Rollbacks in our language always bring the system to
previous visited states and a rollback cannot bring the system back to a point
prior to the last commit. Programmers are relieved from the burden of ensuring
that a rollback never restores a checkpoint imposed by a session participant
different from the rollback requester. Such undesired situations are prevented
at design-time (statically) by relying on a decidable compliance check at the
type level, implemented in MAUDE. We show that the language satisfies
error-freedom and progress of a session
Context constraint integration and validation in dynamic web service compositions
System architectures that cross organisational boundaries are usually implemented based on Web service technologies due to their inherent interoperability benets. With increasing exibility requirements, such as on-demand service provision, a dynamic approach to service architecture focussing on composition at runtime is needed. The possibility of technical faults, but also violations of functional and semantic constraints require a comprehensive notion of context that captures composition-relevant aspects. Context-aware techniques are consequently required to support constraint validation for dynamic service composition. We present techniques to respond to problems occurring during the execution of dynamically composed Web
services implemented in WS-BPEL. A notion of context { covering physical and contractual
faults and violations { is used to safeguard composed service executions dynamically. Our aim is to present an architectural framework from an application-oriented perspective, addressing practical considerations of a technical framework
An Asynchronous Scheme for Rollback Recovery in Message-Passing Concurrent Programming Languages
Rollback recovery strategies are well-known in concurrent and distributed
systems. In this context, recovering from unexpected failures is even more
relevant given the non-deterministic nature of execution, which means that it
is practically impossible to foresee all possible process interactions.
In this work, we consider a message-passing concurrent programming language
where processes interact through message sending and receiving, but shared
memory is not allowed. In this context, we design a checkpoint-based rollback
recovery strategy that does not need a central coordination. For this purpose,
we extend the language with three new operators: check, commit, and rollback.
Furthermore, our approach is purely asynchronous, which is an essential
ingredient to developing a source-to-source program instrumentation
implementing a rollback recovery strategy.Comment: This is the author's version of the work. It is posted here for your
personal use. Not for redistribution. The definitive version was published in
the Proceedings of the 39th ACM/SIGAPP Symposium on Applied Computing (SAC
'24), April 8-12, 2024, Avila, Spain, ACM,
https://doi.org/10.1145/3605098.363605
Checkpoint-based forward recovery using lookahead execution and rollback validation in parallel and distributed systems
This thesis studies a forward recovery strategy using checkpointing and optimistic execution in parallel and distributed systems. The approach uses replicated tasks executing on different processors for forwared recovery and checkpoint comparison for error detection. To reduce overall redundancy, this approach employs a lower static redundancy in the common error-free situation to detect error than the standard N Module Redundancy scheme (NMR) does to mask off errors. For the rare occurrence of an error, this approach uses some extra redundancy for recovery. To reduce the run-time recovery overhead, look-ahead processes are used to advance computation speculatively and a rollback process is used to produce a diagnosis for correct look-ahead processes without rollback of the whole system. Both analytical and experimental evaluation have shown that this strategy can provide a nearly error-free execution time even under faults with a lower average redundancy than NMR
From Reversible Computation to Checkpoint-Based Rollback Recovery for Message-Passing Concurrent Programs
The reliability of concurrent and distributed systems often depends on some
well-known techniques for fault tolerance. One such technique is based on
checkpointing and rollback recovery. Checkpointing involves processes to take
snapshots of their current states regularly, so that a rollback recovery
strategy is able to bring the system back to a previous consistent state
whenever a failure occurs. In this paper, we consider a message-passing
concurrent programming language and propose a novel rollback recovery strategy
that is based on some explicit checkpointing primitives and the use of a
(partially) reversible semantics for rolling back the system
A Rollback Mechanism to Recover from Software Failures in Role-based Adaptive Software Systems
Context-dependent applications are relatively complex due to their multiple variations caused by context activation, especially in the presence of unanticipated adaptation. Testing these systems is challenging, as it is hard to reproduce the same execution environments. Therefore, a software failure caused by bugs is no exception. This paper presents a rollback mechanism to recover from software failures as part of a role-based runtime with support for unanticipated adaptation. The mechanism performs checkpoints before each adaptation and employs specialized sensors to detect bugs resulting from recent configuration changes. When the runtime detects a bug, it assumes that the bug belongs to the latest configuration. The runtime rolls back to the recent checkpoint to recover and subsequently notifes the developer to fix the bug and re-applying the adaptation through unanticipated adaptation. We prototype the concept as part of our role-based runtime engine LyRT and demonstrate the applicability of the rollback recovery mechanism for unanticipated adaptation in erroneous situations
- …