Software transactional memory for dynamic-sized data structures

@inproceedings{Herlihy2003SoftwareTM,
  title={Software transactional memory for dynamic-sized data structures},
  author={Maurice Herlihy and Victor Luchangco and Mark Moir and William N. Scherer},
  booktitle={PODC '03},
  year={2003}
}
We propose a new form of software transactional memory (STM) designed to support dynamic-sized data structures, and we describe a novel non-blocking implementation. The non-blocking property we consider is obstruction-freedom. Obstruction-freedom is weaker than lock-freedom; as a result, it admits substantially simpler and more efficient implementations. A novel feature of our obstruction-free STM implementation is its use of modular contention managers to ensure progress in practice. We… 

Figures from this paper

Transactional Memory for Dynamic-Sized Data Structures

TLDR
This review first introduces STM in general and then describes first influential approach to dynamic STM (DSTM) as given in [1], distinguishing features of this system are obstruction free progress and pluggable contention management.

A New Contention Management Technique for Obstruction Free Transactional Memory

TLDR
The major challenges faced by two state of the art OFTMs viz.

The Scalability of Disjoint Data Structures on a New Hardware Transactional Memory System

  • Gong SuS. Heisig
  • Computer Science
    International Journal of Parallel Programming
  • 2014
TLDR
This paper presents an order preserving hashed structure that permits insertion, deletion, and traversal operations typically supported by a sorted linked list, and presents a concurrent open addressing hash table structure.

Advanced contention management for dynamic software transactional memory

TLDR
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.

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.

Experiences with Disjoint Data Structures in a New Hardware Transactional Memory System

  • Gong SuS. Heisig
  • Computer Science
    2013 25th International Symposium on Computer Architecture and High Performance Computing
  • 2013
TLDR
This paper presents an order preserving hashed structure that permits insertion, deletion, and traversal operations typically supported by a sorted linked list and measures the performance and scalability for these operations on the IBM enterprise EC12 server.

Lowering the Overhead of Nonblocking Software Transactional Memory

TLDR
This work considers the design of low-overhead, obstruction-free software transactional memory for non-garbage-collected languages and eliminates dynamic allocation of transactional metadata and co-locates data that are separate in other systems, thereby reducing the expected number of cache misses on the common-case code path.

A Lightweight Implementation of Obstruction-Free Software Transactional Memory

TLDR
A simple, lightweight, and yet efficient implementation of OFTM that uses simple data structure and does not require any contention manager toward ensuring progress condition, atomicity, and serializability of transactions besides maintaining data consistency is proposed.

Snapshots and software transactional memory

Time-Based Software Transactional Memory

TLDR
The first time-based STM algorithm, the Lazy Snapshot Algorithm (LSA), is formally introduced and its semantics and the impact of its design parameters, notably multiversioning and dynamic snapshot extension are studied.
...

References

SHOWING 1-10 OF 15 REFERENCES

Transactional memory: architectural support for lock-free data structures

TLDR
Simulation results show that transactional memory matches or outperforms the best known locking techniques for simple benchmarks, even in the absence of priority inversion, convoying, and deadlock.

Software transactional memory

TLDR
STM is used to provide a general highly concurrent method for translating sequential object implementations to non-blocking ones based on implementing a k-word compare&swap STM-transaction, and outperforms Herlihy’s translation method for sufficiently large numbers of processors.

Transparent Support for Wait-Free Transactions

TLDR
This paper's implementations automatically detect and resolve conflicts between concurrent transactions, and allow transactions that do not conflict to execute in parallel, and shows that an expensive wait-free MWCAS is not necessary to ensure wait-freedom.

Nonblocking k-compare-single-swap

TLDR
The results lend themselves to efficient and flexible nonblocking manipulation of list-based data structures in today’s architectures and are efficient in the common uncontended case.

A method for implementing lock-free shared-data structures

TLDR
This work presents a technique that provides the semantics of exclusive access to data without using mutual exclusion, and devise the caching method, a general method of implementing lock-free data structures that is provably better than Herlihy's methodology for many weIl-known data structures.

Obstruction-free synchronization: double-ended queues as an example

We introduce obstruction-freedom, a new nonblocking property for shared data structure implementations. This property is strong enough to avoid the problems associated with locks, but it is weaker

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.

Wait-free made fast

TLDR
Inspired by Lamport’s fast mutual exclusion algorithm, universal methods that combine the advantages of both non-blocking and waitfree approaches are devised, i.e., fast when contention is low and guaranteed progress of any individual operation are presented.

Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors

TLDR
The results indicate that the nonblocking queue consistently outperforms the best known alternatives and that data-structure-specific nonblocking algorithms, which exist for queues, stacks, and counters, can work extremely well.

Concurrency of operations on B-trees

TLDR
It is concluded that B-trees can be used advantageously in a multi-user environment because the solution presented here uses simple locking protocols which can be tuned to specific requirements.