Set-Linearizable Implementations from Read/Write Operations: Sets, Fetch &Increment, Stacks and Queues with Multiplicity

Abstract

This work consideres asynchronous shared memory systems in which any number of processes may crash. It identifies relaxations of fetch & increment, queues, sets and stacks that can be non-blocking or wait-free implemented using only Read/Write operations, without Read-After-Write synchronization patterns. Set-linearizability, a generalization of linearizability designed to specify concurrent behaviors, is used to formally express these relaxations and precisely identify the subset of executions which preserve the original sequential behavior. The specifications allow for an item to be returned more than once by different operations, but only in case of concurrency; we call such a relaxation multiplicity. Hence, these definitions give rise to new notions and new objects where concurrency explicitly appears in the specification of the objects. As far as we know, this work is the first to provide relaxations of objects with consensus number two which can be implemented using only Read/Write registers.

Missing proofs steps

This section contains the missing proof steps in the Proof of Theorem 3 in Sect. 6.

Any linearization $\textsf{SetLin} (F)$ implies a set-linearization $\textsf{SetLin} (E)$. Given any linearization $\textsf{SetLin} (F)$ of F, a set-linearization $\textsf{SetLin} (E)$ of E can be obtained as follows: every Pop operation removed from E, is added to the concurrency class of $\textsf{SetLin} (F)$ with the Pop operation returning the same item. To prove the claim, consider two operations $\textsf{op}$ and $\textsf{op}'$ of E such that $\textsf{op} <_E \textsf{op}'$. We will argue that the concurrency class of $\textsf{op}$ appears before the concurrency class of $\textsf{op}'$ in $\textsf{SetLin} (E)$, namely, $\textsf{op} <_{\textsf{SetLin} (E)} \textsf{op}'$, from which follows that $\textsf{SetLin} (E)$ is indeed a set-linearization of E (as E and $\textsf{SetLin} (E)$ have the same set of operations and with the same responses, by construction, and $\textsf{SetLin} (E)$ is a set-sequential execution of a stack with multiplicity, since $\textsf{SetLin} (F)$ is a sequential execution of the stack). We have four cases:

• 1. $\textsf{op}$ and $\textsf{op}'$ appear in F. We have that $\textsf{op} <_F \textsf{op}'$, and hence $\textsf{op} <_{\textsf{SetLin} (F)} \textsf{op}'$, since $\textsf{SetLin} (F)$ is a linearization of F. By definition of $\textsf{SetLin} (E)$, $\textsf{op} <_{\textsf{SetLin} (E)}~\textsf{op}'$.

• 2. $\textsf{op}$ appears in F and $\textsf{op}'$ does not appear in F. It must be that $\textsf{op}'$ is a Pop operation that returns an item, say x. Let $\textsf{op}''$ be the Pop operation of F that returns x. As already explained, in E, the invo-cation-response interval of $\textsf{op}'$ contains the in-vocation-response interval of $\textsf{op}''$. Then, $\textsf{op} <_E \textsf{op}''$, which implies that $\textsf{op} <_F \textsf{op}''$. Thus, $\textsf{op} <_{\textsf{SetLin} (F)} \textsf{op}''$, since $\textsf{SetLin} (F)$ is a linearization of F, and then $\textsf{op} <_{\textsf{SetLin} (E)} \textsf{op}''$, by definition of $\textsf{SetLin} (E)$. Since $\textsf{op}'$ belongs to the concurrency class of $\textsf{op}''$ in $\textsf{SetLin} (E)$, we finally have $\textsf{op} <_{\textsf{SetLin} (E)} \textsf{op}'$.

