We investigate the minimum record needed to replay executions of processes that share causally consistent memory. For a version of causal consistency, we identify optimal records under both offline and online recording setting. Under the offline setting, a central authority has information about every process' view of the execution and can decide what information to record for each process. Under the online setting, each process has to decide on the record at runtime as the operations are observed.
{"title":"Brief Announcement: Optimal Record and Replay under Causal Consistency","authors":"Russell L. Jones, M. S. Khan, N. Vaidya","doi":"10.1145/3212734.3212789","DOIUrl":"https://doi.org/10.1145/3212734.3212789","url":null,"abstract":"We investigate the minimum record needed to replay executions of processes that share causally consistent memory. For a version of causal consistency, we identify optimal records under both offline and online recording setting. Under the offline setting, a central authority has information about every process' view of the execution and can decide what information to record for each process. Under the online setting, each process has to decide on the record at runtime as the operations are observed.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"117243925","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Session details: Session 1B: Shared Memory Theory","authors":"Dan Alistarh","doi":"10.1145/3258696","DOIUrl":"https://doi.org/10.1145/3258696","url":null,"abstract":"","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125641171","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
This paper focuses on understanding the message complexity of randomized agreement in synchronous distributed networks. We focus on the so-called implicit agreement problem where each node starts with an input value (0 or 1) and at the end one or more nodes should decide on a common input value which should be equal to some node's input value (there can be undecided nodes). Implicit agreement is a generalization of the fundamental agreement and leader election problems. We present sublinear (in n, where n is the number of nodes) algorithms and lower bounds on the message complexity of implicit agreement in fully-connected (i.e., complete) networks. Specifically our main results are: We show that for any implicit agreement algorithm that succeeds with probability at least 1 - ε, for some suitably small constant ε > 0, needs at least Ω(n0.5) messages with constant probability. This bound holds regardless of the number of rounds used and applies to both LOCAL and CONGEST models. This lower bound is essentially tight for complete networks, as there exists a randomized agreement algorithm that uses only Õ (n0.5) messages1 with high probability2 and runs inO(1) rounds and succeeds with high probability. Both the upper and lower bounds assume that nodes have access to (only) private coins. In contrast to the above bounds, if nodes have access to an unbiased global (shared) coin, we present a randomized algorithm which, with high probability, achieves implicit agreement, and uses Õ (n0.4) messages in expectation and runs in O(1) rounds (deterministically). This algorithm works in the CONGEST model as well. Our result shows the power of a global coin in significantly improving (by a polynomial factor) the message complexity of agreement. As another contrast, we show that the same benefit does not apply to leader election, i.e., even with access to a global coin, Ω(n0.5) messages (in expectation) are needed for any leader election algorithm that succeeds with probability at least 1 - ε, for a small constant ε > 0. We extend our results to a natural generalization of agreement called as subset agreement where a given (non-empty) subset of nodes should agree on a common value. We show that subset agreement on a subset of size k nodes can be accomplished by a randomized algorithm that succeeds with high probability, and uses (in expecation) Õ (min{kn0.5,n}) (using only private coins) and Õ (min{kn0.4,n}) messages (using global coin) respectively
{"title":"Sublinear Message Bounds for Randomized Agreement","authors":"John E. Augustine, A. R. Molla, Gopal Pandurangan","doi":"10.1145/3212734.3212751","DOIUrl":"https://doi.org/10.1145/3212734.3212751","url":null,"abstract":"This paper focuses on understanding the message complexity of randomized agreement in synchronous distributed networks. We focus on the so-called implicit agreement problem where each node starts with an input value (0 or 1) and at the end one or more nodes should decide on a common input value which should be equal to some node's input value (there can be undecided nodes). Implicit agreement is a generalization of the fundamental agreement and leader election problems. We present sublinear (in n, where n is the number of nodes) algorithms and lower bounds on the message complexity of implicit agreement in fully-connected (i.e., complete) networks. Specifically our main results are: We show that for any implicit agreement algorithm that succeeds with probability at least 1 - ε, for some suitably small constant ε > 0, needs at least Ω(n0.5) messages with constant probability. This bound holds regardless of the number of rounds used and applies to both LOCAL and CONGEST models. This lower bound is essentially tight for complete networks, as there exists a randomized agreement algorithm that uses only Õ (n0.5) messages1 with high probability2 and runs inO(1) rounds and succeeds with high probability. Both the upper and lower bounds assume that nodes have access to (only) private coins. In contrast to the above bounds, if nodes have access to an unbiased global (shared) coin, we present a randomized algorithm which, with high probability, achieves implicit agreement, and uses Õ (n0.4) messages in expectation and runs in O(1) rounds (deterministically). This algorithm works in the CONGEST model as well. Our result shows the power of a global coin in significantly improving (by a polynomial factor) the message complexity of agreement. As another contrast, we show that the same benefit does not apply to leader election, i.e., even with access to a global coin, Ω(n0.5) messages (in expectation) are needed for any leader election algorithm that succeeds with probability at least 1 - ε, for a small constant ε > 0. We extend our results to a natural generalization of agreement called as subset agreement where a given (non-empty) subset of nodes should agree on a common value. We show that subset agreement on a subset of size k nodes can be accomplished by a randomized algorithm that succeeds with high probability, and uses (in expecation) Õ (min{kn0.5,n}) (using only private coins) and Õ (min{kn0.4,n}) messages (using global coin) respectively","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125338427","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Recent years have seen a tremendous growth in the popularity of online services accessed over the Internet. Our daily lives are becoming more and more dependent on these online services, which generate and/or rely on huge amount of data. One core technique to deal with the unprecedented amount of data is the distributed storage systems that allow users/applications to read and write data in a distributed fashion and ensure fault-tolerance, durability, scalability, and availability. This tutorial will focus on the distributed key-value storage systems, i.e., read/write objects. One common implementation of such a read/write object is via replicating data across multiple servers or even data-centers. The replication-based implementation has been studied in the literature, e.g., ABD [Attiya, Bar-Noy and Dolev '96] and LDR [Fan and Lynch '03], and adopted in practice e.g., Cassandra, MongoDB, and DynamoDB. One drawbacks of the replication-based mechanism is high storage cost and communication cost due to unnecessary redundancy. To address the issue, there is an ongoing effort on applying erasure codes to distributed storage systems in both academia and industry. For example, Microsoft applies erasure coding across data-centers to build strongly consistent objects (Giza in Microsoft Azure Storage), and OpenStack provides erasure coding as a storage policy in their read/write object Swift. However, the field is still fairly young and has many interesting open problems. This tutorial will focus on the challenges of using erasure codes in read/write objects that guarantee consistency. To begin with, I will introduce concepts on consistency models, erasure codes followed by some recent algorithms and existing practical systems. I will then discuss the state-of-the-art techniques in this field, and conclude the talk with potential challenges that lead to interesting research problems. The talk will be accessible to anyone with a background a basic knowledge on algorithms or programming. First part of the results are done by Viveck Cadambe, Kishori Konwar, N. Prakash, Nancy Lynch, and Muriel Médard. In the end, I will also share our recent results.
{"title":"Erasure Coding in Object Stores: Challenges and Opportunities","authors":"Lewis Tseng","doi":"10.1145/3212734.3212799","DOIUrl":"https://doi.org/10.1145/3212734.3212799","url":null,"abstract":"Recent years have seen a tremendous growth in the popularity of online services accessed over the Internet. Our daily lives are becoming more and more dependent on these online services, which generate and/or rely on huge amount of data. One core technique to deal with the unprecedented amount of data is the distributed storage systems that allow users/applications to read and write data in a distributed fashion and ensure fault-tolerance, durability, scalability, and availability. This tutorial will focus on the distributed key-value storage systems, i.e., read/write objects. One common implementation of such a read/write object is via replicating data across multiple servers or even data-centers. The replication-based implementation has been studied in the literature, e.g., ABD [Attiya, Bar-Noy and Dolev '96] and LDR [Fan and Lynch '03], and adopted in practice e.g., Cassandra, MongoDB, and DynamoDB. One drawbacks of the replication-based mechanism is high storage cost and communication cost due to unnecessary redundancy. To address the issue, there is an ongoing effort on applying erasure codes to distributed storage systems in both academia and industry. For example, Microsoft applies erasure coding across data-centers to build strongly consistent objects (Giza in Microsoft Azure Storage), and OpenStack provides erasure coding as a storage policy in their read/write object Swift. However, the field is still fairly young and has many interesting open problems. This tutorial will focus on the challenges of using erasure codes in read/write objects that guarantee consistency. To begin with, I will introduce concepts on consistency models, erasure codes followed by some recent algorithms and existing practical systems. I will then discuss the state-of-the-art techniques in this field, and conclude the talk with potential challenges that lead to interesting research problems. The talk will be accessible to anyone with a background a basic knowledge on algorithms or programming. First part of the results are done by Viveck Cadambe, Kishori Konwar, N. Prakash, Nancy Lynch, and Muriel Médard. In the end, I will also share our recent results.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129443283","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Session details: Session 2A: Approximation and Learning","authors":"I. Keidar","doi":"10.1145/3258699","DOIUrl":"https://doi.org/10.1145/3258699","url":null,"abstract":"","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124141622","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
We present improved analyses for two of the well-studied randomized dynamics of stabilizing consensus, namely 2-choice and 3-majority. The resulting bounds are tight up to logarithmic factors. In the latter case, this answers an open question of Becchetti et al. [SODA'16]. Consider a distributed system of n nodes, each initially holding an opinion in 1, 2, ...., k . The system should converge to a setting where all (non-corrupted) nodes hold the same opinion. This consensus opinion should be valid, meaning that it should be among the initially supported opinions, and the (fast) convergence should happen even in the presence of a malicious adversary who can corrupt a bounded number of nodes per round and in particular modify their opinions. Two of the well-studied distributed algorithms for this problem work as follows: In both of these dynamics, each node gathers the opinion of three nodes and sets its new opinion equal to the majority of this set. In the 2-choice dynamics, the three nodes are the node itself and two random nodes and ties are broken towards the node's own opinion. In the 3-majority dynamics, the three nodes are selected at random and ties are broken randomly. Becchetti et al. [SODA'16] showed that the 3-majority dynamics converges to consensus in O((k^2sq√rtlog n + klog n)(k+log n)) rounds, even in the presence of a limited adversary, for k bounded by some polynomial of n. We prove that, even with a stronger adversary, the convergence happens within O(klog n) rounds, both for 3-majority and 2-choice. For 3-majority, this bound is known to be optimal for k=tildeO (√ ). More generally, we prove that 3-majority converges always in Õ (n^2/3 ) time, improving on a Õ (n^3/4 ) upper bound of Berenbrink et al. [PODC'17].
{"title":"Nearly-Tight Analysis for 2-Choice and 3-Majority Consensus Dynamics","authors":"M. Ghaffari, J. Lengler","doi":"10.1145/3212734.3212738","DOIUrl":"https://doi.org/10.1145/3212734.3212738","url":null,"abstract":"We present improved analyses for two of the well-studied randomized dynamics of stabilizing consensus, namely 2-choice and 3-majority. The resulting bounds are tight up to logarithmic factors. In the latter case, this answers an open question of Becchetti et al. [SODA'16]. Consider a distributed system of n nodes, each initially holding an opinion in 1, 2, ...., k . The system should converge to a setting where all (non-corrupted) nodes hold the same opinion. This consensus opinion should be valid, meaning that it should be among the initially supported opinions, and the (fast) convergence should happen even in the presence of a malicious adversary who can corrupt a bounded number of nodes per round and in particular modify their opinions. Two of the well-studied distributed algorithms for this problem work as follows: In both of these dynamics, each node gathers the opinion of three nodes and sets its new opinion equal to the majority of this set. In the 2-choice dynamics, the three nodes are the node itself and two random nodes and ties are broken towards the node's own opinion. In the 3-majority dynamics, the three nodes are selected at random and ties are broken randomly. Becchetti et al. [SODA'16] showed that the 3-majority dynamics converges to consensus in O((k^2sq√rtlog n + klog n)(k+log n)) rounds, even in the presence of a limited adversary, for k bounded by some polynomial of n. We prove that, even with a stronger adversary, the convergence happens within O(klog n) rounds, both for 3-majority and 2-choice. For 3-majority, this bound is known to be optimal for k=tildeO (√ ). More generally, we prove that 3-majority converges always in Õ (n^2/3 ) time, improving on a Õ (n^3/4 ) upper bound of Berenbrink et al. [PODC'17].","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126047256","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
M. Aguilera, N. Ben-David, I. Calciu, R. Guerraoui, E. Petrank, S. Toueg
We introduce a new distributed computing model called m&m that allows processes to both pass messages and share memory. Motivated by recent hardware trends, we find that this model improves the power of the pure message-passing and shared-memory models. As we demonstrate by example with two fundamental problems---consensus and eventual leader election---the added power leads to new algorithms that are more robust against failures and asynchrony. Our consensus algorithm combines the superior scalability of message passing with the higher fault tolerance of shared memory, while our leader election algorithms reduce the system synchrony needed for correctness. These results point to a wide new space for future exploration of other problems, techniques, and benefits.
{"title":"Passing Messages while Sharing Memory","authors":"M. Aguilera, N. Ben-David, I. Calciu, R. Guerraoui, E. Petrank, S. Toueg","doi":"10.1145/3212734.3212741","DOIUrl":"https://doi.org/10.1145/3212734.3212741","url":null,"abstract":"We introduce a new distributed computing model called m&m that allows processes to both pass messages and share memory. Motivated by recent hardware trends, we find that this model improves the power of the pure message-passing and shared-memory models. As we demonstrate by example with two fundamental problems---consensus and eventual leader election---the added power leads to new algorithms that are more robust against failures and asynchrony. Our consensus algorithm combines the superior scalability of message passing with the higher fault tolerance of shared memory, while our leader election algorithms reduce the system synchrony needed for correctness. These results point to a wide new space for future exploration of other problems, techniques, and benefits.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131978341","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
During the past half-century, persistent memory has had an interesting history and relationship to the design of computing and storage systems. In this talk, the history of systems design using persistent memory (as well as non-persistent, aka volatile memory) will be briefly discussed, as well as approaches to data storage. The majority of the talk will focus on two areas. First, the current state of the persistent memory art, as well as a taxonomy of persistent memory. Second, current methods and issues surrounding the use of persistent memory in systems, in particular distributed systems. The relationship between processing (e.g. CPUs) and persistent memory will be discussed in detail, illustrating certain challenges and opportunities with regard to several forms of distributed computation, in particular concerning large-scale multi-processor designs using shared persistent memory technology.
{"title":"Overview of Persistent Memory in Distributed Systems Architecture -- Past, Present, Future","authors":"R. Peglar","doi":"10.1145/3212734.3212796","DOIUrl":"https://doi.org/10.1145/3212734.3212796","url":null,"abstract":"During the past half-century, persistent memory has had an interesting history and relationship to the design of computing and storage systems. In this talk, the history of systems design using persistent memory (as well as non-persistent, aka volatile memory) will be briefly discussed, as well as approaches to data storage. The majority of the talk will focus on two areas. First, the current state of the persistent memory art, as well as a taxonomy of persistent memory. Second, current methods and issues surrounding the use of persistent memory in systems, in particular distributed systems. The relationship between processing (e.g. CPUs) and persistent memory will be discussed in detail, illustrating certain challenges and opportunities with regard to several forms of distributed computation, in particular concerning large-scale multi-processor designs using shared persistent memory technology.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130668906","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The cost of communication is a substantial factor affecting the scalability of many distributed applications. Every message sent can incur a cost in storage, computation, energy and bandwidth. Consequently, reducing the communication costs of distributed applications is highly desirable. The best way to reduce message costs is by communicating without sending any messages whatsoever. This paper initiates a rigorous investigation into the use of silence in synchronous settings, in which processes can fail. We formalize sufficient conditions for information transfer using silence, as well as necessary conditions for particular cases of interest. This allows us to identify message patterns that enable communication through silence. In particular, a pattern called a em silent choir is identified, and shown to be central to information transfer via silence in failure-prone systems. The power of the new framework is demonstrated on the em atomic commitment problem (AC). A complete characterization of the tradeoff between message complexity and round complexity in the synchronous model with crash failures is provided, in terms of lower bounds and matching protocols. In particular, a new message-optimal AC protocol is designed using silence, in which processes decide in~3 rounds in the common case. This significantly improves on the best previously known message-optimal AC protocol, in which decisions were performed in Θ(n) rounds.
{"title":"Silence","authors":"G. Goren, Y. Moses","doi":"10.1145/3212734.3212768","DOIUrl":"https://doi.org/10.1145/3212734.3212768","url":null,"abstract":"The cost of communication is a substantial factor affecting the scalability of many distributed applications. Every message sent can incur a cost in storage, computation, energy and bandwidth. Consequently, reducing the communication costs of distributed applications is highly desirable. The best way to reduce message costs is by communicating without sending any messages whatsoever. This paper initiates a rigorous investigation into the use of silence in synchronous settings, in which processes can fail. We formalize sufficient conditions for information transfer using silence, as well as necessary conditions for particular cases of interest. This allows us to identify message patterns that enable communication through silence. In particular, a pattern called a em silent choir is identified, and shown to be central to information transfer via silence in failure-prone systems. The power of the new framework is demonstrated on the em atomic commitment problem (AC). A complete characterization of the tradeoff between message complexity and round complexity in the synchronous model with crash failures is provided, in terms of lower bounds and matching protocols. In particular, a new message-optimal AC protocol is designed using silence, in which processes decide in~3 rounds in the common case. This significantly improves on the best previously known message-optimal AC protocol, in which decisions were performed in Θ(n) rounds.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132744518","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
We presents a novel abstract individual-process crash-recovery model for non-volatile memory, which enables modularity, so that complex recoverable objects can be constructed in a modular manner from simpler recoverable base objects. Within the framework of this model, we define nesting-safe recoverable linearizability (NRL) -- a novel correctness condition that captures the requirements for nesting recoverable objects. Informally, NRL allows the recovery code to extend the interval of the failed operation until the recovery code succeeds to complete (possibly after multiple failures and recovery attempts). Unlike previous correctness definitions, the NRL condition implies that, following recovery, an implemented (higher-level) recoverable operation is able to complete its invocation of a base-object operation and obtain its response. We present algorithms for nesting-safe recoverable primitives, namely, recoverable versions of widely-used primitive shared-memory operations such as read, write, test-and-set and compare-and-swap, which can be used to implement higher-level recoverable objects. We then exemplify how these recoverable base objects can be used for constructing a recoverable counter object. Finally, we prove an impossibility result on wait-free implementations of recoverable test-and-set (TAS) objects from read, write and TAS operations, thus demonstrating that our model also facilitates rigorous analysis of the limitations of recoverable concurrent objects.
{"title":"Nesting-Safe Recoverable Linearizability: Modular Constructions for Non-Volatile Memory","authors":"H. Attiya, Ohad Ben-Baruch, Danny Hendler","doi":"10.1145/3212734.3212753","DOIUrl":"https://doi.org/10.1145/3212734.3212753","url":null,"abstract":"We presents a novel abstract individual-process crash-recovery model for non-volatile memory, which enables modularity, so that complex recoverable objects can be constructed in a modular manner from simpler recoverable base objects. Within the framework of this model, we define nesting-safe recoverable linearizability (NRL) -- a novel correctness condition that captures the requirements for nesting recoverable objects. Informally, NRL allows the recovery code to extend the interval of the failed operation until the recovery code succeeds to complete (possibly after multiple failures and recovery attempts). Unlike previous correctness definitions, the NRL condition implies that, following recovery, an implemented (higher-level) recoverable operation is able to complete its invocation of a base-object operation and obtain its response. We present algorithms for nesting-safe recoverable primitives, namely, recoverable versions of widely-used primitive shared-memory operations such as read, write, test-and-set and compare-and-swap, which can be used to implement higher-level recoverable objects. We then exemplify how these recoverable base objects can be used for constructing a recoverable counter object. Finally, we prove an impossibility result on wait-free implementations of recoverable test-and-set (TAS) objects from read, write and TAS operations, thus demonstrating that our model also facilitates rigorous analysis of the limitations of recoverable concurrent objects.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116033483","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：