Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Atomic snapshots of shared memory
PODC '90 Proceedings of the ninth annual ACM symposium on Principles of distributed computing
Atomic Snapshots in O (n log n) Operations
SIAM Journal on Computing
Simple Atomic Snapshots: A Linear Complexity Solution with Unbounded Time-Stamps
ICCI '91 Proceedings of the International Conference on Computing and Information: Advances in Computing and Information
Towards a practical snapshot algorithm
ISTCS '95 Proceedings of the 3rd Israel Symposium on the Theory of Computing Systems (ISTCS'95)
Multi-writer composite registers
Distributed Computing
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
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 |
The Java^T^M developers kit requires a size() operation for all objects, tracking the number of elements in the object. Unfortunately, the best known solution, available in the Java concurrency package, has a blocking concurrent implementation that does not scale. This paper presents a highly scalable wait-free implementation of a concurrent size() operation based on a new lock-free interrupting snapshots algorithm. The key idea behind the new algorithm is to allow snapshot scan methods to interrupt each other until they agree on a shared linearization point with respect to update methods. This contrasts sharply with past approaches to the classical atomic snapshot problem, that have had threads coordinate the collecting of a shared global view. As we show empirically, the new algorithm scales well, significantly outperforming existing implementations.