A short counterexample property for safety and liveness verification of fault-tolerant distributed algorithms

@article{Konnov2016ASC,
  title={A short counterexample property for safety and liveness verification of fault-tolerant distributed algorithms},
  author={Igor V. Konnov and Marijana Lazic and Helmut Veith and Josef Widder},
  journal={Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages},
  year={2016}
}
  • I. Konnov, M. Lazic, Josef Widder
  • Published 18 August 2016
  • Computer Science
  • Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages
Distributed algorithms have many mission-critical applications ranging from embedded systems and replicated databases to cloud computing. Due to asynchronous communication, process faults, or network failures, these algorithms are difficult to design and verify. Many algorithms achieve fault tolerance by using threshold guards that, for instance, ensure that a process waits until it has received an acknowledgment from a majority of its peers. Consequently, domain-specific languages for fault… 

Figures and Tables from this paper

Accuracy of Message Counting Abstraction in Fault-Tolerant Distributed Algorithms
TLDR
This paper considers abstractions suitable for many fault-tolerant distributed algorithms that count messages for comparison against thresholds, e.g., the size of a majority of processes, and proves this abstraction useful for model checking: it preserves ATCTL properties, as the abstract and the concrete models simulate each other.
Para$$^2$$2: parameterized path reduction, acceleration, and SMT for reachability in threshold-guarded distributed algorithms
TLDR
This paper encodes bounded executions over integer counters in SMT and introduces a new form of reduction that exploits acceleration and the structure of the FTDAs that aggressively prunes the execution space to be explored by the solver.
Survey on Parameterized Verification with Threshold Automata and the Byzantine Model Checker
TLDR
ByMC implements several techniques for automatic verification of threshold-guarded distributed algorithms, which are implemented in distributed systems that involve hundreds or thousands of processes and need to be verified for all possible values of the parameters.
Synthesis of Distributed Algorithms with Parameterized Threshold Guards
TLDR
An automated method that takes as input a sketch of an asynchronous threshold-based fault-tolerant distributed algorithm and iteratively picks the values for the coefficients and can synthesize distributed algorithms that work for all parameter values that satisfy the resilience condition is introduced.
A Case Study on Parametric Verification of Failure Detectors
TLDR
A case study on formal verification of both safety and liveness of the Chandra and Toueg failure detector that is based on partial synchrony, and conjecture that correctness of other partially synchronous algorithms may be proven by following the presented methodology.
0 : 2 Synthesis of Distributed Algorithms with Parameterized Threshold Guards 1 Introduction
TLDR
An automated method is introduced that automatically synthesizes distributed algorithms that work for all parameter values that satisfy the resilience condition and can synthesize several distributed algorithms from the literature, e.g., Byzantine reliable broadcast and Byzantine one-step consensus.
Verification of Threshold-Based Distributed Algorithms by Decomposition to Decidable Logics
TLDR
This work develops a new methodology for decomposing the verification task of such protocols into two decidable logics: EPR and BAPA, and develops an algorithm for automatically generating the properties needed for verifying a given protocol, facilitating fully automated deductive verification.
Model Checking of Fault-Tolerant Distributed Algorithms : from Classics towards Contemporary
TLDR
The Byzantine model checker was developed for automatic verification of asynchronous fault-tolerant distributed algorithms, and the challenges that are posed by contemporary protocols for Blockchain consensus are discussed.
Synchronous Verification of Asynchronous Distributed Programs
We present pretend synchrony, a new approach to verifying distributed systems, based on the observation that while distributed programs must execute asynchronously, we can often soundly treat them as
Guard Automata for the Verification of Safety and Liveness of Distributed Algorithms
TLDR
This work introduces a framework that abstracts infinite-state distributed systems that represent distributed algorithms into finite-state guard automata, which enable the verification of safety and liveness properties of distributed algorithms.
...
...

References

SHOWING 1-10 OF 77 REFERENCES
SMT and POR Beat Counter Abstraction: Parameterized Model Checking of Threshold-Based Distributed Algorithms
TLDR
A new form of offline partial order reduction that exploits acceleration and the structure of the FTDAs is introduced that aggressively prunes the execution space to be explored by the solver.
A Logic-Based Framework for Verifying Consensus Algorithms
TLDR
This paper gives a semi-decision procedure for the unsatisfiability problem of the logic and identifies a decidable fragment, and successfully applied this framework to verify the correctness of a variety of consensus algorithms tolerant to both benign faults message loss, process crashes and value faults message corruption.
PSync: a partially synchronous language for fault-tolerant distributed algorithms
TLDR
The high-level lockstep abstraction introduced by PSync simplifies the design and implementation of fault-tolerant distributed algorithms and enables automated formal verification.
On Verifying Fault Tolerance of Distributed Protocols
TLDR
This paper describes a framework for verifying the fault tolerance of (synchronous or asynchronous) distributed protocols, based on augmenting the description of the configurations of the system by a mask describing which processes are faulty.
Verdi: a framework for implementing and formally verifying distributed systems
TLDR
Verdi, a framework for implementing and formally verifying distributed systems in Coq, formalizes various network semantics with different faults, and enables the developer to first verify their system under an idealized fault model then transfer the resulting correctness guarantees to a more realistic fault model without any additional proof burden.
On the completeness of bounded model checking for threshold-based distributed algorithms: Reachability
Parameterized model checking of fault-tolerant distributed algorithms by abstraction
TLDR
An automated parameterized verification method for fault-tolerant distributed algorithms (FTDA) using a parametric interval abstraction (PIA) for both data abstraction and a new form of counter abstraction to reduce the parameterized problem to finite-state model checking.
Tutorial on Parameterized Model Checking of Fault-Tolerant Distributed Algorithms
TLDR
This tutorial uses the core of a fault-tolerant distributed broadcasting algorithm as a case study to explain the concepts of the abstraction techniques, and discusses how they can be implemented.
A short counterexample property for safety and liveness verification of fault-tolerant distributed algorithms
TLDR
This research presents a novel and scalable approaches called "Smart Cassandra DSP Integration (SCSI)” that addresses the challenge of integrating NoSQL data stores to distributed systems.
On-the-Fly Analysis of Systems with Unbounded, Lossy FIFO Channels
TLDR
A novel representation formalism, called simple regular expressions (SREs), for representing sets of states of protocols with lossy FIFO channels is proposed, and it is shown that the class of languages representable by SREs is exactly theclass of downward closed languages that arise in the analysis of such protocols.
...
...