• 3. $\textsf{op}$ does not appear in F and $\textsf{op}'$ appears in F. Then, $\textsf{op}$ is a Pop operation that returns an item, say x; let $\textsf{op}''$ be the Pop operation of F that returns x. In E, the responses of $\textsf{op}$ and $\textsf{op}''$ occur at the same Take set-step in Line 06 (recall that invocations and responses of operations are identified with their firsts and lasts steps), and hence $\textsf{op}'' <_E \textsf{op}'$, which implies that $\textsf{op}'' <_F \textsf{op}'$. Thus, $\textsf{op}'' <_{\textsf{SetLin} (F)} \textsf{op}'$, since $\textsf{SetLin} (F)$ is a linearization of F, and then $\textsf{op}'' <_{\textsf{SetLin} (E)} \textsf{op}'$, by definition of $\textsf{SetLin} (E)$. Since $\textsf{op}$ belongs to the concurrency class of $\textsf{op}''$ in $\textsf{SetLin} (E)$, we have $\textsf{op} <_{\textsf{SetLin} (E)} \textsf{op}'$.

• 4. $\textsf{op}$ and $\textsf{op}'$ does not appear in F. In this case $\textsf{op}$ and $\textsf{op}'$ are Pop operations that return distinct items, say x and y, respectively. Let $\textsf{op}''$ and $\textsf{op}'''$ be the Pop operations of F that return x and y, respectively. Using a similar reasoning as in the previous two cases, we can show that $\textsf{op}'' <_{\textsf{SetLin} (E)} \textsf{op}'''$, and then $\textsf{op} <_{\textsf{SetLin} (E)} \textsf{op}'$, as $\textsf{op}$ and $\textsf{op}'$ belong to the concurrency classes of $\textsf{op}''$ and $\textsf{op}'''$ in $\textsf{SetLin} (E)$, respectively.

Any execution F of Set-Seq-Stack can be transformed in an execution H of Seq-Stack. To formalizes the transformation, some definitions are presented, considering the state of the shared base object at the end of F. Let $Top\_sets$ itself denote its content at the end of F. For each $q \ge 1$, let $S_q$ be the set containing every item x such that $\textsf{Push} (x)$ appears in F and the operation obtains q in its step in Line 01. We have that: (1) for every $\textsf{Push} (x)$ in F, there is a set $S_q$ containing x, by definition of the sets $S_q$; (2) for every $q \ge Top\_set$, $S_q$ is empty, by de specification of readable Fetch &Inc with multiplicity; (3) for every $q <Top\_set$, $S_q$ is non-empty, by de specification of readable Fetch &Inc with multiplicity; (4) for every two distinct $q, r < Top\_set$, $S_q$ and $S_r$ are disjoint, since every item is pushed at most once, by assumption. For each $x \in S_q$, let set(x) be the integer q. Also let $|S_{\le q}|$ denote the sum $|S_1| + |S_2| + \ldots + |S_q|$, and let $|S_0|$ denote 0. From now on, we consider only sets $S_q$ with $1 \le q <Top\_set$. Each such set defines a segment of $Items[1, 2, \ldots , |S_{\le Top\_set - 1}|]$, whose length equals the cardinality of the set. Specifically, $S_q$ defines the segment $Items[|S_{\le {q-1}}|+1, \ldots , |S_{\le {q}}|]$; alternatively, we say that the segment is defined by $S_q$.

We now assign each item in $S_q$ to and entry in the segment defined by $S_q$. To do so, we define a strict partial order $\prec$ over the items in $S_q$, and then extend it to a total order from which the assignment is directly obtained. We define $\prec$ by considering the steps $Sets[q].\textsf{Take}$ in F, that correspond to Line 06. Let e be any of these steps that returns an item, say x, and let (T, r) be the state of the set Sets[q] right before e. Then, $x \in T$. For every $y \in T$ distinct to x, we add the relation $y \prec x$. We do the same with any such step e. All $Sets[q].\textsf{Take}$ steps that return $(\emptyset , \cdot )$ do not add any relation. We have that $\prec$ is irreflexive (as every item is pushed at most one, by assumption) and antisymmetric (as once $y \prec x$ is set, x is removed from Sets[q] and never pushed again). Consider the transitive extension of $\prec$, and consider any linear extension of the resulting strict partial order. By abuse of notation, let $\prec$ denote that total order. Let us denote the items in $S_q$ as $x_0, x_1, \ldots , x_{|S_q|-1}$ such that $x_0 \prec x_1 \prec \ldots \prec x_{|S_q|-1}$. Then, each $x_i$ is assigned to $Items[|S_{\le {q-1}}|+1+i]$; namely, $x_0$ is assigned to $Items[|S_{\le {q-1}}|+1]$, $x_1$ to $Items[|S_{\le {q-1}}|+2]$, and so on, up to $x_{|S_q|-1}$ that is assigned to $Items[|S_{\le {q-1}}|+1+|S_q|-1] = Items[|S_{\le {q}}|]$. For each $x_i \in S_q$, let $id(x_i)$ denote $|S_{\le {q-1}}|+1+i$, i..e. the index of Items that is assigned to.

We are now ready to explain in detail how F is transformed into H, arguing during the explanation that H is actually an execution of Seq-Stack (Fig. 3). We take any operation in F and replace its steps with steps of Seq-Stack with consistent responses.

• Push operations. Let e denote any set-step $Tos\_top$.

  $\mathsf{Fetch \& Inc}$ in F. Then, e contains steps that correspond to Line 01 and are of some concurrent Push operations of F. Observe that the set $S_q$ as defined above contains the items pushed by these operations, where q is the value that the Fetch &Inc ’s return in e (hence e contains as many Fetch &Inc operations as the number of items in $S_q$, and the state of $Top\_sets$ right before e is q). Let $x_0, x_0, \ldots , x_{|S_q|-1}$ denote the items in $S_q$ such that $id(x_1)< id(x_2)< \ldots < id(x_{|S_q|-1})$. By definition, $id(x_i) = |S_{\le {q-1}}|+1+i$. Now, in H, e is replaced with a sequence of steps $Top.\mathsf{Fetch \& Inc}$, each of them corresponding to a step in Line 01 of Seq-Stack (Fig. 3). Concretely, e is replaced with the next sequence with $|S_q|$ steps:

  $$ \begin{aligned}&\langle Top.\mathsf{Fetch \& Inc} ():id(x_0) \rangle ,\\&\langle Top.\mathsf{Fetch \& Inc} ():id(x_1) \rangle ,\\&\vdots \\&\langle Top.\mathsf{Fetch \& Inc} ():id(x_{|S_q|-1}) \rangle , \end{aligned}$$

  where $\langle Top.\mathsf{Fetch \& Inc} ():id(x_i) \rangle$ corresponds to the step of $\textsf{Push} (x_i)$ in Line 01, in H. Observe that in H, Top’s content before the sequence that replaces e is $id(x_0) = |S_{\le {q-1}}|+1$, and its content after the sequence is $id(x_{|S_q|-1})+1 = |S_{\le {q}}|+1$, which is consistent with the specifications of Fetch &Inc. Thus, Top follows the specification of Fetch &Inc in H. Consider any $\textsf{Push} (x)$ in F. We just said how its step in Line 01 is replaced in H. We now deal with its step $Sets[set(x)].\textsf{Put} (x)$ corresponding to Line 02, which will be denoted e: the step is simply replaced with $\langle Items[id(x)].\textsf{Write} (x): \textsf{true} \rangle$; this step is of $\textsf{Push} (x)$ in H and corresponds to Line 02 of Seq-Stack (Fig. 3), and will be denoted H(e). Note that in H, the step of $\textsf{Push} (x)$ corresponding to Line 01 obtains id(x), as defined above, and hence it is consistent with Seq-Stack that $\textsf{Push} (x)$ writes in Items[id(x)]. Also observe that in F, the set in Sets[set(x)] contains x right after e happens, and in H, the segment of Items defined by $S_{set(x)}$ contains x in its entry Items[id(x)] right after H(e) happens.

• Pop operations. Consider any Pop operation of F, and let e be its $Top\_sets.\textsf{Read}$ step corresponding to Line 04. In H, this step is replaced with $\langle Top.\textsf{Read} (): |S_{\le q}|+1 \rangle$, where $q+1$ is the content of $Tops\_sets$ at e; let H(e) denote that step of H, which corresponds to a step of Line 04 of Seq-Stack (Fig. 3). We argue that the response of e(H) in H is consistent. Prior to e in F, there are q set-steps that correspond to $Top\_sets.\mathsf{Fetch \& Inc}$ in Line 01; these q set-steps are replaced in H as mentioned above. By construction, the content of Top in H right before e(H) is $|S_{\le {q}}|+1$, from which follows that the response of H(e) in H is consistent. Consider now any step $Sets[q].\textsf{Take}$ of the same Pop operation, which corresponds to a step in Line 06. Let e denote that step. Consider the set $S_q$ as defined before, and let $x_0, x_0, \ldots , x_{|S_q|-1}$ denote the items in $S_q$ such that $id(x_1)< id(x_2)< \ldots < id(x_{|S_q|-1})$. Suppose first that e returns y. By definition, $y \in S_q$. Let $x_i$ such that $y = x_i$. Then, e is replaced in H with the next sequence of steps, which will be denoted H(e):

  $$\begin{aligned}&\langle Items[id(x_{|S_q|-1})].\textsf{Swap} (\bot ):\bot \rangle ,\\&\vdots \\&\langle Items[id(x_{i+1})].\textsf{Swap} (\bot ):\bot \rangle ,\\&\langle Items[id(x_i)].\textsf{Swap} (\bot ):x_i \rangle . \end{aligned}$$

  These steps correspond to steps in Line 06 of Seq-Stack (Fig. 3), all of them of the same Pop operation in H. The set Sets[q] contains $x_i$ right before e, in F. Therefore, the response in the step $\langle Items[id(x_i)].\textsf{Swap} (\bot ):x_i \rangle$ in H(e) is consistent; note that $x_i$ does not appear in the segment defined by $S_q$ after H(e) in H. We argue that the responses in the steps in H(e) before $\langle Items[id(x_i)].\textsf{Swap} (\bot ):x_i \rangle$ are consistent too. The only way one of these responses is inconsistent is if in F, Sets[q] contains an item z right before e, and $z = x_j$ with $id(x_j) > id(x_i)$. Namely, $\langle Items[id(x_j)].\textsf{Swap} (\bot ):\bot \rangle$ appears before $\langle Items[id(x_i)].\textsf{Swap} (\bot ):x_i \rangle$ in H(e) (and hence the response in $\langle Items[id(x_j)].\textsf{Swap} (\bot ):\bot \rangle$ is incorrect in H because $Items[id(x_j)] = x_j$ right before e(H)). But this cannot happen, because $x_j \prec x_i$, by definition of of the relation $\prec$, and hence, the index assigned to $x_j$ is smaller than the index assigned to $x_i$, namely, $id(x_j) < id(x_i)$, from which follows that $\langle Items[id(x_j)].\textsf{Swap} (\bot ):\bot \rangle$ does not even appear in H(e). Thus, all responses in H(e) that replace e are consistent. To conclude the transformation, suppose that e returns $(\emptyset ,\cdot )$. Then, e is replaced in H with the sequence of steps:

  $$\begin{aligned}&\langle Items[id(x_{|S_q|-1})].\textsf{Swap} (\bot ):\bot \rangle ,\\&\vdots \\&\langle Items[id(x_1)].\textsf{Swap} (\bot ):\bot \rangle ,\\&\langle Items[id(x_0)].\textsf{Swap} (\bot ):\bot \rangle . \end{aligned}$$

  As Sets[q] is empty right before e in F, all responses in the sequence are consistent. The transformation from F to H is complete.