Clairvoyant State Machine Replication

TL;DR

This paper introduces a leaderless Byzantine consensus protocol that uses non-skipping timestamps and conflict information to enable faster transaction commits without leader elections in asynchronous systems.

Contribution

It presents a novel leaderless protocol for Byzantine generalized consensus that leverages conflict-aware timestamps, improving efficiency over leader-based methods.

Findings

Achieves consensus with n > 4f servers in asynchronous Byzantine settings.

Eliminates leader election pauses, enabling continuous operation.

Allows early transaction commits based on conflict detection.

Abstract

We propose a new protocol for the generalized consensus problem in asynchronous systems subject to Byzantine server failures. The protocol solves the consensus problem in a setting in which information about conflict between transactions is available (such information can be in the form of transaction read and write sets). Unlike most prior proposals (for generalized or classical consensus), which use a leader to order transactions, this protocol is leaderless, and relies on non-skipping timestamps for transaction ordering. Being leaderless, the protocol does not need to pause for leader elections. The use of non-skipping timestamps permits servers to commit transactions as soon as they know that no conflicting transaction can be ordered earlier. For n servers of which f may be faulty, this protocol requires n > 4f.

Full text

1 Introduction

A distributed ledger is a distributed data structure, replicated across multiple nodes, where transactions from clients are published in an agreed-upon total order. Today, Bitcoin [25] is perhaps the best-known distributed ledger protocol.

There are two kinds of distributed ledgers. In permissionless ledgers, such as Bitcoin, any node can participate in the common protocol by proposing transactions, and helping to order them. In permissioned ledgers, by contrast, a node must be authorized before it can participate. Permissionless ledgers make sense for cryptocurrencies which seek to ensure that nobody can control who can participate. Permissioned ledgers make sense for structured marketplaces, such as financial exchanges, where parties do not necessarily trust one another, but where openness and anonymity are not goals. State machine replication [32] is the most common way to implement permissioned ledgers.

In state machine replication, the servers agree on a total order for all transactions, and every server executes the transactions in the same order. If two successive transactions commute, the two transactions can be executed in different orders by different servers. To determine if two transactions commute, we can check if the state variables accessed for reading or writing (read and write sets) by one transaction are written to by the other transactions and vice-versa. Existing state machine replication protocols are limited in their ability to exploit transaction commutativity. Protocols that exploit general transaction commutativity solve what is called the generalized consensus problem in which a dependency structure is assumed on the transactions [28, 18]. Published work on generalized consensus, [18, 28, 29, 33]with few exceptions, is limited to systems with servers subject to crash failures. Pires et al. [30] propose a leader-based generalized state machine replication algorithm, and Abd-El-Malek et al. [1] propose a client-driven quorum-based protocol called Q/U that is very efficient under low contention, but that requires $n>5f$, and can suffer from livelock in the presence of contention even in synchronous periods.

The contribution of this paper is a novel permissioned ledger algorithm, which we call Byblos. Byblos has three properties of interest.

• •

Generality. Byblos exploits semantic knowledge about client requests to reduce transaction latency. Client transactions include statically-declared read and write sets. The technical key to effectively exploiting semantic knowledge is a novel use of non-skipping timestamp [5] to bound the set of in-flight transactions that might end up ordered before a particular transaction. If an otherwise-complete transaction does not conflict with any of its potential predecessors, that transaction can be committed without further delay. For system loads with few conflicts between transactions, solutions for generalized consensus can be much more efficient than solutions for traditional consensus [18].

• •

Leaderless. Byblos is leaderless. With some exceptions [1, 9, 21], prior replicated state machine algorithms use a leader to order client requests. Leader-based algorithms typically have two kinds of phases: a relatively simple normal phase where the leaders send and receive messages to the others, and a complicated “view change” phase [11, 16, 20, 34] used to detect and replace faulty leaders. Leader election comes at a cost: client requests are typically blocked during leader election even in periods of synchrony. Such delays are especially problematic if valuable periods of synchrony are spent electing leaders instead of making progress. (Other leaderless protocols, such as EPaxos [23], make similar observations.)

In Byblos, transactions are guaranteed to terminate in periods of synchrony. Technically, Byblos does not need a leader because it is centered around a leaderless non-skipping timestamp algorithm.

• •

Simple. Byblos is simple to explain and understand. While simplicity is subjective, readers who are familiar with other protocols for Byzantine fault tolerance will note that the full protocol is described in this paper.

In Byblos, transactions are ordered by timestamp, with ties resolved through some canonical ordering such comparing transaction identifier hashes. For a given timestamp value $t$, Byblos can determine an upper bound on the set of in-flight pending transactions that might have timestamp $t$ assigned to them. We say this ability to bound the set of potentially conflicting pending transactions makes Byblos clairvoyant. If a transaction $T$ with timestamp $t$ is the next one to be executed by a replica among those transactions with timestamp $t$, and $T$ does not conflict with any of the pending transactions, then $T$ can be executed without waiting for the status of the pending transactions to be resolved. Byblos guarantees progress by calling on an “off-the-shelf” asynchronous Byzantine agreement algorithm, preferably early deciding [7, 35], to CANCEL or COMMIT pending transactions 111Asynchronous consensus algorithms are those that guarantee safety at all times, and progress under eventual synchrony.

