Wait-Free Universality of Consensus in the Infinite Arrival Model

TL;DR

This paper proves that consensus remains a universal object in an infinite arrival model of distributed systems and introduces a universal construction with a weak log, expanding the understanding of consensus in dynamic environments.

Contribution

It extends the universality of consensus to the infinite arrival model and proposes a new universal construction with implementations using consensus and compare&swap.

Findings

Consensus is universal even with infinitely many processes.

A weak log construction is proposed for the infinite arrival model.

Two implementations of the weak log are provided, using consensus and compare&swap.

Abstract

In classical asynchronous distributed systems composed of a fixed number n of processes where some proportion may fail by crashing, many objects do not have a wait-free linearizable implementation (e.g. stacks, queues, etc.). It has been proved that consensus is universal in such systems, which means that this system augmented with consensus objects allows to implement any object that has a sequential specification. To this end, many universal constructions have been proposed in systems augmented with consensus objects or with different equivalent objects or special hardware instructions (compare&swap, fetch&add, etc.). In this paper, we consider a more general system model called infinite arrival model where infinitely many processes may arrive and leave or crash during a run. We prove that consensus is still universal in this more general model. For that, we propose a universal construction. As a first step we build a weak log for which we propose two implementations using consensus objects for the first and the compare&swap special instruction for the other.

Full text

Key-words.

Concurrent object, Consensus, Infinite arrival model, Linearizability, Universal construction, Wait-freedom.

1 Introduction

The question of universality has always been central in all areas. What can be done with a given tool and a context, and more importantly what cannot be done with such tool. In sequential computing, universality is represented by a Turing machine that can compute all that is computable. In the context of distributed systems, we have known since 1985 and the famous FLP impossibility result that the consensus problem has no deterministic solution in a distributed system where even one process can fail by crashing [7]. This impossibility is not due to the computing power of the individual processes, but rather to the difficulty of coordination between the different processes that compose the distributed system. Coordination and agreement problems are thus at the heart of computability in distributed systems [10].

A distributed system can be abstracted as a set of processes accessing concurrently a set of concurrent objects. The implementation of these objects are based on read/write registers and hardware instructions. Searching for correct and efficient implementations of usual objects (queues, stacks, etc.) is far from being trivial [11, 14, 16] when the system is failure prone. Intuitively, a “good” implementation of a concurrent object has to satisfy two kinds of properties: a consistency condition and a progress condition. The consistency condition specifies the safety property that is the meaningfulness of the returned results, and the progress condition specifies the guarantees on the liveness.

Linearizability [12] is a consistency criterion. It ensures that all the operations in a distributed history appear as if they were executed sequentially: each operation appears at a single point in time, between its start event and its end event. Such a consistency criterion gives the illusion to the processes to access a physical concurrent object. However, such implementations are often costly, when not impossible.

Definition 1** (Linearizability).**

An execution $\alpha$ is linearizable if all operations return the same value as if they occurred instantly at some instant, called the linearization point, between their invocation and their response, possibly after removing some non-terminated operations.

The use of locks in the implementation may cause blocking in a system where processes can crash. Prohibiting the use of locks leads to several progress conditions, among which wait-freedom [9] and lock-freedom [12]. While wait-freedom guarantees that every operation terminates after a finite time, lock-freedom guarantees that, if the computation run for long enough, at least one process makes progress (this may lead some processes to starve). Wait-freedom is thus stronger than lock-freedom: while lock-freedom is a system-wide condition, wait-freedom is a per-process condition.

Definition 2** (Wait-freedom).**

An execution $\alpha$ is wait-free if no operation takes an infinite number of steps in $\alpha$.

Maurice Herlihy proved in [8] that consensus is universal in classical distributed systems composed of a set of $n$ processes. Namely, any object having a sequential specification has a wait-free implementation using only read/write registers (memory locations) and some number of consensus objects.

For proving the universality of consensus, Herlihy introduced the notion of universal construction111A small guided tour on universal constructions can be found in [15].. It is a generic algorithm that, given a sequential specification of any object whose operations are total222This means that any operation on the object can be called and the call returns regardless of the state of the object., provides a concurrent implementation of this object. Since then, many universal constructions have been proposed for several objects, assuming the availability of hardware special instructions that provide the same computing power as consensus, like compare&swap (CAS), Load-Link/Store-Conditional (LL/SC) etc.

