Laws of order: Expensive synchronization in concurrent algorithms cannot be eliminated

Hagit Attiya, Rachid Guerraoui, Danny Hendler, Petr Kuznetsov, Maged M. Michael, Martin Vechev

Research output: Contribution to journalArticlepeer-review

69 Scopus citations


Building correct and efficient concurrent algorithms is known to be a difficult problem of fundamental importance. To achieve efficiency, designers try to remove unnecessary and costly synchronization. However, not only is this manual trial-and-error process ad-hoc, time consuming and error-prone, but it often leaves designers pondering the question of: is it inherently impossible to eliminate certain synchronization, or is it that I was unable to eliminate it on this attempt and I should keep trying? In this paper we respond to this question.We prove that it is impossible to build concurrent implementations of classic and ubiquitous specifications such as sets, queues, stacks, mutual exclusion and read-modify-write operations, that completely eliminate the use of expensive synchronization. We prove that one cannot avoid the use of either: i) read-afterwrite (RAW), where a write to shared variable A is followed by a read to a different shared variable B without a write to B in between, or ii) atomic write-after-read (AWAR), where an atomic operation reads and then writes to shared locations. Unfortunately, enforcing RAW or AWAR is expensive on all current mainstream processors. To enforce RAW, memory ordering-also called fence or barrier-instructions must be used. To enforce AWAR, atomic instructions such as compare-and-swap are required. However, these instructions are typically substantially slower than regular instructions. Although algorithm designers frequently struggle to avoid RAW and AWAR, their attempts are often futile. Our result characterizes the cases where avoiding RAW and AWAR is impossible. On the flip side, our result can be used to guide designers towards new algorithms where RAW and AWAR can be eliminated.

Original languageEnglish
Pages (from-to)487-498
Number of pages12
JournalACM SIGPLAN Notices
Issue number1
StatePublished - 1 Jan 2011


  • Algorithms
  • Concurrency
  • Lower Bounds
  • Memory Barriers
  • Memory Fences

ASJC Scopus subject areas

  • General Computer Science


Dive into the research topics of 'Laws of order: Expensive synchronization in concurrent algorithms cannot be eliminated'. Together they form a unique fingerprint.

Cite this