Byblos tolerates $f<n/4$ faulty servers, assuming the underlying consensus algorithm does the same. If there are no conflicts between pending transactions and transactions waiting for execution, Byblos can make progress even in periods of complete asynchrony. (This claim does not contradict the FLP impossibility result [15].)

The rest of the paper is organized as follows. Section 2 discusses related work. Section 3 introduces the problem and the system model. Section 4 gives a detailed description of Byblos assuming clients fail by crashing and Section 5 proves its correctness and Section 6 describes how Byzantine clients can be tolerated. Section 7 discusses the performance of Byblos under various assumptions on failures and synchrony and Section 8 concludes the paper.

2 Related Work

Leader-based distributed ledgers such as Paxos [17] and Raft [27] do not exploit knowledge of read-write sets to reduce latency and increase throughput. Distributed ledgers that do exploit such information include Generalized Paxos [18], Egalitarian Paxos [23], Hyperledger Fabric [10], NEO [26], and Bitcoin itself [25].

There is a large body of literature on state machine replication, most of which is leader-based. Clement et al. [12] observe that many Byzantine fault-tolerant (BFT) protocols can perform poorly in the presence of Byzantine failures. They define the notion of a fragile optimization, where a single misbehaving party can knock the system off an optimized path. They also define gracious (synchronous, non-faulty) and uncivil (synchronous, limited Byzantine faults) executions. They argue that while most BFT protocols are optimized only for gracious executions, it is also important that protocols perform well in uncivil executions. They propose Aardvark, a BFT protocol designed to perform well under uncivil executions. Aardvark uses a leader, with regularly-scheduled view changes. The protocol includes safeguards against censorship by the leader. Amir et al. [2] introduce bounded delay as a performance goal for BFT protocols. Bounded delay captures the inability of Byzantine servers or clients to impose arbitrary delays on transaction processing. They introduced Prime, a BFT protocol that uses a leader that is monitored by other servers to provide bounded delay in the presence of limited Byzantine failures.

Paxos [17] and Raft [27] are perhaps the best-known non-Byzantine replication protocols. Other Paxos-related non-Byzantine protocols include Mencius [19] and EPaxos [23]. These protocols, with the exception of EPaxos [23], use some form of leader (or leaders) and view changes. Milosevic et al. [22] proposed a BFT-Mencius which also uses performance monitoring and view changes to limit the effects of slow servers. Byblos does not use view changes or performance monitoring and hence allows unbounded variance below the timeout threshold.

Prior protocols that perform relatively well under uncivil executions perform less well in civil executions, compared to protocols optimized only for civil executions. Byblos is different. Its latency, measured in the number of message round trips, is comparable to protocols optimized for civil execution. In the absence of slow or faulty clients, its latency in uncivil executions is also comparable to that of protocols optimized for civil executions. On the downside, Byblos uses signatures, whereas some protocols use faster message authentication codes.

One BFT protocol that does not use leaders or view changes is HoneyBadgerBFT [21]. Unlike most BFT protocols, HoneyBadgerBFT does not assume eventual (or partial) synchrony, but relies on a randomized atomic broadcast protocol with a cryptographic shared coin. HoneyBadgerBFT ensures censorship resistance through a cryptographic subprotocol. Unlike Byblos, HoneyBadgerBFT does not exploit transaction semantics. The RBFT BFT protocol [4] uses multiple leaders, who track one another, and provide censorship resistance. It is designed for systems in which clients can have multiple parallel pending requests. Aublin et. al [3] describe a family of protocols, some of which have low (2-message) latency in synchronous executions.

As noted, the protocols discussed, with the exception of EPaxos [23] which only tolerates crash failures, do not solve the generalized consensus problem [18, 28]. Abd-El-Malek et al. [1] propose a client-driven quorum-based protocol called Q/U that is very efficient under low contention, but that requires $n>5f$ and can suffer from livelock due to contention even in synchronous periods. The algorithm is leaderless and uses exponential backoff in the presence of contention. Cowling et al. [13] aims at improving Q/U by reverting to using a leader. Recently Pires et al. [30] proposed a leader-based Byzantine version of generalized Paxos.

In general, faulty clients in Byblos can force servers to revert to an “off-the-shelf” binary Byzantine consensus protocol to resolve the outcome of “stuck” transactions. Triggering the agreement protocol might incur a timeout which can be significantly larger than typical communication delay even for fast protocols (for example, Ben-Or et al. [8] or Mostefaoui et al. [24]). It might seem that Byblos replaces one source of delay (a faulty leader) with another (faulty clients), but this replacement allows us to exploit transaction semantics which can be a significant improvement in some settings. In systems in which faulty servers can delay the processing of transactions (which is almost all systems), everyone is delayed. (These issues are discussed in Section 7.)

3 Problem and System Model

