How to share a data structure: A fast timing-based solution∗

We consider the problem of transforming a given sequential implementation of a data structure into a wait-free concurrent implementation. Given the code for different operations of a data structure that is designed to work under the assumption that only a single process accesses it, we want to construct an implementation that works correctly in a concurrent environment where it may be accessed by many processes. We assume a shared memory model with atomic registers. It is well known that, in asynchronous systems, using atomic read/write registers only, it is impossible to construct concurrent implementations of even very simple objects such as test-and-set bits. We show that the knowledge about relative speeds of processes can be used for such implementations. We assume that there is a known upper bound on the time taken by the slowest process to execute a statement involving an access to the shared memory. This timing assumption is very powerful and enables us to construct fast wait-free implementations of data structures such as queues, stacks and synchronization primitives such as test-and-set, compare-and-swap, fetch-and-add, etc. Our transformation works only when the given sequential implementation is bounded, that is, there is a known upper bound on the number of steps required to complete any of the operations it supports. In the absence of contention, transformation guarantees that there is only a small overhead in the cost of executing the concurrent operations over the sequential ones, namely, only a constant number of accesses to the shared memory. ∗A preliminary version of this work has appeared as [AT93]. †Bell Laboratories, and Department of Electrical Engineering and Computer Science, University of California, Berkeley, CA 94720. alur@eecs.berkeley.edu. ‡The Open University, 16 Klausner street, P.O. Box 39328, Tel-Aviv 61392, Israel, and AT&T Labs. gadi@tavor.openu.ac.il.