On Partial Wait-Freedom in Transactional Memory

@article{Kuznetsov2015OnPW,
  title={On Partial Wait-Freedom in Transactional Memory},
  author={Petr Kuznetsov and Srivatsan Ravi},
  journal={Proceedings of the 2015 International Conference on Distributed Computing and Networking},
  year={2015}
}
  • P. Kuznetsov, Srivatsan Ravi
  • Published 25 July 2014
  • Computer Science
  • Proceedings of the 2015 International Conference on Distributed Computing and Networking
Transactional memory (TM) is a convenient synchronization tool that allows concurrent threads to declare sequences of instructions on shared data as speculative transactions with "all-or-nothing" semantics. It is known that dynamic transactional memory cannot provide wait-free progress ensuring that every transaction commits in a finite number of its own steps. In this paper, we explore the costs of providing wait-freedom to only a subset of transactions. We require that read-only transactions… 

Figures from this paper

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.
Operation-Level Wait-Free Transactional Memory with Support for Irrevocable Operations
TLDR
This paper presents a TM algorithm that guarantees wait-freedom for any transactional operation, based on the weakest synchronization primitive possible (test-and-set), and guarantees opacity and strong progressiveness.
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.
Ensuring Irrevocability in Wait-free Transactional Memory
TLDR
This paper presents an algorithm that guarantees wait-freedom for each transactional operation, based on the weakest synchronization primitive possible (test-and-set), and guarantees opacity and strong progressiveness.
The PCL theorem: transactions cannot be parallel, consistent and live
TLDR
It is shown that it is impossible to design a transactional memory system which ensures parallelism, i.e. that transactions eventually commit if they run solo, and which is weaker than snapshot isolation, processor consistency, and any other consistency condition stronger than them.
Universal constructions that ensure disjoint-access parallelism and wait-freedom
TLDR
This work shows that there is no universal construction that is both disjoint-access parallel (guaranteeing the processes operating on different parts of an implemented object do not interfere with one another) and wait-free (gu Guaranteeing progress for each nonfaulty process when accessing an object).
The PCL Theorem
TLDR
It is established that it is impossible to design a transactional memory algorithm that ensures parallelism, i.e., transactions do not need to synchronize unless they access the same application objects.
Data Structures for Current Multi-core and Future Many-core Architectures. (Structures de données pour des architectures multi-cœur actuelles et de futures architectures many-cœur)
TLDR
This work proposes WFR-TM, an approach based on transactional memory (TM), which is a concurrent programming paradigm that employs transactions in order to synchronize the access to shared data, and presents Dense, a concurrent graph implementation, an innovative concurrent graph model that provides addition and removal of any edge of the graph, as well as atomic traversals of a part (or the entirety) of thegraph.
Concurrency for the Masses: The Paradigm of Software Transactional Memory
  • P. Fatourou
  • Computer Science
    2017 19th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC)
  • 2017
TLDR
The basics of Software Transactional Memory (STM) algorithms are reviewed, some of their properties are examined, and a collection of impossibility and possibility results in STM computing are discussed.
...
...

References

SHOWING 1-10 OF 25 REFERENCES
Principles of Transactional Memory
TLDR
The aim of this book is to provide theoretical foundations for transactional memory, as well as answering precisely when a TM implementation is correct, what kind of properties it can ensure, what are the power and limitations of a TM, and what inherent trade-offs are involved in designing a TM algorithm.
Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory
TLDR
A lower bound of Ω(t) is proved on the number of writes needed in order to implement a read-only transaction of t items, which successfully terminates in a disjoint-access parallel TM implementation, which assumes strict serializability and thus hold under the assumption of opacity.
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.
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 the Cost of Concurrency in Transactional Memory
TLDR
The Transactional Memory abstraction is proposed as a synchronization mechanism that relieves the programmer of the overhead of reasoning about data conflicts that may arise from concurrent operations without severely limiting the program's performance.
Transactional scheduling for read-dominated workloads
On maintaining multiple versions in STM
TLDR
This paper studies inherent properties of STMs that use multiple versions to guarantee successful commits of all read-only transactions, and presents an STM algorithm using visible reads that efficiently garbage collects useless object versions.
The PCL theorem: transactions cannot be parallel, consistent and live
TLDR
It is shown that it is impossible to design a transactional memory system which ensures parallelism, i.e. that transactions eventually commit if they run solo, and which is weaker than snapshot isolation, processor consistency, and any other consistency condition stronger than them.
Wait-free synchronization
TLDR
A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy.
Towards formally specifying and verifying transactional memory
TLDR
TMS1 (Transactional Memory Specification 1), a precise specification of correct behaviour of a TM runtime library, is presented and a simulation proof that TMS2 implements TMS1 is presented, thus showing that to prove that an implementation satisfies T MS1, it suffices to proved that it satisfies TMS 2.
...
...