Linearizable State Machine Replication of State-Based CRDTs without Logs

TL;DR

This paper introduces a novel protocol for linearizable state machine replication of CRDTs that eliminates the need for consensus or a leader, significantly reducing synchronization costs and improving throughput in distributed systems.

Contribution

It presents a leaderless, consensus-free protocol for linearizable CRDT replication leveraging monotonic growth, enabling in-place updates and minimal message overhead.

Findings

Over 99% of queries handled in 1-3 round trips

Significant reduction in synchronization overhead compared to traditional methods

High throughput achieved without leader election or command logs

Abstract

General solutions of state machine replication have to ensure that all replicas apply the same commands in the same order, even in the presence of failures. Such strict ordering incurs high synchronization costs caused by distributed consensus or by the use of a leader. This paper presents a protocol for linearizable state machine replication of conflict-free replicated data types (CRDTs) that neither requires consensus nor a leader. By leveraging the properties of state-based CRDTs - in particular, the monotonic growth of a join semilattice - synchronization overhead is greatly reduced. As a result, updates only need a single round trip and modify the state 'in-place' without the need for a log. Furthermore, the message size overhead for coordination consists of a single counter per message. For queries, we guarantee finite writes termination. We show in an experimental evaluation that more than 99 % of queries can be handled in one to three round trips under highly concurrent accesses. Our protocol achieves high throughput without auxiliary processes such as command log management or leader election. Thus, it is well suited for practical scenarios that need linearizable access to CRDT data on a fine-granular scale.

Figures

Equations

$$\forall Q\in QS$$

$$\forall Q_1,Q_2\in QS$$

$$\forall m^{\prime }\in S,x⊑m^{\prime }\wedge y⊑m^{\prime }:x⊑m\wedge y⊑m\wedge m⊑m^{\prime }$$

$$\exists s^{\prime }\equiv q.s:C(s^{\prime })={\mathcal{U}}_q$$

$$o_1{\prec }_{\bar{H}}{o}_2\Rightarrow \forall r{\in }_r\bar{H},o_2.f\in C(r):o_1.f\in C(r)$$

$$\forall u\in {\mathcal{U}}_r,\exists s^{\prime }\equiv r.s:u\in C(s^{\prime })$$

Full text

This paper presents a protocol for linearizable state machine replication of conflict-free replicated data types (CRDTs) that neither requires consensus nor a leader. By leveraging the properties of state-based CRDTs—in particular, the monotonic growth of a join semilattice—synchronization overhead is greatly reduced. As a result, updates only need a single round trip and modify the state ‘in-place’ without the need for a log. Furthermore, the message size overhead for coordination consists of a single counter per message. For queries, we guarantee finite writes termination. We show in an experimental evaluation that more than 99 % of queries can be handled in one to three round trips under highly concurrent accesses.

Our protocol achieves high throughput without auxiliary processes such as command log management or leader election. Thus, it is well suited for practical scenarios that need linearizable access to CRDT data on a fine-granular scale.

I Introduction

The implementation of a replicated state machine (RSM) is a well-established approach for designing fault-tolerant services. In its common form, clients submit update commands that modify the state of the replicated object, or read commands returning (part of) its state back to the client. To guarantee linearizable [20] access to an RSM, all replicas must apply the same commands in the same order. This is commonly achieved by using a consensus protocol such as Paxos [25, 24], Raft [32], or variations thereof [31, 22, 27]. However, the use of consensus often incurs significant synchronization overhead. In particular, most approaches require the use of a central coordinator (leader) to achieve acceptable performance and require to maintain a command log, which must be regularly truncated to prevent unbounded memory consumption. This often makes the correct implementation of RSMs a challenging task [14].

A wealth of previous work exists that aims to reduce the cost associated with fault-tolerant replication. Some approaches reduce synchronization by leveraging the commutativity of some submitted commands by solving generalized consensus [26]. Other approaches avoid the cost associated with consensus by using a weaker consistency model such as strong eventual consistency (SEC). SEC was formalized by Shapiro et al. [40] with the introduction of conflict-free replicated data types (CRDTs). CRDTs are data structures whose mathematical properties ensure the convergence of all replicas as long as all updates are propagated to them in arbitrary order. They do not require protocol-level conflict resolution mechanisms, as conflicting updates can be resolved computationally. This allows the conflict-free execution of both queries and updates in relaxed consistency models like SEC. Data structures that can be implemented as a CRDT include counters, sets, and certain types of graphs [40]. Due to their low synchronization costs, numerous practical systems have employed CRDTs to this date, such as Redis [35], Riak [12], SoundCloud [11], and Akka [3].

However, their usage is restricted to cases where relaxed consistency suffices, as there is no guarantee on when replicas converge and inconsistent states can be observed in the meantime. This prevents their usage to implement, for example, atomic counters, which is a ubiquitous primitive in distributed computing.

This paper introduces a protocol to implement a special class of replicated state machines that allows linearizable access on CRDTs without the need of log management while keeping the message size overhead at a single counter per message. These RSMs support update operations that modify the state and query operations that return a value but do not modify the state. Operations that both modify the state and return a value are not supported.

By leveraging the properties of CRDTs, our protocol can achieve high throughput even in the absence of a leader. Thereby, the need for implementing leader election mechanisms is eliminated, which allows continuous availability as long as a majority of replicas is reachable. Our protocol does not replicate a log of commands, which is commonly the case for consensus protocols. Instead, we replicate the state directly and update it ‘in-place’. Our protocol just needs a single counter per replica and it avoids the complexity associated with command log state and memory management.

Our approach relies on solving generalized lattice agreement (GLA). Similar to CRDTs, values proposed in GLA belong to a join semilattice—a partially ordered set that defines a join (least upper bound) for all element pairs. In contrast, for generalized consensus it is not required that such a join always exists. This difference makes generalized lattice agreement an easier problem to solve. In fact, previous work has shown that wait-free [19] solutions to this problem exist [16], which is proven to be impossible for consensus [17] in an asynchronous system in the presence of process failures. However, the protocol described by Faleiro et al. [16] requires sending an ever-increasing set of commands in its messages to provide state machine replication. In contrast, our approach features message sizes that are bounded by the state of the CRDT and guarantees finite writes termination [1], which is a weaker termination property than wait-freedom.

The main contributions of this paper are as follows (a brief announcement of this paper is published in [41]):

• •

We present a protocol that provides linearizable state machine replication of state-based CRDTs by solving generalized lattice agreement. The protocol is light-weight as it does not rely on auxiliary processes for leader election or log management (see Sect. III).

