#
Relaxed Data Types as Consistency Conditions ^{†}

^{*}

^{†}

^{‡}

## Abstract

**:**

## 1. Introduction and Background

## 2. Model

#### 2.1. Data Types

**Definition**

**1.**

- 1.
- A set $OPS$ of operations and the sets $args\left(OP\right)$ of valid arguments and $rets\left(OP\right)$ of valid return values for each $OP\in OPS$. An instance of an operation $OP$, denoted $OP(arg,ret)$, contains the argument(s) $arg$ and the value(s) returned, $ret$. In a sequential environment, instances are indivisible, but we will consider them as a distinct invocation and matching response in the distributed setting.When either $args\left(OP\right)$ or $rets\left(OP\right)$ contains only a null value (⊥), we condense the notation to $OP\left(arg\right)$ or $OP\left(ret\right)$, as appropriate.
- 2.
- A set $\mathcal{L}$ of sequences of operation instances, called legal sequences , which satisfies two properties:
- (a)
- Prefix Closure: If a sequence ρ is in $\mathcal{L}$, then every prefix of ρ is also in $\mathcal{L}$.
- (b)
- Completeness: If a sequence ρ is in $\mathcal{L}$, then for every operation $OP\in OPS$ and every argument $arg$ for $OP$, there is a response $ret$ such that $\rho .OP(arg,ret)$ is in $\mathcal{L}$, where “.” represents concatenation of sequences.

**Definition**

**2.**

**Definition**

**3**(Read/Write Register)

**.**

- 1.
- $OPS=\{Read,Write\}$, $args\left(Read\right)=\{\perp \}$, $rets\left(Read\right)=\mathbb{Z}$,$args\left(Write\right)=\mathbb{Z}$, and $rets\left(Write\right)=\{\perp \}$.
- 2.
- $\mathcal{L}$ is the set of all sequences in which every $Write$ instance returns ⊥ and every $Read$ instance returns the argument of the last $Write$ instance preceding it.

**Definition**

**4**(FIFO Queue)

**.**

- 1.
- $OPS=\{Enqueue,Dequeue\}$,$args\left(Enqueue\right)=\mathbb{Z}$, $rets\left(Enqueue\right)=\{\perp \}$,$args\left(Dequeue\right)=\{\perp \}$, and $rets\left(Dequeue\right)=\mathbb{Z}$.
- 2.
- $\mathcal{L}$ is the set of all sequences in which every $Enqueue$ instance returns ⊥ and every $Dequeue$ instance returns the argument of the first $Enqueue$ instance whose argument has not yet been returned by a $Dequeue$ or ⊥ if no such $Enqueue$ instance exists.

#### 2.2. Consistency Conditions

**Definition**

**5.**

**Definition**

**6**(Linearizability)

**.**

## 3. Relaxed Data Types

**Definition**

**7**(k-Out-of-Order Relaxed ADT)

**.**

- 1.
- $OPS\left({T}^{\prime}\right)=OPS\left(T\right)$
- 2.
- A sequence Π of operation instances is legal in ${T}^{\prime}$ if for every instance $op$ where $\Pi =\pi .op.\rho $, there is some sequence $u.v.w,\left|v\right|\le k$, which is a minimum-length sequence equivalent in T to π, and there exists a sequence x, where
- (a)
- $u.w$ is legal in T and minimum-length among the set of sequences equivalent to it in T;
- (b)
- $u.w.op$ is legal in T; and
- (c)
- i.
- $u.w.op\equiv x.w$ and $\pi .op\equiv x.v.w$ or
- ii.
- $u.w.op\equiv u.x$ and $\pi .op\equiv u.v.x$.

**Definition**

**8**(k-Lateness Relaxed ADT)

**.**

- 1.
- $OPS\left({T}^{\prime}\right)=OPS\left(T\right)$
- 2.
- A sequence Π of operation instances is legal in ${T}^{\prime}$ if for every instance $op$ such that $\Pi =\pi .op.\rho $, there exists $l\ge 0$ such that $\pi .op$ is legal by the semantics of an l-Out-of-Order relaxed T, and at least one in every k consecutive mutator instances in ${\Pi |}_{m}$ must have $l=0$.