A ledger (Figure 1) can be thought of as an automaton consisting of a set of states (for example, clients’ account balances), a set of deterministic state transitions called transactions ( for example, deposits, withdrawals, and transfers), and a log recording the sequence of transactions. The state is needed to efficiently compute transactions’ return values (for example, overdrawn account). The log provides an audit trail: one can reconstruct any prior state of the ledger, and trace who was responsible for each transaction.

Our solution encompasses the following components. There are $n$ servers that maintain the ledger’s long-lived state via a set of replicated logs. Up to $f$ of $n=4f+1$ servers may be Byzantine (not behaving according to the protocol). The rest of the servers are correct. The logs of correct servers are only modified by appending new transactions. The servers satisfy the following safety property: for any pair of correct servers, one server’s log is a prefix of the other’s. It follows that correct servers execute all transactions in the same order.

There is a potentially unbounded number of clients who originate transactions. It is the servers’ job to accept transactions from clients, order them, and publish this order. We assume that the clients are not Byzantine; in Section 6 we explain how to handle Byzantine clients.

Communication is handled by an underlying message-diffusion system. Clients broadcast messages, which are eventually delivered to all correct servers. Servers communicate with one another through the same diffusion infrastructure. We assume that messages are delivered in the order they are sent which can be easily implemented in practice using message counters. We assume that the identity of the sender is included in the message and that messages cannot be forged; a client or server cannot send a message to another server or client that has a different sender than the actual sender. In practice, this is enforced using signatures.

The ledger state is a key-value store. Each client transaction declares a read set, the set of keys it might possibly read, and a write set, the set of keys it might possibly write. Any transaction that violates its declaration is rejected. (Systems such as Generalized Paxos [18], Egalitarian Paxos [23], and NEO [26] all make use of similar conflict declarations.)

4 Byblos Description

In Byblos, transactions are assigned integer timestamps, which partially determine the order in which transactions are applied. If two transactions do not overlap in time, the later one will be assigned a larger timestamp, but overlapping transactions may be assigned the same timestamp. One can think of assigning a timestamp as assigning a slot to a transaction. Non-overlapping transactions will be in different slots, but overlapping transactions might be in the same slot. The protocol we use for assigning timestamps guarantees that a new slot will not be assigned to a transaction before every previous slot has at least one transaction in it. This is guaranteed by non-skipping property of the assigned timestamps [5]: if a timestamp $t$ is assigned to a transaction, then every timestamp whose value is less than $t$ must have been previously assigned to some other transaction.

The non-skipping timestamp protocol [5] at the heart of the algorithm is simple. A client broadcasts a timestamp request to the servers, and collects at least $n-f$ timestamps in response. The client selects the $(f+1)^{\textrm{st}}$ latest timestamp, which is guaranteed to be less than or equal to the latest timestamp assigned to any transaction. The client increments that timestamp by one, and later broadcasts it to the servers. It has been shown [5] that this way of choosing timestamps ensures that no timestamp value is skipped.

The properties of non-skipping timestamps suggest a simple way for servers to execute transactions in a deterministic order in the absence of client failures. Starting with timestamp 1, execute all transactions with timestamp 1 in some deterministic order, then execute all transaction with timestamp 2 in some deterministic order, and so on. In general, once all transactions with timestamp $t$ are executed, transactions with timestamp $t+1$ can be executed. This technique is, of course, too simple, even in the absence of client failures. The catch is that servers cannot determine when all transactions with a given timestamp value have been received.

To determine when all transactions with timestamp $t$ have been received, Byblos calculates for each timestamp $t$, a set of pending[$t$] of transactions that were detected to be concurrent with, or occurring before transactions with timestamp $t$. The set of pending transactions contains transactions, but not their assigned timestamps, because those timestamps might not be known at the time a transaction is added to a pending set. The crucial property is the following: pending[$t$] is guaranteed to contain all transactions whose assigned timestamp will be $t$ or less. However, it may also include some transactions that will be assigned timestamps larger than $t$. For a given transaction $T$ with timestamp $t$, if the timestamps of the transactions in pending[$t$] are known, then, by the property of the pending set, the set of all transaction that could be assigned timestamp $t$ is also known. In the absence of client failures, servers can execute transactions as follows: transactions with timestamp $t$ can be executed when the timestamps of all transactions in the pending set become known and all transactions ordered earlier have been executed.

Servers can do better by taking into consideration potential conflicts between transactions. Given a deterministic ordering on transactions, with transactions with smaller timestamps appearing before transactions with larger timestamps in the order, a transaction $T$ with timestamp $t$ can be executed when all conflicting transactions that appear before $T$ in the order are executed and there are no conflicting transactions in the pending set that could be ordered before $T$ (this requires that the timestamps of those conflicting transactions be known).

The description so far assumes no client failures. If clients can fail, some transactions in the pending set might never be assigned timestamps, and the servers will be stuck, unable to determine when all potentially conflicting transactions with timestamp $t$ have been received. We resolve this situation by falling back to a binary consensus algorithm, over the values COMMIT and CANCEL, to resolve the fates of orphaned transactions. Each client tries to commit its own transaction using the consensus algorithm, and servers try to cancel pending transactions that are slow to receive their timestamps. We can use any ”off-the-shelf” consensus algorithm that is guaranteed to terminate if the system is eventually synchronous, including known algorithms that terminate in one round if the system is well-behaved [35]. Transaction execution proceeds as follows. Once all conflicting transactions in the pending set of some transaction $T$ with timestamp $t$ are either cancelled or their timestamp is known, the position of $T$ in the order will be known and the execution can then proceed as outlined above for all transactions that have not been cancelled.