• •

The protocol processes updates in a single round-trip. Queries support finite writes termination (see Sect. III-F). We show in our evaluation that more than 99 % of queries can be processed in one to three round-trips in the presence of a continuous stream of updates (see Sect. IV).

• •

We compare the performance of our protocol with open-source implementations of Paxos and Raft, two well-known approaches for linearizable RSMs (see Sect. IV).

II Preliminaries

In this section, we discuss the assumed system model and give an introduction to CRDTs.

II-A System Model

We consider a distributed system of $N$ independent and asynchronous processes $\mathcal{P}=\{p_{1},p_{2},\ldots,p_{N}\}$, which communicate by message passing. We consider processes that fail under the crash-stop model and assume unreliable message transfer, i.e., messages can arrive out of order, can be delayed arbitrarily, or can be lost. We refer to a process that does not fail as a correct process.

We assume over $\mathcal{P}$ a fixed quorum system $\mathit{QS}$ [44], i.e., a set of sets of processes with mutual overlap:

[TABLE]

Elements in $\mathit{QS}$ are called quorums. A necessary condition for progress is that at least a quorum of processes does not crash and is able to pairwise exchange messages for a sufficiently long time.

II-B State-Based Conflict-Free Replicated Data Types

Eventual consistency promises better performance and availability in large scale systems in which the coordination required for linearizable approaches is not feasible [43]. Updates are applied at some replica and at a later time propagated across the system. Eventually, all replicas receive all updates, possibly in different orders. However, concurrent updates may cause conflicts. Resolving them often requires roll-backs and consensus decisions.

The use of conflict-free replicated data types (CRDTs) [40], introduced as part of the strong eventual consistency model, eliminates the need for roll-backs or consensus by leveraging mathematical properties preventing the emergence of conflicts. Operation-based CRDTs require the commutativity of all its update operations, whereas state-based CRDTs rely on monotonicity in a join semilattice [39]. Both types have advantages and disadvantages. In general, operation-based CRDTs have lower bandwidth needs but require reliable, i.e., exactly once, and causally ordered delivery of updates [39]. As our system model assumes unreliable communication, we only focus on state-based CRDTs in this paper. However, both types of CRDTs can emulate each other [39].

State-based CRDTs are based on the concept of join semilattices:

Definition 1 (Join Semilattice).

A join semilattice $\mathcal{S}$ is a set $S$ equipped with a partial order $x\sqsubseteq y$ and a least upper bound (LUB) $x\sqcup y$ for all pairs of elements $x,y\in S$.

The LUB of two elements $x,y\in S$ is the smallest element in $S$ that is equal or larger than both $x$ and $y$.

Definition 2 (Least Upper Bound).

$m=x\sqcup y$* is a LUB of $\{x,y\}$ under partial order $\sqsubseteq$ iff:*

[TABLE]

From this definition it follows that $\sqcup$ is idempotent ($x\sqcup x=x$), commutative ($x\sqcup y=y\sqcup x$), and associative ($(x\sqcup y)\sqcup z=x\sqcup(y\sqcup z)$).

The join semilattice represents the set of possible states of a state-based CRDT. Clients can read its current state via query commands and modify it via update commands111To be consistent with RSM terminology, we use the term ’command’ instead of ’function’, which is commonly used in the context of CRDTs..

Definition 3 (State-Based CRDT).

*A state-based CRDT consists of a triple $(\mathcal{S},Q,U)$, where $\mathcal{S}$ is a join semilattice defining the possible payload states $S$, $Q$ is a set of side-effect free query commands, and $U$ is a set of monotonically non-decreasing update commands, i.e., $\forall u\in U,s\in S:s\sqsubseteq u(s)$. *

Two payload states $s_{1},s_{2}\in S$ are equivalent ($s_{1}\equiv s_{2}$) if all queries return the same result for both, i.e., $s_{1}\sqsubseteq s_{2}\land s_{2}\sqsubseteq s_{1}\implies s_{1}\equiv s_{2}$. They are comparable if they can be ordered, i.e., $s_{1}\sqsubseteq s_{2}\lor s_{2}\sqsubseteq s_{1}$.

Example. One of the most simple state-based CRDTs is a monotonically increasing counter, called G-counter (grow-only counter). Its state-based definition is shown in Algorithm 1. The payload state of such a counter, replicated on $n$ processes, consists of an array of length $n$. All replicas, which are assumed to be distinguishable by an ID, manage their own local copy of the counter’s state. Locally incrementing the counter increments the array element corresponding to the ID of the respective replica. The merge and compare functions implement $\sqcup$ and $\sqsubseteq$, respectively.

In a system that provides SEC, a replica that receives an increment command from a client increments its counter (its slot) by calling update. It periodically propagates its counter state $g$ to the other replicas. Any replica that receives such a counter state updates its own counter state using merge. As all replicas only increment their own slot, no updates are lost and eventually all replicas converge to the same state.

III Linearizable and Logless RSM

of State-Based CRDTs

Next, we discuss how to leverage the properties of state-based CRDTs for linearizable access.

III-A Problem Statement

We consider a state-based CRDT $(\mathcal{S},Q,U)$ replicated on $N$ processes. Each process starts with an initial state $s_{0}\in S$. Clients can perform update and query operations by respectively sending an update command $u\in U$ or query command $q\in Q$ to any process. Each process may receive an arbitrary number of commands. An operation is invoked if a client sends a corresponding message to a process, which may eventually respond by sending a message with the operation result back. An operation $op_{1}$ precedes $op_{2}$, if a process sends an $op_{1}$ response before $op_{2}$ is invoked. For brevity, we refer to query and update commands as queries and updates. Furthermore, a command is invoked if the operation it is included in is invoked. Command precedence is defined analogously.

Updates modify the state of the CRDT without returning a result to the client (besides a completion acknowledgment). To simplify formal reasoning we assume updated to be unique, e.g., by attaching IDs. The causal history [40] $C(s)$ of state $s$ is the set of updates applied on $s_{0}$ to reach state $s$. More formally, $C(s_{0})=\varnothing$, $u\in C(u(s))$ and $C(s_{1})\cup C(s_{2})=C(s_{1}\sqcup s_{2})$. Shapiro et al. [40] have shown that $C(s_{1})=C(s_{2})\Rightarrow s_{1}\equiv s_{2}$ due to the properties of updates and LUBs. A state $s$ includes update $u$ if $u\in C(s)$. Note that causal histories are an aid for formal reasoning, which do not have to be explicitly stored by an implementation.

