Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Unreliable failure detectors for reliable distributed systems
Journal of the ACM (JACM)
Fault-tolerant wait-free shared objects
Journal of the ACM (JACM)
Concurrent reading and writing
Communications of the ACM
Distributed computing: fundamentals, simulations and advanced topics
Distributed computing: fundamentals, simulations and advanced topics
Monitors: an operating system structuring concept
Communications of the ACM
Atomic shared register access by asynchronous hardware
SFCS '86 Proceedings of the 27th Annual Symposium on Foundations of Computer Science
Help when needed, but no more: efficient read/write partial snapshot
DISC'09 Proceedings of the 23rd international conference on Distributed computing
Resilience of mutual exclusion algorithms to transient memory faults
Proceedings of the 30th annual ACM SIGACT-SIGOPS symposium on Principles of distributed computing
A survey on some recent advances in shared memory models
SIROCCO'11 Proceedings of the 18th international conference on Structural information and communication complexity
Looking for efficient implementations of concurrent objects
PaCT'11 Proceedings of the 11th international conference on Parallel computing technologies
Help when needed, but no more: Efficient read/write partial snapshot
Journal of Parallel and Distributed Computing
On the implementation of concurrent objects
Dependable and Historic Computing
Computability in distributed computing: a Tutorial
ACM SIGACT News
Hi-index | 0.00 |
A concurrent object is an object that can be concurrently accessed by several processes. It has been shown by Maurice Herlihy that any concurrent object O defined by a sequential specification can be waitfree implemented from reliable atomic registers (shared variables) and consensus objects. Wait-free means that any invocation of an operation of the object O issued by a non-faulty process does terminate, whatever the behavior of the other processes (e.g., despite the fact they are very slow or even have crashed). So, an important issue consists in providing reliable atomic registers and reliable consensus objects despite the failures experienced by the base objects from which these atomic registers and consensus objects are built. This paper considers self-implementations, i.e., the case where a reliable atomic register (resp., consensus object) is built from unreliable atomic registers (resp., unreliable consensus objects). The paper addresses the object failure model where the base objects can suffer responsive or nonresponsive crash failures. When there are solutions the paper presents corresponding algorithms, and when there is no solution, it presents the corresponding impossibility result. The paper has a tutorial flavor whose aim is to make the reader familiar with important results when one has to build resilient concurrent objects. To that aim, the paper use both algorithms from the literature and new algorithms.