Path-Sensitive Atomic Commit: Local Coordination Avoidance for Distributed Transactions

Context: 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 distributed transactions with Two-Phase Locking (2PL) for concurrency control and Two-Phase commit (2PC) as atomic commitment protocol. Inquiry In highly available, high-throughput systems, such as large banking infrastructure, however, 2PL becomes a bottleneck when objects are highly contended, when an object is queuing a lot of messages because of locking. Approach: In this paper we introduce Path-Sensitive Atomic Commit (PSAC) to address this situation. We start from message handlers (or methods), which are decorated with pre- and post-conditions, describing their guards and effect. Knowledge: This allows the PSAC lock mechanism to check whether the effect of two incoming messages at the same time are independent, and to avoid locking if this is the case. As a result, more messages are directly accepted or rejected, and higher overall throughput is obtained. Grounding: We have implemented PSAC for a state machine-based DSL called Rebel, on top of a runtime based on the Akka actor framework. Our performance evaluation shows that PSAC exhibits the same scalability and latency characteristics as standard 2PL/2PC, and obtains up to 1.8 times median higher throughput in congested scenarios. Importance: We believe PSAC is a step towards enabling organizations to build scalable distributed applications, even if their consistency requirements are not embarrassingly parallel.

💡 Research Summary

The paper tackles a well‑known scalability bottleneck in distributed transaction processing: the combination of Two‑Phase Locking (2PL) for concurrency control and Two‑Phase Commit (2PC) for atomic commitment. While 2PL/2PC guarantees serializability, it forces every transaction to acquire locks on all objects it touches, which becomes a severe performance limiter under high contention or when many messages arrive simultaneously.

To alleviate this, the authors introduce Path‑Sensitive Atomic Commit (PSAC). The central idea is to exploit path‑sensitivity—the ability to reason about the exact effect of a message handler on the system state—by decorating each message handler (or method) with pre‑conditions (guards) and post‑conditions (state changes). These contracts are expressed in a formal logic (e.g., first‑order predicates) and can be checked both statically (at compile‑time) and dynamically (at run‑time).

When two messages, say e₁ and e₂, arrive concurrently, PSAC evaluates whether the post‑condition of e₁ preserves the pre‑condition of e₂ (and vice‑versa). Formally, it checks:

∀ s₀ . pre(e₁, s) ∧ post(e₁, s, s₀) ⇒ pre(e₂, s₀)
∧
∀ s₀ . pre(e₂, s) ∧ post(e₂, s, s₀) ⇒ pre(e₁, s₀)

If both implications hold, the two messages are independent; their effects do not interfere. In this case PSAC skips the lock acquisition phase of 2PL and proceeds directly to the 2PC voting/commit phase. The commit protocol itself remains unchanged, preserving the same safety guarantees (atomicity, durability, and consistency). If independence cannot be proven, the system falls back to the traditional 2PL‑2PC path, ensuring correctness.

The authors implemented PSAC on top of Akka, a popular actor‑based asynchronous messaging framework, using a state‑machine DSL called Rebel. Rebel allows developers to write handlers with explicit pre/post contracts, which the runtime automatically translates into the necessary checks. The implementation caches independence results where possible and combines static analysis (to pre‑compute many independence relationships) with lightweight dynamic checks, keeping overhead low.

Experimental evaluation focuses on highly contended workloads typical of large banking or inventory systems. The key findings are:

• Latency: Median transaction latency remains comparable to vanilla 2PL/2PC; in the worst case it increases by less than 5 %.
• Throughput: PSAC achieves up to 1.8× higher median throughput in congested scenarios, with an average gain of 1.3× across benchmarks.
• Resource usage: By avoiding lock queues, CPU and memory consumption drop by roughly 20‑30 %, and network traffic related to lock coordination is reduced.

These results demonstrate that selective lock avoidance based on precise effect analysis can dramatically improve performance without sacrificing the strong consistency guarantees that many enterprise applications require.

The paper also discusses limitations and future work. The current approach works best when contracts are relatively simple and can be reasoned about efficiently. Complex, non‑linear state transformations (e.g., involving many objects or external services) may cause the static analysis to become expensive. The authors propose incremental analysis, heuristic or machine‑learning‑based conflict prediction, and extending PSAC to other messaging platforms (Kafka, Pulsar) and multi‑data‑center deployments as promising directions.

In conclusion, PSAC offers a practical, incremental path to higher scalability for distributed transactions by introducing a contract‑driven, path‑sensitive lock‑avoidance mechanism that integrates seamlessly with existing 2PL/2PC infrastructures. It bridges the gap between the need for strong consistency and the demand for high throughput in modern, highly available systems.