This last decade, first with peer-to-peer systems, and then with multi-core machines and the multi-threading model, the assumption of a closed system with a fixed number $n$ of processes and where every process knows the identifiers of all processes became too restrictive. Hence the infinite arrival model introduced in [13]. In this model, any number of processes can crash (or leave, in a same way as in the other model), but any number (be it finite or not) of processes can also join the network. When a process joins such a system, it is not known to the already running processes, so no fixed number of processes can be used in the implementations as a parameter. Three kinds of arrival models can be distinguished: the bounded arrival model in which at most $N$ processes may participate, the unbounded arrival model in which a finite number of processes participate in each execution but the number of participants is unknown to them, and the infinite arrival model where new processes may keep arriving during the whole execution. Let us note that, at any time, the number of processes that have already joined the system is finite, but can be infinitely growing. The classical system is part of the bounded arrival model where all the processes arrive at once. In this article, we focus on the infinite arrival model.

Problem statement

The aim of this paper is to extend universality of consensus to the infinite arrival model. Solutions to the consensus problem have already been investigated for the infinite arrival model [2, 5, 13] and consensus has been used as a base for reasoning about computability in this model [1]. The question is thus “is it possible to build a universal wait-free linearizable construction based on consensus objects and read/write atomic registers?” This is not trivial for different reasons. First, although the lock-free universal constructions still work in the infinite arrival model because they ensure a global progress condition, this is no more the case for wait-free universal constructions. Second, wait-free implementations rely on what is called help mechanism, that has been recently formalized in [4]. This mechanism requires any process, before terminating its operation, to help processes having pending operations, in order to reach wait-freedom. One of the difficulties in the infinite arrival model is that helping is not obvious. Indeed, helping requires at least that a process needing to be helped is able to announce its existence to other processes willing to help it. Due to the infinite number of potential participating processes over time, it is not reasonable to assume that each process can write in a dedicated register, and to require helping processes to read them all. When only consensus and read/write registers are accessible to a process, a newly arriving process must compete with a potentially infinite number of other arriving processes on either a consensus object or a same memory location; and may fail on all its attempts.

Contributions

This paper has two main contributions.

• •

Similarly to [6] which first proposes a Collect object that will be used as a building block for a universal construction, we first propose a construction that implements a weak log object. This log is used as a list of presence where a process that arrives registers. We propose two implementations of a weak log using respectively consensus objects and the special hardware instructions compare&swap.

• •

We propose a universal construction based on consensus objects and the weak log object in the infinite arrival model where, moreover, processes are anonymous. This proves that consensus is universal even in this model.

Organization of the paper

The remainder of this paper is organized as follows. We first present the infinite arrival model in Section 2. Then, Section 3 introduces a new abstraction, called the weak log. In Section 4, we show how the weak log can be used together with consensus to implement a wait-free universal construction. In Section 5, we give an implementation of the weak log using consensus objects. In Section 6, we discuss a simpler algorithm that uses compare&swap instead of consensus to implement a weak log. Finally, Section 7 concludes the paper.

2 System Model

The infinite arrival model is composed of an infinite set of processes called $p_{0},p_{1},\dots$ Processes communicate through an infinite memory composed of unbounded registers 333Memory addresses of an infinite memory are unbounded, so this assumption is necessary to store references.. Processes can only access atomic memory locations through references or thanks to a memory allocation mechanism that creates a finite number of memory locations when it is invoked. In other words, it is not possible to create an infinite array in this model. Memory is composed of three kinds of registers: immutable registers, read/write registers and consensus objects defined thereafter.

An immutable register

$x$ is initialized with a fixed value and cannot be modified later. It provides a read operation, simply denoted by $x$ in the algorithms, that returns the internal value of the register.

A read/write register

$x$ provides two operations: a read operation $x.\textnormal{{read}}()$ that returns the internal value of the register, and a write operation $x.\textnormal{{write}}(v)$ that replaces the current value of $x$ by $v$.

A consensus object

$x$ provides two operations: a read operation similar to the read operation on an immutable register, and an operation $x.\textnormal{{propose}}(v)$ that atomically checks if the current value is $\bot$, then sets the value of $x$ to $v$ if it is the case, and finally returns the value of $x$. In other words, the first proposed value is written on $x$, which becomes immutable from this point on 444 This definition is close to the sticky bit and is not exactly the same as commonly accepted definitions of consensus. However, it is easy to implement it using a regular consensus task and one read/write register, initialized to $\bot$ and written when the consensus is decided. We use this definition for the sake of clarity of the proposed algorithms. .

