Revocable locks for non-blocking programming

@article{Harris2005RevocableLF,
  title={Revocable locks for non-blocking programming},
  author={Timothy L. Harris and Keir Fraser},
  journal={Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming},
  year={2005}
}
  • T. Harris, K. Fraser
  • Published 15 June 2005
  • Computer Science
  • Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming
In this paper we present a new form of revocable lock that streamlines the construction of higher level concurrency abstractions such as atomic multi-word heap updates. The key idea is to expose revocation by displacing the previous lock holder's execution to a safe address. This provides mutual exclusion without needing to block threads. This brings many simplifications, often removing the need for dynamic memory management and letting us strip operations from common-case execution paths. As… 

Figures from this paper

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.
Preemptible atomic regions for real-time Java
TLDR
The results suggest that programs that use PARs, depending on their semantics, can run faster and experience less jitter than those that use locks.
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.
Revocation techniques for Java concurrency
TLDR
Two approaches to managing concurrency in Java using a guarded region abstraction are proposed, one of which extends the functionality of revocable monitors by implementing guarded regions as lightweight transactions that can be executed concurrently (or in parallel on multiprocessor platforms).
A runtime system for software lock elision
TLDR
This paper investigates an alternative: a software runtime system that allows threads to speculatively execute lock-based critical sections in parallel, and does not require that programs be written in type-safe languages, nor does it require any form of garbage collection.
NOrec: streamlining STM by abolishing ownership records
TLDR
An ownership-record-free software transactional memory (STM) system that combines extremely low overhead with unusually clean semantics is presented, and the experience suggests that NOrec may be an ideal candidate for such a software system.
Nonblocking transactions without indirection using alert-on-update
TLDR
A second nonblocking STM system is presented that uses multiple AOU lines (one per accessed object) to eliminate validation overhead entirely, resulting in a nonblocking, zero-indirection STM systems that outperforms competing systems by as much as a factor of 2.
Transactional Memory, 2nd edition
TLDR
This book presents an overview of the state of the art in the design and implementation of transactional memory systems, as of early spring 2010.
Coping With Context Switches in Lock-Based Software Transacional Memory Algorithms
TLDR
Lock Stealing is presented, a novel contention management algorithm for minimizing the effect of context switches by enabling threads to acquire locks which are held by other threads.
FGSCM: A Fine-Grained Approach to Transactional Lock Elision
TLDR
The Fine-Grained Software-assisted Conflict Management (FGSCM) scheme is proposed, a TLE technique that employs multiple locks so as to avoid unnecessary serialization of the code and an in-depth performance evaluation using a microbenchmark to stress several conflict behaviors is provided.
...
...

References

SHOWING 1-10 OF 31 REFERENCES
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.
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.
Transactional lock-free execution of lock-based programs
TLDR
This paper proposes Transactional Lock Removal (TLR) and shows how a program that uses lock-based synchronization can be executed by the hardware in a lock-free manner, even in the presence of conflicts, without programmer support or software changes.
The Repeat Offender Problem: A Mechanism for Supporting Dynamic-Sized, Lock-Free Data Structures
TLDR
Here the first solution to the ROP problem is presented and its correctness proof is presented, which is implementable in most modern shared memory multiprocessors.
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.
Exceptions and side-effects in atomic blocks
  • T. Harris
  • Computer Science
    Sci. Comput. Program.
  • 2005
Lock reservation: Java locks can mostly do without atomic operations
TLDR
A novel algorithm called lock reservation, which exploits thread locality of Java locks, which claims that the locking sequence of a Java lock contains a very long repetition of a specific thread.
Transactional Lock-Free Objects for Real-time Java
TLDR
Experimental results undertaken in the context of Ovm indicates that transactional lock-free objects can improve the responsiveness of high priority threads compared to priority-inheritance based approaches at the cost of a reduction throughput.
Safe memory reclamation for dynamic lock-free objects using atomic reads and writes
TLDR
This paper presents the firstLock-free memory management method for dynamic lock-free objects that allows arbitrary memory reuse, and does not require special operating system or hardware support, and guarantees an upper bound on the number of removed nodes not yet freed at any time.
Practical considerations for non-blocking concurrent objects
  • B. Bershad
  • Computer Science
    [1993] Proceedings. The 13th International Conference on Distributed Computing Systems
  • 1993
TLDR
The author examines the compare-and-swap operation in the content of contemporary bus-based shared memory multiprocessors, and it is shown that the common techniques for reducing synchronization overhead in the presence of contention are inappropriate when used as the basis for nonblocking synchronization.
...
...