Conflict-free replicated data type

Operation-based CRDTs

Operation-based CRDTs are referred to as commutative replicated data types, or CmRDTs. CmRDT replicas propagate state by transmitting only the update operation. For example, a CmRDT of a single integer might broadcast the operations (+10) or (−20). Replicas receive the updates and apply them locally. The operations are commutative. However, they are not idempotent. The communications infrastructure must therefore ensure that all operations on a replica are delivered to the other replicas, without duplication, but in any order.

Pure operation-based CRDTs^[10] are a variant of operation-based CRDTs that reduces the metadata size.

State-based CRDTs

State-based CRDTs are called convergent replicated data types, or CvRDTs. In contrast to CmRDTs, CvRDTs send their full local state to other replicas, where the states are merged by a function which must be commutative, associative, and idempotent. The merge function provides a join for any pair of replica states, so the set of all states forms a semilattice. The update function must monotonically increase the internal state, according to the same partial order rules as the semilattice.

Delta state CRDTs^[12][13] (or simply Delta CRDTs) are optimized state-based CRDTs where only recently applied changes to a state are disseminated instead of the entire state.

Comparison

While CmRDTs place more requirements on the protocol for transmitting operations between replicas, they use less bandwidth than CvRDTs when the number of transactions is small in comparison to the size of internal state. However, since the CvRDT merge function is associative, merging with the state of some replica yields all previous updates to that replica. Gossip protocols work well for propagating CvRDT state to other replicas while reducing network use and handling topology changes.

Some lower bounds^[14] on the storage complexity of state-based CRDTs are known.

G-Counter (Grow-only Counter)

payload integer[n] P
    initial [0,0,...,0]
update increment()
    let g = myId()
    P[g] := P[g] + 1
query value() : integer v
    let v = 
 P[i]
compare (X, Y) : boolean b
    let b = (
 [0, n - 1] : X.P[i] 
 Y.P[i])
merge (X, Y) : payload Z
    let 
 [0, n - 1] : Z.P[i] = max(X.P[i], Y.P[i])

This CvRDT implements a counter for a cluster of n nodes. Each node in the cluster is assigned an ID from 0 to n - 1, which is retrieved with a call to myId(). Thus each node is assigned its own slot in the array P, which it increments locally. Updates are propagated in the background, and merged by taking the max() of every element in P. The compare function is included to illustrate a partial order on the states. The merge function is commutative, associative, and idempotent. The update function monotonically increases the internal state according to the compare function. This is thus a correctly-defined CvRDT and will provide strong eventual consistency. The CmRDT equivalent broadcasts increment operations as they are received.^[2]

PN-Counter (Positive-Negative Counter)

payload integer[n] P, integer[n] N
    initial [0,0,...,0], [0,0,...,0]
update increment()
    let g = myId()
    P[g] := P[g] + 1
update decrement()
    let g = myId()
    N[g] := N[g] + 1
query value() : integer v
    let v = 
 P[i] - 
 N[i]
compare (X, Y) : boolean b
    let b = (
 [0, n - 1] : X.P[i] 
 Y.P[i] 
 
 [0, n - 1] : X.N[i] 
 Y.N[i])
merge (X, Y) : payload Z
    let 
 [0, n - 1] : Z.P[i] = max(X.P[i], Y.P[i])
    let 
 [0, n - 1] : Z.N[i] = max(X.N[i], Y.N[i])

A common strategy in CRDT development is to combine multiple CRDTs to make a more complex CRDT. In this case, two G-Counters are combined to create a data type supporting both increment and decrement operations. The "P" G-Counter counts increments; and the "N" G-Counter counts decrements. The value of the PN-Counter is the value of the P counter minus the value of the N counter. Merge is handled by letting the merged P counter be the merge of the two P G-Counters, and similarly for N counters. Note that the CRDT's internal state must increase monotonically, even though its external state as exposed through query can return to previous values.^[2]

G-Set (Grow-only Set)

payload set A
    initial 

update add(element e)
    A := A 
 {e}
query lookup(element e) : boolean b
    let b = (e 
 A)
compare (S, T) : boolean b
    let b = (S.A 
 T.A)
merge (S, T) : payload U
    let U.A = S.A 
 T.A

The G-Set (grow-only set) is a set which only allows adds. An element, once added, cannot be removed. The merger of two G-Sets is their union.^[2]

2P-Set (Two-Phase Set)

payload set A, set R
    initial 
, 

query lookup(element e) : boolean b
    let b = (e 
 A 
 e 
 R)
update add(element e)
    A := A 
 {e}
update remove(element e)
    pre lookup(e)
    R := R 
 {e}
compare (S, T) : boolean b
    let b = (S.A 
 T.A 
 S.R 
 T.R)
merge (S, T) : payload U
    let U.A = S.A 
 T.A
    let U.R = S.R 
 T.R

Two G-Sets (grow-only sets) are combined to create the 2P-set. With the addition of a remove set (called the "tombstone" set), elements can be added and also removed. Once removed, an element cannot be re-added; that is, once an element e is in the tombstone set, query will never again return True for that element. The 2P-set uses "remove-wins" semantics, so remove(e) takes precedence over add(e).^[2]

LWW-Element-Set (Last-Write-Wins-Element-Set)

LWW-Element-Set is similar to 2P-Set in that it consists of an "add set" and a "remove set", with a timestamp for each element. Elements are added to an LWW-Element-Set by inserting the element into the add set, with a timestamp. Elements are removed from the LWW-Element-Set by being added to the remove set, again with a timestamp. An element is a member of the LWW-Element-Set if it is in the add set, and either not in the remove set, or in the remove set but with an earlier timestamp than the latest timestamp in the add set. Merging two replicas of the LWW-Element-Set consists of taking the union of the add sets and the union of the remove sets. When timestamps are equal, the "bias" of the LWW-Element-Set comes into play. A LWW-Element-Set can be biased towards adds or removals. The advantage of LWW-Element-Set over 2P-Set is that, unlike 2P-Set, LWW-Element-Set allows an element to be reinserted after having been removed.^[2]

OR-Set (Observed-Removed Set)

OR-Set resembles LWW-Element-Set, but using unique tags instead of timestamps. For each element in the set, a list of add-tags and a list of remove-tags are maintained. An element is inserted into the OR-Set by having a new unique tag generated and added to the add-tag list for the element. Elements are removed from the OR-Set by having all the tags in the element's add-tag list added to the element's remove-tag list. To merge two OR-Sets, for each element, let its add-tag list be the union of the two add-tag lists, and likewise for the two remove-tag lists. An element is a member of the set if and only if the add-tag list less the remove-tag list is nonempty.^[2]

Sequence CRDTs

A sequence, list, or ordered set CRDT can be used to build a Collaborative real-time editor, as an alternative to Operational transformation (OT).

Some known Sequence CRDTs are Treedoc,^[5] RGA,^[15] Woot,^[4] Logoot,^[16] and LSEQ.^[17] CRATE^[18] is a decentralized real-time editor built on top of LSEQ and runnable on a network of browsers using WebRTC. LogootSplit ^[19] was proposed as an extension of Logoot in order to reduce the metadata for sequence CRDTs. MUTE ^{[20] [21]} is an online web-based peer-to-peer real-time collaborative editor relying on LogootSplit algorithm.