Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
PODC '90 Proceedings of the ninth annual ACM symposium on Principles of distributed computing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Atomic snapshots of shared memory
Journal of the ACM (JACM)
Disjoint-access-parallel implementations of strong shared memory primitives
PODC '94 Proceedings of the thirteenth annual ACM symposium on Principles of distributed computing
Distributed snapshots: determining global states of distributed systems
ACM Transactions on Computer Systems (TOCS)
Practical implementations of non-blocking synchronization primitives
PODC '97 Proceedings of the sixteenth annual ACM symposium on Principles of distributed computing
Atomic Snapshots in O (n log n) Operations
SIAM Journal on Computing
Distributed Algorithms
Linear-Time Snapshot Using Multi-writer Multi-reader Registers
WDAG '94 Proceedings of the 8th International Workshop on Distributed Algorithms
Algorithms adapting to point contention
Journal of the ACM (JACM)
Long-Lived Adaptive Collect with Applications
FOCS '99 Proceedings of the 40th Annual Symposium on Foundations of Computer Science
Distributed Computing: Fundamentals, Simulations and Advanced Topics
Distributed Computing: Fundamentals, Simulations and Advanced Topics
A pleasant stroll through the land of infinitely many creatures
ACM SIGACT News
An adaptive collect algorithm with applications
Distributed Computing
An optimal multi-writer snapshot algorithm
Proceedings of the thirty-seventh annual ACM symposium on Theory of computing
Multi-writer composite registers
Distributed Computing
Synchronization Algorithms and Concurrent Programming
Synchronization Algorithms and Concurrent Programming
On the correctness of transactional memory
Proceedings of the 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming
Transactions are back---but are they the same?
ACM SIGACT News
Needed: foundations for transactional memory
ACM SIGACT News
Distributed computing and the multicore revolution
ACM SIGACT News
Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures
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
From unreliable objects to reliable objects: the case of atomic registers and consensus
PaCT'07 Proceedings of the 9th international conference on Parallel Computing Technologies
On adaptive renaming under eventually limited contention
SSS'10 Proceedings of the 12th international conference on Stabilization, safety, and security of distributed systems
A highly-efficient wait-free universal construction
Proceedings of the twenty-third annual ACM symposium on Parallelism in algorithms and architectures
A survey on some recent advances in shared memory models
SIROCCO'11 Proceedings of the 18th international conference on Structural information and communication complexity
Help when needed, but no more: Efficient read/write partial snapshot
Journal of Parallel and Distributed Computing
SIROCCO'09 Proceedings of the 16th international conference on Structural Information and Communication Complexity
The renaming problem in shared memory systems: An introduction
Computer Science Review
Hi-index | 0.00 |
An atomic snapshot object is an object that can be concurrently accessed by asynchronous processes prone to crash. It is made of m components (base atomic registers) and is defined by two operations: an update operation that allows a process to atomically assign a new value to a component and a snapshot operation that atomically reads and returns the values of all the components. To cope with the net effect of concurrency, asynchrony and failures, the algorithm implementing the update operation has to help concurrent snapshot operations so that they always terminate. This paper is on partial snapshot objects. Such an object provides a snapshot operation that can take any subset of the components as input parameter, and atomically reads and returns the values of this subset of components. The paper has two contributions. The first is the introduction of two properties for partial snapshot object algorithms, called help-locality and freshness. Help-locality requires that an update operation helps only the concurrent partial snapshot operations that read the component it writes. When an update of a component r helps a partial snapshot, freshness requires that the update provides the partial snapshot with a value of the component r that is at least as recent as the value it writes into that component. (No snapshot algorithm proposed so far satisfies these properties.) The second contribution consists of an update and a partial snapshot algorithms that are wait-free, linearizable and satisfy the previous efficiency properties. Interestingly, the principle that underlies the proposed algorithms is different from the one used so far, namely, it is based on the "write first, and help later" strategy. An improvement of the previous algorithms is also presented. Based on LL/SC atomic registers (instead of read/write registers) this improvement decreases the number of base registers from O(n2) to O(n). This shows an interesting tradeoff relating the synchronization power of the base operations and the number of base atomic registers when using the "write first, and help later" strategy.