Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory

@article{Attiya2009InherentLO,
  title={Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory},
  author={Hagit Attiya and Eshcar Hillel and Alessia Milani},
  journal={Theory of Computing Systems},
  year={2009},
  volume={49},
  pages={698-719}
}
Transactional memory (TM) is a popular approach for alleviating the difficulty of programming concurrent applications; TM guarantees that a transaction, consisting of a sequence of operations, appear to be executed atomically. Two fundamental properties of TM implementations are disjoint-access parallelism and the invisibility of read operations. Disjoint access parallelism ensures that operations on disconnected data do not interfere, and thus it is critical for TM scalability. The… 
Disjoint-Access Parallelism: Impossibility, Possibility, and Cost of Transactional Memory Implementations
TLDR
It is shown that adopting WRTO makes it possible to design a strictly DAP TM with invisible and wait-free read-only transactions, while preserving strong progressiveness for write transactions and an isolation level known in literature as Extended Update Serializability.
Disjoint-Access Parallelism in Software Transactional Memory
TLDR
This chapter will formalize the requirement that unrelated transactions progress independently, without interference, even if they occur at the same time, by presenting impossibility results and discussing some of the disjoint-access parallel STM implementations.
Practical and Lock-free Parallel Nesting for Software Transactional Memory
TLDR
This paper presents the first lock-free parallel nesting algorithm with support for multi-versions, which is used to outperform the original STM on several known benchmarks by up to 2.8 times.
The Cost of Privatization in Software Transactional Memory
TLDR
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.
Snapshot Isolation Does Not Scale Either
TLDR
It was shown however that a TM cannot ensure strict disjoint-access-parallelism if it also needs to ensure serializability and obstruction-freedom and therefore they are highly desirable when designing TM implementations.
The Cost of Privatization
TLDR
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.
Grasping the gap between blocking and non-blocking transactional memories
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.
Boosting Transactional Memory with Stricter Serializability
TLDR
This work presents a matching algorithm that supports invisible reads, lazy snapshots, and that can trade synchronization for more parallelism, and presents a novel and flexible approach based on a new consistency criteria named stricter serializability.
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.
...
...

References

SHOWING 1-10 OF 38 REFERENCES
Disjoint-access-parallel implementations of strong shared memory primitives
TLDR
An efficient, non-blocking, disjointaccess-parallel implementation of LL and SCn, using Read and CBS and the asynchronous shar-ed memory model is presented.
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.
Lock-free Serializable Transactions
TLDR
The first serializable, lock-free software transactional memory, which supports dynamic transactions, provides early failure indication, requires a single interface for both read-only and read-write transactions, keeps multiple versions of objects, and allows for disjoint-access parallelism is presented.
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.
A Lock-based Protocol for Software Transactional Memory
TLDR
This paper presents a new lock-based STM system designed from simple basic principles that does not require the shared memory to manage several versions of each object, uses neither timestamps, nor version numbers, never aborts a write only transaction, and employs only bounded control variables.
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.
Serializability of Transactions in Software Transactional Memory
TLDR
An obstruction-free STM system that uses CS with multi-versioning is implemented and evaluation shows that the use of CS significantly reduces abort rates in programs with high abort rates, resulting in up to 2.5 times improvement in throughput.
Software transactional memory for dynamic-sized data structures
TLDR
A new form of software transactional memory designed to support dynamic-sized data structures, and a novel non-blocking implementation of this STM that uses modular contention managers to ensure progress in practice.
On obstruction-free transactions
TLDR
It is proved that OFTMs cannot ensure disjoint-access-parallelism (in a strict sense) and may result in artificial "hot spots" and thus limit the performance of OFT Ms.
Maintaining Consistent Transactional States without a Global Clock
TLDR
TLC is the proof that one can devise coherent-state STM systems without a global clock, and the big promise of the TLC approach is in providing a decentralized solution for future large scale machines, ones with hundreds of cores.
...
...