On Non-Interference and Locality in Transactional Memory

The promise of transactional memory is 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 usually expedcted that 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 the writes of aborted or incomplete transactions do not appear in the global serial execution, and, thus, no committed transaction can be affected by them. We consider another, less obvious, feature of "not taking effect" called non-interference: aborted or incomplete transactions should not force any other transaction to abort. More precisely, 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. We show that for a correctness criterion to be implementable in a non-interfering way it is sufficient %and, in many cases, necessary, to be local, i.e., to only require that every transaction can be serialized along with (a subset of) the transactions committed before its last event. For example, opacity requires that all aborted transactions to fit in a single global serialization (along with all the committed transactions) is not local and cannot achieve non-interference. We propose a simple though efficient implementation that satisfies non-interference and local opacity, a novel correctness criterion that is interesting in its own right. In addition to strict serializability, local opacity captures the safety semantics of opacity: aborted transactions do not witness inconsistent states.