Transactional memory: models and algorithms

Modern multicore architectures enable the concurrent execution of an unprecedented number of threads. This gives rise to the opportunity for extreme performance and the complex challenge of synchronization. Conventional lock-based synchronization has several drawbacks which limits the parallelism offered by multicore architectures. Coarse-grained locks do not scale. Fine-grained locks are difficult to program correctly because locks are generally not composable. Transactional memory (TM) [45, 81] provides an alternative synchronization mechanism that is non-blocking, composable, and easier to write than lock-based code [64]. TM-based synchronization has recently been included in IBM’s Blue Gene/Q [39, 84] and Intel’s Haswell processors [20]. TM is predicted to be widely used in future processors, possibly even GPUs [32, 86]. In the research community, several TM implementations (hardware, software, and hybrid) have been proposed and studied, e.g., [16, 24, 26, 30, 31, 43, 44, 60]. The TM book by Harris et al. [40] provides an excellent overview of the design and implementation of TM systems up to early spring 2010. TM operates in a way similar to database transactions, and aggregates a sequence of shared resource accesses (reads or writes) that should be executed atomically (by a single thread) in a fundamental module called transaction. A transaction is a piece of code that executes a series of reads and writes to shared memory. These reads and writes logically occur as a transaction at a single instance in time; intermediate states are not visible to other (successful) transactions. TM increases parallelism as no threads need to wait for access to a shared resource and different threads can simultaneously modify disjoint parts of a data structure that would normally be protected under the same lock. A transaction ends either by committing, in which case all of the updates take effect, or by aborting, in which case no update is effective. Each program thread generates a sequence of transactions. Transactions of the same thread execute sequentially by following the program execution flow. However, transactions of different threads may conflict when they attempt to access the same shared memory resources. The advantage of TM is that if there are no conflicts