In contrast to updates, queries do not modify the state of the CRDT but return a value as result. To process a query $q$ that was sent to a process $p$, $p$ must first learn a state $s\in S$ by exchanging messages with the other processes. The query is then applied on $s$ and the result is returned to the client. We say that $s$ is the state learned by query $q$ at process $p$.

All learned states must satisfy the following conditions:

Validity

The causal history of any learned state is a subset of all previously invoked updates.

Stability

For any two states $s_{1},s_{2}$ learned by queries $q_{1},q_{2}$, where $q_{1}$ precedes $q_{2}$: $s_{1}\sqsubseteq s_{2}$.

Consistency

Any two learned states are comparable.

These conditions are derived from generalized lattice agreement (GLA) [16]. Informally, they capture the notion that queries observe the effect of a monotonically increasing set of invoked updates.

The conditions stated above define the behavior of queries. We now define the behavior of updates.

Update Stability

If update $u_{1}$ precedes update $u_{2}$, then every learned state that includes $u_{2}$ also includes $u_{1}$.

Update Visibility

If update $u$ precedes query $q$, then the state learned by $q$ includes $u$.

We show in Sect. III-E that these condition suffice to provide linearizability.

III-B The Protocol

The success path of the protocol is depicted in Algorithm 2. We consider two roles that processes can assume: proposer and acceptor. Roughly speaking, proposers process incoming requests from clients and acceptors act as the replicated storage of the CRDT. We assume that all processes implement both the acceptor and proposer role.

Conventions.

To keep the presented code brief, we follow several conventions. First, we assume messages to be tuples with a tag and an arbitrary number of elements. They are denoted as $\langle\mathit{TAG},e_{0},\ldots,e_{n}\rangle$. Processes wait until they have received enough messages with a specific tag before executing its corresponding action. If an action requires messages from a set of processes, we aggregate the received messages element-wise into multisets. For example, two messages $\langle\mathit{TAG},a_{0},b_{0}\rangle$, $\langle\mathit{TAG},a_{1},b_{1}\rangle$ would be aggregated into the message $\langle\mathit{TAG},\breve{A}=\{a_{0},a_{1}\},\breve{B}=\{b_{0},b_{1}\}\rangle$. At any time, each process executes at most one action.

The second concept we use are rounds. A common way to generate unique round numbers is that each process appends its process ID to a local counter, which is incremented for each new round. Thus, rounds are pairs of a round number and a round ID. Round $r$ is denoted as $r=(\mathit{number},\mathit{ID})$, with $r_{\mathit{nr}}$ and $r_{\mathit{id}}$ providing access to its number and ID, respectively. Round numbers are used to order concurrent requests, and round IDs guarantee that the round of each request is unique. The special value $\bot$ denotes empty fields, which is smaller than any other round number or round ID. Rounds are partially ordered by comparing their round numbers. Round IDs are only relevant for equality checks.

We furthermore assume that proposers implement a mechanism to keep track of ongoing requests and can differentiate to which request an incoming message belongs to. In practice, this can be done by generating a unique ID per request which is included in all messages.

Internal State.

Each acceptor holds as its internal state the current payload state $s$ of the CRDT and the highest round $r$ it has observed so far. In the beginning, each acceptor’s state is initialized with some initial payload state $s_{0}$ and some round with round number [math] and an ID that is smaller than any ID generated by proposers.

Proposers only have to temporarily store data of ongoing requests and unprocessed messages (in order to wait for replies from a quorum). No further state is required.

Update Operations.

Update operations are processed in a single round trip. They do not require any synchronization. If a proposer receives an update command $\mathit{cmd}_{u}\in U$, it applies the update locally and sends the resulting new payload state to all other acceptors in a $\mathit{MERGE}$ message. Upon receiving the message, each acceptor updates its own payload state by LUB computation and sends an acknowledgment message back to the proposer. After receiving replies from a quorum, the update is complete and the client is notified by the proposer.

Query Operations.

Query operations require synchronization as a quorum must agree upon some payload state in order to satisfy Validity, Stability, and Consistency (Sect. III-A). This is achieved with a modified variant of the Paxos algorithm [25].

Proposer $p$ begins the query protocol with the reception of a query command $\mathit{cmd}_{q}\in Q$. Before executing the command, it must first learn the current payload state in two phases. First, $p$ announces its intent to learn a state with $\mathit{PREPARE}$ messages and then proposes to learn a state, which acceptors have to agree on.

In the first phase, $p$ first chooses a round (line 12), which is later used for the proposal in the second phase. The round number can be chosen by $p$ in two ways. First, $p$ can decide on a fixed integer as a round number. We refer to this as a fixed prepare. The chosen number should be larger than all round numbers previously chosen by any proposer, as otherwise $p$ cannot succeed in this phase. However, $p$ has only knowledge of its own proposals, which can make it difficult to decide on an acceptable number. Therefore, proposers may choose to opt for an incremental prepare by leaving the round number undefined (denoted as $\bot$).

In addition to a round, $p$ includes its own payload state in its $\mathit{PREPARE}$ message. This state can be either $s_{0}$, or some recently observed state $s$. Including such a state is not required for safety, but it can speed-up the convergence of acceptors’ payload states.

Each acceptor updates its rounds and payload state according to the $\mathit{PREPARE}$ message it receives (incremental or fixed). Note that acceptors do not accept a fixed prepare if it includes a round with a round number smaller than the highest round number already seen by this acceptor (lines 48–50). In practice, the acceptors reply with $\mathit{NACK}$ messages (not shown for brevity) so that the proposer can retry its request. An incremental prepare is always accepted and the local round number of the acceptor is increased (line 47).

The prepare is successful if a quorum has replied with $\mathit{ACK}$ messages (line 14). Depending on the replies, $p$ can either (a) immediately learn a state, (b) propose a state to learn, or (c) retry the prepare phase.

(a) If all acceptors of the quorum replied with the same payload state, then this state can be considered to be learned by $p$. Thus, the second phase can be skipped, $p$ can apply $\mathit{cmd}_{q}$ on the learned state, and send the result to the client. We refer to such state as learned by consistent quorum (lines 16–18). The second phase can be skipped here as $p$ is already certain of a payload state that is established in a quorum.

(b) If a quorum of acceptors replied with the same round, the first phase was successful. In the second phase, the proposer can propose a payload state to learn, which is the LUB of all received acceptor payloads. This state is sent with the round used in the first phase in $\mathit{VOTE}$ messages to all acceptors (lines 19–21).

