LL/SC and Atomic Copy: Constant Time, Space Efficient Implementations using only pointer-width CAS

TL;DR

This paper introduces a constant-time, space-efficient implementation of multiple LL/SC objects using only pointer-sized CAS, by developing a new primitive called Single-Writer Copy, improving concurrency control.

Contribution

It presents the first constant-time, space-efficient LL/SC implementation using only pointer-sized CAS and introduces the Single-Writer Copy primitive for concurrent algorithms.

Findings

Achieves constant time for M LL/SC objects with Θ(M+kP^2) space.

Supports L-word LL/SC objects in Θ(L) time and Θ((M+kP^2)L) space.

Introduces the Single-Writer Copy primitive for atomic copying with write restrictions.

Abstract

When designing concurrent algorithms, Load-Link/Store-Conditional (LL/SC) is often the ideal primitive to have because unlike Compare and Swap (CAS), LL/SC is immune to the ABA problem. However, the full semantics of LL/SC are not supported by any modern machine, so there has been a significant amount of work on simulations of LL/SC using Compare and Swap (CAS), a synchronization primitive that enjoys widespread hardware support. All of the algorithms so far that are constant time either use unbounded sequence numbers (and thus base objects of unbounded size), or require $\Omega(MP)$ space for $M$ LL/SC object (where $P$ is the number of processes). We present a constant time implementation of $M$ LL/SC objects using $\Theta(M+kP^2)$ space, where $k$ is the maximum number of overlapping LL/SC operations per process (usually a constant), and requiring only pointer-sized CAS objects. Our implementation can also be used to implement $L$-word $LL/SC$ objects in $\Theta(L)$ time (for both $LL$ and $SC$) and $\Theta((M+kP^2)L)$ space. To achieve these bounds, we begin by implementing a new primitive called Single-Writer Copy which takes a pointer to a word sized memory location and atomically copies its contents into another object. The restriction is that only one process is allowed to write/copy into the destination object at a time. We believe this primitive will be very useful in designing other concurrent algorithms as well.