Multitolerant barrier synchronization

doi:10.1016/S0020-0190(97)00143-9

Information Processing Letters

Volume 64, Issue 1, 14 October 1997, Pages 29-36

https://doi.org/10.1016/S0020-0190(97)00143-9 Get rights and content

Abstract

We designed a multitolerant program for synchronizing the phases of concurrent processes. The tolerances of the program enable processes to: (i) execute all phases correctly in the presence of faults that corrupt the process state in a detectable manner, and (ii) execute only a minimum possible number of phases incorrectly before resuming correct computation in the presence of faults that corrupt the process state in an undetectable manner.

References (6)

J. Misra
Phase synchronization
Inform. Process. Lett.
(1991)
A. Arora et al.
Component based design of multitolerance
IEEE Trans. Soft. Eng.
(1997)
P.A. Bernstein et al.
Concurrency Control and Recovery in Database Systems
(1987)

There are more references available in the full text version of this article.

Cited by (15)

Gradual stabilization
2019, Journal of Parallel and Distributed Computing
Citation Excerpt :
The three versions of unison we consider are respectively named strong, weak, and partial unison, and differ by their safety property. Strong unison is also known as the phase or barrier synchronization problem [24,26]. The weak unison appeared first in [8] under the name of asynchronous unison.
We consider dynamic distributed systems, i.e., distributed systems that can suffer from topological changes over the time. Following the superstabilizing approach, we assume here that topological changes are transient events. In this context, we introduce the notion of gradual stabilization under $(τ, ρ)$ -dynamics (gradual stabilization, for short). A gradually stabilizing algorithm is a self-stabilizing algorithm with the following additional feature: after up to $τ$ dynamic steps of a given type $ρ$ occur starting from a legitimate configuration, it first quickly recovers to a configuration from which a specification offering a minimum quality of service is satisfied. It then gradually converges to specifications offering stronger and stronger safety guarantees until reaching a configuration (1) from which its initial (strong) specification is satisfied again, and (2) where it is ready to achieve gradual convergence again in case of up to $τ$ new dynamic steps of type $ρ$ . A gradually stabilizing algorithm being also self-stabilizing, it still recovers within finite time (yet more slowly) after any other finite number of transient faults, including for example more than $τ$ arbitrary dynamic steps or other failure patterns such as memory corruptions. We illustrate this new property by considering three variants of a synchronization problem respectively called strong, weak, and partial unison. We propose a self-stabilizing unison algorithm which achieves gradual stabilization in the sense that after one dynamic step of a certain type $BULCC$ (such a step may include several topological changes) occurs starting from a configuration which is legitimate for the strong unison, it maintains clocks almost synchronized during the convergence to strong unison: it satisfies partial unison immediately after the dynamic step, then converges in at most one round to weak unison, and finally re-stabilizes to strong unison.
Action-based discovery of satisfying subsets: A distributed method for model correction
2013, Information and Software Technology
Citation Excerpt :
The corrected actions of P2 and P3 are structurally similar to those of P1, hence omitted. The automatically corrected Barrier protocol is the same as the one manually designed in [28]. While the instance of the Barrier synchronization protocol presented in this section includes only three processes, Section 5 presents our results on correcting instances of this protocol with up to 159 processes.
Understanding and resolving counterexamples in model checking is a difficult task that often takes a significant amount of resources and many rounds of regression model checking after any fix. As such, it is desirable to have algorithmic methods that correct finite-state models when their model checking for a specific property fails without undermining the correctness of the rest of the properties, called the model correction problem.
The objective of this paper is to mitigate time and space complexity of correction.
To achieve the objective, this paper presents a distributed method that solves the model correction problem using the concept of satisfying subsets, where a satisfying subset is a subset of model computations that meets a new property while preserving existing properties. The proposed method automates the elimination of superfluous non-determinism in models of concurrent computing systems, thereby generating models that are correct by construction.
We have implemented the proposed method in a distributed software tool, called the Model Corrector (ModCor). Due to the distributed nature of the correction algorithms, ModCor exploits the processing power of computer clusters to mitigate the space and time complexity of correction. Our experimental results are promising as we have used a small cluster of five regular PCs to automatically correct large models (with about 3¹⁵⁹ reachable states) in a few hours. Such corrections would have been impossible without using ModCor.
The results of this paper illustrate that partitioning finite-state models based on their transition relations and distributing them across a computer cluster facilitates the automated correction of models when their model checking fails.
Resettable vector clocks
2006, Journal of Parallel and Distributed Computing
Vector clocks (VC) are an inherent component of a rich class of distributed applications. In this paper, we first consider the problem of realistic implementation—more specifically, bounded-space and fault-tolerant—of applications that use vector clocks (VC). To this end, we generalize the notion of VC to resettable vector clocks (RVC), and provide a realistic implementation of RVC. Further, we identify an interface contract under which our RVC implementation can be substituted for VC in client applications, without affecting the client's correctness. This interface contract is designed for phase-based applications that provide certain communication guarantees. Based on such substitution and the use of the interface contract, we show how to transform the client so that it is itself realistically implemented. We illustrate our method in the context of Ricart–Agrawala's mutual exclusion program and Garg–Chase's predicate detection program.
Resettable Encoded Vector Clock for Causality Analysis with an Application to Dynamic Race Detection
2021, IEEE Transactions on Parallel and Distributed Systems
Size-independent self-stabilizing asynchronous phase synchronization in general graphs
2010, Journal of Information Science and Engineering
A time-optimal self-stabilizing synchronizer using a phase clock
2007, IEEE Transactions on Dependable and Secure Computing

View all citing articles on Scopus

^☆: Research supported in part by OSU Grant 221506, NSF CCR-93-08640, and NSA MDA904-96-1-1011.

View full text

Multitolerant barrier synchronization☆

Abstract

Inform. Process. Lett.

Component based design of multitolerance

IEEE Trans. Soft. Eng.

Concurrency Control and Recovery in Database Systems