(c) If neither payload states nor rounds are consistent, the first phase has failed. In this case, the proposer used an incremental prepare. It can then retry with a fixed prepare by choosing a round number that is larger than all seen round numbers (lines 24–26).

Each acceptor that received a $\langle\mathit{VOTE},s^{\prime},r^{\prime}\rangle$ message has to decide whether the proposal is valid. This is the case when the acceptor has received $p$’s $\mathit{PREPARE}$ message and its state was not modified by a concurrent update or query in the meantime (line 53). If the proposal is valid, then the acceptor replies with a $\mathit{VOTED}$ message. Otherwise, it denies the proposal by optionally sending a $\mathit{NACK}$ so that $p$ can retry (not shown). If $p$ receives a quorum of $\mathit{VOTED}$ messages, then its proposed state is learned. We refer to this as a state learned by vote. Then, $p$ can apply the received query and send the result to the client.

Retrying Requests.

Acceptors may deny concurrently submitted queries by sending $\mathit{NACK}$ to the respective proposer. It is helpful to include the current payload state of the denying acceptor in this message to speed-up the convergence with the remaining acceptors in the system.

Any proposer that received a $\mathit{NACK}$ before receiving a quorum of $\mathit{ACK}$ or $\mathit{VOTED}$ messages must retry its request. It can compute the LUB of all received payloads as the state to include in its next $\mathit{PREPARE}$ messages. By always retrying with an incremental prepare, eventual liveness (see Sect. III-F) can be guaranteed. However, retrying with a fixed prepare also does not violate any safety condition of Sect. III-A.

III-C Relation to Paxos and ABD

The query protocol is closely related to the classical single-decree Paxos algorithm [24]. Single-decree Paxos can be used to agree on a single value or command sent to the RSM. This makes it necessary to use multiple chained Paxos instances to learn a sequence of commands. Paxos solves consensus for arbitrary values. Therefore, it can not assume that properties such as commutativity and idempotence generally exist. In contrast, CRDT state merges always exhibit these properties, which allows us to modify Paxos to exploit them. First, a single instance of our protocol can be re-used to repeatedly merge states received from proposers in arbitrary order, even if the attached round number is outdated. This speeds-up the convergence of acceptors states under concurrent access. Second, our approach needs only a single round number, whereas Paxos requires an additional round number in the state of acceptors to identify the newest proposed value in the case of concurrent proposals. As we can simply merge all observed values, this round number is not needed. Third, proposers in our approach can terminate early if they observe consistent states from a quorum of acceptors. This optimization makes our approach viable in leader-less deployments, as shown in Sect. IV.

Due to the modifications made to Paxos, our approach somewhat resembles the multi-writer generalization of the ABD algorithm [5]. ABD provides a wait-free fault-tolerant atomic register. As such, newer values submitted by clients overwrite the old register state in ABD. These semantics alone do not suffice for state machine replication, which requires sequential agreement on commands. For our state-based CRDTs, accepted updates are merged into the previous state, which ensures that clients observe monotonically increasing CRDT states.

III-D Proof of Safety

In the following, we prove that our protocol satisfies the conditions outlined in Sect. III-A. The query protocol begins by either incremental or fixed prepare. The following invariants hold for both of them, as can be directly inferred from Algorithm 2:

I1

If a proposer learns some state, then it has received $\mathit{ACK}$’s from a quorum (line 17, line 28 via line 21).

I2

Any learned state is the LUB of all payload states received in $\mathit{ACK}$ messages from a quorum (line 15).

I3

If a proposer sends a $\mathit{VOTE}$ message, then it has received the same round in $\mathit{ACK}$ messages from a quorum (lines 19–21).

I4

If a proposer has received an $\mathit{ACK}$ message from an acceptor (line 14), then this acceptor has increased its round number due to the proposer’s $\mathit{PREPARE}$ message (line 49).

Theorem 1 (Validity).

The causal history of any learned state is a subset of all previously invoked updates.

Proof.

All acceptors start with payload $s_{0}$ (line 33). Payload modifications only happen by either application of a received update command or by LUB computation. Every update is applied at most once and only if it was previously received by a proposer. Furthermore, computing the LUB of two payload states computes the union of their respective causal histories. Thus, the causal history of every learned state must be a subset of previously invoked updates. ∎

Lemma 1.

The payload state of every acceptor increases monotonically.

Proof.

Both LUB computation and the direct application of update commands are monotonically increasing. ∎

Corollary 1.

If messages $\langle\mathit{ACK},r,s\rangle$ and $\langle\mathit{ACK},r^{\prime},s^{\prime}\rangle$ are send by the same acceptor in this order, then $s\sqsubseteq s^{\prime}$.

Lemma 2.

If state $s$ is learned by any proposer, then there exists a quorum $Q$ with $s\sqsubseteq a.s,\forall a\in Q$, where $a.s$ designates the local state variable $s$ of an acceptor process $a$.

Proof.

State $s$ can be learned (i) by consistent quorum from messages of a quorum $Q_{cons}$ (line 17) or (ii) by vote from messages of a quorum $Q_{\mathit{vote}}$ (line 28).

(i)

Trivial, as all acceptors in $Q_{\mathit{cons}}$ have included a state $s^{\prime}\equiv s$ in their $\mathit{ACK}$ message (lines 45 and 50).

(ii)

$p$ sent $s$ in $\mathit{VOTE}$ messages. At least all acceptors in $Q_{\mathit{vote}}$ must have received the message and have merged their payload state with $s$ by LUB computation (line 52) before replying with $\mathit{VOTED}$ (line 55).

∎

Theorem 2 (Stability).

For any two states $s_{1},s_{2}$ learned by queries $q_{1},q_{2}$, where $q_{1}$ precedes $q_{2}$: $s_{1}\sqsubseteq s_{2}$.

Proof.

From Lemma 2 it follows that once a proposer $p$ has received the $\mathit{QUERY}$ message of $q_{2}$, there exists a quorum $Q$ such that $s_{1}\sqsubseteq a.s,\forall a\in Q$. To learn a state, $p$ eventually receives $\mathit{ACK}$ messages from quorum $Q^{\prime}$. As $Q\cap Q^{\prime}\neq\varnothing$, there exists some $a^{\prime}\in Q^{\prime}$ with $s_{1}\sqsubseteq a^{\prime}\!\!.s$. The state learned by $p$ is the LUB of all received states included in the $\mathit{ACK}$ messages. Thus, $s_{1}\sqsubseteq a^{\prime}\!\!.s\sqsubseteq s_{2}$. ∎

