Atomic Read/Write Memory in Signature-Free Byzantine Asynchronous Message-Passing Systems

Abstract

This article presents a signature-free distributed algorithm which builds an atomic read/write shared memory on top of a fully connected peer-to-peer n-process asynchronous message-passing system in which up to t<n/3 processes may commit Byzantine failures. From a conceptual point of view, this algorithm is designed to be as close as possible to the algorithm proposed by Attiya, Bar-Noy and Dolev. J. ACM 42(1), 121–132 (1995), which builds an atomic register in an n-process asynchronous message-passing system where up to t<n/2 processes may crash. The proposed algorithm is particularly simple. It does not use cryptography to cope with Byzantine processes, and is optimal from a t-resilience point of view (t<n/3). A read operation requires O(n) messages, and a write operation requires O(n ²) messages.

Appendix A: Bracha’s Reliable Broadcast Algorithm

The r-broadcast algorithm presented in Fig. 2 is Bracha’s algorithm [6] enriched with sequence numbers. Each process p _i manages a local array n e x t _i [1..n], where n e x t _i [j] is the sequence number sn of the next application message (namely, app (−,s n)) from p _j , that p _i will process (line 3). Initially, for all i,j, n e x t _i [j] = 1.

Fig. 2

Reliable Broadcast in ${\mathcal {B}\mathcal {A}\mathcal {M}\mathcal {P}}_{n,t}[t<n/3]$, (code for process p _i )

When a process p _i invokes R_b r o a d c a s t app(v,s n), it broadcasts the message app (v,s n) (line 1) where sn is its next sequence number. On its “server” role, the behavior of a process p _i is as follows.

• When a process p _i receives a message app (v,s n) from a process, it discards it if it has already received a message app (−,s n ^′) such that s n ^′ = s n. This is because, in this case p _j is Byzantine (a correct process issues a single r-broadcast per sequence number). If p _i has not previously received from p _j a message app (−,s n ^′) such that s n ^′ = s n, it waits until it can process this message according to its sequence number (line 3). When this occurs, p _i broadcasts the message echo (j,v,s n) to inform the other processes it received the application message app (v,s n) (line 3).

• Then, when p _i has received the same message echo (j,v,s n) from “enough” processes (where enough means that “more than (n + t)/2 different processes”), and has not yet broadcast a message ready (j,v,s n), it does it (lines 6-9).

  The aim of (a) the messages echo (j,v,s n), and (b) the cardinality “greater than (n + t)/2 processes”, is to ensure that no two correct processes can r-deliver distinct messages from p _j (even if p _j is Byzantine). The aim of the messages ready (j,v,s n) is related to the liveness of the algorithm. More precisely, its aim is to allow the r-delivery by the correct processes of the very same message app (v,s n) from p _j , and this must always occur if p _j is correct. It is nevertheless possible that a message r-broadcast by a Byzantine process p _j may never be r-delivered by the correct processes.

• Finally, when p _i has received the message ready (j,v,s n) from (t+1) different processes, it broadcasts the same message ready (j,v,s n), if not yet done. This is required to ensure the RB-termination property. If p _i has received “enough” messages ready (j,v,s n) (“enough” means here “from at least (2t+1) different processes”), it r-delivers the message app (v,s n) r-broadcast by p _j .

More explanations and proofs that this algorithm satisfies the properties defining the reliable broadcast abstraction can be found in [6, 20].