An execution in the infinite arrival model is a (finite or infinite) sequence of steps. In each step, one process executes either a local transition of its algorithm, accesses an operation available on a register, or returns a value. A process that has already returned a value cannot execute a step afterwards. Processes are asynchronous, in the sense that there is no constraint on which process takes each step of an execution: a process may take an unbounded but finite number of consecutive steps, or wait an unbounded but finite number of other processes’ steps between two of its own steps. Moreover, it is possible that a process stops taking steps at some point in the execution even if it has not returned yet, which is similar to a crash in the classical model.

We say that a process $p_{i}$ arrives in an execution at the time of its first step during this execution. Remark that, although the number of processes in the system is infinite, the number of processes that have arrived into the system at any step is finite.

Processes are anonymous, in the sense that they do not know their unique identifier: this hypothesis models the fact that it would be unreasonably costly to base an algorithm on unbounded identifiers, especially when the attribution of identifiers is not controlled by the arrival order of processes in the system. Moreover, by assuming anonymous processes, the result becomes more general.

3 The Weak Log Abstraction

As explained previously, the main difficulty in building a wait-free universal construction in the infinite arrival model resides in replacing helping mechanisms already in place in algorithms for the finite arrival model. In this section, we introduce the weak log, an abstraction that allows each process to announce its own value.

In the infinite arrival model, long-lived linearizable objects can be expressed as distributed tasks, as a process that invokes several operations on a long-lived object can be modelled as several processes each issuing a unique operation [3]. We now define the weak log abstraction as a distributed task.

In an instance of the weak log, each process $p_{i}$ proposes a value through an operation $\textnormal{{append}}(v_{i})$, that returns the sequence of all the values previously appended. The weak log is wait-free but not linearizable, in the sense that there might be no inclusion between the sequences returned by different processes. Instead, it is specified that the value proposed by a correct process will eventually appear in all subsequent sequences. Moreover, the order of the values inside sequences is consistent over the different sequences returned by all processes.

Definition 3** (weak log).**

All processes $p_{0},p_{1},\dots$ propose distinct values $v_{0},v_{1},\dots$ by invoking $\textnormal{{append}}(v_{i})$, that returns a finite sequence $w_{i}=w_{i,1}\cdot w_{i,2}\cdots w_{i,|w_{i}|}$ such that:

Validity

All values in a sequence $w_{i}$ have been appended by some process: $\forall j,\exists k:w_{i,j}=v_{k}.$

suffixing

If process $p_{i}$ terminates its invocation, then its value is appended at the end of its returned sequence: $w_{i,|w_{i}|}=v_{i}$

Total order

If two processes $p_{i}$ and $p_{j}$ terminate their invocations, then all pairs of values that $w_{i}$ and $w_{j}$ both contain appear in the same order: there is no $k_{i},k_{j},l_{i},l_{j}$ such that $w_{i,k_{i}}=w_{j,k_{j}}$, $w_{i,l_{i}}=w_{j,l_{j}}$, $k_{i}\leq k_{j}$ and $l_{i}>l_{j}$.

Eventual visibility

If some process $p_{i}$ terminates its invocation, then, eventually, all processes terminating their invocation will return a sequence containing $v_{i}$. In other words, the number of returned sequences that do not contain $v_{i}$ is finite.

Wait-freedom :

No process takes an infinite number of steps in an execution.

4 A Universal Construction

Algorithm 1 presents a universal construction using a weak log and consensus objects. This algorithm is similar to the one presented in [11], except that the array of single-writer/multiple-reader registers used by processes to announce their operations is replaced by a weak log. The shared object to implement is represented by an initial state initialState and a set of operations that change the state of the object and return a value.

Processes share two variables:

• •

announce is a weak log in which processes append their own invocation;

• •

operations is a consensus object at the tail of a linked list of operations. The list is a succession of nodes of the form $\langle v,\textnormal{{cons}}\rangle$, where $v$ is the invocation of a process and cons is a consensus object, referencing another node after the consensus has been won by some process.