The protocol guarantees safety at all times and liveness under eventual synchrony [11]. The rest of this section describes the client and server code in details. In this description we assume that clients can fail by crashing but are not Byzantine. We address Byzantine clients in Section 6.

4.1 Client Code

The client code (Figure 2) proceeds in two stages. In the first stage (Lines 5–11), the client sends a Propose message to all servers, and collects at least $n-f$ ProposeAck responses. Each response contains an integer timestamp that is the local clock value at the server when the server received the client request. The client calculates $\hat{t}$ which is equal to 1 plus the $(f+1)^{\textrm{st}}$ largest among the timestamps it received and assigns it to its transaction. It is important to note that this particular way of choosing timestamps is what guarantees timestamps to be non-skipping. In the second stage (Line 14–21), the client broadcasts a Confirm message with $\hat{t}$,and waits to receive $f+1$ identical ResolveAck responses to determine the transaction’s outcome. A ResolveAck message has three fields: (1) the transaction, (2) a code, either COMMIT or CANCEL, and (3) a result. If the return code is COMMIT, the call was successful, and the result is returned, otherwise a failure indication is returned. If the return code is CANCEL, the call was unsuccessful. perhaps because the client was delayed in the middle of the protocol. If a failure indication $\bot$ is returned, the client is free to attempt the call again.

4.2 Server Code

4.2.1 Server State

The server state (Figure 3 ) is composed of the following fields.

• •

state is the ledger state. A transaction is applied to state when it commits.

• •

clock is an integer counter that tracks the latest timestamp assigned to a transaction. We assume this counter does not overflow. Since timestamps are non-skipping, a 128-bit counter should be more than sufficient in practice.

• •

proposed keeps track of transactions that have been proposed at various servers and the local clocks at those servers when the proposed message was received. When a transaction is added to proposed[$s$][$\mit{k}$], where $s$ is a server and $\mit{k}$ is a clock value, the timestamp of the transaction might not be known.

• •

pending is a map from timestamps to sets of transactions. For timestamp $t$, pending[t] is the set of transactions that might be assigned timestamp $t$ or earlier.

• •

confirmed is a map from timestamps to sets of transactions. For timestamp $t$, confirmed[t] is the set of known transactions that will either commit with timestamp $t$ or will be cancelled.

• •

committed is set of transactions known to have committed.

• •

cancelled is the set of transactions known to be cancelled.

• •

log is the sequence of committed transactions as they are applied to the ledger.

• •

timer is an array of timers used to timeout pending transactions.

• •

time is a local time at the server to measure real time for timeouts. The local time of servers are independent and need not be synchronized.

4.2.2 Server Actions

The server continually receives messages (Figure 4). In the pseudocode we denote the sender of a message received by a server with $c$ if the sender is a client and with $s$ if the sender is a server.

When the server receives a Propose(T) (Lines 2–5) message from client c, it adds (T,clock) to proposed[self], where self denotes the server executing the code and clock is the local clock value when the proposed message is received. The server returns the current clock value to the client and forwards the proposed message together with the clock value at which it was received to all other servers. When a server receives a forwarded Propose message from server s, it adds the message to the set proposed[s] of proposed messages that server s is aware of. These sets of messages will be used in calculating the sets of pending transactions for any timestamp value.

When a server receives a Confirm(T,$\hat{t}$) (Line 10) message from a client or a server, the server advances clock to the maximum of $\hat{t}$ and its current value, and adds the transaction to the set of confirmed transactions for timestamp $\hat{t}$ and forwards the Confirm message to the other servers. If the received Confirm message is from a server s, s is added to a set ConfirmWitness[T], which is the set of servers that has received the Confirm message for transaction T. If the set of witnesses is large enough, and the set pending[$\hat{t}$] is not yet calculated, the server calculates the set pending[$\hat{t}$] by taking the union of all propose messages that servers in the set of witnesses were aware of before receiving the Confirm message for T . We will show that this pending set is guaranteed to contain all transactions that can be confirmed with timestamp $\hat{t}$ or less. Finally, if the transaction T for which the Confirm message is received is not in the process of being resolved (not resolving), the server also launches a consensus protocol with the other servers to try to to COMMIT T. The consensus protocol is run in a ResolveThread forked by the server (Figure 5).

The only remaining point that can obstruct T’s execution are pending transactions. These are transactions that might be confirmed with timestamps less than or equal to the timestamp of T and, if they conflict with T, will be applied to the log before T. The server sets a timer to give each pending transaction time to be confirmed. If the timer expires and a transaction in the pending set is not confirmed, the transaction is considered obstructing, and a starting a consensus protocol is launched to try to CANCEL the the transaction. In practice, timer delay can be adjusted dynamically to match the current level of synchrony [20]. We discuss the timer requirements later in the correctness proofs.