Lemma 3.

Two learned states $s_{1}$ and $s_{2}$ are comparable if at least one state is learned by consistent quorum.

Proof.

(By contradiction) Let $s_{1}$ and $s_{2}$ be learned due to queries handled at proposer $p_{1}$ and $p_{2}$, respectively. $p_{1}$ and $p_{2}$ have received $\mathit{ACK}$s from quorums $Q_{1}$ and $Q_{2}$, respectively. Assume $s_{1}$ is learned by consistent quorum and $s_{1}$ is not comparable to $s_{2}$. In this case, the following conditions must hold:

C1

$\forall a\in Q_{1}\cap Q_{2}$: $a$ must send an $\mathit{ACK}$ to $p_{2}$ with state $s:(s\sqsubseteq s_{1})\land\neg(s\equiv s_{1})$, otherwise $s_{1}\sqsubseteq s_{2}$. This implies that $a$ receives $p_{2}$’s $\mathit{PREPARE}$ message before $p_{1}$’s.

C2

$\forall a\in Q_{1}$: $a$ must receive a $\mathit{PREPARE}$ message from $p_{1}$ before receiving $\mathit{VOTE}$ from $p_{2}$ (otherwise $s_{2}\sqsubseteq s_{1}$).

$s_{2}$ cannot be learned by consistent quorum, as this would imply $s_{2}\equiv s\sqsubseteq s_{1}$ (C1 and Corollary 1). Thus, to learn $s_{2}$, $p_{2}$ must receive $\mathit{VOTED}$ messages from a quorum with at least one acceptor $a$ in $Q_{1}$. For that, $p_{2}$ sends a $\langle\mathit{VOTE},r,s_{2}\rangle$ message to $a$. It follows from C1 and C2 that $a$ has received $p_{1}$’s $\mathit{PREPARE}$ message in between $p_{2}$’s $\mathit{PREPARE}$ and $\mathit{VOTE}$ message. Due to invariant I4, $a$ has modified its round and $r\neq a.r$. Therefore, $a$ does not reply with a $\mathit{VOTED}$ message and $s_{2}$ cannot be learned. ∎

Lemma 4.

Two learned states $s_{1}$ and $s_{2}$ are comparable if both are learned by vote.

Proof.

Let $s_{1}$ and $s_{2}$ be learned due to query requests handled at proposer $p_{1}$ and $p_{2}$, respectively. $p_{1}$ has received $\mathit{ACK}$s from quorum $Q_{1}$ and $p_{2}$ from quorum $Q_{2}$. As $Q_{1}\cap Q_{2}\neq\varnothing$, there is at least one acceptor $a$ that has sent $\mathit{ACK}$s to both $s_{1}$ and $s_{2}$. Assume $a$ sends an $\mathit{ACK}$ to $p_{1}$ first. Therefore, $p_{1}$ sends $\langle\mathit{VOTE},r_{1},s_{1}\rangle$ and $p_{2}$ sends $\langle\mathit{VOTE},r_{2},s_{2}\rangle$ with $r_{1}<r_{2}$. Let $Q_{v}$ be the quorum of acceptors that replied to $p_{1}$ with $\mathit{VOTED}$ messages. All acceptors $a\in Q_{v}\cap Q_{2}$ must receive $p_{1}$’s $\mathit{VOTE}$ before $p_{2}$’s $\mathit{PREPARE}$ message, as otherwise either $p_{2}$ receives inconsistent rounds or $a$ does not reply to $p_{1}$. Therefore, $a$ includes state $s$ with $s_{1}\sqsubseteq s$ in its $\mathit{ACK}$ message to $p_{2}$. As $p_{2}$ computes the LUB of all states received in $\mathit{ACK}$ messages, $s_{1}\sqsubseteq s\sqsubseteq s_{2}$. ∎

Theorem 3 (Consistency).

Any two learned states are comparable.

Proof.

Follows from Lemma 3 and Lemma 4. ∎

Theorem 4 (Update Stability).

If update $u_{1}$ precedes update $u_{2}$, then every learned state that includes $u_{2}$ also includes $u_{1}$.

Proof.

(By contradiction) As $u_{1}$ precedes $u_{2}$, there is a quorum $Q_{u}$ that has received $\mathit{MERGE}$ messages with a payload including $u_{1}$ before any acceptor includes $u_{2}$. Thus, there cannot be a quorum at any time that includes $u_{2}$ but not $u_{1}$.

Assume a proposer $p$ learns state $s$ that includes $u_{2}$ but not $u_{1}$. So, there must be a quorum $Q_{ack}$ that has replied to $p$ an $\mathit{ACK}$ message before receiving the $\mathit{MERGE}$ message and at least one acceptor replied with a payload including $u_{2}$. It follows that $s$ is not learned by consistent quorum. It also follows that all acceptors in $Q_{u}$ received the $\mathit{MERGE}$ before $p$ received all replies from $Q_{ack}$. To propose a state in $\mathit{VOTE}$ messages, $p$ must have received the same round $r$ from all acceptors in $Q_{ack}$. However, $\nexists Q:a.r=r,\forall a\in Q$, as $\forall a\in Q_{u}$ updated their round. Therefore, $p$’s proposal cannot succeed and $s$ is not learned by vote. ∎

Theorem 5 (Update Visibility).

If update $u$ precedes query $q$, then the state learned by $q$ includes $u$.

Proof.

Since the proposer processing update $u$ has generated a response event, there exists a quorum of acceptors including $u$. Thus, any proposer that processes a subsequent query receives at least one $\mathit{ACK}$ message that includes $u$. ∎

III-E Proof of Linearizability

In this section, we show that any protocol that satisfied Theorems 1–5 provides linearizable access to CRDTs. Therefore, it may be of general interest, independent of our proposed protocol. In the sequential specification of a CRDT, the state $q.s$ learned by query $q$ satisfies the following condition. Let $\mathcal{U}_{q}$ be the set of all updates that precede $q$.

[TABLE]

Informally, this captures the notion that the effect of all preceding updates must be observed by the query. The effect of future updates must not be visible.

Furthermore, we rely on the following Lemma.

Lemma 5.

$s_{1}\sqsubseteq s_{2}\Rightarrow\exists s\equiv s_{2}:C(s_{1})\subseteq C(s)$**

Proof.

