Static local coordination avoidance for distributed objects

Soethout, Tim; Storm, Tijs van der; Vinju, Jurgen

doi:10.1145/3358499.3361222

Cited by 7 publications

(16 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For instance, the Rebel domain-specific language has been used to specify realistic systems (for instance, in the financial domain), from which highly scalable implementations are generated using novel consistency algorithms [25][26][27]. It is however, a far from trivial endeavour to state and prove isolation guarantees of some of these algorithms.…”

Section: Discussion and Future Workmentioning

confidence: 99%

Automated Validation of State-Based Client-Centric Isolation with TLA$$^+$$

Soethout

Storm

Vinju

2021

Software Engineering and Formal Methods. SEFM 2020 Collocated Workshops

Self Cite

View full text Add to dashboard Cite

Clear consistency guarantees on data are paramount for the design and implementation of distributed systems. When implementing distributed applications, developers require approaches to verify the data consistency guarantees of an implementation choice. Crooks et al. define a state-based and client-centric model of database isolation. This paper formalizes this state-based model in tla + , reproduces their examples and shows how to model check runtime traces and algorithms with this formalization. The formalized model in tla + enables semi-automatic model checking for different implementation alternatives for transactional operations and allows checking of conformance to isolation levels. We reproduce examples of the original paper and confirm the isolation guarantees of the combination of the well-known 2-phase locking and 2-phase commit algorithms. Using model checking this formalization can also help finding bugs in incorrect specifications. This improves feasibility of automated checking of isolation guarantees in synthesized synchronization implementations and it provides an environment for experimenting with new designs.

show abstract

Section: Discussion and Future Workmentioning

confidence: 99%

Automated Validation of State-Based Client-Centric Isolation with TLA$$^+$$

Soethout

Storm

Vinju

2021

Software Engineering and Formal Methods. SEFM 2020 Collocated Workshops

Self Cite

View full text Add to dashboard Cite

show abstract

“…These approaches may strengthen the consistency level of many operations, thereby, increasing the latency of user requests and deteriorating the scalability and availability of the system. Soethout et al [2019] statically detect pairs of events that are always independent and thus do not require coordination at runtime. Wang et al [2019] propose replication-aware linearizability, a criterion that enables sequential reasoning to prove the correctness of CRDT implementations.…”

Section: Related Workmentioning

confidence: 99%

ECROs: building global scale systems from sequential code

Porre

Ferreira

Preguiça

et al. 2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

To ease the development of geo-distributed applications, replicated data types (RDTs) offer a familiar programming interface while ensuring state convergence, low latency, and high availability. However, RDTs are still designed exclusively by experts using ad-hoc solutions that are error-prone and result in brittle systems. Recent works statically detect conflicting operations on existing data types and coordinate those at runtime to guarantee convergence and preserve application invariants. However, these approaches are too conservative, imposing coordination on a large number of operations. In this work, we propose a principled approach to design and implement efficient RDTs taking into account application invariants. Developers extend sequential data types with a distributed specification, which together form an RDT. We statically analyze the specification to detect conflicts and unravel their cause. This information is then used at runtime to serialize concurrent operations safely and efficiently. Our approach derives a correct RDT from any sequential data type without changes to the data type's implementation and with minimal coordination. We implement our approach in Scala and develop an extensive portfolio of RDTs. The evaluation shows that our approach provides performance similar to conflict-free replicated data types for commutative operations, and considerably improves the performance of non-commutative operations, compared to existing solutions.

show abstract

“…Independent Events, a definition of independent operation pairs, guaranteeing local internal state machine consistency, but not global serializability. Soethout et al [23,25] 5…”

Section: Iementioning

confidence: 99%

“…Subset of IE, statically determined for all possible object states using an smt solver. Soethout et al [23] 5 ci…”

Section: Siementioning

confidence: 99%

Contract-based return-value commutativity: safely exploiting contract-based commutativity for faster serializable transactions

Soethout

Storm

Vinju

2021

Proceedings of the 11th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control

Self Cite

View full text Add to dashboard Cite

A key challenge of designing distributed software systems is maintaining data consistency. We can define data consistency and data isolation guarantees -e.g. serializability-in terms of schedules of atomic reads and writes, but this excludes schedules that would be semantically consistent. Others use manually provided information on "non-conflicting operations" to define guarantees that work for more applications allowing more parallel schedules. To be safe, an engineer might avoid marking operations as non-conflicting, with detrimental effects to efficiency. To be fast, they might mark more non-conflicting operations than is strictly safe.Our goal is to help engineers by automatically deriving commutative operations (using their respective contracts) such that more parallel schedules with global consistency are possible. We define a new general consistency and isolation guarantee named "Return-Value Serializability" to check consistency claims automatically, and we present distributed event processing algorithms that make use of the same "Contractbased Commutativity" information. We validated both the definitions and the algorithms using model-checking with tla + . Previous work provided evidence that local coordination avoidance such as applied here has a significant positive effect on the performance of distributed transaction systems.Client-centric return-value commutativity promises to hit a sweet spot in design trade-offs for business applications, such as payment systems, that must scale-out while their operations are not embarrassingly parallel and consistency guarantees are of the highest priority. It can also provide design feedback, indicating that some operations will simply not scale together even before a line of code has been written.

show abstract

Static local coordination avoidance for distributed objects

Cited by 7 publications

References 11 publications

Automated Validation of State-Based Client-Centric Isolation with TLA$$^+$$

Automated Validation of State-Based Client-Centric Isolation with TLA$$^+$$

ECROs: building global scale systems from sequential code

Contract-based return-value commutativity: safely exploiting contract-based commutativity for faster serializable transactions

Contact Info

Product

Resources

About