The ResolveThread (Figure 5) encapsulates the consensus protocol executed by the servers. The first message sent by ResolveThread is a StartResolution(T,code) message (Line 2 of ResolveThread) which lets a server that has not heard directly from a client join the consensus protocol for a given transaction (Lines 23–32 of the server code). After sending the StartResolution message, the ResolveThread starts a binary consensus protocol for the transaction with initial value 1 for COMMIT and initial value 0 for CANCEL. The ResolveThread adds $T$ to the set committed if the decision of the consensus protocol is 1 and adds $T$ to the set cancelled if the decision of the consensus protocol is 0.

When a server receives a StartResolution(T,code), its behavior depends on whether code is COMMIT or CANCEL. A server immediately joins an attempt to commit a transaction, but joins an attempt to cancel a transaction if it receives $f+1$ distinct StartResolution(T,CANCEL) messages for transaction $T$, ensuring that at least one correct server timed out that transaction.

Finally, a server attempts to apply transactions (Figure 6) to the replica state. It is essential that conflicting transactions are executed in the same order by all servers. We use the OrderBefore() predicate which to determine the order of confirmed transactions (whose timestamps are known). Servers order confirmed transactions first by timestamp, and then by hashing their transaction identifiers, yielding a deterministic order on transactions, called the canonical order (Figure 6, Line 3). If any transaction is not confirmed, the OrderBefore() predicate evaluates to false.

A transaction can be applied once is committed and confirmed for timestamp $t$, the set of pending transactions for $t$ is known, and if every other transaction T” in the pending set is either non-conflicting, cancelled, or already applied to the log.

Note that it is possible that pending transactions might appear in groups with different timestamps at different correct servers, but if they become committed, they will have the same timestamp at all correct servers, and if they are cancelled, they will be cancelled by all correct servers.

5 Proofs of Correctness

In this section we prove that the solution correctly implements a distributed ledger by showing that client transactions receive the same responses from all correct replicas, and that in periods of synchrony the non-faulty clients’ transactions are eventually applied.

We start by restating the model assumptions. Messages are delivered in the order sent: if a correct server $s_{1}$ receives a forwarded Confirm message from another correct server $s_{2}$, then $s_{1}$ must have received all previously forwarded Propose messages from $s_{2}$. In periods of synchrony, the binary consensus protocol is guaranteed to terminate. All correct servers invoke ResolveThread), and either they all add the transaction to the committed set, or they all add the transaction to the cancelled set. Finally, client messages forwarded by servers are signed by the clients and cannot be forged. (We omit message validation from our code for simplicity.)

5.1 Supporting Lemmas

Lemma 1 (Same confirmed timestamp)

If a transaction is confirmed with timestamps $t$ and $t^{\prime}$ at two correct servers, then $t=t^{\prime}$.

Proof

A transaction is added to a the confirmed set if a Confirm(T,$\hat{t}$) is received from a client directly or indirectly forwarded by a server (Figure 4 Line 10). Since messages by the client are assumed to be signed by the client and clients are assumed to be non-Byzantine, a server cannot forge a confirm message and the confirm message sent by the client to different servers will have the same timestamp.

The previous lemma allows us to define what it means for a transaction to be assigned a timestamp value.

Definition 1 (Assigned timestamp)

We say that a transaction $T$ is assigned timestamp $t$ if some correct server received a Confirm(T, $\hat{t}$) message from a client.

Lemma 2 (Non-Skipping timestamps)

If a transaction is assigned timestamp $t$, then for every $t^{\prime}$, $0<t^{\prime}<t$, some transaction is assigned timestamp $t^{\prime}$.

Proof

We show that for any $t_{0}$, the first timestamp larger than $t_{0}$ assigned to a transaction is $t_{0}+1$. Consider the first transaction ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}^{\prime}$ for which a timestamp $t^{\prime}>t_{0}$ is assigned. The client must have received replies greater than or equal $t^{\prime}-1$ from $f+1$ servers one of which must be correct.

Consider the correct server that returned a timestamp $t^{\prime\prime}\geq t^{\prime}-1\geq t_{0}$. The timestamp $t^{\prime\prime}$ must have been assigned to an earlier transaction because the clock can only advance at a correct server after a timestamp is assigned (Line 11). This means that $t^{\prime\prime}$ cannot be greater than $t^{\prime}-1$ for otherwise an earlier transaction is assigned timestamp larger than $t_{0}$. But $t^{\prime}-1\geq t_{0}$, which gives us $t^{\prime\prime}\leq t_{0}$. So, we have established that $t_{0}\leq t^{\prime}-1\leq t^{\prime\prime}$ and $t^{\prime\prime}\leq t_{0}$, which means that $t^{\prime\prime}=t_{0}$ and $t^{\prime}=t_{0}+1$.

The next two lemmas establish that if ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ does not see ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$, then ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ must have a larger timestamp and executing ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ can be done without establishing the resolution status of ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$. We start with a definition of what it means for a transaction to see another.

Definition 2 (Transaction seeing another)

We say a transaction $T_{1}$ sees that is assigned timestamp $t_{1}$ sees transaction $T_{2}$ if $T_{2}$ is added to the pending[$t_{1}$] set of some correct server.

