Enforcing isolation and ordering in STM

Abstract

Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity: Accessing shared data both inside and outside a transaction can result in unexpected, implementation-dependent behavior. To guarantee isolation and consistent ordering in such a system, programmers are expected to enclose all shared-memory accesses inside transactions.A system that provides strong atomicity guarantees isolation even in the presence of threads that access shared data outside transactions. A strongly-atomic system also orders transactions with conflicting non-transactional memory operations in a consistent manner.In this paper, we discuss some surprising pitfalls of weak atomicity, and we present an STM system that avoids these problems via strong atomicity. We demonstrate how to implement nontransactional data accesses via efficient read and write barriers, and we present compiler optimizations that further reduce the overheads of these barriers. We introduce a dynamic escape analysis that differentiates private and public data at runtime to make barriers cheaper and a static not-accessed-in-transaction analysis that removes many barriers completely. Our results on a set of Java programs show that strong atomicity can be implemented efficiently in a high-performance STM system.

Transactional memory

“…However, strong atomicity is more difficult to implement in software transactional memory systems. Most software transactional memory proposals so far have only supported weak atomicity, but recent work, e.g., [13,91,6,2], show how some of these short-comings can be addressed.…”

“…One problem with software transactional memory systems only supporting weak atomicity (isolation) is the privatization problem [95,91,1]. The problem occurs when a thread makes some shared object(s) private for, e.g., performance reasons.…”

Set-Congruence Dynamic Analysis for Thread-Level Speculation (TLS)

“…It follows that war and waw dependencies are implicitly satisfied. In-place models [16,8,20] access (modify) directly the program state, while still enforcing the sequential semantics. Important differences with respect to serial commit models are that (i) all types of dependencies (raw, war and waw) may generate violations, but (ii) they are scalable -in number of processors that may contribute to speed-up, and (iii) allow a more flexible iteration-to-thread partitioning (threads may execute non-consecutive groups of iterations, see later).…”

Ordering-Based Semantics for Software Transactional Memory

“…Many possible semantics for TM have been proposed, including strong and weak isolation (also known as strong and weak atomicity) [1,17], single lock atomicity (SLA) [7], and approaches based on language memory models [4], linearizability [5,15], and operational semantics [12]. Of these, SLA has received the most attention.…”