Abstract:

Traditional software transactional memory systems implement synchronization 
and recovery by tracking memory access.  In recent work, we introduced
transactional boosting, a methodology whereby performance is improved by
forgoing read/write sets and relying instead on data structure commutativity
and abstract locks for synchronization.  In this paper, we describe a method
for concurrent execution of non-commuting operations from distinct
transactions. Abstract locks are speculatively passed from one transaction to
the next, and dependencies are created, enforcing certain commit orders.We
present an efficient implementation, and describe novel techniques for
performing recovery lazily and detecting cyclic dependencies.  We show that the
performance gain for long-lived transactions can offset the cost of tracking
dependencies.  Moreover we quantify the somewhat counter-intuitive discovery
that dependent transactions afford scalability under increased contention.

Joint work with Eric Koskinen