Eventually linearizable shared objects

Marco Serafini, Dan Dobre, Matthias Majuntke, Péter Bokor, Neeraj Suri

Research output: Chapter in Book/Report/Conference proceedingConference contribution

8 Citations (Scopus)

Abstract

Linearizability is the strongest known consistency property of shared objects. In asynchronous message passing systems, Linearizability can be achieved with ◇S and a majority of correct processes. In this paper we introduce the notion of Eventual Linearizability, the strongest known consistency property that can be attained with ◇S and any number of crashes. We show that linearizable shared object implementations can be augmented to support weak operations, which need to be linearized only eventually. Unlike strong operations that require to be always linearized, weak operations terminate in worst case runs. However, there is a tradeoff between ensuring termination of weak and strong operations when processes have only access to ◇S. If weak operations terminate in the worst case, then we show that strong operations terminate only in the absence of concurrent weak operations. Finally, we show that an implementation based on ◇P exists that guarantees termination of all operations.

Original languageEnglish
Title of host publicationProceedings of the Annual ACM Symposium on Principles of Distributed Computing
Pages95-104
Number of pages10
DOIs
Publication statusPublished - 8 Sep 2010
Externally publishedYes
Event29th ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, PODC 2010 - Zurich, Switzerland
Duration: 25 Jul 201028 Jul 2010

Other

Other29th ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, PODC 2010
CountrySwitzerland
CityZurich
Period25/7/1028/7/10

Fingerprint

Message passing

Keywords

  • Availability
  • Eventual linearizability
  • Graceful degradation

ASJC Scopus subject areas

  • Software
  • Hardware and Architecture
  • Computer Networks and Communications

Cite this

Serafini, M., Dobre, D., Majuntke, M., Bokor, P., & Suri, N. (2010). Eventually linearizable shared objects. In Proceedings of the Annual ACM Symposium on Principles of Distributed Computing (pp. 95-104) https://doi.org/10.1145/1835698.1835723

Eventually linearizable shared objects. / Serafini, Marco; Dobre, Dan; Majuntke, Matthias; Bokor, Péter; Suri, Neeraj.

Proceedings of the Annual ACM Symposium on Principles of Distributed Computing. 2010. p. 95-104.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Serafini, M, Dobre, D, Majuntke, M, Bokor, P & Suri, N 2010, Eventually linearizable shared objects. in Proceedings of the Annual ACM Symposium on Principles of Distributed Computing. pp. 95-104, 29th ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing, PODC 2010, Zurich, Switzerland, 25/7/10. https://doi.org/10.1145/1835698.1835723
Serafini M, Dobre D, Majuntke M, Bokor P, Suri N. Eventually linearizable shared objects. In Proceedings of the Annual ACM Symposium on Principles of Distributed Computing. 2010. p. 95-104 https://doi.org/10.1145/1835698.1835723
Serafini, Marco ; Dobre, Dan ; Majuntke, Matthias ; Bokor, Péter ; Suri, Neeraj. / Eventually linearizable shared objects. Proceedings of the Annual ACM Symposium on Principles of Distributed Computing. 2010. pp. 95-104
@inproceedings{437db8f96130452d9644643b1d4c9852,
title = "Eventually linearizable shared objects",
abstract = "Linearizability is the strongest known consistency property of shared objects. In asynchronous message passing systems, Linearizability can be achieved with ◇S and a majority of correct processes. In this paper we introduce the notion of Eventual Linearizability, the strongest known consistency property that can be attained with ◇S and any number of crashes. We show that linearizable shared object implementations can be augmented to support weak operations, which need to be linearized only eventually. Unlike strong operations that require to be always linearized, weak operations terminate in worst case runs. However, there is a tradeoff between ensuring termination of weak and strong operations when processes have only access to ◇S. If weak operations terminate in the worst case, then we show that strong operations terminate only in the absence of concurrent weak operations. Finally, we show that an implementation based on ◇P exists that guarantees termination of all operations.",
keywords = "Availability, Eventual linearizability, Graceful degradation",
author = "Marco Serafini and Dan Dobre and Matthias Majuntke and P{\'e}ter Bokor and Neeraj Suri",
year = "2010",
month = "9",
day = "8",
doi = "10.1145/1835698.1835723",
language = "English",
isbn = "9781605588889",
pages = "95--104",
booktitle = "Proceedings of the Annual ACM Symposium on Principles of Distributed Computing",

}

TY - GEN

T1 - Eventually linearizable shared objects

AU - Serafini, Marco

AU - Dobre, Dan

AU - Majuntke, Matthias

AU - Bokor, Péter

AU - Suri, Neeraj

PY - 2010/9/8

Y1 - 2010/9/8

N2 - Linearizability is the strongest known consistency property of shared objects. In asynchronous message passing systems, Linearizability can be achieved with ◇S and a majority of correct processes. In this paper we introduce the notion of Eventual Linearizability, the strongest known consistency property that can be attained with ◇S and any number of crashes. We show that linearizable shared object implementations can be augmented to support weak operations, which need to be linearized only eventually. Unlike strong operations that require to be always linearized, weak operations terminate in worst case runs. However, there is a tradeoff between ensuring termination of weak and strong operations when processes have only access to ◇S. If weak operations terminate in the worst case, then we show that strong operations terminate only in the absence of concurrent weak operations. Finally, we show that an implementation based on ◇P exists that guarantees termination of all operations.

AB - Linearizability is the strongest known consistency property of shared objects. In asynchronous message passing systems, Linearizability can be achieved with ◇S and a majority of correct processes. In this paper we introduce the notion of Eventual Linearizability, the strongest known consistency property that can be attained with ◇S and any number of crashes. We show that linearizable shared object implementations can be augmented to support weak operations, which need to be linearized only eventually. Unlike strong operations that require to be always linearized, weak operations terminate in worst case runs. However, there is a tradeoff between ensuring termination of weak and strong operations when processes have only access to ◇S. If weak operations terminate in the worst case, then we show that strong operations terminate only in the absence of concurrent weak operations. Finally, we show that an implementation based on ◇P exists that guarantees termination of all operations.

KW - Availability

KW - Eventual linearizability

KW - Graceful degradation

UR - http://www.scopus.com/inward/record.url?scp=77956249645&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=77956249645&partnerID=8YFLogxK

U2 - 10.1145/1835698.1835723

DO - 10.1145/1835698.1835723

M3 - Conference contribution

SN - 9781605588889

SP - 95

EP - 104

BT - Proceedings of the Annual ACM Symposium on Principles of Distributed Computing

ER -