Practical weak-atomicity semantics for java stm

Abstract

As memory transactions have been proposed as a languagelevel replacement for locks, there is growing need for welldefined semantics. In contrast to database transactions, transaction memory (TM) semantics are complicated by the fact that programs may access the same memory locations both inside and outside transactions. Strongly atomic semantics, where non-transactional accesses are treated as implicit single-operation transactions, remain difficult to provide without specialized hardware support or significant performance overhead. As an alternative, many in the community have informally proposed that a single global lock semantics [18,10], where transaction semantics are mapped to those of regions protected by a single global lock, provide an intuitive and efficiently implementable model for programmers.In this paper, we explore the implementation and performance implications of single global lock semantics in a weakly atomic STM from the perspective of Java, and we discuss why even recent STM implementations fall short of these semantics. We describe a new weakly atomic Java STM implementation that provides single global lock semantics while permitting concurrent execution, but we show that this comes at a significant performance cost. We also propose and implement various alternative semantics that loosen single lock requirements while still providing strong guarantees. We compare our new implementations to previous ones, including a strongly atomic STM. [24]

Ordering-Based Semantics for Software Transactional Memory

“…2 Conversely, in an STM system based on undo logs, a privatizing thread may see erroneous updates made (temporarily) by a transaction that has aborted but not yet cleaned up. As observed by Menon et al [11], such reads appear to be fundamentally incompatible with the prohibition against "out of thin air" reads. We therefore assume a redo log in the remainder of this paper.…”

“…It specifies that transactions behave as if they acquired a single global mutual exclusion lock. Unfortunately, as several groups have noted [7,11,18], SLA requires behavior that can be expensive to enforce, particularly when a thread privatizes shared data (rendering it logically inaccessible to other threads), works on it for a while (ideally without incurring transactional overheads), and then publishes it again [10,11,18].…”

“…In an attempt to reduce those costs, Menon et al [11] have proposed a series of semantics that relax the requirement for serialization among transactions. These semantics are described in terms of locking protocols significantly more complex than SLA.…”

“…// initialize node atomic { PQ.insert(node) } atomic { node = PQ.extract_min() } // use node privately Figure 1: Examples of publication (left) and privatization (right). More obscure examples, involving antidependences or even empty transactions, are also possible [11].…”

“…1 In light of these costs, most STM systems provide some form of weak isolation, in which nontransactional accesses do not serialize with transactions. As several groups have noted [4,11,12,18], the exact meaning of weak isolation is open to interpretation. Perhaps the most popular interpretation is single lock atomicity (SLA) [7, p. 20], which states that transactions behave as if they acquired a global mutex lock.…”