When process $p_{i}$ calls $\textnormal{{apply}}(\textnormal{{invoc}})$, it first appends invoc to announce and obtains a list $\textnormal{{toHelp}}_{i}$ of invocations in return. Then, it attempts to insert invocations of $\textnormal{{toHelp}}_{i}$ at the end of the list operations until all the invocations of announce have been inserted. While traversing the list, it maintains a state $\textnormal{{state}}_{i}$ of the implemented object, initialized to initialState and on which all invocations are applied in their order of appearance in the list.

We now prove that Algorithm 1 is linearizable and wait-free. Linearizability is achieved by Algorithm 1 in the same way as in [11], so the proof of Lemma 1 is similar.

Lemma 1** (Linearizability).**

All executions admissible by Algorithm 1 are linearizable.

Proof.

Let $\alpha$ be an execution admissible by Algorithm 1.

Let us first remark that, for any operation $\textnormal{{apply}}(\textnormal{{invoc}})$ invoked by process $p_{i}$, at most one memory location cons is such that $\textnormal{{cons}}.\textnormal{{head}}=\textnormal{{invoc}}$. Indeed, suppose this is not the case, and let us consider the first two such memory locations, $\textnormal{{cons}}_{j}$ and $\textnormal{{cons}}_{k}$. Both were proposed on line 1 by some processes $p_{j}$ and $p_{k}$. As operations are totally ordered in a list, Process $p_{k}$ accessed $\textnormal{{cons}}_{j}$ before accessing $\textnormal{{cons}}_{k}$. After accessing $\textnormal{{cons}}_{j}$, $\textnormal{{invoc}}\notin\textnormal{{toHelp}}_{k}$ because of line 1, which contradicts the fact that $p_{k}$ proposed invoc on $\textnormal{{cons}}_{k}$.

Let us define the linearization point of any operation $\textnormal{{apply}}(\textnormal{{invoc}})$ for which there is a memory location cons such that $\textnormal{{cons}}.\textnormal{{head}}=\textnormal{{invoc}}$ as the first step in which some process invoked $\textnormal{{cons}}.\textnormal{{propose}}$.

We now prove that any operation $\textnormal{{apply}}(\textnormal{{invoc}})$ done by a terminating process $p_{i}$ has a linearization point, between its invocation and termination point. By the validity property of announce, and as all invoc values are different, no process proposes invoc before $p_{i}$ arrived in the system. By the suffixing property of announce, at the beginning of $p_{i}$’s loop, $\textnormal{{invoc}}\in\textnormal{{toHelp}}_{i}$. When $p_{i}$ terminates, $\textnormal{{invoc}}\notin\textnormal{{toHelp}}_{i}$. Therefore, invoc was removed on line 1 of some iteration of the loop, and cons at the beginning of the iteration is such that $\textnormal{{cons}}.\textnormal{{head}}=\textnormal{{invoc}}$ at the end of the loop.

Finally, operations are applied by $p_{i}$ on $s$ in the same order as they appear in the list (Lines 1 and 1), which is the same order as their linearization points, which concludes the proof. ∎

The proof of wait-freedom (Lemma 2) is more challenging because the proof of [11] heavily relies on the fact that the number of processes is finite.

Lemma 2** (Wait-freedom).**

All executions admissible by Algorithm 1 are wait-free.

Proof.

Suppose there is an execution $\alpha$ admissible by Algorithm 1 that is not wait-free. It means that some process $p_{i}$ takes an infinite number of steps in $\alpha$. By the wait-freedom property of announce, $p_{i}$ enters the while loop after a finite number of steps, and each iteration of the loop terminates. Therefore, $p_{i}$ executes an infinite number of loop iterations. Let $w_{i}=w_{i,1}\cdot w_{i,2}\cdots w_{i,|w_{i}|}$ be the initial value of $\textnormal{{toHelp}}_{i}$. As $w_{i}$ is finite and $p_{i}$ proposes some $\langle w_{i,k},\bot\rangle$ at each iteration, there exists a value $k$ such that $p_{i}$ proposes $\langle w_{i,k},\bot\rangle$ an infinite number of times.

Let $win_{0},win_{1},\dots$ be the infinite sequence of the values taken by $\textnormal{{winner}}_{i}$ during the execution, let $p_{\omega(j)}$ be the process that took the step on line 1 installing the value $win_{j}$ in the consensus and let $p_{a(j)}$ be the process that invoked $\textnormal{{apply}}(win_{j})$.

