Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Renaming in an asynchronous environment
Journal of the ACM (JACM)
Sharing memory robustly in message-passing systems
Journal of the ACM (JACM)
Impossibility of distributed consensus with one faulty process
Journal of the ACM (JACM)
ACM Transactions on Computer Systems (TOCS)
Adaptive and Efficient Algorithms for Lattice Agreement and Renaming
SIAM Journal on Computing
Linear-Time Snapshot Using Multi-writer Multi-reader Registers
WDAG '94 Proceedings of the 8th International Workshop on Distributed Algorithms
Atomic snapshots using lattice agreement
Distributed Computing
CScale: a programming model for scalable and reliable distributed applications
Proceedings of the 17th Monterey conference on Large-Scale Complex IT Systems: development, operation and management
Hi-index | 0.00 |
Lattice agreement is a key decision problem in distributed systems. In this problem, processes start with input values from a lattice, and must learn (non-trivial) values that form a chain. Unlike consensus, which is impossible in the presence of even a single process failure, lattice agreement has been shown to be decidable in the presence of failures. In this paper, we consider lattice agreement problems in asynchronous, message passing systems. We present an algorithm for the lattice agreement problem that guarantees liveness as long as a majority of the processes are non-faulty. The algorithm has a time complexity of O(N) message delays, where N is the number of processes. We then introduce the generalized lattice agreement problem, where each process receives a (potentially unbounded) sequence of values from an infinite lattice and must learn a sequence of increasing values such that the union of all learnt sequences is a chain and every proposed value is eventually learnt. We present a wait-free algorithm for solving generalized lattice agreement. The algorithm guarantees that every value received by a correct process is learnt in O(N) message delays. We show that this algorithm can be used to implement a class of replicated state machines where (a) commands can be classified as reads and updates, and (b) all update commands commute. This algorithm can be used to realize serializable and linearizable replicated versions of commonly used data types.