Mark Moir

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 than previous nonblocking properties-specifically lock-freedom and wait-freedom-allowing greater flexibility in the design of efficient implementations. Obstruction-freedom admits substantially simpler implementations, and we believe that in practice it provides the benefits of wait-free and lock-free implementations. To illustrate the benefits of obstruction-freedom, we present two obstruction-free CAS-based implementations of double-ended queues (deques); the first is implemented on a linear array, the second on a circular array. To our knowledge, all previous nonblocking deque implementations are based on unrealistic assumptions about hardware support for synchronization, have restricted functionality, or have operations that interfere with operations at the opposite end of the deque even when the deque has many elements in it. Our obstruction-free implementations have none of these drawbacks, and thus suggest that it is much easier to design obstruction-free implementations than lock-free and wait-free ones. We also briefly discuss other obstruction-free data structures and operations that we have implemented.

Early experience with a commercial hardware transactional memory implementation

We report on our experience with the hardware transactional memory (HTM) feature of two pre-production revisions of a new commercial multicore processor. Our experience includes a number of promising results using HTM to improve performance in a variety of contexts, and also identifies some ways in which the feature could be improved to make it even better. We give detailed accounts of our experiences, sharing techniques we used to achieve the results we have, as well as describing challenges we faced in doing so.

Practical implementations of non-blocking synchronization primitives

This paper is concerned with system support for nonblocking synchronization in shared-memory multipr~ cesaors. Many non-blocking algorithms published recently depend on the Load-Linked (L L), Validate (VL), and Store-Con&ltional (SC) instructions. However, most systems support either Compare-and-Swap (CAS) or a weak form of LL and SC that imposes several restrictions on the use of these instructions and does not provide the exact semantics expected and assumed by algorithm designers. These limitations currently render several recent non-blocking algorithms inapplicable in most systems. The results presented here eliminate this problem by providing practical means for implementing any algorithm that is based on these instructions on any multiprocessor that provides either CAS or a form of LL and SC that is sufficiently weak that it is provided by all current hardware implementations of these instructions. This is achieved in two steps. First, we propose a slight modification to the interface for LL, VL, and SC, which will not greatly impact programmers. We then exploit this modification to provide time-optimal, space-efficient implementations of the desired primitives using commonly available ones.

Lock-free reference counting

Assuming the existence of garbage collection makes it easier to design implementations of concurrent data structures. However, this assumption limits their applicability. We present a methodology that, for a significant class of data structures, allows designers to first tackle the easier problem of designing a garbage-collection-dependent implementation, and then apply our methodology to achieve a garbage-collection-independent one. Our methodology is based on the well-known reference counting technique, and employs the double compare-and-swap operation.

Wait-free algorithms for fast, long-lived renaming

Abstract In the classic “one-time” renaming problem, processes are required to choose new names in order to reduce the size of their name space. We introduce a new, more general version of the renaming problem called “long-lived” renaming, in which processes may repeatedly acquire and release names. We also present several wait-free algorithms for both one-time and long-lived renaming on shared-memory multiprocessing systems. Previous wait-free renaming algorithms have time complexity that is dependent on the size of the original name space. In contrast, most of our algorithms have time complexity that is independent of the size of the original name space.

A lazy concurrent list-based set algorithm

List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the JavaTM Concurrency Package of JDK 1.6.0. However, Michaels lock-free algorithm has several drawbacks, most notably that it requires all list traversal operations, including membership tests, to perform cleanup operations of logically removed nodes, and that it uses the equivalent of an atomically markable reference, a pointer that can be atomically “marked,” which is expensive in some languages and unavailable in others. We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes, eliminating the need to use the equivalent of an atomically markable reference. It also has a novel wait-free membership test operation (as opposed to Michaels lock-free one) that does not need to perform cleanup operations and is more efficient than that of all previous algorithms. Empirical testing shows that the new lazy-list algorithm consistently outperforms all known algorithms, including Michaels lock-free algorithm, throughout the concurrency range. At high load, with 90% membership tests, the lazy algorithm is more than twice as fast as Michaels. This is encouraging given that typical search structure usage patterns include around 90% membership tests. By replacing the lock-free membership test of Michaels algorithm with our new wait-free one, we achieve an algorithm that slightly outperforms our new lazy-list (though it may not be as efficient in other contexts as it uses Javas RTTI mechanism to create pointers that can be atomically marked).

The repeat offender problem: a mechanism for supporting dynamic-sized lock-free data structures

We define the Repeat Offender Problem (ROP). Elsewhere, we have presented the first dynamic-sized, lock-free data structures that can free memory to any standard memory allocator--even after thread failures--without requiring special support from the operating system, the memory allocator, or the hardware. These results depend on a solution to the ROP problem. Here we present the first solution to the ROP problem and its correctness proof. Our solution is implementable in most modern shared memory multiprocessors.

A Lazy Concurrent List-Based Set Algorithm

We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes and includes a simple wait-free membership test. Our algorithm improves on the performance of all previous such algorithms.

Transparent Support for Wait-Free Transactions

This paper concerns software support for non-blocking transactions in shared-memory multiprocessors. We present mechanisms that convert sequential transactions into lock-free or wait-free ones. In contrast to some previous mechanisms, ours support transactions for which the set of memory locations accessed cannot be determined in advance. Our implementations automatically detect and resolve conflicts between concurrent transactions, and allow transactions that do not conflict to execute in parallel. The key to the efficiency of our wait-free implementation lies in using a lock-free (but not wait-free) multi-word compare-and-swap (MWCAS) operation. By introducing communication between a high-level helping mechanism and the lock-free MWCAS, we show that an expensive wait-free MWCAS is not necessary to ensure wait-freedom.

Formal Verification of a Practical Lock-Free Queue Algorithm

We describe a semi-automated verification of a slightly optimised version of Michael and Scott’s lock-free FIFO queue implementation. We verify the algorithm with a simulation proof consisting of two stages: a forward simulation from an automaton modelling the algorithm to an intermediate automaton, and a backward simulation from the intermediate automaton to an automaton that models the behaviour of a FIFO queue. These automata are encoded in the input language of the PVS proof system, and the properties needed to show that the algorithm implements the specification are proved using PVS’s theorem prover.