Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Knowledge in shared memory systems (preliminary version)
PODC '91 Proceedings of the tenth annual ACM symposium on Principles of distributed computing
Bounds on shared memory for mutual exclusion
Information and Computation
The communication requirements of mutual exclusion
Proceedings of the seventh annual ACM symposium on Parallel algorithms and architectures
Time and space lower bounds for non-blocking implementations (preliminary version)
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
Contention in shared memory algorithms
Journal of the ACM (JACM)
A time complexity lower bound for randomized implementations of some shared objects
PODC '98 Proceedings of the seventeenth annual ACM symposium on Principles of distributed computing
An improved lower bound for the time complexity of mutual exclusion
Proceedings of the twentieth annual ACM symposium on Principles of distributed computing
Shared-memory mutual exclusion: major research trends since 1986
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Hundreds of impossibility results for distributed computing
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Multithreading strategies for replicated objects
Proceedings of the 9th ACM/IFIP/USENIX International Conference on Middleware
Time and space lower bounds for implementations using k-CAS
DISC'05 Proceedings of the 19th international conference on Distributed Computing
A CPU-GPU framework for optimizing the quality of large meshes
Journal of Parallel and Distributed Computing
| Hi-index | 0.00 |
The "wait-free hierarchy" classifies multiprocessor synchronization primitives according to their power to solve consensus. The classification is based on assigning a number n to each synchronization primitive, where n is the maximal number of processes for which deterministic wait-free consensus can be solved using instances of the primitive and read write registers. Conditional synchronization primitives, such as Compare-and-Swap and Load-Linked/Store-Conditional, can implement deterministic wait-free consensus for any number of processes (they have consensus number ∞), and are thus considered to be among the strongest synchronization primitives; Compare-and-Swap and Load-Linked/Store-Conditional have consequently became the synchronization primitives of choice, and have been implemented in hardware in many multiprocessor architectures.This paper shows that, though they are strong in the context of consensus, conditional synchronization primitives are not efficient in terms of memory space for implementing many key objects. Our results hold for starvation-free implementations of mutual exclusion, and for wait-free implementations of a large class of concurrent objects, that we call Visible(n). Roughly, Visible(n) is a class that includes all objects that support some operation that must perform a "visible" write before it terminates. Visible(n) includes many useful objects; some examples are: counters, stacks, queues, swap, fetch-and-add, and single-writer snapshot objects. We show that at least n conditional registers are required by any such implementation, even if registers are of unbounded size. We also obtain tradeoffs between time and space for n-process wait-free implementations of any one-time object in Visible(n) . All these results hold for both deterministic and randomized implementations.Starvation-free mutual exclusion and wait-free implementations of some objects in Visible(n) (e.g. counters, swap and fetch-and-add) can be implemented by O(1) non-conditional primitives. Thus we believe that basing multiprocessor strong synchronization solely on conditional synchronization primitives might not be the best design choice.