On Register Linearizability and Termination

Abstract

It is well-known that, for deterministic algorithms, linearizable objects can be used as if they were atomic objects. As pointed out by Golab, Higham, and Woelfel, however, a randomized algorithm that works with atomic objects may lose some of its properties if we replace the atomic objects that it uses with objects that are only linearizable. It was not known whether the properties that can be lost include the all-important property of termination (with probability 1). In this paper, we first show that a randomized algorithm can indeed lose its termination property if we replace the atomic registers that it uses with linearizable ones. Golab et al. also introduced strong linearizability, and proved that strongly linearizable objects can be used as if they were atomic objects, even for randomized algorithms: they can replace atomic objects while preserving the algorithm s correctness properties, including termination. Unfortunately, there are important cases where strong linearizability is impossible to achieve. In particular, Helmi, Higham, and Woelfel showed a large class of non-trivial objects, including MWMR registers, do not have strongly linearizable implementations from SWMR registers. Thus we propose a new type of register linearizability, called write strong-linearizability, that is strictly stronger than (plain) linearizability but strictly weaker than strong linearizability. This intermediate type of linearizability has some desirable properties. We prove that some randomized algorithms that fail to terminate with linearizable registers, work with write strongly-linearizable ones. In other words, there are cases where linearizability is not sufficient but write strong-linearizability is. In contrast to the impossibility result mentioned above, we prove that write strongly-linearizable MWMR registers are implementable from SWMR registers. While the well-known ABD implementation of SWMR registers in message-passing system is not strongly linearizable, we show that it is actually write strongly-linearizable. In fact, we prove that any linearizable implementation of SWMR registers is necessarily write strongly-linearizable, but that this is not case for MWMR registers.