Hany E. Ramadan, Christopher J. Rossbach, and Emmett Witchel
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%.