Because of $s_{1}\sqcup s_{2}=s\equiv s_{2}$ and $C(s_{1}\sqcup s_{2})=C(s)=C(s_{1})\cup C(s_{2})$, it follows that $C(s_{1})\subseteq C(s)$. ∎

Let $\prec_{H}$ be an irreflexive partial order on operations induced by history $H$ [20]. Then, $op_{1}\prec_{H}op_{2}$ is satisfied if $op_{1}$ precedes $op_{2}$. In the following, we denote query and update operations by $r$ and $w$, respectively. For example, $\forall r\in_{r}X$, denotes ’for all query operations in X’. Operations that can be of either type are denoted by $o$, where $o.f$ is the command of operation $o$. We denote the state learned by query operation $r$ as $r.s$.

Proof.

Fix an execution $E$ of an algorithm that satisfies Theorems 1–5 with history $H$. Let $\bar{H}$ be an extension of $H$ by adding response events to pending invocations. Let $\prec_{Inv}$ be a total order over $\bar{H}$, where $o_{1}\prec_{Inv}o_{2}$ if the invocation of $o_{1}$ precedes the invocation of $o_{2}$. We construct a sequential history $S$ from $\bar{H}$. For every pair $(o_{1},o_{2})$, $o_{1}\neq o_{2}$ in $\bar{H}$:

• S1

For $(w,r)$ or $(r,w)$:

if $r\not\prec_{\bar{H}}w\ \land\ \exists s^{\prime}\equiv r.s:w.f\in C(s^{\prime})\Rightarrow w\prec_{S}r$

else $r\prec_{S}w$

• S2

For $(r_{1},r_{2})$:

$r_{1}.s\sqsubset r_{2}.s\ \lor\ (r_{1}.s\equiv r_{2}.s\ \land\ r_{1}\prec_{Inv}r_{2})\Rightarrow r_{1}\prec_{S}r_{2}$

• S3

For $(w_{1},w_{2})$:

Let $r^{*}\notin S$ be an auxiliary query operation after $w_{1}$ and $w_{2}$ with $\forall r\in S:r\prec_{S}r^{*}$; The queries immediately following $w_{1}$ and $w_{2}$ are then:

$r_{w_{i}}=\min_{\prec_{S}}(\{r\in_{r}S:w_{i}\prec_{S}r\}\cup\{r^{*}\}),\ i\in\{1,2\}$;

$r_{w_{1}}\prec_{S}r_{w_{2}}\ \lor\ (r_{w_{1}}=r_{w_{2}}\ \land\ w_{1}\prec_{Inv}w_{2})\Rightarrow w_{1}\prec_{S}w_{2}$

The set of query operations in $S$ is totally ordered by $\prec_{S}$ due to Theorem 3. Thus, $\min_{\prec_{S}}$ in case S3 is well defined and always exists. It is easy to see that $\prec_{S}$ is antisymmetric, i.e., $(o_{1}\prec_{S}o_{2})\oplus(o_{2}\prec_{S}o_{1})$, for $o_{1}\neq o_{2}$, where $\oplus$ denotes the exclusive or operator.

Lemma 6.

$\prec_{\bar{H}}\subseteq\prec_{S}$**

Theorems 1, 2, 4, and 5 define the behavior of any pair of non-overlapping operations. Let $o_{1},o_{2}\in\bar{H}$. If $o_{1}$ and $o_{2}$ are query operations, $o_{1}\prec_{\bar{H}}o_{2}\Rightarrow o_{1}\prec_{S}o_{2}$ follows trivially by case S2 and Theorem 2. If either $o_{1}$ or $o_{2}$ is an update, the same follows directly by case S1 and Theorem 5 or 1, respectively. Let both $o_{1}$ and $o_{2}$ be update operations. Theorem 4 states:

[TABLE]

Let $r_{w_{1}}$ and $r_{w_{2}}$ be the query operations following $o_{1}$ and $o_{2}$ respectively, as defined in case S3. It follows from equation 2 that $o_{1}.f\in C(r_{w_{2}})$. Thus, $r_{w_{2}}\not\prec_{S}r_{w_{1}}$. Therefore, $r_{w_{1}}\prec_{S}r_{w_{2}}$ or $r_{w_{1}}=r_{w_{2}}$. In both cases, $o_{1}\prec_{S}o_{2}$.

Lemma 7.

$S$* is a sequential history.*

The relation $\prec_{S}$ is antisymmetric and relates all pairs of elements in some way. Thus, $\prec_{S}$ is a total order if $\prec_{S}$ is also transitive, which implies that $S$ is a sequential history. Let $r_{1},r_{2},r_{3}$ and $w_{1},w_{2},w_{3}$ be any three query or update operations, respectively.

(A) $r_{1}\prec_{S}r_{2}\prec_{S}r_{3}\Rightarrow r_{1}\prec_{S}r_{3}$, follows trivially from case S2. In addition, case S2 implies $r_{1}\prec_{S}r_{2}\Rightarrow r_{1}.s\sqsubseteq r_{2}.s$. Thus, by applying Lemma 5 and case S1, (B) $w_{1}\prec_{S}r_{1}\prec_{S}r_{2}\Rightarrow w_{1}\prec_{S}r_{2}$. Let $r_{w_{1}}$ and $r_{w_{2}}$ be the query operations following $w_{1}$ and $w_{2}$ respectively, as defined in case S3. From (A) and case S3 follows $w_{1}\prec_{S}w_{2}\Rightarrow r_{w_{2}}\not\prec_{S}r_{w_{1}}$, thereby (C) $w_{1}\prec_{S}w_{2}\prec_{S}r_{1}\Rightarrow w_{1}\prec_{S}r_{1}$ and (D) $w_{1}\prec_{S}w_{2}\prec_{S}w_{3}\Rightarrow w_{1}\prec_{S}w_{3}$.

We derive from (B) that (E) $r_{1}\prec_{S}r_{2}\prec_{S}w_{1}\Rightarrow r_{1}\prec_{S}w_{1}$ holds using the following argument: Assume $r_{1}\not\prec_{S}w_{1}$. By antisymmetry of $\prec_{S}$, $w_{1}\prec_{S}r_{1}$. We arrive at an contradiction because $r_{1}\prec_{S}r_{2}$, which implies $w_{1}\prec_{S}r_{2}$ due to (B).

As this argument does not rely on the operation type, it can be applied to derive the remaining cases from (C) and (E). Thereby, $\prec_{S}$ is transitive.

Lemma 8.

$S$* is legal in respect to the sequential specification of CRDTs.*

