A fast mutual exclusion algorithm
ACM Transactions on Computer Systems (TOCS)
Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Forward and backward simulations I.: untimed systems
Information and Computation
Practical Byzantine fault tolerance
OSDI '99 Proceedings of the third symposium on Operating systems design and implementation
I/O Automata and Beyond: Temporal Logic and Abstraction in Isabelle
Proceedings of the 11th International Conference on Theorem Proving in Higher Order Logics
Isar - A Generic Interpretative Approach to Readable Formal Proof Documents
TPHOLs '99 Proceedings of the 12th International Conference on Theorem Proving in Higher Order Logics
Proving Hybrid Protocols Correct
TPHOLs '01 Proceedings of the 14th International Conference on Theorem Proving in Higher Order Logics
Adaptive and efficient abortable mutual exclusion
Proceedings of the twenty-second annual symposium on Principles of distributed computing
A Correctness Proof for a Practical Byzantine-Fault-Tolerant Replication Algorithm
A Correctness Proof for a Practical Byzantine-Fault-Tolerant Replication Algorithm
Distributed Computing
The Chubby lock service for loosely-coupled distributed systems
OSDI '06 Proceedings of the 7th USENIX Symposium on Operating Systems Design and Implementation - Volume 7
Abortable and query-abortable objects and their efficient implementation
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Zyzzyva: speculative byzantine fault tolerance
Proceedings of twenty-first ACM SIGOPS symposium on Operating systems principles
NSDI'08 Proceedings of the 5th USENIX Symposium on Networked Systems Design and Implementation
Proceedings of the 5th European conference on Computer systems
Paxos replicated state machines as the basis of a high-performance data store
Proceedings of the 8th USENIX conference on Networked systems design and implementation
On the cost of composing shared-memory algorithms
Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures
Introducing speculation in self-stabilization: an application to mutual exclusion
Proceedings of the 2013 ACM symposium on Principles of distributed computing
Hi-index | 0.00 |
Linearizability is a key design methodology for reasoning about implementations of concurrent abstract data types in both shared memory and message passing systems. It provides the illusion that operations execute sequentially and fault-free, despite the asynchrony and faults inherent to a concurrent system, especially a distributed one. A key property of linearizability is inter-object composability: a system composed of linearizable objects is itself linearizable. However, devising linearizable objects is very difficult, requiring complex algorithms to work correctly under general circumstances, and often resulting in bad average-case behavior. Concurrent algorithm designers therefore resort to speculation: optimizing algorithms to handle common scenarios more efficiently. The outcome are even more complex protocols, for which it is no longer tractable to prove their correctness. To simplify the design of efficient yet robust linearizable protocols, we propose a new notion: speculative linearizability. This property is as general as linearizability, yet it allows intra-object composability: the correctness of independent protocol phases implies the correctness of their composition. In particular, it allows the designer to focus solely on the proof of an optimization and derive the correctness of the overall protocol from the correctness of the existing, non-optimized one. Our notion of protocol phases allows processes to independently switch from one phase to another, without requiring them to reach agreement to determine the change of a phase. To illustrate the applicability of our methodology, we show how examples of speculative algorithms for shared memory and asynchronous message passing naturally fit into our framework. We rigorously define speculative linearizability and prove our intra-object composition theorem in a trace-based as well as an automaton-based model. To obtain a further degree of confidence, we also formalize and mechanically check the theorem in the automaton-based model, using the I/O automata framework within the Isabelle interactive proof assistant. We expect our framework to enable, for the first time, scalable specifications and mechanical proofs of speculative implementations of linearizable objects.