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
ACM Transactions on Programming Languages and Systems (TOPLAS)
Randomized wait-free concurrent objects (extended abstract)
PODC '91 Proceedings of the tenth annual ACM symposium on Principles of distributed computing
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)
Time/contention trade-offs for multiprocessor synchronization
Information and Computation
Journal of Computer and System Sciences
Atomic Snapshots in O (n log n) Operations
SIAM Journal on Computing
On the space complexity of randomized synchronization
Journal of the ACM (JACM)
The time complexity of updating snapshot memories
Information Processing Letters
Bounds on the shared memory requirements for long-lived & adaptive objects (extended abstract)
Proceedings of the nineteenth annual ACM symposium on Principles of distributed computing
Distributed computing: fundamentals, simulations and advanced topics
Distributed computing: fundamentals, simulations and advanced topics
An improved lower bound for the time complexity of mutual exclusion
Proceedings of the twentieth annual ACM symposium on Principles of distributed computing
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
Computing in Totally Anonymous Asynchronous Shared Memory Systems
DISC '98 Proceedings of the 12th International Symposium on Distributed Computing
Concurrent Timestamping Made Simple
ISTCS'92 Proceedings of the Israel Symposium on Theory of Computing and Systems
Hundreds of impossibility results for distributed computing
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Distributed Computing
Multi-writer composite registers
Distributed Computing
Hundreds of impossibility results for distributed computing
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Lower bounds for adaptive collect and related objects
Proceedings of the twenty-third annual ACM symposium on Principles of distributed computing
Efficient synchronous snapshots
Proceedings of the twenty-third annual ACM symposium on Principles of distributed computing
Time-space tradeoffs for implementations of snapshots
Proceedings of the thirty-eighth annual ACM symposium on Theory of 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
The complexity of updating multi-writer snapshot objects
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
The complexity of updating multi-writer snapshot objects
ICDCN'06 Proceedings of the 8th international conference on Distributed Computing and Networking
How hard is it to take a snapshot?
SOFSEM'05 Proceedings of the 31st international conference on Theory and Practice of Computer Science
Hi-index | 0.00 |
A snapshot object consists of a collection of m 1 components, each capable of storing a value, shared by n processes in an asynchronous shared-memory distributed system. It supports two operations: a process can UPDATE any individual component or atomically SCAN the entire collection to obtain the values of all the components. It is possible to implement a snapshot object using m registers so that each operation takes O(mn) time.In a previous paper, we proved that m registers are necessary to implement a snapshot object with m components. Here we prove that, for any such space-optimal implementation, Ω(mn) steps are required to perform a SCAN operation in the worst case, matching the upper bound. We also extend our space and time lower bounds to implementations that use single-writer registers in addition to the multi-writer registers. Specifically, we prove that at least m multi-writer registers are still needed, provided the SCANS do not read a large fraction of the single-writer registers. We also prove that any implementation that uses single-writer registers in addition to $m$ multi-writer registers uses Ω(√mn) steps in the worst case. Our proof yields insight into the structure of any implementation that uses only m multi-writer registers, showing that processes must access the multi-writer registers in a very constrained way.