On the inherent weakness of conditional primitives

Authors:
Faith Ellen Fich;Danny Hendler;Nir Shavit
Affiliations:
Department of Computer Science, University of Toronto, Toronto, Ontario, Canada;Department of Computer Science, University of Toronto, Toronto, Ontario, Canada and Faculty of Industrial Engineering and Management Technion, Haifa, Israel;Computer Science, Department Tel-Aviv University, Ramat Aviv, Israel and Scalable Synchronization Research Group, Sun Microsystems Laboratories, Burlington, MA
Venue:
Distributed Computing - Special issue: PODC 04
Year:
2006

Citing 9
Cited 2

Wait-free synchronization

ACM Transactions on Programming Languages and Systems (TOPLAS)
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
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
Time and Space Lower Bounds for Nonblocking Implementations

SIAM Journal on Computing
An improved lower bound for the time complexity of mutual exclusion

Distributed Computing - Special issue: Selected papers from PODC '01
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

Combinable memory-block transactions

Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures
Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated

Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages

Quantified Score

Hi-index	0.00

Visualization

Abstract

Some well-known primitive operations, such as compare-and-swap, can be used, together with read and write, to implement any object in a wait-free manner. However, this paper shows that, for a large class of objects, including counters, queues, stacks, and single-writer snapshots, wait-free implementations using only these primitive operations and a large class of other primitive operations cannot be space efficient: the number of base objects required is at least linear in the number of processes that share the implemented object. The same lower bounds are obtained for implementations of starvation-free mutual exclusion using only primitive operations from this class. For wait-free implementations of a closely related class of one-time objects, lower bounds on the tradeoff between time and space are presented