On the inherent weakness of conditional synchronization primitives

Faith Fich, Danny Hendler, Nir Shavit

Research output: Contribution to conferencePaperpeer-review

Abstract

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 synchronization solely on conditional synchronization primitives might not be the best design choice.

Original languageEnglish
Pages80-87
Number of pages8
DOIs
StatePublished - 2004
EventProceedings of the 23rd Annual ACM Symposium on Principles of Distributed Computing - St. John's, Nfld., Canada
Duration: 25 Jul 200428 Jul 2004

Conference

ConferenceProceedings of the 23rd Annual ACM Symposium on Principles of Distributed Computing
Country/TerritoryCanada
CitySt. John's, Nfld.
Period25/07/0428/07/04

Keywords

  • Compare-and-Swap
  • Load-Linked
  • Lower bounds
  • Store-Conditional
  • Synchronization primitives
  • Test-and-Set
  • Wait-freedom

Fingerprint

Dive into the research topics of 'On the inherent weakness of conditional synchronization primitives'. Together they form a unique fingerprint.

Cite this