Privatization techniques for software transactional memory

  title={Privatization techniques for software transactional memory},
  author={Michael F. Spear and Virendra J. Marathe and Luke Dalessandro and Michael L. Scott},
  booktitle={ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing},
Early implementations of software transactional memory (STM) assumed that sharable data would be accessed only within transactions. Memory may appear inconsistent in programs that violate this assumption, even when program logic would seem to make extra-transactional accesses safe. Designing STM systems that avoid such inconsistency has been dubbed the privatization problem. We argue that privatization comprises a pair of symmetric subproblems: private operations may fail to see updates made by… 

Figures from this paper

Privatization-Safe Transactional Memories (Extended Version)

This paper shows that a variant of Transactional DRF by Dalessandro et al. is appropriate for a class of privatization-safe TMs, which allow using privatization idioms, and proves that a TM cannot be progressive and have invisible reads if it guarantees strongly atomic semantics for TDRF programs.

Safe privatization in transactional memory

A notion of transactional DRF is proposed and proved that, if a TM satisfies a certain condition generalizing opacity and a program using it is DRF assuming strong atomicity, then the program indeed has strongly atomic semantics.

The Cost of Privatization in Software Transactional Memory

It is shown that a transaction privatizing k items must have a data set of size at least k, in an STM with invisible reads, which is oblivious to different nonconflicting executions and guarantees progress in such executions.

Towards a Fully Pessimistic STM Model

This paper introduces the first STM system that is fully pessimistic, that is, each and every transaction, whether reading or writing, is executed once and never aborts, putting in question the commonly accepted understanding of the tradeoffs between pessimism and performance.

The Cost of Privatization

It is shown that a transaction privatizing k items must have a data set of size at least k, in an STM with invisible reads, which is oblivious to different non-conflicting executions and guarantees progress in such executions.

Inevitability Mechanisms for Software Transactional Memory

It is demonstrated that it is possible for an inevitable transaction to run in parallel with (non-conflicting) non-inevitable transactions, without introducing significant overhead in the non-invitable case.

Enforcing isolation and ordering in STM

The results on a set of Java programs show that strong atomicity can be implemented efficiently in a high-performance STM system and introduces 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.

Generalizing the Correctness of Transactional Memory

While a TM can be implemented in a way to ensure opacity for transactions, there is little one can do (on a given platform or run-time environment) to change the underlying memory model, so it is desirable to define opacity parametrized by a memory model.

Ordering-Based Semantics for Software Transactional Memory

This work proposes selective strict serializability (SSS) semantics, in which transactions have a global total order, but nontransactional accesses are globally ordered only with respect to explicitly marked transactions.

Transactions in the jungle

This work proposes a correctness condition for TMs, parametrized opacity, to formally capture the now folklore notion of strong atomicity by stipulating the two following intuitive requirements: first, every transaction appears as if it is executed instantaneously with respect to other transactions and non-transactional operations, and second, non- transactorional operations conform to the given underlying memory model.



Conflict Detection and Validation Strategies for Software Transactional Memory

The most comprehensive study to date of conflict detection strategies is presented, characterizing the tradeoffs among them and identifying the ones that perform the best for various types of workload and introducing a lightweight heuristic mechanism—the global commit counter— that can greatly reduce the cost of validation and of single-threaded execution.

Subtleties of transactional memory atomicity semantics

It is shown that a direct translation of lock-based critical sections into transactions can introduce deadlock into otherwise correct programs, and the terms strong atomicity and weak atomicity are introduced to describe the interaction of transactional and non-transactional code.

Adaptive Software Transactional Memory

This paper considers four dimensions of the STM design space and presents a new Adaptive STM (ASTM) system that adjusts to the offered workload, allowing it to match the performance of the best known existing system on every tested workload.

Hardware Acceleration of Software Transactional Memory

RTM is presented, in which hardware is used to accelerate a TM implementation controlled fundamentally by software, and allows for a wide variety of policies for contention management, deadlock and livelock avoidance, data granularity, nesting, and virtualization.

Contention Management in Dynamic Software Transactional Memory ∗

This work considers the Java-based obstruction-free Dynamic Software Transaction Memory (DSTM) system of Herlihy et al, introduces several novel policies for contention management, and evaluates their performance on a variety of benchmarks.

Advanced contention management for dynamic software transactional memory

This work considers both visible and invisible versions of read access, and benchmarks that vary in complexity, level of contention, tendency toward circular dependence, and mix of reads and writes, and identifies a candidate default policy.

Deconstructing Transactional Semantics: The Subtleties of Atomicity

This work shows that a direct translation of lock-based critical sections into transactions can introduce deadlocks into otherwise correct programs, and defines an atomicity model for transactions, in which the terms strong and weak atomicity are introduced.

Nonblocking transactions without indirection using alert-on-update

A second nonblocking STM system is presented that uses multiple AOU lines (one per accessed object) to eliminate validation overhead entirely, resulting in a nonblocking, zero-indirection STM systems that outperforms competing systems by as much as a factor of 2.

Compiler and runtime support for efficient software transactional memory

A high-performance software transactional memory system (STM) integrated into a managed runtime environment is presented and the JIT compiler is the first to optimize the overheads of STM, and novel techniques for enabling JIT optimizations on STM operations are shown.

Weak ordering—a new definition

This work re-define weak ordering as a contract between software and hardware, where software agrees to some formally specified constraints, and hardware agrees to appear sequentially consistent to at least the software that obeys those constraints.