**Definition**

**9**(k-Stuttering Relaxed ADT)

**.**

- 1.
- $OPS\left({T}^{\prime}\right)=OPS\left(T\right)$.
- 2.
- A sequence $\Pi =o{p}_{1}.o{p}_{2}...$ of operation instances is legal in ${T}^{\prime}$ if for every $o{p}_{i}$, with$\Pi ={\pi}_{i}.o{p}_{i}.{\rho}_{i}$, $o{p}_{i}$ returns a value such that ${\pi}_{i}^{\prime}.o{p}_{i}$ is legal in T, where ${\pi}_{i}^{\prime}$ is a sequence of mutator instances such that:
- (a)
- ${\pi}_{1}^{\prime}=\epsilon $, the empty sequence;
- (b)
- ${\pi}_{i}^{\prime}\in \{{\pi}_{i-1}^{\prime},{\pi}_{i-1}^{\prime}.o{p}_{i-1}\}$ for $i>1$; and
- (c)
- ${\pi}_{i}^{\prime}$ includes at least one of every k consecutive mutators in ${\pi}_{i}$.

## 4. Converting Relaxations to Consistency Conditions

**Definition**

**10**(OutofOrderCC(k))

**.**

- 1.
- There exists a permutation Π of all operation instances in the schedule, which respects the schedule order of non-overlapping instances.
- 2.
- For every $op\in \Pi $, with $\Pi =\pi .op.\rho $, there is some sequence $u.v.w$, $\left|v\right|\le k$, which is a minimum-length sequence equivalent in T to π, and there exists a sequence x, such that:
- (a)
- $u.w$ is legal in T and minimum-length among the set of sequences equivalent to it in T;
- (b)
- $u.w.op$ is legal in T; and
- (c)
- i.
- $u.w.op\equiv x.w$ and $\pi .op\equiv x.v.w$, or
- ii.
- $u.w.op\equiv u.x$ and $\pi .op\equiv u.v.x$.

**Theorem**

**1.**

**Definition**

**11**(LatenessCC(k))

**.**

- 1.
- There exists a permutation Π of all operation instances in the schedule which respects the schedule order of non-overlapping instances.
- 2.
- For every $op\in \Pi $, with $\Pi =\pi .op.\rho $, there exists $l\ge 0$ such that $\pi .op$ is legal by the semantics of an l-Out-of-Order relaxed T, and at least one in every k consecutive mutator instances in Π must have $l=0$.

**Theorem**

**2.**

**Definition**

**12**(StutteringCC(k))

**.**

- 1.
- There exists a permutation $\Pi =o{p}_{1}.o{p}_{2}...$ of all operation instances in the schedule, respecting the schedule order of non-overlapping instances.
- 2.
- For every instance $o{p}_{i}$ in Π, let $\Pi ={\pi}_{i}.o{p}_{i}.{\rho}_{i}$. $o{p}_{i}$ returns a value that such that ${\pi}_{i}^{\prime}.o{p}_{i}$ is legal in T, where ${\pi}_{i}^{\prime}$ is a sequence of mutator instances such that:
- (a)
- ${\pi}_{1}^{\prime}=\epsilon $;
- (b)
- ${\pi}_{i}^{\prime}\in \{{\pi}_{i-1}^{\prime},{\pi}_{i-1}^{\prime}.o{p}_{i-1}\}$, for $i>1$; and
- (c)
- ${\pi}_{i}^{\prime}$ includes at least one of every k consecutive mutators in ${\pi}_{i}$

**Theorem**

**3.**

## 5. Consistency Condition to Relaxation

#### k-Atomicity

**Definition**

**13**(k-Atomicity)

**.**

**Definition**

**14**(k-Atomic-Equiv Relaxed ADT)

**.**

