Abstract—Transactional memory (TM) is a promising paradigm

for helping programmers take advantage of emerging multicore

platforms. Though they perform well under low contention,

hardware TM systems have a reputation of not performing well

under high contention, as compared to locks. This paper presents

a model and implementation of dependence-aware transactional

memory (DATM), a novel solution to the problem of scaling under

contention. Unlike many proposals to deal with write-shared data

(which arise in common data structures like counters and linked

lists), DATM operates transparently to the programmer.

The main idea in DATM is to accept any transaction execution

interleaving that is conflict serializable, including interleavings

that contain simple conflicts. Current TM systems reduce useful

concurrency by restarting conflicting transactions, even if the

execution interleaving is conflict serializable. DATM manages dependences

between uncommitted transactions, sometimes forwarding

data between them to safely commit conflicting transactions.

The evaluation of our prototype shows that DATM increases

concurrency, for example by reducing the runtime of STAMP

benchmarks by up to 39% and reducing transaction restarts by

up to 94%.

In  MICRO

Details