Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
The best of both worlds: guaranteeing termination in fast randomized Byzantine agreement protocols
Information Processing Letters
ACM Transactions on Programming Languages and Systems (TOPLAS)
A lower bound on the local time complexity of universal constructions
PODC '98 Proceedings of the seventeenth annual ACM symposium on Principles of distributed computing
The inherent price of indulgence
Proceedings of the twenty-first annual symposium on Principles of distributed computing
ACM SIGACT News
Wait-free Test-and-Set (Extended Abstract)
WDAG '92 Proceedings of the 6th International Workshop on Distributed Algorithms
Adaptive and efficient abortable mutual exclusion
Proceedings of the twenty-second annual symposium on Principles of distributed computing
Long lived adaptive splitter and applications
Distributed Computing
Abortable and query-abortable objects and their efficient implementation
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
The complexity of obstruction-free implementations
Journal of the ACM (JACM)
Proceedings of the 5th European conference on Computer systems
Proceedings of the 19th international conference on Parallel architectures and compilation techniques
Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Generating fast indulgent algorithms
ICDCN'11 Proceedings of the 12th international conference on Distributed computing and networking
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Hi-index | 0.00 |
Decades of research in distributed computing have led to a variety of perspectives on what it means for a concurrent algorithm to be efficient, depending on model assumptions, progress guarantees, and complexity metrics. It is therefore natural to ask whether one could compose algorithms that perform efficiently under different conditions, so that the composition preserves the performance of the original components when their conditions are met. In this paper, we evaluate the cost of composing shared-memory algorithms. First, we formally define the notion of safely composable algorithms and we show that every sequential type has a safely composable implementation, as long as enough state is transferred between modules. Since such generic implementations are inherently expensive, we present a more general light-weight specification that allows the designer to transfer very little state between modules, by taking advantage of the semantics of the implemented object. Using this framework, we implement a composed long-lived test-and-set object, with the property that each of its modules is asymptotically optimal with respect to the progress condition it ensures, while the entire implementation only uses objects with consensus number at most two. Thus, we show that the overhead of composition can be negligible in the case of some important shared-memory abstractions.