Robustness Against Transactional Causal Consistency

@inproceedings{Beillahi2019RobustnessAT,
  title={Robustness Against Transactional Causal Consistency},
  author={Sidi Mohamed Beillahi and Ahmed Bouajjani and Constantin Enea},
  booktitle={CONCUR},
  year={2019}
}
Distributed storage systems and databases are widely used by various types of applications. Transactional access to these storage systems is an important abstraction allowing application programmers to consider blocks of actions (i.e., transactions) as executing atomically. For performance reasons, the consistency models implemented by modern databases are weaker than the standard serializability model, which corresponds to the atomicity abstraction of transactions executing over a sequentially… 

Figures from this paper

Checking Robustness Between Weak Transactional Consistency Models

TLDR
This work investigates the problem of checking whether a given program has the same set of behaviors when replacing a consistency model with a weaker one, and shows that checking robustness between these models is polynomial time reducible to a state reachability problem under serializability.

Verifying Weakly Consistent Transactional Programs Using Symbolic Execution

TLDR
This work uses symbolic execution techniques and satisfiability checkers to build a satisfiability formula that precisely captures all possible valuations of the data variables under a given consistency model.

Semantics, Specification, and Bounded Verification of Concurrent Libraries in Replicated Systems

TLDR
This paper proposes appropriate semantics and specifications for highly-concurrent libraries in a weakly-consistent, replicated setting and develops a static analysis framework that can automatically detect correctness violations of library implementations parameterized with respect to the different consistency policies provided by the underlying system.

Robustness Against Read Committed: A Free Transactional Lunch

TLDR
It is shown how to lift robustness testing to transaction templates as well as to programs to increase practical applicability and discuss open questions and highlight promising directions for future research.

Robustness against Read Committed for Transaction Templates with Functional Constraints

TLDR
This work increases the modeling power of transaction templates by extending them with functional constraints, which are useful for capturing data dependencies like foreign keys, and shows that the incorporation of functional constraints can identify more workloads as robust that otherwise would not be.

Robustness against Read Committed for Transaction Templates

TLDR
An expressive model of transaction programs is introduced to better reason about the serializability of transactional workloads and develops tractable algorithms to decide whether any possible schedule of a workload executed under RC is serializable (referred to as the robustness problem).

Verifying observational robustness against a c11-style memory model

TLDR
This work introduces a novel "observational robustness" property that fills the gap in existing robustness notions that allows the verification of programs that use speculative reads as in the sequence lock mechanism, and shows how to soundly check for observational robustness.

Microservice Decomposition for Transactional Causal Consistent Platforms

. Today, there are many software applications that have been designed using monolithic configurations that could benefit from being decomposed into a combination of microservices or, in some cases,…

Implementing and Verifying Release-Acquire Transactional Memory (Extended Version)

TLDR
This paper develops TMS2-ra, a relaxed operational TM specification that integrates TMS1-ra with RC11 (the repaired C11 memory model that disallows load-buffering) to provide a formal semantics for TM libraries and their clients and uses a simulation-based verification technique to prove correctness of TML-ra.

Deciding Robustness for Lower SQL Isolation Levels

TLDR
The robustness problem for the lower SQL isolation levels READ UNCOMMITTED and READ COMMITTED which are defined in terms of the forbidden dirty write and dirty read patterns is addressed and the coNP-hardness proof is obtained.

References

SHOWING 1-10 OF 111 REFERENCES

On verifying causal consistency

TLDR
It is proved that for data independent implementations, the problem of checking the correctness of a single execution w.r.t. the read-write memory abstraction is polynomial time, and it is shown that for such implementations the set of non-causally consistent executions can be represented by means of a finite number of register automata.

Serializability for eventual consistency: criterion, analysis, and applications

TLDR
The experimental results indicate that the generalization of conflict serializability to the setting of eventual consistency reveals harmful synchronization problems in applications, is more effective at finding them than prior approaches, and can be used for the development of practical, eventually consistent applications.

Automated Detection of Serializability Violations under Weak Consistency

TLDR
This work combines a dependency graph-based characterization of serializability and the framework of abstract executions to develop a fully-automated approach for statically finding boundedserializability violations under any weak consistency model.

Causal consistency: beyond memory

TLDR
This paper presents a new approach to define causal consistency for any abstract data type based on sequential specifications and explores, formalizes and studies the differences between three variations of causal consistency and highlights them in the light of PRAM, eventual consistency and sequential consistency.

Causal memory: definitions, implementation, and programming

TLDR
This paper provides a formal definition of causal memory and gives an implementation for message-passing systems, and describes a practical class of programs that, if developed for a strongly consistent memory, run correctly with causal memory.

Static serializability analysis for causal consistency

TLDR
This paper proposes a static analysis for detecting non-serializable behaviors of applications running on top of causally-consistent databases, based on a novel, local serializability criterion and combines a generalization of graph-based techniques from the database literature with another, complementary analysis technique that encodes it into first-order logic formulas to be checked by an SMT solver.

Weak Consistency: A Generalized Theory and Optimistic Implementations for Distributed Transactions

TLDR
This thesis presents the first implementation-independent specifications of existing ANSI isolation levels and a number of levels that are widely used in commercial systems, e.g., Cursor Stability, Snapshot Isolation, and specifies a variety of guarantees for predicate-based operations in an implementation- independent manner.

Analysing Snapshot Isolation

TLDR
An alternative specification to SI is given that characterises it in terms of transactional dependency graphs of Adya et al., generalising serialization graphs, and does not require adding additional information to dependency graphs about start and commit points of transactions.

Checking and Enforcing Robustness against TSO

TLDR
It is shown that detecting attacks can be parallelized, and can be solved using state reachability queries under the SC semantics in a suitably instrumented program obtained by a linear size source-to-source translation.

The serializability of concurrent database updates

TLDR
Several efficiently recognizable subclasses of the class of senahzable histories are introduced and it is shown how these results can be extended to far more general transaction models, to transactions with partly interpreted functions, and to distributed database systems.
...