Possibility and Impossibility of Reliable Broadcast in the Bounded Model

TL;DR

This paper investigates the limits of reliable broadcast in asynchronous systems with bounded memory, proving impossibility results for crash faults and presenting a self-stabilizing protocol for repeated single-value streams, highlighting the difference between crash and Byzantine faults.

Contribution

It establishes fundamental impossibility results for bounded memory reliable broadcast with crash faults and introduces a self-stabilizing protocol for repeated single-value streams, differentiating crash and Byzantine fault tolerances.

Findings

No bounded memory protocol can guarantee a common suffix with crash faults in asynchronous systems.

A bounded memory self-stabilizing protocol exists for repeated single-value streams with crash faults.

The problem is unsolvable with Byzantine faults, separating Byzantine from crash fault behaviors.

Abstract

The Reliable Broadcast concept allows an honest party to send a message to all other parties and to make sure that all honest parties receive this message. In addition, it allows an honest party that received a message to know that all other honest parties would also receive the same message. This technique is important to ensure distributed consistency when facing failures. In the current paper, we study the ability to use \RR to consistently transmit a sequence of input values in an asynchronous environment with a designated sender. The task can be easily achieved using counters, but cannot be achieved with a bounded memory facing failures. We weaken the problem and ask whether the receivers can at least share a common suffix. We prove that in a standard (lossless) asynchronous system no bounded memory protocol can guarantee a common suffix at all receivers for every input sequence if a single party might crash. We further study the problem facing transient faults and prove that when limiting the problem to transmitting a stream of a single value being sent repeatedly we show a bounded memory self-stabilizing protocol that can ensure a common suffix even in the presence of transient faults and an arbitrary number of crash faults. We further prove that this last problem is not solvable in the presence of a single Byzantine fault. Thus, this problem {\bf separates} Byzantine behavior from crash faults in an asynchronous environment.