We show that all query operations in $S$ satisfy equation 1 by construction rule S1. Let $r$ be a fixed query operation in $S$ and $\mathcal{U}_{r}=\{w.f:w\in_{w}S\land w\prec_{S}r\}$, i.e., the set of all updates preceding $r$. By case S1:

[TABLE]

Let $\mathcal{U}_{r}=\{u_{1},\dots,u_{n}\}$. We proceed by induction to show that an $s^{\prime}$ exists, so that $C(s^{\prime})=\mathcal{U}_{r}$. Let $s_{i}$ be a state equivalent to $r.s$ that includes all $u_{j}$ with $j\leq i$. We show that $s_{i}$ can be constructed using $s_{i-1}$, starting $s_{0}=r.s$:

If $u_{i}\in C(s_{i-1})$, then $s_{i}=s_{i-1}$. 2. 2.

Otherwise, $s_{i}=u_{i}(s_{i-1})$. As updates are non-decreasing, $s_{i-1}\sqsubseteq s_{i}$. Let $s^{\prime}$ be any state that satisfies equation 3 in respect to $u_{i}$ and $s_{m}=s^{\prime}\sqcup s_{i-1}$. Because of $C(s_{i})=C(s_{i-1})\cup\{u_{i}\}\subseteq C(s_{m})$ it follows that $s_{m}\not\sqsubset s_{i}$. As $s_{m}\equiv r.s\equiv s_{i-1}$, we have $s_{i-1}\not\sqsubset s_{i}$. Thus, $s_{i}\equiv s_{i-1}$.

By construction of $s_{n}$, we know that $C(s_{n})=\mathcal{U}_{r}\cup C(r.s)$. By Theorem 1 and case S1 it follows $C(r.s)\subseteq\mathcal{U}_{r}$. Therefore, $C(s_{n})=\mathcal{U}_{r}$.

As $S$ satisfies Lemma 6, 7 and 8, $\bar{H}$ is linearizable. Since $\bar{H}$ is the extention of $H$, $H$ is also linearizable. ∎

III-F Liveness

Faleiro et al. [16] show that wait-free protocols for solving GLA exist. However, their approach is bandwidth expensive, as it requires to exchange an ever growing set of accepted input commands in messages.

In contrast, the protocol presented in Sect. III-B satisfies a weaker liveness condition called finite writes termination (FW-termination) [1] if a quorum of processes is correct. Informally, FW-termination guarantees that write operations (updates) always terminate, whereas read operations (queries) are guaranteed to terminate only if a finite number of concurrent writes is present. Every FW-terminating protocol is also lock-free and by extension obstruction-free [21].

To guarantee the progress of query operations of our protocol, the number of update operations that occur in parallel with queries must be limited by a contention management mechanism such as a leader oracle [1], which is applicable but beyond the scope of this paper. However, we show in our evaluation (Sect. IV) that more than 99 % of queries can be processed within one to three round-trips without using such mechanism.

In the remainder of this section, we sketch an argument for the FW-termination of our protocol if proposers use incremental prepares to retry failed queries attempts:

Trivially, all update operations terminate within a single round-trip. As there are a finite number of updates, there is a point in time in which the apply_update function is called for the last time, i.e., no new updates are included in any acceptor. Any proposer that is executing a query after this point will execute incremental prepares (possibly interleaved with fixed prepares) until it learns a state. Each time an incremental prepare is executed, the proposer will either learn a state by consistent quorum or receive at least one reply with a different payload. If the request fails, the proposer retries with the LUB of all received payloads from the previous iteration. In each unsuccessful iteration, the updates of at least one additional acceptor are included in the LUB. As there is a finite number of acceptors, eventually all acceptors include all updates and the proposer learns a state by consistent quorum.

III-G Optimizations

The base protocol described in Sect. III-B can be optimized in several ways.

Improve convergence.

In Algorithm 2, proposers include $s_{0}$ in their initial $\mathit{PREPARE}$ messages. However, computing the LUB with $s_{0}$ will never increase the payload of an acceptor. Instead, proposers can either include a payload known from a previous request, or the payload of a co-located acceptor.

Sending less payloads.

Acceptors do not need to include payloads in $\mathit{VOTED}$ messages, as this is the state they received from the proposer. Instead, proposers can simply remember the proposed payload and apply the queries on it once a quorum of responses is received.

Using delta-mutators.

In the algorithm described above, full CRDT payload values are sent repeatedly by proposers and acceptors in messages. This can cause high bandwidth overhead for larger CRDTs. To prevent this, delta-mutators can be used, as described by Almeida et al. [4]. With delta-mutators it suffices to send state-deltas instead of full values. This can be combined with techniques introduced by Enes et al. [15] to further reduce the amount of redundantly transmitted data.

Batching.

Batching is a common strategy to reduce synchronization overhead and bandwidth needs in workloads with high concurrent access by sacrificing some latency [18]. Implementing batching on a per-proposer basis is simple. Each proposer manages a separate update and query batch in which it buffers all commands it has received since the previous batch. To process an update batch, the respective proposer applies all update commands in the batch on the local replica and then executes the update protocol normally. For a query batch, the proposer executes the query protocol and then applies all batched queries on the learned value.

By the design of our protocol, only a single CRDT payload value is transferred. It is independent of the size of the batch. Thus, the required bandwidth only depends on the CRDT’s size. In contrast, other approaches that provide GLA-based state machine replication agree on command sets, which means that the full batch of commands must be transmitted (see Sect. V).

IV Evaluation

We implemented [36] our protocol as part of the distributed key-value store Scalaris [38], which is written in Erlang. The implementation’s correctness was tested using a protocol scheduler that enforces random interleavings of incoming messages.

For comparison, we use open-source Erlang implementations of Multi-Paxos [9, 25] and Raft [34, 32]. We configured both approaches to write their respective command logs on a RAM disk to minimize their performance impact. The protocol proposed by Faleiro et al. [16] exchanges an ever growing set of accepted input commands between its participants. This set needs to be truncated for this approach to be practical. Unfortunately, such a mechanism is not described. As we found that designing one is a non-trivial task, we consider it out of scope for our evaluation. Thus, the protocol is not included in the evaluation despite its theoretical importance.