- 1.
- $OPS\left({T}^{\prime}\right)=OPS\left(T\right)$.
- 2.
- ${\mathcal{L}}_{{\mathcal{T}}^{\prime}}$ is the set of sequences Π, where for each accessor instance $op$, with $\Pi =\pi .op.\rho $, there exists a sequence ${\pi}^{\prime}$ such that ${\pi}^{\prime}.op$ is legal in T, where ${\pi}^{\prime}$ is obtained by removing up to k consecutive instances from the end of ${\pi |}_{m}$.

**Theorem**

**4.**

## 6. Placing New Consistency Conditions

**Definition**

**15.**

**Definition**

**16**(k-Regularity)

**.**

- 1.
- if $op$ is a mutator or overlaps with no mutator instances, ${\pi |}_{m}.op$ is legal by k-Atomicity; and
- 2.
- if $op$ is an accessor overlapping with at least one other mutator, there exists a sequence ${\pi}^{\prime}$ such that ${\pi}^{\prime}.op$ is legal in T, where ${\pi}^{\prime}$ is constructed either by deleting up to k instances from the end of ${\pi |}_{m}$ or by moving any subset of the mutator instances overlapping with $op$ from after $op$ in Π to before it and placing them in some order.

**Definition**

**17**(k-Safety)

**.**

- 1.
- if $op$ is a mutator or overlaps with no mutator instances, ${\pi |}_{m}.op$ is legal by k-Atomicity; and
- 2.
- if $op$ is an accessor overlapping with at least one other mutator, it may return any value in $rets\left(OP\right)$.

**Theorem**

**5**

- If we can show that a consistency condition C does not contain (is not weaker than) k-Atomicity, then we immediately know that C is not weaker than either k-Regularity or k-Safety. This follows from the fact that, whatever element in k-Atomicity is not in C is also in the supersets k-Regularity and k-Safety, showing that they are not contained in C.
- Conversely, if k-Safety does not contain C, then neither k-Regularity nor k-Atomicity can contain C. This is because k-Regularity and k-Atomicity are subsets of k-Safety, and thus also do not contain any element which is not in k-Safety. Since k-Safety does not contain C, such an element must exist in C. Thus, we know that C is not stronger than any of the three.

**Theorem**

**6.**

- 1.
- For all $k,l\ge 1$, OutofOrderCC$\left(k\right)$ is incomparable with any of l-Safety, l-Regularity, and l-Atomicity.
- 2.
- For all $k\ge 2$ and $l\ge 1$, LatenessCC$\left(k\right)$ is incomparable with any of l-Safety, l-Regularity, and l-Atomicity.
- 3.
- For all $k\ge 2$ and $l\ge 1$, StutteringCC$\left(k\right)$ is incomparable with any of l-Safety, l-Regularity, and l-Atomicity.

**Proof.**

- OutofOrderCC$\left(k\right)$:
- To show that OutofOrderCC$\left(k\right)$ does not contain l-Atomicity, consider the following sequential schedule of a register:$$Write\left(1\right).Write\left(2\right).Read\left(1\right)$$For every $l\ge 1$, this schedule is legal under l-Atomicity, since the $Read$ can ignore the presence of the last preceding mutator instance, the $Write\left(2\right)$. This schedule is not legal under OutofOrderCC$\left(k\right)$, for any $k\ge 1$, as the minimal-length equivalent sequence to $Write\left(1\right).Write\left(2\right)$ is simple $Write\left(2\right)$, and $Read\left(1\right)$ is not legal after any sequence obtained by deleting instances from this.
- To show that OutofOrderCC$\left(k\right)$ is not contained in l-Safety, consider the following sequential schedule of a restricted FIFO queue:$$Enqueue\left(1\right).Enqueue\left(2\right).Peek\left(2\right)$$This is legal under OutofOrderCC$\left(k\right)$, for every $k\ge 1$, as the prefix $Enqueue\left(1\right).Enqueue\left(2\right)$ is a minimal-length sequence equivalent to itself, and $Peek\left(2\right)$ is legal after the sequence $Enqueue\left(2\right)$ obtained by removing one mutator instance. This schedule is not legal under l-Safety, for any $l\ge 1$, since none of the instances are concurrent, and $Peek\left(2\right)$ is not legal after any sequence obtained by deleting consecutive mutators from the end of the preceding sequence. Thus, OutofOrderCC$\left(k\right)$ is not a subset of l-Safety and is thus not stronger than any of l-Safety, l-Regularity, and l-Atomicity.

