Efficient and practical constructions of LL/SC variables

Abstract

Over the past decade, a pair of synchronization instructions known as LL/SC has emerged as the most suitable set of instructions to be used in the design of lock-free algorithms. However, no existing multiprocessor system supports these instructions in hardware. Instead, most modern multiprocessors support instructions such as CAS or RLL/RSC (e.g. POWER4, MIPS, SPARC, IA-64). This paper presents two efficient algorithms that implement 64-bit LL/SC from 64-bit CAS or RLL/RSC. Our re~ults are summarized as follows.We present a practical algorithm for implementing a 64-bit LL/SC object from 64-bit CAS or RLL/RSC objects. Our result shows, for the first time, a practical way of simulating a 64-bit LL/SC memory word using 64-bit CAS memory words (or 64-bit RLL/RSC memory words), incurring only a small constant space overhead per process and a small constant factor slowdown.Although our first solution performs correctly in any practical system, its theoretical correctness depends on unbounded sequence numbers. We present a bounded algorithm that implements a 64-bit LL/SC object from 64-bit CAS or RLL/RSC objects, and has the same time and space complexities as the first algorithm.This and the previous algorithm improve on existing implementations of LL/SC objects by

Revocable locks for non-blocking programming

“…As with other early designs, it used nesting LL/SC operations. These are not directly supported by hardware and possible implementations, using basic LL/SC or CAS, operate by reserving per-processor 'valid' bits or counters in each word [22] or by having several per-processor data structures for each word in the heap [18]. These space costs make the design impractical for general use.…”

Bringing practical lock-free synchronization to 64-bit applications

“…The only previous 64-bit-clean cas-based implementation of ll/sc is due to Jayanti and Petrovic [10]. While their implementation is wait-free [5], it requires O(mn) space, where m is the number of variables that support ll/sc and n is the number of threads that can access those variables; ours uses only O(m+n) space.…”

“…While their implementation is wait-free [5], it requires O(mn) space, where m is the number of variables that support ll/sc and n is the number of threads that can access those variables; ours uses only O(m+n) space. Furthermore, the implementation in [10] requires a priori knowledge of a fixed upper bound on the number of threads that will access an ll/sc variable. We call such implementations population-aware [8].…”

Efficient Wait-Free Implementation of Multiword LL/SC Variables

“…In the following we explain (i) what it means for SC to succeed or fail, and (ii) the rule for determining the SC's success or failure. [1,2,6,11,14,16,17]. Most of this research is focused on implementing small LL/SC objects, i.e., LL/SC objects whose value fits in a single machine word (which is 64-bits in the case of most machines) [2,6,11,14,16,17].…”

“…[1,2,6,11,14,16,17]. Most of this research is focused on implementing small LL/SC objects, i.e., LL/SC objects whose value fits in a single machine word (which is 64-bits in the case of most machines) [2,6,11,14,16,17]. However, many existing applications [1,4,12,13] need large LL/SC objects, i.e., LL/SC objects whose value does not fit in a single machine word.…”