As processes $w_{\omega(j)}$ always propose the first invocation of $\textnormal{{toHelp}}_{\omega(j)}$ that was not inserted in the list yet, there is an infinite number of values $win_{j}$ such that either

• •

$w_{i,k}$ is not part of $w_{\omega(j)}$ or

• •

$w_{i,k}$ is part of $w_{\omega(j)}$, but appears after $win_{j}$ in the list.

By the eventual visibility property, the first case only concerns a finite number of $win_{j}$, so there is a finite number of values $win_{j}$ in the second case.

For each of them, by the suffixing property, $win_{j}=w_{a(j),|w_{a(j)}|}$, that is the process that invoked $\textnormal{{apply}}(win_{j})$ obtained $win_{j}$ at the last value of its $\textnormal{{toHelp}}_{a(j)}$. By the total order property, it is impossible that $p_{\omega(j)}$ obtains $win_{j}$ before $w_{i,k}$ and $p_{a(j)}$ obtains $w_{i,k}$ before $win_{j}$. Therefore $w_{a(j)}$ does not contain $w_{i,k}$. However, this contradicts the eventual visibility property that prevents an infinite number of $p_{a(j)}$ processes to ignore $w_{i,k}$.

This is a contradiction meaning the assumption of a non-wait-free execution is absurd. ∎

5 From Consensus to the Weak Log

The main difficulty in the implementation of a weak log lies in the allocation of one memory location per process, where it can safely announce its invoked operation. As it is impossible to allocate an infinite array at once, it is necessary to build a data structure in which processes allocate their own piece of memory, and make it reachable to other processes, by winning a consensus. The list of Algorithm 1 follows a similar pattern, but it poses a challenge: as an infinite number of processes access the same sequence of consensus objects, one process may loose all its attempts to insert its own node, breaking wait-freedom.

Algorithm 2 solves this issue by using a novel feature, that we call passive helping: when a process wins a consensus, it creates a side list to host values of processes concurrently competing on the same consensus object. As only a finite number of processes have arrived in the system when the consensus is won, a finite number of processes will try to insert their value in the side list, which ensures termination. Figure 1 presents an execution of Algorithm 2.

Processes executing Algorithm 2 share two variables: first and last defined as follows.

• •

first is a consensus object that accepts values of the form $\textnormal{{list}}=\langle\textnormal{{list}}.\textnormal{{head}},\textnormal{{list}}.\textnormal{{tail}}\rangle$ to be proposed, where $\textnormal{{list}}.\textnormal{{tail}}$ is a consensus object that stores values of the same type as first. $\textnormal{{list}}.\textnormal{{head}}$ is a node of the side list of the form $\textnormal{{node}}=\langle\textnormal{{node}}.\textnormal{{head}},\textnormal{{node}}.\textnormal{{tail}}\rangle$, where $\textnormal{{node}}.\textnormal{{head}}$ is a value appended by some process and $\textnormal{{node}}.\textnormal{{tail}}$ is a consensus object containing values of the same type as node. In other words, first references the beginning of a list of lists of appended values.

• •

last is a read/write register referencing a consensus object of the same type as first, and initialized to the address of first. In absence of concurrency, last references the end of the list starting with first.

When process $p_{i}$ invokes $\textnormal{{append}}(v)$, it first reads last, then it proposes a list containing $v$ as its successor and it writes the value returned by the consensus in last. If $p_{i}$ loses the consensus, it inserts $v$ in the side list of the successor (Lines 2 and 2). After that, $p_{i}$ traverses the list of lists to build the sequence $\textnormal{{log}}_{i}$ it returns ($\oplus$ represents concatenation).

Note that the consensus and the write on lines 2 and 2 are not done atomically. This means that a very old value can be written in last, in which case its value could move backward. The central property of the algorithm, proved by Lemma 3, is that last eventually moves forward, allowing very slow processes to find some place in a side list.

Lemma 3**.**

If an infinite number of processes execute line 2, then the number of processes that read the same last value at line 2 is finite.

Proof.

We first prove by induction on the list of lists of the weak log that for all $\textnormal{{list}}=\langle\textnormal{{list}}.\textnormal{{head}},\textnormal{{list}}.\textnormal{{tail}}\rangle$, the number of write operations of list in last at line 2 is finite.

