Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
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)
Atomic Snapshots in O (n log n) Operations
SIAM Journal on Computing
A new solution of Dijkstra's concurrent programming problem
Communications of the ACM
f-arrays: implementation and applications
Proceedings of the twenty-first annual symposium on Principles of distributed computing
Adaptive and Efficient Algorithms for Lattice Agreement and Renaming
SIAM Journal on Computing
Time and Space Lower Bounds for Nonblocking Implementations
SIAM Journal on Computing
Reading Many Variables in One Atomic Operation: Solutions with Linear or Sublinear Complexity
IEEE Transactions on Parallel and Distributed Systems
Towards a Necessary and Sufficient Condition for Wait-free Synchronization (Extended Abstract)
WDAG '93 Proceedings of the 7th International Workshop on Distributed Algorithms
Linear-Time Snapshot Using Multi-writer Multi-reader Registers
WDAG '94 Proceedings of the 8th International Workshop on Distributed Algorithms
An optimal multi-writer snapshot algorithm
Proceedings of the thirty-seventh annual ACM symposium on Theory of computing
Distributed Computing
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)
How hard is it to take a snapshot?
SOFSEM'05 Proceedings of the 31st international conference on Theory and Practice of Computer Science
Lower bounds for restricted-use objects: extended abstract
Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures
| Hi-index | 0.00 |
This paper presents a novel implementation of a snapshot object for n processes, with O(log2blogn) step complexity for update operations and O(logb) step complexity for scan operations, where b is the number of updates. The algorithm uses only reads and writes. For polynomially many updates, this is an exponential improvement on previous snapshot algorithms, which have linear step complexity. It overcomes the existing Ω(n) lower bound on step complexity by having the step complexity depend on the number of updates. The key to this implementation is the construction of a new object consisting of a pair of max registers that supports a scan operation. Applications of this construction include an implementation of a limited-use generalized counter with polylogarithmic step complexity. This can be used, for example, to monitor the number of active processes, which is crucial to adaptive algorithms.