Transactional memory: architectural support for lock-free data structures

@inproceedings{Herlihy1993TransactionalMA,
  title={Transactional memory: architectural support for lock-free data structures},
  author={M. Herlihy and J. Moss},
  booktitle={ISCA '93},
  year={1993}
}
A shared data structure is lock-free if its operations do not require mutual exclusion. If one process is interrupted in the middle of an operation, other processes will not be prevented from operating on that object. In highly concurrent systems, lock-free data structures avoid common problems associated with conventional locking techniques, including priority inversion, convoying, and difficulty of avoiding deadlock. This paper introduces transactional memory, a new multiprocessor… Expand
Architectural Transactional Memory: 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. Expand
LOFT: lock-free transactional data structures
TLDR
This work presents a design of a transactional framework supporting linearizable transactions of multiple operations on multiple data structures in a lock-free manner, and presents an evaluation of the system showing that it outperform general software transactional memory, and are competitive with lock-based transactional data structures. Expand
Practical lock-freedom
TLDR
This dissertation introduces and evaluates practical abstractions and data structures that facilitate the development of large-scale lock-free systems and presents an implementation of two useful abstractions that make it easier to develop arbitrary lock- free data structures. Expand
Practical Dynamic Transactional Data Structures
TLDR
This work presents the first wait-free hash map which allows a large number of threads to concurrently insert, get, and remove information and implements a non- blocking transactional hash map using an existing algorithm that transforms non-blocking sets into static transactional versions (LFTT), and modified to support maps. Expand
Concurrent programming without locks
TLDR
This article presents three APIs which make it easier to develop nonblocking implementations of arbitrary data structures, and compares the performance of the resulting implementations against one another and against high-performance lock-based systems. Expand
Hybrid transactional memory
TLDR
This work proposes a novel hybrid hardware-software transactional memory scheme that approaches the performance of a hardware scheme when resources are not exhausted and gracefully falls back to a software scheme otherwise. Expand
Design and Analysis of Lock-free Data Structures
TLDR
This work focuses on implementing a lock-free data structure suitable for a real-world application and certain insights related to reduced complexity of the implementation and atomicity of lock- free implementation that make it robust are discussed. Expand
Lock-free and scalable multi-version software transactional memory
TLDR
A new lock-free commit algorithm is presented that allows write transactions to proceed in parallel, by allowing them to run their validation phase independently of each other, and by resorting to helping from threads that would otherwise be waiting to commit, during the write-back phase. Expand
Lock-free Transactions without Rollbacks for Linked Data Structures
TLDR
This work's approach leverages the semantic knowledge of the data structure to eliminate the overhead of false conflicts and rollbacks in high-performance lock-free transactional linked data structures without revamping the data structures' original synchronization design. Expand
A Scalable, Non-blocking Approach to Transactional Memory
  • H. Chafi, J. Casper, +5 authors K. Olukotun
  • Computer Science
  • 2007 IEEE 13th International Symposium on High Performance Computer Architecture
  • 2007
TLDR
This paper presents the first scalable TM implementation for directory-based distributed shared memory systems that is livelock free without the need for user-level intervention and is based on transactional coherence and consistency (TCC), which supports continuous transactions and fault isolation. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 58 REFERENCES
Transactional Memory: Architectural Support For Lock-free Data Structures
  • M. Herlihy, J. Moss
  • Computer Science
  • Proceedings of the 20th Annual International Symposium on Computer Architecture
  • 1993
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. Expand
A methodology for implementing highly concurrent data structures
TLDR
This paper proposes a new methodology for constructing non-blocking and wait-free implementations of concurrent objects, whose representation and operations are written as stylized sequential programs, with no explicit synchronization. Expand
Algorithms for scalable synchronization on shared-memory multiprocessors
TLDR
The principal conclusion is that contention due to synchronization need not be a problemin large-scale shared-memory multiprocessors, and the existence of scalable algorithms greatly weakens the case for costly special-purpose hardware support for synchronization, and provides protection against so-called “dance hall” architectures. Expand
A Lock-Free Multiprocessor OS Kernel
TLDR
This work has implemented a complete multiprocessor OS kernel, including threads, virtual memory, and I/O (including a window system and a file system), using only lockfree synchronization methods based on Compare-and-Swap. Expand
Performance issues in non-blocking synchronization on shared-memory multiprocessors
TLDR
This paper presents two protocols that address factors hindering the performance of Herlihy's standard non-blocking protocol, and introduces a second, optimistic protocol that avoids copying, except in the case when a thread of control is delayed during its attempted update. Expand
The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors
  • T. Anderson
  • Computer Science
  • IEEE Trans. Parallel Distributed Syst.
  • 1990
The author examines the questions of whether there are efficient algorithms for software spin-waiting given hardware support for atomic instructions, or whether more complex kinds of hardware supportExpand
Efficient synchronization primitives for large-scale cache-coherent multiprocessors
TLDR
A set of efficient primitives for process synchronization in multiprocessors that make use of synchronization bits to provide a simple mechanism for mutual exclusion and to implement Fetch and Add with combining in software rather than hardware is proposed. Expand
Detecting violations of sequential consistency
TLDR
A new implementation of release consistency is presented, which conclusively determines either that the execution is sequentially consistent or that the program has data races. Expand
Performance evaluation of memory consistency models for shared-memory multiprocessors
TLDR
The results show that in an environment where processor reads are blocking and writes are buffered, a significant performance increase is achieved from allowing reads to bypass previous writes, and the sequential consistency model performs poorly relative to all other models. Expand
Synchronization algorithms for shared-memory multiprocessors
A performance evaluation of the Symmetry multiprocessor system revealed that the synchronization mechanism did not perform well for highly contested locks, like those found in certain parallelExpand
...
1
2
3
4
5
...