Blunting an Adversary Against Randomized Concurrent Programs with Linearizable Implementations

  title={Blunting an Adversary Against Randomized Concurrent Programs with Linearizable Implementations},
  author={Hagit Attiya and Constantin Enea and Jennifer L. Welch},
  journal={Proceedings of the 2022 ACM Symposium on Principles of Distributed Computing},
  • H. Attiya, C. Enea, J. Welch
  • Published 29 June 2021
  • Computer Science
  • Proceedings of the 2022 ACM Symposium on Principles of Distributed Computing
Atomic shared objects, whose operations take place instantaneously, are a powerful abstraction for designing complex concurrent programs. Since they are not always available, they are typically substituted with software implementations. A prominent condition relating these implementations to their atomic specifications is linearizability, which preserves safety properties of the programs using them. However linearizability does not preserve hyper-properties, which include probabilistic… 

Figures from this paper



An Impossibility Result on Strong Linearizability in Message-Passing Systems

It is proved that there is no 1-resilient strongly linearizable implementation of a weak object in asynchronous message-passing systems, and this weak object can be directly implemented by a single-writer single-reader (SWSR) register.

On Register Linearizability and Termination

This paper first shows that a randomized algorithm can indeed lose its termination property if the authors replace the atomic registers that it uses with linearizable ones, and proposes a new type of register linearizability, called write strong-linearizable, that is strictly stronger than (plain)linearizability but strictly weaker than strong linearIZability.

Strongly linearizable implementations: possibilities and impossibilities

For several objects including multi-writer registers, max-registers, snapshots, and counters there is no strongly linearizable, non-blocking implementation from multi-reader/single-writer atomic registers, even though each of these objects has a linearizable implementation meeting the stronger wait-free progress requirement.

Linearizable implementations do not suffice for randomized distributed computation

It is proved that a strong adversary (i.e., one that sees the outcome of each coin flip immediately) gains no additional power when atomic objects are replaced by strongly linearizable implementations, and that strong linearizability is a local and composable property.

Sharing memory robustly in message-passing systems

Emulators that translate algorithms from the shared-memory model to two different message-passing models are presented. Both are achieved by implementing a wait-free, atomic, single-writer

Bounded time-stamps

  • A. IsraeliMing Li
  • Computer Science
    28th Annual Symposium on Foundations of Computer Science (sfcs 1987)
  • 1987
A theory of bounded time-stamp schemes is developed and the complexity of their implementation is analyzed, indicating a direction for developing a general tool for converting time-Stamp based protocols to bounded protocols.

Atomic snapshots of shared memory

Three wait-free implementations of atomicsnapshot memory are presented, one of which uses unbounded(integer) fields in these registers, and is particularly easy tounderstand, while the second and third use bounded registers.

Linearizable Implementations Suffice for Termination of Randomized Concurrent Programs

A simple modification of some existing linearizable implementations is proposed with the property that if a concurrent program has non-zero termination probability when used with atomic objects, then it also hasnon-zerotermination probability when it is used with the modifiedlinearizable implementations.

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

There are no strongly-linearizable fault-tolerant message-passing implementations of multi-writer registers, max-registers, snapshots or counters, and the reduction is a novel extension of the BG simulation that connects shared-memory and message- passing, supports long-lived objects, and preserves strong linearizability.

On atomic registers and randomized consensus in M&M systems

This work gives an algorithm that implements an atomic single-writer multi-reader register in m&m systems and shows that it is optimal in the number of process crashes that it tolerates, and combines the implementation with a randomized consensus algorithm of Aspnes and Herlihy.