Lemma 3 (Non-concurrent transactions get different timestamps)

If ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ does not see ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ and $t_{1}$ is assigned a timestamp, then ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ is assigned a later timestamp.

Proof

Suppose ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ are assigned timestamps $\hat{t}_{1}$ and $\hat{t}_{2}$ respectively. When a correct server receives ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s Confirm message, its clock value will be at least $\hat{t}_{1}$ (Line 11). Since ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ is assigned a timestamp, its Confirm message is received by some correct server, and eventually all correct server will receive ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s Confirm message. It follows that that there will be enough witnesses to ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s Confirm message and pending[$t_{1}$] will be calculated by every correct server (Line 16), When pending[$t_{1}$] is calculated, a set of $n-f$ servers, which we will call $S_{1}$, has confirmed the receipt of ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s Confirm message with timestamp $\hat{t_{1}}$. Because ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ did not see ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ , ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$’s Propose message could not have preceded ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s Confirm message at any correct sever in $S_{1}$.

Let $S_{2}$ be the set of servers that acknowledge ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$’s Propose messages. Every correct server in $S_{2}$, added ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ to the proposed set and returned its local clock value to the client (Line 8). Because ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{S}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{S}}}}}}_{2}$ both have size at least $n-f$, their intersection includes at least $f+1$ correct servers. At each of these servers, ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$’s Propose message arrived after ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s Confirm message, so ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ received at least $f+1$ ProposeAck messages with timestamp values greater than or equal to $\hat{t}_{1}$, so ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ will choose $\hat{t}_{2}$ greater than $\hat{t}_{1}$.

It follows that, for a given transaction T with timestamp $\hat{t}$, the set ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ at a correct server contains only transactions that can be assigned timestamp $\hat{t}$ or less because any transaction not in the set will be assigned a timestamp larger than $t$. But we need to be sure that if ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ at a given correct server is not empty, then it will contain all transaction that could ever be in ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{confirmed}}}}}}[t^{\prime}]$, $t^{\prime}\leq t$. This would allow the server to detect when all conflicting transactions with timestamp $t$ or less have been resolved (COMMIT or CANCEL), at which time it can execute those among them that have not been cancelled. The following lemma establishes this fact.

Lemma 4 (pending has all the information needed to resolve transactions)

At all times, ${\bigcup_{t^{\prime}<t}\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{confirmed}}}}}}[t^{\prime}]\subseteq P$, where ${P=\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ is a non-empty ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ set calculated by a correct server.

Proof

The lemma states that any transaction that will ever be confirmed with timestamp less than or equal to $t$ must be in every ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ set calculated by a correct server. The proof is similar to the proof of 3. Let T be a transaction that is assigned timestamp $t$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ by the pending set calculated by a correct server on the receipt of T Confirm message when there are enough witnesses to the Confirm message. If a transaction T” will be assigned timestamp $t^{\prime}\leq t$, then at most $f$ servers reply to the client’s Propose message with timestamp value greater than $t^{\prime}-1$. Of the remaining $n-2f$ servers, at most $f$ are faulty, which leaves $f+1$ correct servers that reply to the propose message with a timestamp less than $t^{\prime}$. One of these $f+1$ servers must forward T’s Confirm message and must have forwarded the Propose message before that. It follows that ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ must contain transaction T.

5.2 Safety

We start by showing that all correct servers execute conflicting transactions in the same order, and that all correct servers execute the same transactions. Then we show that the execution at each correct server is equivalent to a “canonical” execution in which transactions (even non-conflicting ones) are executed according to timestamp order (with ties broken canonically). This implies that correct servers return the same result for each transaction. Then we show that the execution is linearizable by showing that it is equivalent to an execution in which each transaction is executed atomically at some point between its invocation and response.

Lemma 5 (Same order for applied conflicting transactions)

If two correct servers apply two conflicting non-cancelled transactions ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ to the log, they apply them in the same order.

Proof

If ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ are two conflicting non-cancelled transactions and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ is applied before ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$, then OrderBefore(${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$,${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$) must be true, implying that that ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$’s assigned timestamp is smaller than that of ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$, or that both are assigned the same timestamp and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ appears before ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ in the canonical order. This property holds at every correct server, so all correct servers that apply both transactions will apply them in the same order.

Lemma 6 (Agreement on transaction resolution)

If a correct server decides to commit or cancel a transaction, then every correct server eventually makes the same decision.

Proof

The decision to commit or cancel a transaction depends on the decision of the consensus protocol initiated in the ResolveThread (Figure). By the agreement property of consensus, any two correct servers will have the same decision value.

Definition 3 (Canonical execution)

A canonical execution is one that contains all transactions applied to the log of some correct server ordered by first by timestamp, then by transaction hash code. Cancelled transactions with unknown timestamp are assumed to be assigned the smallest timestamp for which they appear in a pending set of a correct server.

Since all correct servers execute the same sequence of transactions, this definition is independent of the particular correct server chosen.

Lemma 7 (Every execution is equivalent to the canonical execution)

The responses of transactions as applied to the log of a correct server is identical to the responses of the same transactions as they appear in the canonical execution.

Proof

We consider an execution $E$ of a correct server in which transactions are applied as allowed by the protocol. We say that two transactions ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ are out-of-order if ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ appears before ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ in $E$ but ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ appears before ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ in the canonical execution. We prove by induction on the number of out-of-order pairs of transactions that $E$ is equivalent to the canonical execution. For the base case, there are no out-of-order transactions and $E$ is the canonical execution. For the induction step, since $E$ has at least one out-of-order pair of transactions, it must have to successive transactions, say ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$, that are out of order. Consider the execution E” which is identical to varE’ except that ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ appears before ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ in E”. We show that E” and $E$ are equivalent. Also, compared to $E$, E” has exactly one less pair of transaction that are out-of-order. It follows by the induction hypothesis E” is equivalent to the canonical execution, so $E$ is also equivalent to the canonical execution.

Since ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ are out of order in $E$, it follows that either both are committed and do not conflict or at least one of them is cancelled. If one of them is cancelled, it is immediate that E” and $E$ are equivalent. If ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ do not conflict, we divide E” into three parts: (1) $E_{b}$ of transactions that appear before ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$, (2) ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ followed by ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$, and (3) \mbox{E}_{a} of transactions that appear after ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$. The execution of \mbox{E}_{b} is the same in $E$ and E”, so the state of the ledger is identical in $E$ and E” after executing \mbox{E}_{b}. Since ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ and ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ do not conflict, they access and modify different parts of the state (read and write sets are disjoint), so executing ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ followed by ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ after \mbox{E}_{b} will result in the same ledger state and same responses as executing ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{1}$ followed by ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{T}}}}}}_{2}$ \mbox{E}_{b}. Finally \mbox{E}_{a} is identical in $E$ and E” and executed starting from the same ledger state, so all transactions in \mbox{E}_{a} will return the same response.

