Path-Sensitive Atomic Commit: Local Coordination Avoidance for Distributed Transactions (Technical Report)

@article{Soethout2021PathSensitiveAC,
  title={Path-Sensitive Atomic Commit: Local Coordination Avoidance for Distributed Transactions (Technical Report)},
  author={Tim Soethout and Jurgen J. Vinju and Tijs van der Storm},
  journal={Art Sci. Eng. Program.},
  year={2021},
  volume={5},
  pages={3}
}
Concurrent objects with asynchronous messaging are an increasingly popular way to structure highly available, high performance, large-scale software systems. To ensure data-consistency and support synchronization between objects such systems often use an atomic commitment protocol such as Two-Phase commit (2PC). In highly available, high-throughput systems, such as large banking infrastructure, however, 2PC becomes a bottleneck when objects are highly congested (one object queuing a lot of… 

Figures and Tables from this paper

Static local coordination avoidance for distributed objects
TLDR
This paper proposes Static Local Coordination Avoidance, which analyzes application invariants at compile time to detect whether messages are independent, so that synchronization at run time is avoided, and parallelism is increased.
Contract-based return-value commutativity: safely exploiting contract-based commutativity for faster serializable transactions
TLDR
This work defines a new general consistency and isolation guarantee named "Return-Value Serializability" to check consistency claims automatically, and presents distributed event processing algorithms that make use of the same "Contract-based Commutativity" information.
Contract-Based Return-Value Commutativity
TLDR
A new general consistency and isolation guarantee named “Return-Value Serializability” is defined to check consistency claims automatically, and distributed event processing algorithms that make use of the same “Contractbased Commutativity” information are presented.
Exploiting models for scalable and high throughput distributed software
TLDR
This short paper focuses on research on the opportunity of leveraging application specific knowledge captured by model driven engineering approaches, to increase application performance in high-contention scenarios, while maintaining functional application-level consistency.

References

SHOWING 1-10 OF 54 REFERENCES
Extracting More Concurrency from Distributed Transactions
TLDR
ROCOCO is presented, a novel concurrency control protocol for distributed transactions that outperforms 2PL and OCC by allowing more concurrency and is compared to OCC and 2PL using a scaled TPC-C benchmark.
Putting consistency back into eventual consistency
TLDR
This work presents the design and evaluation of Indigo, a middleware that provides Explicit Consistency on top of a causally-consistent data store that guarantees strong application invariants while providing similar latency to an eventually-cons consistent system in the common case.
Transactions for Distributed Actors in the Cloud
TLDR
A new transaction protocol is presented that avoids blocking by releasing all of a transaction’s locks during phase one of two-phase commit, and by tracking commit dependencies to implement cascading abort.
Static local coordination avoidance for distributed objects
TLDR
This paper proposes Static Local Coordination Avoidance, which analyzes application invariants at compile time to detect whether messages are independent, so that synchronization at run time is avoided, and parallelism is increased.
Coordination Avoidance in Database Systems
TLDR
A formal framework is developed that determines whether an application requires coordination for correct execution by operating on application-level invariants over database states and shows that many are invariant confluent and therefore achievable without coordination.
Coordination Avoidance in Distributed Databases
TLDR
This thesis investigates the potential for coordination avoidance---the use of as little coordination as possible while ensuring application integrity---in several modern data-intensive domains and demonstrates how to leverage the semantic requirements of applications in data serving, transaction processing, and web services to enable more efficient distributed algorithms and system designs.
Precision locks
TLDR
It is shown that transactions under PL are well formed and two phased which is sufficient to maintain consistency and the execution cost of PL is compared to a conventional tuple-level locking method and it is found that PL usually is cheaper to execute.
Observable atomic consistency for CvRDTs
TLDR
This paper provides a distributed implementation of OACP, the observable atomic consistency protocol, based on Akka, a widely-used actor-based middleware, and shows that OACP can reduce coordination overhead compared to other protocols providing atomic consistency.
The Escrow transactional method
TLDR
The Escrow Method offered here is designed to support nonblocking record updates by transactions that are “long lived” and thus require long periods to complete, and several advantages result.
Keeping CALM: When Distributed Consistency is Easy
TLDR
This paper presents an informal introduction to the CALM Theorem, which answers the question of when coordination is actually required precisely by moving up from traditional storage consistency to consider properties of programs.
...
...