All benchmarks were performed on a cluster equipped with two Intel Xeon E5-2670 v3 2.4 GHz per node running Ubuntu 16.04.6 LTS. The nodes are fully connected with 10 Gbit/s. For all measurements, we implemented a replicated counter that is replicated on three nodes using the respective approaches. In our approach, to which we will refer to as CRDT Paxos, we implemented a G-Counter as described in Sect. II-B. We applied the optimizations outlined in Sect. III-G, with the exception of delta-mutators. For Multi-Paxos and Raft, we used a replicated integer as the counter. All experiments were executed using Erlang 19.3. Up to three separate nodes were used to generate load using the benchmarking tool Basho Bench [8]. All measurements ran over a duration of 10 minutes with request data aggregation in 1 s intervals. For Figure 1 and Figure 2(a), we show the median with 99 % confidence intervals (CI). The CI is always within three percent of the reported medians.

IV-A Failure-free Operation

In this experiment, we measured the throughput of the approaches under different loads and increasing number of clients (see Figure 1), which were distributed evenly across three load generators. Each client independently invokes requests to one of the three replicas and then waits for a response before invoking the next request. CRDT Paxos performs better for query heavy workloads as it distinguishes between query and update requests. A decrease in update increases the probability of observing a consistent quorum, which also increases the ability to process requests in a single round trip. In contrast, both the Raft and Multi-Paxos implementation append updates and consistent queries to its command log, which results in their consistent performance for all load types. Overall, CRDT Paxos achieves a higher throughput for mixed workloads with a low percentage of updates and less than 1500 clients. This is mainly due to its better load distribution across all replicas compared to the leader based designs. For more clients, its performance degrades because of the interference between updates and queries. Note that the $95^{\mathrm{th}}$ percentile query latency of our approach is slightly higher compared to the other approaches as a small percentage of queries must be retried due to update conflicts (see Figure 2(a) and 2(b)). As updates are always answered in a single round trip, their latencies are consistently low as long as the nodes and network are not saturated.

The issue of query-update conflicts can be resolved by applying a simple batching scheme (see Sect. III-G): Each proposer processes at most one query and one update command at a time. During the time a request is processed, all new incoming commands of the same type (query or update) are batched. Once the ongoing request is completed the respective batch is submitted.

As this scheme limits the number of concurrently processed commands, the conflict probability is greatly reduced. Although no leader is used, more than $99$% of queries were processed within three round trips for some measured workloads. Thus, this batching scheme achieves similar throughput in mixed workloads as CRDT Paxos without batching in query- and update-only workloads, which are conflict-free and can be processed within a single round-trip.

IV-B Node Failure

One drawback to leader-based approaches is their brief unavailability during leader failure and the added complexity of implementing a leader election algorithm. As our approach does not require a leader, continuous availability can be achieved as long as a quorum of replicas is reachable. Figure 2(c) shows the impact of a node failure on the $95^{\mathrm{th}}$ percentile latency for 64 clients and 10 % updates. Latencies increase slightly for the base protocol without batching as all the remaining replicas must be consistent to reach a consistent quorum. This increases the likelihood of updates interference. In contrast, a failed replica improves the response latency when using our batching scheme because the number of concurrently proposed batches is decreased by one.

V Related Work

As previously mentioned, a wealth of consensus protocols were invented with the advent of the state machine approach [37], most notably Paxos [25, 24], Raft [32] and variations of them [31, 22, 27]. To partially alleviate the high synchronization costs incurred by consensus, numerous protocols were designed to exploit commutative operations [26, 31, 42]. In contrast to these generalized consensus protocols, which allow any pair of commands to commute with each other or not, our approach solves generalized lattice agreement [16] by requiring that all update commands commute with each other. This restriction simplifies the problem so that a high number of concurrent clients can be supported without the need for a leader or central coordinator. In contrast, solving (generalized) consensus often relies on efficient leader election [32, 2, 28] or multi-leader approaches [29, 13] to alleviate the leader performance bottleneck and impact on the system’s availability during a leader failure.

Starting with the original formalization of CRDTs [40], numerous works discuss the design and composition of these data structures [7, 33, 30, 10, 39]. Normal usage of state-based CRDTs require the transmission of the complete state while dispersing updates to remote replicas. This becomes costly when CRDTs grow larger. A solution to this problem is discussed by Almeida et al. [4] by only transmitting state-deltas instead of the complete data structure. Enes et al.  [15] show how to further reduce network bandwidth by refining state-delta based synchronization techniques. Auvolat et al. [6] encode state-based CRDTs into Merkle Search Trees for efficient access in large networks with high churn and low update rates.

Some CRDT designs suffer from state inflation, e.g., due to accumulation of tombstone values. Garbage collection mechanisms are discussed by Shapiro et al. [39]. Further research is needed to find ways to incorporate this into our protocol.

Several protocols that solve generalized lattice agreement in an asynchronous setting exist. Faleiro et al. [16] discusses a wait-free protocol in which a value is always learned in $\mathcal{O}(N)$ messages delays, where $N$ is the number of proposers. Zheng et al. [46] improve this upper bound to $min\{\mathcal{O}(h(L),\mathcal{O}(f))\}$, where $h(L)$ denotes the height of the input lattice and $f$ the number of tolerated failures. However, message sizes can grow unbounded with the number of proposed values in both approaches. Recent work [45] improves this bound further to $\mathcal{O}(\log{}f)$ round trips and also addresses the problem of truncating the internally managed command sets. Imbs et al. [23] solves lattice agreement by introducing a Set-Constrained Delivery (SCD) broadcast primitive, which is build on top of FIFO broadcast. SCD broadcasting a message requires $\mathcal{O}(N^{2})$ messages. All these approaches agree on growing sets of commands. In contrast, we agree on the resulting CRDT value directly, which enables some of the optimizations for reducing bandwidth discussed in Sect. III-G.

VI Conclusion

In this paper, we presented a protocol that provides linearizable state machine replication for state-based CRDTs. The protocol guarantees that updates always terminate in a single round trip. Even though wait-freedom is not provided for query commands in the presence of concurrent updates, our experimental evaluation showed that high throughput can be sustained even under highly concurrent access and without a leader-based deployment commonly used for consensus-related problems. In addition, our protocol is lightweight and requires no growing log as it has the memory and message size overhead of a single counter in addition to the replicated data. Thereby, no auxiliary processes for leader election or state management are required for a practical deployment of our approach. This contrasts our design to the original solution of the generalized lattice agreement problem [16], which is wait-free but requires additional effort to truncate the managed state or message sizes.

VII Acknowledgment

We thank Alexander Reinefeld for dedicated comments and valuable discussions that helped to improve this manuscript. This work was supported by the German Research Foundation (DFG) under grant RE 1389 as part of the DFG priority program SPP 2037 (Scalable Data Management for Future Hardware).