Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Fast randomized consensus using shared memory
Journal of Algorithms
Wait-free data structures in the asynchronous PRAM model
SPAA '90 Proceedings of the second annual ACM symposium on Parallel algorithms and architectures
Atomic snapshots of shared memory
Journal of the ACM (JACM)
Time- and space-efficient randomized consensus
Journal of Algorithms
Bounds on shared memory for mutual exclusion
Information and Computation
Are wait-free algorithms fast?
Journal of the ACM (JACM)
Impossibility of distributed consensus with one faulty process
Journal of the ACM (JACM)
Contention-free complexity of shared memory algorithms
Information and Computation
Optimal time-space tradeoff for shared memory leader election
Journal of Algorithms
Atomic Snapshots in O (n log n) Operations
SIAM Journal on Computing
Crowds: anonymity for Web transactions
ACM Transactions on Information and System Security (TISSEC)
On the space complexity of randomized synchronization
Journal of the ACM (JACM)
The time complexity of updating snapshot memories
Information Processing Letters
Project “anonymity and unobservability in the Internet”
Proceedings of the tenth conference on Computers, freedom and privacy: challenging the assumptions
Distributed Algorithms
Space-optimal multi-writer snapshot objects are slow
Proceedings of the twenty-first annual symposium on Principles of distributed computing
Time and Space Lower Bounds for Nonblocking Implementations
SIAM Journal on Computing
Linear-Time Snapshot Using Multi-writer Multi-reader Registers
WDAG '94 Proceedings of the 8th International Workshop on Distributed Algorithms
Concurrent Timestamping Made Simple
ISTCS'92 Proceedings of the Israel Symposium on Theory of Computing and Systems
A tight time lower bound for space-optimal implementations of multi-writer snapshots
Proceedings of the thirty-fifth annual ACM symposium on Theory of computing
Faster approximate agreement with multi-writer registers
FOCS '95 Proceedings of the 36th Annual Symposium on Foundations of Computer Science
Operation-valency and the cost of coordination
Proceedings of the twenty-second annual symposium on Principles of distributed computing
Hundreds of impossibility results for distributed computing
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Distributed Computing: Fundamentals, Simulations and Advanced Topics
Distributed Computing: Fundamentals, Simulations and Advanced Topics
Distributed Computing
Multi-writer composite registers
Distributed Computing
What can be implemented anonymously?
DISC'05 Proceedings of the 19th international conference on Distributed Computing
Single-scanner multi-writer snapshot implementations are fast!
Proceedings of the twenty-fifth annual ACM symposium on Principles of distributed computing
Time-optimal, space-efficient single-scanner snapshots & multi-scanner snapshots using CAS
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Time lower bounds for implementations of multi-writer snapshots
Journal of the ACM (JACM)
The space complexity of unbounded timestamps
DISC'07 Proceedings of the 21st international conference on Distributed Computing
Hi-index | 0.00 |
A snapshot object is an abstraction of the fundamental problem of obtaining a consistent view of the contents of the shared memory in a distributed system while other processes may concurrently update those contents. A snapshot object stores an array of m components and can be accessed by two operations: an UPDATE that changes the value of an individual component and a powerful SCAN that returns the contents of the entire array.This paper proves time-space tradeoffs for fault-tolerant implementations of a snapshot object from registers that support only Read and Write operations. For anonymous implementations (where all processes are programmed identically), we prove that a SCAN requires Ω(n/r) time, where n is the number of processes in the system and r is the number of registers used by the implementation. For the general non-anonymous case, we prove that, for any fixed r, the time required to do a SCAN grows without bound as n increases. These tradeoffs hold even in the case where the snapshot object has just two components.This is the first time a lower bound on the tradeoff between time complexity and the number of registers has been proved for any problem in asynchronous shared-memory systems. We introduce a new tool for proving distributed lower bounds: the notion of a shrinkable execution, from which an adversary can remove portions as necessary.