• •

Initially, first is never written in last, because only decided values on line 2 are written, and first is never proposed.

• •

We now prove that, if the number of writes of list in last is finite, then the number of writes of $\textnormal{{list}}.\textnormal{{tail}}$ in last is finite.

We prove the following contrapositive proposition: if the number of writes of $\textnormal{{list}}.\textnormal{{tail}}$ in last is infinite, then the number of writes of list in last is infinite as well.

In order to write $\textnormal{{list}}.\textnormal{{tail}}$ in last, a process needs to read list in last at line 2. As $\textnormal{{list}}.\textnormal{{tail}}$ is written an infinite number of times and list is read an infinite number of times, then necessarily, list is written an infinite number of times as well.

Let us now suppose that an infinite number of processes execute line 2, and that an infinite number of reads of last return list. This implies that there was an infinite number of write operations of list in last at line 2, which contradicts the previous induction result. ∎

Lemma 4** (Validity).**

All values in the sequence $w_{i}$ have been appended by some process.

Proof.

The value log returned by the algorithm, is built by concatenation of values $\textnormal{{node}}.\textnormal{{head}}$, that can only be created on line 2 or 2, using an appended value. ∎

Lemma 5** (suffixing).**

$w_{i,|w_{i}|}=v_{i}$**

Proof.

This is a direct consequence of the fact that $v_{i}$ is appended at the end of $\textnormal{{log}}_{i}$ at line 2 just before the return statement on line 2. ∎

Definition 4 formalizes the order in which values are ordered in the weak log. Intuitively, this order is the concatenation of all the side lists. In Algorithm 2, the list of list is traversed in this precedence order, which ensures consistency of the order of all returned sequence (Total order property of the weak log).

Definition 4** (Precedence).**

A value $v_{i}$ precedes a value $v_{j}$ in the weak log if:

• •

$v_{i}$* is in a list $l_{i}$ and $v_{j}$ is in a list $l_{j}$ such that there exists a sequence of lists $\{l_{1},\dots,l_{n}\}$ such that for all $l_{k}$, $l_{k}=\langle node_{k},l_{k+1}\rangle$, and $l_{i}=\langle node_{i},l_{1}\rangle\wedge l_{n}=\langle node_{n},l_{j}\rangle$.*

• •

$v_{i}$* and $v_{j}$ are in the same list $l$ and there exists a sequence of nodes $\{n_{1},\dots,n_{n}\}$ such that for all $n_{k}$, $n_{k}=\langle v,n_{k+1}\rangle$, $n_{1}=\langle v_{i},n_{2}\rangle$ and $n_{n}=\langle v_{j},n_{n+1}\rangle$.*

We extend the notion of precedence to lists and nodes using the same definition.

Lemma 6** (Total order).**

If two processes $p_{i}$ and $p_{j}$ terminate their invocations, then all pairs of values that $w_{i}$ and $w_{j}$ both contain appear in the same order.

Proof.

Let us remark that both processes $p_{i}$ and $p_{j}$ append values in their log following the precedence order defined by Definition 4. Therefore, for any two values $v_{k}$ and $v_{l}$ that are both contained by $w_{i}$ and $w_{j}$, $p_{i}$ and $p_{j}$ have appended them at the end of the log in the same order, which proves the lemma. ∎

Lemma 7** (Eventual visibility).**

If some process $p_{i}$ terminates its invocation, then the number of returned sequences that do not contain $v_{i}$ is finite.

Proof.

Let us denote by $l_{i}$ and $n_{i}$ the values of $\textnormal{{list}}_{i}$ and $\textnormal{{node}}_{i}$ when $p_{i}$ terminates.

Let us suppose (by contradiction) that there is an infinite number of processes whose returned sequence does not contain $v_{i}$, and an infinite number of them started their operation after $p_{i}$ returned. For each process $p_{j}$ of them, let $l_{j}$ and $n_{j}$ be the values of $\textnormal{{list}}_{j}$ and $\textnormal{{node}}_{j}$ when $p_{j}$ terminates its execution. As the collect loop respects the precedence order of Definition 4, for an infinite number of $p_{j}$, $l_{j}$ precedes $l_{i}$. As there is only a finite number of lists preceding $l_{i}$ ($p_{i}$ terminates), an infinite number of processes have the same value $l$ of $l_{j}$. All of them read the same value of last at line 2 and wrote on line 2. This contradicts Lemma 3. ∎