Theorem 5.1 (Linearizability)

The implementation is linearizable.

Proof

Since all applied transactions are committed and correct servers commit the same set of transactions, it follows that the sets of transactions applied by correct servers are the same. The previous lemma shows that the responses of transactions applied by the correct servers is the same. It remains to define an execution that is consistent with real time order and consistent with the executions of correct servers and such that a transaction takes effect somewhere between its invocation and response in this execution. For each transaction, we assign the real time at which the first correct server adds the transaction to its log and we define an execution in which transactions are ordered according to this order and in which their responses are as they are for the executions of correct servers. This execution is consistent with the protocol order. It follows that it is equivalent to the canonical order and therefore equivalent to the execution of every correct server. Finally, the assigned time for a transaction is somewhere between its invocation and response because a response is not produced before a correct server adds the transaction to its log.

5.3 Progress

In periods of synchrony we assume there is an upper bound $d$ on message transmission. For a correct client that sends messages to all servers, we assume that the maximum delay in the reception of messages between servers is $d$. We consider processing delay at correct servers to be negligible.

Lemma 8

If $\delta>2d$, all transactions of correct clients will be committed.

Proof

We consider a transaction T of a correct server that is initiated at real time $t_{1}$ and that is assigned timestamp $\hat{t}$. At time $t_{1}+3d$ every correct server will receive a message Confirm(T,$\hat{t}$) for the transaction. The earliest time at which T can the ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t^{\prime}]$ set of a correct server for some $t^{\prime}$is $t_{1}+d$. So, the earliest time to propose to CANCEL T being $t_{1}+d+\delta$ (Figure 4, Line 17). Since $\delta>2d$, a correct server will receive Confirm(T,$\hat{t}$) and adds T to resolving before time $t_{1}+\delta$ and the server will propose to COMMIT the transaction at that time. So, we have shown that no correct process will propose to CANCEL a transaction by a correct client in periods of synchrony. It follows that the transaction will be committed. In fact, all but the $t$ faulty servers will propose to COMMIT the transaction. By the validity requirement of the consensus protocol, the decision of all correct servers should be to COMMIT.

Lemma 9 (Pending transactions are resolved)

If ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]\neq\emptyset$ at a correct server, all transactions in ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]$ will eventually be resolved at every correct server.

Proof

Every transaction in ${\mbox{\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@language\lst@@@set@numbers\lst@@@set@language\lst@@@set@numbers{\@listingGroup{ltx_lst_identifier}{pending}}}}}}[t]\neq\emptyset$ will be proposed to be committed or cancelled (Figure 4, Line 20 or 39) and every correct server will eventually commit or cancel the transaction.

Theorem 5.2 (Progress in periods of synchrony)

In periods of synchrony, all transactions of correct clients are applied.

Proof

Lemma 9 shows that all transactions of correct clients will be committed in periods of synchrony. It remains to show that transactions of correct clients will be applied by the servers. Consider a committed transaction T of a correct client $c$ with timestamp $\hat{t}$. We need to show that T will be applied. At the time a correct server receives the Confirm message for T, it will calculate the pending set if the set if empty and the set will have to contain the transaction T. By Lemma 9, each transaction in that set will eventually be committed or cancelled. This means that the termination condition (Figure 6, Line 7) is guaranteed to be satisfied for every transaction that can be applied before T. Each correct server will then be able to apply all non-cancelled transactions in confirmed[t’] for every $t^{\prime}<t$.