- LatenessCC$\left(k\right)$:
- Consider this sequential schedule of a register:$$Write\left(1\right).Write\left(2\right).Read\left(1\right)$$This schedule is legal under l-Atomicity, for $l\ge 1$, since the first two instances are legal in a register, and the $Read\left(1\right)$ is legal after the sequence obtained by ignoring the last previous mutator. This schedule is not legal under LatenessCC$\left(k\right)$, $k\ge 2$, since the minimal-length equivalent sequence of $Write\left(1\right).Write\left(2\right)$ is $Write\left(2\right)$, so $Read\left(1\right)$ is not legal after any sequence obtained by deleting instances from a minimal sequence equivalent to the sequence of preceding instances.
- Consider the following sequential schedule of a restricted FIFO queue:$$Enqueue\left(1\right).Enqueue\left(2\right).Peek\left(2\right)$$This schedule is legal under LatenessCC$\left(k\right)$, for $k\ge 2$, since $Enqueue\left(1\right).Enqueue\left(2\right)$ is legal in a FIFO queue and $Peek\left(2\right)$ is legal after the sequence $Enqueue\left(2\right)$ obtained by removing one instance, which is allowed because $Enqueue\left(1\right).Enqueue\left(2\right)$ is a minimal-length equivalent sequence of itself. This schedule is not legal under l-Safety, for any $l\ge 1$, because $Peek\left(2\right)$ is not concurrent with any mutator and not legal after any sequence obtained by deleting instances from the end of $Enqueue\left(1\right).Enqueue\left(2\right)$.

- StutteringCC$\left(k\right)$:
- Consider the following sequential schedule of a register:$$Write\left(1\right).Write\left(2\right).Read\left(1\right).Read\left(2\right)$$This schedule is legal under l-Atomicity, $l\ge 1$, since the first $Read$ instance may ignore the last previous mutator, while the second $Read$ may see it. For $k\ge 2$, this schedule is not legal under StutteringCC$\left(k\right)$, as the first $Read$ may only return 1 if $Write\left(2\right)$ stuttered, but then no succeeding $Read$ can see the $Write\left(2\right)$.
- Consider the following sequential schedule of a restricted FIFO queue:$$Enqueue\left(1\right).Enqueue\left(2\right)\dots Enqueue(k-1).Enqueue\left(k\right)\dots Enqueue(k+l).Peek\left(k\right)$$This schedule is legal under StutteringCC$\left(k\right)$, $k\ge 2$ (Recall that StutteringCC$\left(1\right)$ is merely Linearizability), since the first $k-1$$Enqueue$ instances may stutter, leaving $Peek\left(k\right)$ legal after the prefix $Enqueue\left(k\right)\dots Enqueue(k+l)$. This schedule is not legal under l-Safety, $l\ge 1$, since the $Peek$ is not concurrent with any mutator and ignoring up to l of the last previous mutators will not allow $Peek$ to return any value besides 1.

**Theorem**

**7.**

**Proof.**

**Theorem**

**8.**

**Proof.**

- First, we compare OutofOrderCC$\left(k\right)$ and LatenessCC$\left(l\right)$, showing that neither condition contains the other.
- On a FIFO queue, the sequential schedule$$Enqueue\left(1\right)\dots Enqueue(l+2).Dequeue\left(2\right)\dots Dequeue(l+2)$$
- On a FIFO queue, the sequential schedule$$Enqueue\left(1\right)\dots Enqueue(k+2).Dequeue(k+2)$$

