  Transaction Memory (TM) is a concurrency control abstraction that allows the
programmer to specify blocks of code to be executed atomically as transactions.
However, since transactional code can contain just about any operation
attention must be paid to the state of shared variables at any given time.
E.g., contrary to a database transaction, if a TM transaction reads a stale
value it may execute dangerous operations, like attempt to divide by zero,
access an illegal memory address, or enter an infinite loop. Thus
serializability is insufficient, and stronger safety properties are required in
TM, which regulate what values can be read, even by transactions that abort.
Hence, a number of TM safety properties were developed, including opacity, and
TMS1 and TMS2. However, such strong properties preclude using early release as
a technique for optimizing TM, because they virtually forbid reading from live
transactions. On the other hand, properties that do allow early release are
either not strong enough to prevent any of the problems mentioned above
(recoverability), or add additional conditions on transactions with early
release that limit their applicability (elastic opacity, live opacity, virtual
world consistency). This paper introduces last-use opacity, a new TM safety
property that is meant to be a compromise between strong properties like
opacity and serializability. The property eliminates all but a small class of
inconsistent views and poses no stringent conditions on transactions. For
illustration, we present a last-use opaque TM algorithm and show that it
satisfies the new safety property.
