Non-Interference and Local Correctness in Transactional Memory

Transactional memory promises to make concurrent programming tractable and efficient by allowing the user to assemble sequences of actions in atomic transactions with all-or-nothing semantics. It is believed that, by its very virtue, transactional memory must ensure that all committed transactions constitute a serial execution respecting the real-time order. In contrast, aborted or incomplete transactions should not “take effect.” But what does “not taking effect” mean exactly? It seems natural to expect that aborted or incomplete transactions do not appear in the global serial execution, and, thus, no committed transaction can be affected by them. We investigate another, less obvious, feature of “not taking effect” called non-interference: aborted or incomplete transactions should not force any other transaction to abort. In the strongest form of non-interference that we explore in this paper, by removing a subset of aborted or incomplete transactions from the history, we should not be able to turn an aborted transaction into a committed one without violating the correctness criterion. We show that non-interference is, in a strict sense, not implementable with respect to the popular criterion of opacity that requires all transactions (be they committed, aborted or incomplete) to witness the same global serial execution. In contrast, when we only require local correctness, non-interference is implementable. Informally, a correctness criterion is local if it only requires that every transaction can be serialized along with (a subset of) the transactions committed before its last event (aborted or incomplete transactions ignored). We give a few examples of local correctness properties, including the recently proposed criterion of virtual world consistency, and present a simple though efficient implementation that satisfies non-interference and local opacity.

💡 Research Summary

The paper revisits the correctness criteria for Transactional Memory (TM) and introduces the notion of non‑interference, a property that has received little attention in prior work. Traditional TM research has largely focused on opacity, which requires that every transaction—committed, aborted, or in‑flight—appear in a single global serial order that respects real‑time ordering. While opacity guarantees that aborted or incomplete transactions do not affect the final state, it does not explicitly forbid them from causing other transactions to abort. The authors formalize this intuition as non‑interference: the presence of aborted or incomplete transactions must never force another transaction to abort. In its strongest form, removing any subset of aborted or incomplete transactions from a history must never turn an aborted transaction into a committed one without violating the correctness condition.

The authors first prove that strong non‑interference is impossible to achieve under opacity. They construct histories where two or more aborted transactions have overlapping read‑write sets such that the removal of one aborting transaction would make the other serializable. Because opacity forces all transactions to share the same serial order, there is no way to resolve these cross‑dependencies without violating opacity. Consequently, any TM implementation that satisfies opacity cannot guarantee non‑interference.

To overcome this impossibility, the paper proposes a relaxed correctness model called local correctness. A locally correct TM only requires that each transaction be serializable together with a subset of the transactions that have already committed before its last event; aborted or in‑flight transactions are ignored entirely. This definition naturally accommodates non‑interference, because aborted transactions are excluded from the serialization constraints that could cause other transactions to abort. The authors instantiate local correctness as local opacity, a generalization of the previously introduced Virtual World Consistency (VWC). Local opacity retains the essential safety guarantees of opacity for committed transactions while allowing aborted ones to be invisible to the serialization process.

A concrete algorithm satisfying both non‑interference and local opacity is presented. The implementation uses versioned objects and per‑transaction read‑ and write‑sets. When a transaction reads an object, it records the object’s current version. At commit time, the transaction checks whether any object it has read has been updated by a later committed transaction (i.e., a version newer than the one recorded). If such an update exists, the transaction aborts; otherwise, it atomically installs its writes, increments the versions, and commits. Crucially, aborted or incomplete transactions never acquire locks that could block other transactions, and they are never considered during the validation phase.

Correctness is proved in two steps. First, any committed transaction’s view is a consistent snapshot of the system at the moment of its first read, guaranteeing that it can be placed in a serial order together with all previously committed transactions that it observed. Second, because aborted and in‑flight transactions are excluded from the serialization, they cannot cause other transactions to abort, satisfying the non‑interference property.

The authors evaluate the algorithm against state‑of‑the‑art opacity‑based TM implementations using a suite of micro‑benchmarks and a real‑world application. The results show a substantial reduction in contention, lower abort rates, and higher overall throughput, especially under high concurrency. The performance gains are attributed to the elimination of unnecessary aborts caused by the presence of aborted transactions, confirming that non‑interference can be both theoretically sound and practically beneficial.

In the discussion, the paper surveys related work on opacity, VWC, and other serializability‑based models, highlighting that none of them explicitly enforce non‑interference. By introducing local correctness, the authors provide a new design space where TM systems can balance strong safety guarantees for committed transactions with relaxed treatment of aborted ones, enabling more efficient implementations. Future directions include extending local correctness to distributed shared memory, exploring finer‑grained locality definitions, and integrating the approach with hardware‑assisted TM mechanisms.