[Paper Review] Repairing Conflicts among MVCC Transactions

Mohammad Dashti, Sachin Basil John+2 more|arXiv (Cornell University)|Mar 2, 2016

Distributed systems and fault tolerance19 references3 citations

TL;DR

This paper proposes MV3C, a novel MVCC concurrency control algorithm that resolves transaction conflicts by partially re-executing only the conflicting code blocks instead of aborting and restarting entire transactions. By using lightweight dependency annotations and a closure-based repair mechanism, MV3C reduces overhead and improves throughput under high contention, achieving near-zero performance penalty in conflict-free scenarios and significant speedups when conflicts are frequent.

ABSTRACT

The optimistic variants of MVCC (Multi-Version Concurrency Control) avoid blocking concurrent transactions at the cost of having a validation phase. Upon failure in the validation phase, the transaction is usually aborted and restarted from scratch. The "abort and restart" approach becomes a performance bottleneck for the use cases with high contention objects or long running transactions. In addition, restarting from scratch creates a negative feedback loop in the system, because the system incurs additional overhead that may create even further conflicts. In this paper, we propose a novel approach for conflict resolution in MVCC for in-memory databases. This low overhead approach summarizes the transaction programs in the form of a dependency graph. The dependency graph also contains the constructs used in the validation phase of the MVCC algorithm. Then, in the case of encountering conflicts among transactions, the conflict locations in the program are quickly detected, and the conflicting transactions are partially re-executed. This approach maximizes the reuse of the computations done in the initial execution round, and increases the transaction processing throughput.

Motivation & Objective

• To address the performance bottleneck caused by the 'abort and restart' strategy in optimistic MVCC, especially under high contention or long-running transactions.
• To eliminate the negative feedback loop where aborts increase contention and further conflicts.
• To design a low-overhead conflict resolution mechanism that reuses prior computation instead of restarting from scratch.
• To enable efficient repair of conflicting transactions by identifying and re-executing only the affected code blocks using dependency annotations.

Proposed method

• The MV3C algorithm constructs a dependency graph from transaction programs using lightweight annotations to track data and control dependencies.
• Conflicts are detected during validation by checking if read operations access stale data versions.
• When a conflict occurs, only the dependent code blocks—identified via closure boundaries—are re-executed, minimizing recomputation.
• The system uses predicate graphs and compiler-optimized closures to maintain low runtime overhead.
• Write-write conflicts are resolved without premature aborts by deferring conflict resolution until commit time.
• An optional result-set repair mechanism is provided for long-running queries to further improve recovery efficiency.

Experimental results

Research questions

• RQ1 Can conflict resolution in MVCC be improved by partially re-executing only the conflicting portions of transactions rather than aborting and restarting?
• RQ2 What is the performance overhead of maintaining dependency annotations and repair mechanisms in conflict-free execution scenarios?
• RQ3 How does MV3C perform compared to traditional optimistic MVCC (OMVCC) under increasing transaction contention?
• RQ4 Can MV3C effectively handle write-write conflicts without premature aborts?
• RQ5 To what extent does partial repair reduce the ripple effect of conflicts on subsequent transactions?

Key findings

• In conflict-free scenarios, MV3C incurs less than 1% overhead compared to OMVCC, both in serial and concurrent execution.
• For high-contention workloads such as the Trading benchmark with increasing Zipf parameter α, MV3C reduces processing time for 5 million transactions significantly compared to OMVCC.
• The ripple effect experiment shows that MV3C’s repair mechanism reduces overall system load and prevents cascading conflicts, unlike OMVCC which suffers from increasing contention.
• In the TPC-C benchmark with one warehouse, MV3C achieves nearly identical performance to OMVCC, confirming no measurable overhead despite high transaction complexity.
• MV3C’s repair mechanism is particularly effective in scenarios with long-running queries and high contention, where full abort-and-restart would be prohibitively expensive.