6 Byzantine Clients

We have assumed clients fail by crashing, To tolerate Byzantine client behavior, we must perform additional validation. In particular, each client must prove that the the timestamp in its Confirm message is correctly constructed by including the signed timestamps Avoiding replay attacks is straightforward by having the servers sign a cryptographic hash of the messages they send to the clients, including transaction identifiers, which serve as nonces.

7 Performance

To evaluate performance, we adopt the definitions of gracious and uncivil executions from Clement et al. [12].

Definition 4 (Gracious execution [12])

An execution is gracious if and only if (a) the execution is synchronous with some implementation-dependent short bound on message delay and (b) all clients and servers behave correctly.

Definition 5 (Uncivil execution [12])

An execution is uncivil if and only if (a) the execution is synchronous with some implementation-dependent short bound on message delay, (b) up to $f$ servers and an arbitrary number of clients are Byzantine, and (c) all remaining clients and servers are correct.

7.1 Performance in gracious executions

7.1.1 Performance in the absence of contention

In gracious executions, and in the absence of contention, the protocol requires 2.5 round-trip message delay from the time a client makes a request to the time it gets the result. It takes one round-trip delay to receive the first response and calculate the timestamp $\hat{t}$. It takes 1/2 round-trip delay for the servers to receive $\hat{t}$. At that time, (1) correct servers initiate a consensus protocol to commit the transaction and (2) forward the Confirm message to all other servers. Another 1/2 round-trip delay later (2 round-trip delay from the start of the transaction), all correct servers decide to COMMIT the transaction (this is possible because all correct servers will be proposing the same COMMIT value) and calculate the pending sets. At that point , the transaction can be executed (in the absence of contention) and a response is received another 1/2 round-trip delay later at 2.5 round-trip delay from the start of the transaction

7.1.2 Performance in the presence of contention

In the presence of contention, processing can be delayed by conflicting transactions that have the same timestamp. The latest a transaction started after T can be assigned the same timestamp as T is just short of 1.5 round-trip delay from the time T started (we assume that previous transactions that are not concurrent with T have already been cleared). In fact, a transaction that starts 1.5 round-trip delay after T cannot reach the servers before the time T’s timestamp is propagated and will be assigned a later timestamp (assuming the Propose message for the contending transaction will propagate instantaneously in the worst case). So, in the presence of contention, a response might not arrive before 4 round-trip delays in gracious executions.

It is important to note that these calculations are for one individual transaction delay and not the system throughput under load. The throughput is not affected by individual transaction latency. The protocol is competitive in terms of latency with PBFT [11] which achieves 2 round-trip delay in civil executions with a number of optimizations including speculative execution, but PBFT does not perform well in uncivil executions.

7.2 Performance in uncivil executions

In uncivil executions, the delay depends on the level of contention. If a transaction is initiated and is not overlapping with any other conflicting transaction, its delay will be the same as in gracious executions. This is particularly good compared to leader-based protocols in which a slow leader might need to be timed out before processing a transaction even if it does not conflict with other transactions.

In the presence of contention, a transaction can be delayed further. As in the gracious execution case, we consider the latest time a transaction can be added to the pending set of transaction T. As in the case of gracious executions, the time is 1.5 round-trip delay after T is initiated. If the client of the contending transaction fails, the full timeout would need to be incurred and a consensus protocol would need to be executed. So, the delay in this case would be the timeout value $\delta$ plus the consensus time. The client will get a response by 0.5 round-trip delay after the consensus has ended (because the other message exchanges of the client overlap with the timeout time).

7.3 Other Performance Considerations

It is important to note that the delays are not additive. If we have transactions with different timestamps, and for each timestamp there is a slow pending transaction, no transaction incurs more than one timeout plus consensus delay because the timers are started in a pipelined fashion. This ensures that Byblos average throughput under client delays is minimally affected by slow clients. Also, recall that this delay is only incurred by conflicting transactions whereas in systems in which faulty servers are the source of the delay, all transactions are affected by server delays.

Another potential performance improvement that we did not consider is transaction batching [11] in which a number of transactions are processed in batches. In our solution, servers communicate information about individual transactions. On the positive side, in Byblos, in the presence of contention, more transactions will get the same timestamp and the delay incurred for that timestamp is one for all transactions. This should improve throughput.

As described, Byblos uses public-key signatures [14, 31], which can add significant overhead. Replacing signatures with message authentication codes [6] is a subject for future work. Finally, the message complexity of our solution is rather high: $\mit{O}(n^{2})$ messages per transaction. Such high message complexity is not unusual for protocols that aim to achieve bounded delay ([2, 4, 12, 22] for example).

8 Conclusion

We showed that non-skipping timestamps can substantially simplify state-machine replication, facilitating a leaderless algorithm that exploits transaction semantics to enhance concurrency. For future work, there are many ways to further improve Byblos’ performance through fast-path optimizations, and through closely integrating a consensus protocol with the state-machine replication solution.