- Next, we compare OutofOrderCC$\left(k\right)$ and StutteringCC$\left(m\right)$:
- Consider the following sequential schedule of a FIFO queue:$$Enqueue\left(1\right).Enqueue\left(2\right).Dequeue\left(2\right).Dequeue\left(1\right)$$This schedule is legal under OutofOrderCC$\left(k\right)$, since removing $Enqueue\left(1\right)$, which is already minimal-length, from the preceding sequence gives $Enqueue\left(2\right).Dequeue\left(2\right)$, which is legal in a FIFO queue. The prefix of the first three instances is then equivalent to $Enqueue\left(1\right)$, and $Enqueue\left(1\right).Dequeue\left(1\right)$ is legal, so the entire sequence is legal. This schedule is not legal under StutteringCC$\left(m\right)$, because ${\pi}^{\prime}$ for $Dequeue\left(2\right)$ must not include $Enqueue\left(1\right)$, so no later ${\pi}^{\prime}$ may include $Enqueue\left(1\right)$ and 1 cannot be returned by a $Dequeue$. In other words, $Enqueue\left(1\right)$ stutters, having no effect, so the second $Dequeue$ instance cannot return 1.
- Consider the following sequential schedule of a FIFO queue:$$Enqueue\left(1\right).Dequeue\left(1\right).Dequeue\left(1\right)$$This schedule is legal under StutteringCC$\left(m\right)$, but not under OutofOrderCC$\left(k\right)$. In StutteringCC$\left(m\right)$, ${\pi}^{\prime}$ for the first $Dequeue$ instance is $Enqueue\left(1\right)$, leaving out no previous instances. This $Dequeue$ instance stutters, having no effect, so ${\pi}^{\prime}$ for the second $Dequeue$ is $Enqueue\left(1\right)$, and thus ${\pi}^{\prime}.Dequeue\left(1\right)$ is legal. For OutofOrderCC$\left(k\right)$, the empty sequence $\epsilon $ is the minimal-length equivalent sequence of $Enqueue\left(1\right).Dequeue\left(1\right)$ and, since $\epsilon .Dequeue\left(1\right)$ is not legal in a FIFO queue, the original schedule is not legal.

- Finally, compare LatenessCC$\left(l\right)$ and StutteringCC$\left(m\right)$:
- On a FIFO queue, the sequential schedule$$Enqueue\left(1\right)\dots Enqueue(m+2).Dequeue(m+2)$$
- The sequential schedule$$Enqueue\left(1\right).Dequeue\left(1\right).Dequeue\left(1\right)$$

## 7. Application: Hybrid Consistencies

**Definition**

**18**(Consistency Condition for Register with Strong and Weak Writes)

**.**

- 1.
- Each $Read$ instance returns the argument of the previous $Write$ instance in Π or ⊥ if there is none.
- 2.
- If $o{p}_{1}$ and $o{p}_{2}$ are instances in Π where $o{p}_{1}$ precedes $o{p}_{2}$ in the schedule order and either at least one is a $Writ{e}_{s}$ instance or both are $Read$ instances, then $o{p}_{1}$ precedes $o{p}_{2}$ in Π.

**Definition**

**19**(Register with Strong and Weak Writes)

**.**

- 1.
- $OPS=\{Read,Writ{e}_{s},Writ{e}_{w}\}$
- 2.
- $\mathcal{L}$ is the set of all sequences of instances of operations in $OPS$ such that each $Read$ instance $rop$ returns the argument of any $Write$ instance $wop$ ($Writ{e}_{s}$ or $Writ{e}_{w}$) starting with the latest preceding $Writ{e}_{s}$ (or ⊥ if there is no preceding $Writ{e}_{s}$) up to and not including the next $Writ{e}_{s}$, such that no previous $Read$ returned the argument of a $Write$ instance later than $wop$.

**Definition**

**20**(Hybrid Consistency for Queues with Weak Peek)

**.**

- 1.
- ${\Pi |}_{\{Enqueue,Dequeue\}}$ is legal by the specification of a FIFO queue and
- 2.
- Each $Peek$ instance $op$ with $\Pi =\pi .op.\rho $ returns a value such that ${\pi}^{\prime}.op$ is legal, where ${\pi}^{\prime}$ is obtained by deleting a contiguous sequence of up to k instances from a minimal-length sequence equivalent to π. That is, $op$ returns one of the k oldest elements currently in the queue and may return ⊥ if there are fewer than k elements currently in the queue.

