Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
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
On the space complexity of randomized synchronization
Journal of the ACM (JACM)
Time and Space Lower Bounds for Nonblocking Implementations
SIAM Journal on Computing
Obstruction-Free Synchronization: Double-Ended Queues as an Example
ICDCS '03 Proceedings of the 23rd International Conference on Distributed Computing Systems
Linear Lower Bounds on Real-World Implementations of Concurrent Objects
FOCS '05 Proceedings of the 46th Annual IEEE Symposium on Foundations of Computer Science
Probabilistic computations: Toward a unified measure of complexity
SFCS '77 Proceedings of the 18th Annual Symposium on Foundations of Computer Science
The complexity of obstruction-free implementations
Journal of the ACM (JACM)
Approximate shared-memory counting despite a strong adversary
ACM Transactions on Algorithms (TALG)
Optimal-time adaptive strong renaming, with applications to counting
Proceedings of the 30th annual ACM SIGACT-SIGOPS symposium on Principles of distributed computing
FOCS '11 Proceedings of the 2011 IEEE 52nd Annual Symposium on Foundations of Computer Science
Mutual Exclusion with O(log^2 Log n) Amortized Work
FOCS '11 Proceedings of the 2011 IEEE 52nd Annual Symposium on Foundations of Computer Science
Polylogarithmic concurrent data structures from monotone circuits
Journal of the ACM (JACM)
Time and Space Lower Bounds for Implementations Using k-CAS
IEEE Transactions on Parallel and Distributed Systems
Faster than optimal snapshots (for a while): preliminary version
PODC '12 Proceedings of the 2012 ACM symposium on Principles of distributed computing
Hi-index | 0.00 |
Concurrent objects play a key role in the design of applications for multi-core architectures, making it imperative to precisely understand their complexity requirements. For some objects, it is known that implementations can be significantly more efficient when their usage is restricted. However, apart from the specific restriction of one-shot implementations, where each process may apply only a single operation to the object, very little is known about the complexities of objects under general restrictions. This paper draws a more complete picture by defining a large class of objects for which an operation applied to the object can be "perturbed" L consecutive times, and proving lower bounds on the time and space complexity of deterministic implementations of such objects. This class includes bounded-value max registers, limited-use approximate and exact counters, and limited-use collect and compare-and-swap objects; L depends on the number of times the object can be accessed or the maximum value it supports. For implementations that use only historyless primitives, we prove lower bounds of Omega(min(log L, n)) on the worst-case step complexity of an operation, where n is the number of processes; we also prove lower bounds of Omega( min( L, n )) on the space complexity of these objects. When arbitrary primitives can be used, we prove that either some operation incurs Omega( min( log L, n)) memory stalls or some operation performs Omega( min( log L, n)) steps. In addition to these deterministic lower bounds, the paper establishes a lower bound on the expected step complexity of restricted-use randomized approximate counting in a weak oblivious adversary model.