Partial snapshot objects

Attiya, Hagit; Guerraoui, Rachid; Ruppert, Eric

doi:10.1145/1378533.1378591

Cited by 27 publications

(32 citation statements)

References 29 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Operation READ(i) returns the last written value from C i 's register, and may be called by any client. Our algorithm makes use of an atomic single-writer snapshot object S with n components [24,25]. Snapshot object S provides two atomic operations: UPDATE(d, S, i), that changes the state of component i of S to d, and SCAN(S) that returns vector (d 1 , .…”

Section: A Weak Fork-linearizable Shared Memorymentioning

confidence: 99%

See 1 more Smart Citation

Fork-consistent constructions from registers

Majuntke

Dobre

Suri

2011

Proceedings of the 30th Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

Abstract. Users increasingly execute services online at remote providers, but they may have security concerns and not always trust the providers. Fork-consistent emulations offer one way to protect the clients of a remote service, which is usually correct but may suffer from Byzantine faults. They feature linearizability as long as the service behaves correctly, and gracefully degrade to fork-consistent semantics in case the service becomes faulty. This guarantees data integrity and service consistency to the clients. All currently known fork-consistent emulations require the execution of nontrivial computation steps by the service. From a theoretical viewpoint, such a service constitutes a read-modify-write object, representing the strongest object in Herlihy's wait-free hierarchy [1]. A read-modify-write object is much more powerful than a shared memory made of so-called registers, which lie in the weakest class of all shared objects in this hierarchy. In practical terms, it is important to reduce the complexity and cost of a remote service implementation as computation resources are typically more expensive than storage resources. In this paper, we address the fundamental structure of a fork-consistent emulation and ask the question: Can one provide a fork-consistent emulation in which the service does not execute computation steps, but can be realized only by a shared memory? Surprisingly, the answer is yes. Specifically, we provide two such algorithms that can be built only from registers: A fork-linearizable construction of a universal type, in which operations are allowed to abort under concurrency, and a weakly fork-linearizable emulation of a shared memory that ensures waitfreedom when the registers are correct.

show abstract

Section: A Weak Fork-linearizable Shared Memorymentioning

confidence: 99%

“…. , n. Formally, d i is the state written by the last UPDATE to component i prior to SCAN. It has been shown, that such a shared snapshot object can be wait-free implemented only from registers [24,25].…”

Section: A Weak Fork-linearizable Shared Memorymentioning

confidence: 99%

Fork-consistent constructions from registers

Majuntke

Dobre

Suri

2011

Proceedings of the 30th Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

show abstract

“…Independently of consistency reasons, a transaction T can also be aborted by the process that issued it. (From our point of view, namely the definition of consistency conditions for STM systems, we consider that such aborts include the case where transactions are aborted in order to improve the global efficiency 4 .) Events at the shared memory level Each transaction generates events defined as follows.…”

Section: Imbs and M Raynalmentioning

confidence: 99%

A Versatile STM Protocol with Invisible Read Operations That Satisfies the Virtual World Consistency Condition

Imbs

Raynal

2010

Structural Information and Communication Complexity

View full text Add to dashboard Cite

To cite this version:Damien Imbs, Michel Raynal. A versatile STM protocol with invisible read operations that satisfies the virtual world consistency condition. Abstract:The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, a STM system provides the programmer with the concept of a transaction. The job of the programmer is to decompose each sequential process the application is made up of into transactions. A transaction is a piece of code that accesses concurrent objects, but contains no explicit synchronization statement. It is the job of the underlying STM system to provide the illusion that each transaction appears as being executed atomically. For efficiency, a STM system allows transactions to execute concurrently. Consequently, due to the underlying STM concurrency management, a transaction commits or aborts. This paper first presents a new STM consistency condition, called virtual world consistency. This condition states that no transaction reads object values from an inconsistent global state. It is similar to opacity for the committed transactions but weaker for the aborted transactions. More precisely, it states that (1) the committed transactions can be totally ordered, and (2) the values read by each aborted transaction are consistent with respect to its causal past only. Hence, virtual world consistency is weaker than opacity while keeping its spirit. Then, assuming the objects shared by the processes are atomic read/write objects, the paper presents a STM protocol that ensures virtual world consistency (while guaranteeing the invisibility of the read operations). From an operational point of view, this protocol is based on a vector-clock mechanism. Finally, the paper considers the case where the shared objects are regular read/write objects. It also shows how the protocol can be weakened to satisfy the causal consistency condition (that is weaker than virtual world consistency).Virtual world consistency does not require the aborted transactions to agree on what they have seen. This is captured by the local vector clocks associated with each process and the vector timestamps associated with each object. From a comprehensive point of view, the paper addresses how the interplay of these local control informations allows the execution of a set of transactions to be provided with a global meaning. Key-words:Atomic object, Causal past, Commit/abort, Concurrency control, Consistency condition, Consistent global state, Lock, Read-from relation, Regular Read/write object, Serializability, Shared memory, Software transactional memory, Vector clock, Transaction.

show abstract

“…Hence, they are called SWMR snapshot objects. Snapshot objects were the underlying atomic registers are MWMR (Multi-Writer/Multi-Reader) have also been studied (e.g., [5,15,16]). …”

Section: Introductionmentioning

confidence: 99%

Implementing Snapshot Objects on Top of Crash-Prone Asynchronous Message-Passing Systems

Delporte-Gallet

Fauconnier

Rajsbaum³

et al. 2016

Algorithms and Architectures for Parallel Processing

View full text Add to dashboard Cite

Distributed snapshots, as introduced by Chandy and Lamport in the context of asynchronous failure-free message-passing distributed systems, are consistent global states in which the observed distributed application might have passed through. It appears that two such distributed snapshots cannot necessarily be compared (in the sense of determining which one of them is the "first"). Differently, snapshots introduced in asynchronous crash-prone read/write distributed systems are totally ordered, which greatly simplify their use by upper layer applications.In order to benefit from shared memory snapshot objects, it is possible to simulate a read/write shared memory on top of an asynchronous crash-prone message-passing system, and build then snapshot objects on top of it. This algorithm stacking is costly in both time and messages. To circumvent this drawback, this paper presents algorithms building snapshot objects directly on top of asynchronous crash-prone message-passing system. "Directly" means here "without building an intermediate layer such as a read/write shared memory". To the authors knowledge, the proposed algorithms are the first providing such constructions. Interestingly enough, these algorithms are efficient and relatively simple.

show abstract

Partial snapshot objects

Cited by 27 publications

References 29 publications

Fork-consistent constructions from registers

Fork-consistent constructions from registers

A Versatile STM Protocol with Invisible Read Operations That Satisfies the Virtual World Consistency Condition

Implementing Snapshot Objects on Top of Crash-Prone Asynchronous Message-Passing Systems

Contact Info

Product

Resources

About