Principles of Transactional Memory

@inproceedings{Guerraoui2010PrinciplesOT,
  title={Principles of Transactional Memory},
  author={Rachid Guerraoui and Michal Kapalka},
  booktitle={Synthesis Lectures on Distributed Computing Theory},
  year={2010}
}
Transactional memory (TM) is an appealing paradigm for concurrent programming on shared memory architectures. With a TM, threads of an application communicate, and synchronize their actions, via in-memory transactions. Each transaction can perform any number of operations on shared data, and then either commit or abort. When the transaction commits, the effects of all its operations become immediately visible to other transactions; when it aborts, however, those effects are entirely discarded… 
Progressive Transactional Memory in Time and Space
TLDR
It is shown that the total number of remote memory references RMRs that take place in an execution of a progressive TM in which n concurrent processes perform transactions on a single data item might reach $$\varOmega n \log n$$, which appears to be the first RMR complexity lower bound for transactional memory.
Safe privatization in transactional memory
TLDR
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.
On Non-Interference and Locality in Transactional Memory
TLDR
A simple though efficient implementation is proposed that satisfies non-interference and local opacity, a novel correctness criterion that is interesting in its own right and captures the safety semantics of opacity: aborted transactions do not witness inconsistent states.
Transactional Memory Repair
TLDR
It is important to make sure that the implementation itself is correct, i.e. that it satisfies safety and liveness properties, as well as to verify if a TM implementation satisfies some safety property.
Towards a universal construction for transaction-based multiprocess programs
Estimating parallelism of Transactional Memory programs
TLDR
This paper presents an approach to application of a well-established methodology, which is based on modeling programs as DAGs, and calculating their work, span, parallelism, and speedup, in order to calculate the parallelism of a typical TM program for processing a group of transactions on a set of bank accounts.
Privatization-Safe Transactional Memories (Extended Version)
TLDR
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.
Last-use Opacity: A Strong Safety Property for Transactional Memory with Early Release Support
TLDR
Last-use opacity and strong last- use opacity are introduced, a pair of new TM safety properties meant to be a compromise between strong properties like opacity and minimal ones like serializability, which eliminate all but a small class of benign inconsistent views and pose no stringent conditions on transactions.
Why Transactional Memory Should Not Be Obstruction-Free
TLDR
This paper explains the shift in the TM practice theoretically, via complexity bounds, and proves a few important lower bounds on obstruction-free TMs, and presents a lock-based TM implementation that beats all of these lower bounds.
Proving Opacity of Transactional Memory with Early Release
TLDR
A proof technique is proposed that makes it possible to demonstrate that a TM with early release can be opaque as long as it prevents inconsistent views.
...
...

References

SHOWING 1-10 OF 68 REFERENCES
On the correctness of transactional memory
TLDR
Opacity is defined as a property of concurrent transaction histories and its graph theoretical interpretation is given and it is proved that every single-version TM system that uses invisible reads and does not abort non-conflicting transactions requires, in the worst case, k steps for an operation to terminate.
Sequential Specification of Transactional Memory Semantics
TLDR
This work identifies TM implementations from the literature corresponding to several specific conflict and arbitration functions, and offers candidate sequential specifications to capture the semantics of transactional memory.
RingSTM: scalable transactions with a single atomic instruction
TLDR
The RingSTM system is the first STM that is inherently livelock-free and privatization-safe while at the same time permitting parallel writeback by concurrent disjoint transactions.
Transactional Locking II
TLDR
This paper introduces the transactional locking II (TL2) algorithm, a software transactional memory (STM) algorithm based on a combination of commit-time locking and a novel global version-clock based validation technique, which is ten-fold faster than a single lock.
Nested parallelism in transactional memory
This paper investigates adding transactions with nested parallelism and nested transactions to a dynamically multithreaded parallel programming language that generates only series-parallel programs.
Semantics of transactional memory and automatic mutual exclusion
TLDR
This paper develops semantics and type systems for the constructs of the Automatic Mutual Exclusion (AME) programming model and model STM systems that use in-place update, optimistic concurrency, lazy conflict detection, and roll-back.
The semantics of progress in lock-based transactional memory
TLDR
This paper is the first to formally define the progress semantics of lockbased TMs, which are considered the most effective in practice, and uses this semantics to reduce the problems of reasoning about the correctness and computability power of lock- based TMs to those of simple try-lock objects.
Consensus Numbers of Transactional Objects
This paper describes the ability of asynchronous shared-memory distributed systems to solve the consensus problem in a wait-free manner if processes are permitted to perform transactions on the
Ordering-Based Semantics for Software Transactional Memory
TLDR
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.
Adaptive Software Transactional Memory
TLDR
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.
...
...