Lemma 8** (Wait-freedom).**

No process takes an infinite number of steps in an execution.

Proof.

Let us suppose that there exists an execution $\alpha$ such that process $p_{i}$ takes an infinite number of steps in $\alpha$ trying to append $v_{i}$. This means that either of the two loops (lines 2 and 2) are looping an infinite number of times:

• •

If the loop at line 2 loops for an infinite number of times, it means that $\textnormal{{node}}.\textnormal{{head}}\neq v_{i}$ for an infinite number of nodes. This implies that an infinite number of values are appended in the same list at line 2, which means that an infinite number of processes read the same value at line 2, and wrote at line 2 which contradicts Lemma 3.

• •

If the loop at line 2 loops for an infinite number of times, this means that $p_{i}$ never reads $v_{i}$, and as there is a finite number of lists that precedes the list $l_{i}$ in which $v_{i}$ has been appended, one of these lists contains an infinite number of nodes. All these nodes were created by processes reading the same value of last in line 2, which contradicts Lemma 3.

Both cases lead to a contradiction, so the algorithm is wait-free. ∎

6 From Compare&Swap to the Weak Log

In multi-threaded environments, consensus is usually replaced by special operations like compare&swap. In this section, we replace read/write registers and consensus objects by CAS registers. A CAS register $x$ provides two operations: a read operation $x$ working as the read operation of the immutable register and a compare&swap operation $x.\textnormal{{CAS}}(\mathit{expect},\mathit{update})$ that atomically checks if the current value of $x$ is $\mathit{expect}$, changes it to $\mathit{update}$ and returns true if it is the case. If $x\neq\mathit{expect}$, then $x.\textnormal{{CAS}}(\mathit{expect},\mathit{update})$ returns false without changing the value of $x$. On the one hand, like in the finite arrival model consensus objects and CAS registers are computationally equivalent: a consensus object can be easily simulated by implementing $x.\textnormal{{propose}}(v)$ as $x.\textnormal{{CAS}}(\bot,v)$, and conversely, compare&swap can be implemented using consensus as proved in the previous section. On the other hand, compare&swap is more flexible as it allows to write several times in the same register.

Algorithm 3 presents a simplified implementation of the weak log based on CAS registers instead of consensus objects. There are two main differences between Algorithm 3 and Algorithm 2. First, values are stored in a list instead of a list of lists. Second, the list is managed as a stack, and not as a queue. Figure 2 illustrates an execution of the algorithm.

Processes share a unique CAS register last, that stores either the initial value, empty, or nodes of the form $\langle\textnormal{{head}},\textnormal{{tail}}\rangle$, where head is a value appended by a process and tail has the same type as last.

When a process invokes $\textnormal{{append}}(v)$, it first attempts to add $v$ at the top of the stack, by winning a compare&swap on last. If this attempt fails and a value $v^{\prime}$ was inserted concurrently by $p_{j}$, $p_{i}$ continuously tries to inserts $v$ after $v^{\prime}$. Similarly to Algorithm 2, $p_{i}$ eventually succeeds because it only competes in this task with the finite set of processes that read last before $p_{j}$ won its compare&swap. After $p_{i}$ inserted $v$ in the list, it traverses the list to its end to build its return sequence. Traversal is done in a last-in-first out manner, so read values are appended at the beginning of $\textnormal{{log}}_{i}$.

7 Conclusion

Consensus is a central problem in distributed computing, because it allows wait-free linearizable implementations of all objects with a sequential specification, in systems composed of $n$ asynchronous processes that may crash. In this paper, we asked the question of whether the result still hold in the infinite arrival model, in which a potentially infinite number of processes can arrive and leave during an execution. We answered this question positively by giving a wait-free and linearizable universal construction using only consensus objects and read/write registers.

Our proposed construction is based on two lists containing all the operations invoked on the object. An interesting question is whether it is possible to reduce the cost in memory by eventually removing the operations from both lists. Our approach does not allow such optimizations, as it relies on a “passive helping” mechanism, in which processes winning a consensus instance allocate memory locations to host the value of potential processes that loose all the consensus instances they are involved in.

8 Acknowledgements

This work was partially supported by the French ANR project 16-CE25-0005 O’Browser devoted to the study of decentralized applications on Web browsers.