**Definition**

**21**(Augmented FIFO Queue with Relaxed Peek)

**.**

- 1.
- $OPS=\{Enqueue,Dequeue,Peek\}$
- 2.
- $\mathcal{L}$ is the set of all sequences of instances of operations in $OPS$ such that each $Dequeue$ instance returns the argument of the first $Enqueue$ instance whose argument has not previously been returned by a $Dequeue$ instance or ⊥ if none exists. Each $Peek$ instance returns the argument of one of the first k$Enqueue$ instances whose arguments have not been returned by a previous $Dequeue$ instance or possibly ⊥ if there are fewer than k such $Enqueue$ instances.

## 8. Conclusions and Future Work

## Author Contributions

## Acknowledgments

## Conflicts of Interest

## References

- Herlihy, M.; Wing, J.M. Linearizability: A Correctness Condition for Concurrent Objects. ACM Trans. Program. Lang. Syst.
**1990**, 12, 463–492. [Google Scholar] [CrossRef] - Attiya, H.; Guerraoui, R.; Hendler, D.; Kuznetsov, P.; Michael, M.M.; Vechev, M.T. Laws of order: Expensive synchronization in concurrent algorithms cannot be eliminated. In Proceedings of the 38th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2011, Austin, TX, USA, 26–28 January 2011; Ball, T., Sagiv, M., Eds.; ACM: New York, NY, USA, 2011; pp. 487–498. [Google Scholar]
- Attiya, H.; Welch, J.L. Sequential Consistency versus Linearizability. ACM Trans. Comput. Syst.
**1994**, 12, 91–122. [Google Scholar] [CrossRef] - Lipton, R.J.; Sandberg, J.S. PRAM: A Scalable Shared Memory; Technical Report CS-TR-180-88; Department of Computer Science, Princeton University: Princeton, NJ, USA, 1988. [Google Scholar]
- Wang, J.; Talmage, E.; Lee, H.; Welch, J.L. Improved Time Bounds for Linearizable Implementations of Abstract Data Types. In Proceedings of the 2014 IEEE 28th International Parallel and Distributed Processing Symposium, IEEE Computer Society, Phoenix, AZ, USA, 19–23 May 2014; pp. 691–701. [Google Scholar]
- Talmage, E.; Welch, J.L. Improving Average Performance by Relaxing Distributed Data Structures. In Proceedings of the 28th International Symposium on Distributed Computing, DISC 2014, Austin, TX, USA, 12–15 October 2014; Lecture Notes in Computer Science. Kuhn, F., Ed.; Springer: Berlin, Germany, 2014; Volume 8784, pp. 421–438. [Google Scholar]
- Viotti, P.; Vukolic, M. Consistency in Non-Transactional Distributed Storage Systems. ACM Comput. Surv.
**2016**, 49. [Google Scholar] [CrossRef] - Shapiro, M.; Preguiça, N.M.; Baquero, C.; Zawirski, M. Conflict-Free Replicated Data Types. In Proceedings of the 13th International Symposium on Stabilization, Safety, and Security of Distributed Systems, Grenoble, France, 10–12 October 2011; Lecture Notes in Computer Science. Défago, X., Petit, F., Villain, V., Eds.; Springer: Berlin, Germany, 2011; Volume 6976, pp. 386–400. [Google Scholar]
- Afek, Y.; Korland, G.; Yanovsky, E. Quasi-Linearizability: Relaxed Consistency for Improved Concurrency. In Proceedings of the 14th International Conference on Principles of Distributed Systems, OPODIS 2010, Tozeur, Tunisia, 14–17 December 2010; Lecture Notes in Computer Science. Lu, C., Masuzawa, T., Mosbah, M., Eds.; Springer: Berlin, Germany, 2010; Volume 6490, pp. 395–410. [Google Scholar]
- Henzinger, T.A.; Kirsch, C.M.; Payer, H.; Sezgin, A.; Sokolova, A. Quantitative relaxation of concurrent data structures. In Proceedings of the 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL’13, Rome, Italy, 23–25 January 2013; Giacobazzi, R., Cousot, R., Eds.; ACM: New York, NY, USA, 2013; pp. 317–328. [Google Scholar]
- Alistarh, D.; Kopinsky, J.; Li, J.; Shavit, N. The SprayList: A scalable relaxed priority queue. In Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2015, San Francisco, CA, USA, 7–11 February 2015; Cohen, A., Grove, D., Eds.; ACM: New York, NY, USA, 2015; pp. 11–20. [Google Scholar]
- Kirsch, C.M.; Lippautz, M.; Payer, H. Fast and Scalable k-FIFO Queues; Technical Report 2012-04; Department of Computer Sciences, University of Salzburg: Salzburg, Austria, 2012. [Google Scholar]
- Rihani, H.; Sanders, P.; Dementiev, R. Brief Announcement: MultiQueues: Simple Relaxed Concurrent Priority Queues. In Proceedings of the 27th ACM on Symposium on Parallelism in Algorithms and Architectures, SPAA 2015, Portland, OR, USA, 13–15 June 2015; Blelloch, G.E., Agrawal, K., Eds.; ACM: New York, NY, USA, 2015; pp. 80–82. [Google Scholar]
- Wimmer, M.; Gruber, J.; Träff, J.L.; Tsigas, P. The lock-free k-LSM relaxed priority queue. In Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2015, San Francisco, CA, USA, 7–11 February 2015; Cohen, A., Grove, D., Eds.; ACM: New York, NY, USA,, 2015; pp. 277–278. [Google Scholar]
- Shavit, N.; Taubenfeld, G. The computability of relaxed data structures: Queues and stacks as examples. Distrib. Comput.
**2016**, 29, 395–407. [Google Scholar] [CrossRef] - Talmage, E.; Welch, J.L. Anomalies and Similarities Among Consensus Numbers of Relaxed Queues. In Proceedings of the 5th Edition of the International Conference on Networked Systems, NETYS 2017, Marrakech, Morocco, 17–19 May 2017; Lecture Notes in Computer Science. Abbadi, A.E., Garbinato, B., Eds.; Springer: Berlin, Germany, 2017; Volume 10299. [Google Scholar]
- Michael, M.M.; Vechev, M.T.; Saraswat, V.A. Idempotent work stealing. In Proceedings of the 14th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2009, Raleigh, NC, USA, 14–18 February 2009; Reed, D.A., Sarkar, V., Eds.; ACM: New York, NY, USA, 2009; pp. 45–54. [Google Scholar]
- Payer, H.; Röck, H.; Kirsch, C.M.; Sokolova, A. Scalability versus semantics of concurrent FIFO queues. In Proceedings of the 30th Annual ACM Symposium on Principles of Distributed Computing, PODC 2011, San Jose, CA, USA, 6–8 June 2011; Gavoille, C., Fraigniaud, P., Eds.; ACM: New York, NY, USA, 2011; pp. 331–332. [Google Scholar]
- Bermbach, D.; Kuhlenkamp, J. Consistency in Distributed Storage Systems - An Overview of Models, Metrics and Measurement Approaches. In Proceedings of the First International Conference on Networked Systems, NETYS 2013, Marrakech, Morocco, 2–4 May 2013; Lecture Notes in Computer Science. Gramoli, V., Guerraoui, R., Eds.; Springer: Berlin, Germany, 2013; Volume 7853, pp. 175–189. [Google Scholar]
- Friedman, R.; Vitenberg, R.; Chockler, G.V. On the composability of consistency conditions. Inf. Process. Lett.
**2003**, 86, 169–176. [Google Scholar] [CrossRef] - Vitenberg, R.; Friedman, R. On the Locality of Consistency Conditions. In Proceedings of the 17th International Conference on Distributed Computing, DISC 2003, Sorrento, Italy, 1–3 October 2003; Lecture Notes in Computer Science. Springer: Berlin, Germany, 2003; Volume 2848, pp. 92–105. [Google Scholar]
- Talmage, E.; Welch, J.L. Relaxed Data Types as Consistency Conditions. In Proceedings of the 19th International Symposium on Stabilization, Boston, MA, USA, 5–8 November 2017; Lecture Notes in Computer Science. Spirakis, P., Tsigas, P., Eds.; Springer: Berlin, Germany, 2017. [Google Scholar]
- Neiger, G. Set-Linearizability. In Proceedings of the Thirteenth Annual ACM Symposium on Principles of Distributed Computing, Los Angeles, CA, USA, 14–17 August 1994; Anderson, J.H., Peleg, D., Borowsky, E., Eds.; ACM: New York, NY, USA, 1994; p. 396. [Google Scholar]
- Castañeda, A.; Rajsbaum, S.; Raynal, M. Specifying Concurrent Problems: Beyond Linearizability and up to Tasks—(Extended Abstract). In Proceedings of the 29th International Symposium on Distributed Computing, DISC 2015, Tokyo, Japan, 7–9 October 2015; Lecture Notes in Computer Science. Moses, Y., Ed.; Springer: Berlin, Germany, 2015; Volume 9363, pp. 420–435. [Google Scholar]
- Aiyer, A.; Alvisi, L.; Bazzi, R.A. On the Availability of Non-strict Quorum Systems. In Distributed Computing; Lecture Notes in Computer Science; Fraigniaud, P., Ed.; Springer: Berlin/Heidelberg, Germany, 2005; Volume 3724, pp. 48–62. [Google Scholar]
- Hemed, N.; Rinetzky, N. Brief announcement: Concurrency-Aware Linearizability. In Proceedings of the ACM Symposium on Principles of Distributed Computing, PODC’14, Paris, France, 15–18 July 2014; Halldórsson, M.M., Dolev, S., Eds.; ACM: New York, NY, USA, 2014; pp. 209–211. [Google Scholar]
- Hemed, N.; Rinetzky, N.; Vafeiadis, V. Modular Verification of Concurrency-Aware Linearizability. In Proceedings of the 29th International Symposium on Distributed Computing, DISC 2015, Tokyo, Japan, 7–9 October 2015; Lecture Notes in Computer Science. Moses, Y., Ed.; Springer: Berlin, Germany, 2015; Volume 9363, pp. 371–387. [Google Scholar]
- Lamport, L. On Interprocess Communication. Part II: Algorithms. Distrib. Comput.
**1986**, 1, 86–101. [Google Scholar] [CrossRef] - Shao, C.; Welch, J.L.; Pierce, E.; Lee, H. Multiwriter Consistency Conditions for Shared Memory Registers. SIAM J. Comput.
**2011**, 40, 28–62. [Google Scholar] [CrossRef] - Kosa, M.J. Time Bounds for Strong and Hybrid Consistency for Arbitrary Abstract Data Types. Chicago J. Theor. Comput. Sci.
**1999**. [Google Scholar] [CrossRef] - Attiya, H.; Friedman, R. A Correctness Condition for High-Performance Multiprocessors. SIAM J. Comput.
**1998**, 27, 1637–1670. [Google Scholar] [CrossRef]

© 2018 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Talmage, E.; Welch, J.L.
Relaxed Data Types as Consistency Conditions ^{†}. *Algorithms* **2018**, *11*, 61.
https://doi.org/10.3390/a11050061

**AMA Style**

Talmage E, Welch JL.
Relaxed Data Types as Consistency Conditions ^{†}. *Algorithms*. 2018; 11(5):61.
https://doi.org/10.3390/a11050061

**Chicago/Turabian Style**

Talmage, Edward, and Jennifer L. Welch.
2018. "Relaxed Data Types as Consistency Conditions ^{†}" *Algorithms* 11, no. 5: 61.
https://doi.org/10.3390/a11050061