## Linear lower bounds on real-world implementations of concurrent objects (2005)

### Cached

### Download Links

- [www.cs.bgu.ac.il]
- [research.sun.com]
- [research.sun.com]
- DBLP

### Other Repositories/Bibliography

Venue: | In Proceedings of the 46th Annual Symposium on Foundations of Computer Science (FOCS |

Citations: | 15 - 10 self |

### BibTeX

@INPROCEEDINGS{Fich05linearlower,

author = {Faith Ellen Fich and Nir Shavit and Sun Microsystems Laboratories},

title = {Linear lower bounds on real-world implementations of concurrent objects},

booktitle = {In Proceedings of the 46th Annual Symposium on Foundations of Computer Science (FOCS},

year = {2005},

pages = {165--173}

}

### Years of Citing Articles

### OpenURL

### Abstract

Abstract This paper proves \Omega (n) lower bounds on the time to perform a single instance of an operationin any implementation of a large class of data structures shared by n processes. For standarddata structures such as counters, stacks, and queues, the bound is tight. The implementations considered may apply any deterministic primitives to a base object. No bounds are assumedon either the number of base objects or their size. Time is measured as the number of steps a process performs on base objects and the number of stalls it incurs as a result of contentionwith other processes. 1

### Citations

917 | Linearizability: a correctness condition for concurrent objects
- Herlihy, Wing
- 1990
(Show Context)
Citation Context ...esses contend for the object, leaving progress to real-world probabilistic mechanisms such as backoff. Linearizability is a consistency condition for concurrent objects introduced by Herlihy and Wing =-=[15]-=- which essentially says that all operations on the object appear to happen atomically. Apart from simple read and write operations, modern multiprocessor machines support special read-modify-write (RM... |

728 | Wait-free synchronization
- Herlihy
- 1991
(Show Context)
Citation Context ...ncrement synchronization primitive, then the simplest way of implementing a concurrent counter, shared by n processes, is by using the following straight-forward non-blocking (and, in fact, wait-free =-=[12]-=-) implementation: all processes share a single object on which each performs a fetch&increment operation to get a number. Unfortunately, this implementation has a serious drawback: it is essentially s... |

169 | Atomic snapshots of shared memory
- Afek, Attiya, et al.
- 1993
(Show Context)
Citation Context ...e. At the core of our paper, we use a new variant of a covering argument [6, 10] to prove linear time lower bounds on a class of objects that includes shared counters [14] and single-writer snapshots =-=[3, 1, 5]-=-. Covering arguments bring processes to a state in which they are poised to overwrite certain shared objects, causing a loss of information, which leads to incorrect behavior. Our proof technique does... |

167 | Obstruction-Free Synchronization: Double-Ended Queues as an Example. icdcs
- Herlihy, Luchangco, et al.
- 2003
(Show Context)
Citation Context ...ended abstract, we will focus on recent work aimed at deriving 2slower bounds for implementing common data structures on real machines. Obstruction-freedom, introduced by Herlihy, Luchangco, and Moir =-=[13]-=-, is perhaps the weakest natural non-blocking progress condition. An obstruction-free implementation of a concurrent object guarantees that any process can complete an operation in a finite number of ... |

108 | Multi-writer composite registers
- Anderson
- 1994
(Show Context)
Citation Context ...e. At the core of our paper, we use a new variant of a covering argument [6, 10] to prove linear time lower bounds on a class of objects that includes shared counters [14] and single-writer snapshots =-=[3, 1, 5]-=-. Covering arguments bring processes to a state in which they are poised to overwrite certain shared objects, causing a loss of information, which leads to incorrect behavior. Our proof technique does... |

104 | Counting networks
- Aspnes, Herlihy, et al.
- 1994
(Show Context)
Citation Context ...d as a read-modify-write primitive. At the core of our paper, we use a new variant of a covering argument [6, 10] to prove linear time lower bounds on a class of objects that includes shared counters =-=[14]-=- and single-writer snapshots [3, 1, 5]. Covering arguments bring processes to a state in which they are poised to overwrite certain shared objects, causing a loss of information, which leads to incorr... |

63 | Contention in shared memory algorithms
- Dwork, Herlihy, et al.
- 1997
(Show Context)
Citation Context ...al world behavior, researchers such as Merritt and Taubenfeld [18], Cypher [7], and Anderson and Kim [2] have devised complexity measures, based on an approach suggested by Herlihy, Dwork, and Waarts =-=[8]-=-, in which time complexity counts not only the number of accesses to shared objects, but also the number of stalls, the delays as a result of waiting for other processes that access the object at the ... |

57 | Diffracting trees
- Shavit, Zemach
- 1996
(Show Context)
Citation Context ...hared counters that ensure that many processes can never access a single object at the same time. However, all such structures provide counters that are either not linearizable or require linear time =-=[14, 19, 20]-=-. For counters, the implication of the lower bounds in our paper is that, in the worst case, there is no implementation that has time complexity better than the straight-forward centralized solution. ... |

48 |
Atomic snapshots in o(n log n) operations
- Attiya, Rachman
- 1998
(Show Context)
Citation Context ...e. At the core of our paper, we use a new variant of a covering argument [6, 10] to prove linear time lower bounds on a class of objects that includes shared counters [14] and single-writer snapshots =-=[3, 1, 5]-=-. Covering arguments bring processes to a state in which they are poised to overwrite certain shared objects, causing a loss of information, which leads to incorrect behavior. Our proof technique does... |

47 | Bounds on shared memory for mutual exclusion
- Burns, Lynch
- 1993
(Show Context)
Citation Context ...ead-modify-write primitives. Note that any operation on a single shared object can be expressed as a read-modify-write primitive. At the core of our paper, we use a new variant of a covering argument =-=[6, 10]-=- to prove linear time lower bounds on a class of objects that includes shared counters [14] and single-writer snapshots [3, 1, 5]. Covering arguments bring processes to a state in which they are poise... |

42 | Elimination trees and the construction of pools and stacks
- Shavit, Touitou
- 1997
(Show Context)
Citation Context ...hared counters that ensure that many processes can never access a single object at the same time. However, all such structures provide counters that are either not linearizable or require linear time =-=[14, 19, 20]-=-. For counters, the implication of the lower bounds in our paper is that, in the worst case, there is no implementation that has time complexity better than the straight-forward centralized solution. ... |

41 | An improved lower bound for the time complexity of mutual exclusion
- Anderson, Kim
- 2001
(Show Context)
Citation Context ...f contention it incurs at an object when other processes access it concurrently. To capture this real world behavior, researchers such as Merritt and Taubenfeld [18], Cypher [7], and Anderson and Kim =-=[2]-=- have devised complexity measures, based on an approach suggested by Herlihy, Dwork, and Waarts [8], in which time complexity counts not only the number of accesses to shared objects, but also the num... |

41 |
Time and Space Lower Bounds for Nonblocking Implementations
- Jayanti, Tan, et al.
(Show Context)
Citation Context ...ication of the lower bounds in our paper is that, in the worst case, there is no implementation that has time complexity better than the straight-forward centralized solution. Jayanti, Tan, and Toueg =-=[16]-=- prove linear time and space lower bounds for implementations of a class of objects, called perturbable, from historyless primitives [9] and resettable consensus. Some key objects in our class, such a... |

40 | Hundreds of impossibility results for distributed computing
- Fich, Ruppert
(Show Context)
Citation Context ...ead-modify-write primitives. Note that any operation on a single shared object can be expressed as a read-modify-write primitive. At the core of our paper, we use a new variant of a covering argument =-=[6, 10]-=- to prove linear time lower bounds on a class of objects that includes shared counters [14] and single-writer snapshots [3, 1, 5]. Covering arguments bring processes to a state in which they are poise... |

39 | On the space complexity of randomized synchronization
- Fich, Herlihy, et al.
- 1998
(Show Context)
Citation Context ...straight-forward centralized solution. Jayanti, Tan, and Toueg [16] prove linear time and space lower bounds for implementations of a class of objects, called perturbable, from historyless primitives =-=[9]-=- and resettable consensus. Some key objects in our class, such as counters and single-writer snapshots, are also perturbable. Their result is stronger that ours in the following sense: they only count... |

38 | The communication requirements of mutual exclusion
- Cypher
- 1995
(Show Context)
Citation Context ..., but also by the amount of contention it incurs at an object when other processes access it concurrently. To capture this real world behavior, researchers such as Merritt and Taubenfeld [18], Cypher =-=[7]-=-, and Anderson and Kim [2] have devised complexity measures, based on an approach suggested by Herlihy, Dwork, and Waarts [8], in which time complexity counts not only the number of accesses to shared... |

11 |
Knowledge in shared memory systems
- Merrit, Taubenfeld
- 1991
(Show Context)
Citation Context ...s must access, but also by the amount of contention it incurs at an object when other processes access it concurrently. To capture this real world behavior, researchers such as Merritt and Taubenfeld =-=[18]-=-, Cypher [7], and Anderson and Kim [2] have devised complexity measures, based on an approach suggested by Herlihy, Dwork, and Waarts [8], in which time complexity counts not only the number of access... |

7 |
util.concurrent.ConcurrentHashMap in java.util.concurrent the Java Concurrency Package
- Lea
(Show Context)
Citation Context ...sign of concurrent data structures for multiprocessor machines is an important area of research. It is becoming crucial in practice with the advent of libraries such as the JavaTM Concurrency Package =-=[17]-=- (of JDK 1.5.0, distributed onto 10 million machines) and the introduction of multi-threaded multi-core chips onto the desktop. Because these machines involve extensive context switching, their behavi... |

6 | Operation-valency and the cost of coordination
- Hendler, Shavit
(Show Context)
Citation Context ...implementations require time linear in n, the number of processes. The best lower bounds that had been attained for implementations that use arbitrary read-modify-write primitives were in \Omega (pn) =-=[11]-=-. Thus, it was open whether the linear upper bounds were inherent. This paper provides a matching linear lower bound for non-blocking concurrent implementations of a large class of objects, including ... |

3 |
Chapter 47 – Concurrent Data Structures – Handbook of Data Structures and Applications. Chapman and Hall/CRC, first edition edition
- Moir, Shavit
- 2004
(Show Context)
Citation Context ... Concurrency Package are non-blocking, that is, they avoid the use of locks. Unfortunately, even though these concurrent data structures are widely available and have been extensively researched (see =-=[19]-=- for a detailed survey of the literature), we lack a basic understanding of the limitations in achieving high scalability in their design. Even for standard concurrent data structures, such as counter... |