  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.
