Wait-Freedom with Advice

We motivate and propose a new way of thinking about failure detectors which allows us to define, quite surprisingly, what it means to solve a distributed task \emph{wait-free} \emph{using a failure detector}. In our model, the system is composed of \emph{computation} processes that obtain inputs and are supposed to output in a finite number of steps and \emph{synchronization} processes that are subject to failures and can query a failure detector. We assume that, under the condition that \emph{correct} synchronization processes take sufficiently many steps, they provide the computation processes with enough \emph{advice} to solve the given task wait-free: every computation process outputs in a finite number of its own steps, regardless of the behavior of other computation processes. Every task can thus be characterized by the \emph{weakest} failure detector that allows for solving it, and we show that every such failure detector captures a form of set agreement. We then obtain a complete classification of tasks, including ones that evaded comprehensible characterization so far, such as renaming or weak symmetry breaking.

💡 Research Summary

The paper introduces a novel framework for solving distributed tasks wait‑free by separating the system into two distinct sets of processes: computation processes (C‑processes) that receive inputs and must produce outputs within a bounded number of their own steps, and synchronization processes (S‑processes) that are equipped with failure‑detector modules and may fail. The S‑processes act as an external oracle that supplies “advice” about failures to the C‑processes via shared memory. The key requirement is that, provided the correct S‑processes take sufficiently many steps, every participating C‑process that continues to take steps must eventually decide, regardless of the speed or failures of other C‑processes. This definition yields a true wait‑free guarantee for the computation side, unlike classical failure‑detector models where progress can depend on other processes.

The authors formalize tasks as input‑output vector relations and introduce the notion of k‑concurrent executions: at any moment at most k C‑processes are active without having decided. They show that in the External Failure Detection (EFD) model, a task can be solved with concurrency level at most k iff the system possesses the weakest failure detector denoted ¬Ω_k (anti‑Ω_k). ¬Ω_k is precisely the information needed to solve k‑set agreement: it tells the processes which k of them will survive indefinitely, but provides no stronger guarantees. Consequently, any failure detector that can solve a task must be at least as strong as ¬Ω_k, and an algorithm using ¬Ω_k can solve any task that tolerates k‑concurrency.

This leads to a complete classification of all distributed tasks based on their maximal tolerable concurrency. For a task T, let k* be the largest integer such that T can be solved k‑concurrently. Then the weakest failure detector for T in the EFD model is exactly ¬Ω_{k*}. Tasks that are k‑concurrent but not (k+1)‑concurrent (e.g., k‑set agreement itself) are all equivalent in terms of required advice; they need precisely ¬Ω_k. The framework therefore subsumes previously elusive “colored” tasks such as renaming and weak symmetry breaking. For example, (j, j)‑renaming (strong renaming) cannot be solved 2‑concurrently, so it is equivalent to consensus and requires ¬Ω_2. More generally, (j, j + k − 1)‑renaming can be solved k‑concurrently, and thus ¬Ω_k suffices.

A notable technical contribution is the generalization of a recent result by Delporte‑Gallet et al.: if a failure detector can solve k‑set agreement among any subset of k + 1 processes, then it can solve k‑set agreement among all processes. The authors prove this for every k ≥ 1 within the EFD model, something that had resisted proof in the classic model.

The paper also emphasizes that the EFD model naturally leverages simulation‑based techniques: S‑processes simulate the progress of all C‑processes, allowing them to collectively bring every participating process to its output. This simulation viewpoint simplifies many previously intricate relationships between asynchrony, failures, and progress.

In summary, the authors:

1. Define the External Failure Detection model that cleanly separates computation from synchronization and introduces advice‑based wait‑freedom.
2. Identify ¬Ω_k as the exact weakest failure detector for any task with concurrency level k.
3. Provide a full taxonomy of tasks (including renaming, weak symmetry breaking, and other colored tasks) based on their maximal concurrency.
4. Generalize the “local to global” k‑set agreement strength result to all k.
5. Show that implementing only the minimal advice (¬Ω_k) is sufficient for solving the corresponding class of tasks, offering practical guidance for system designers.

The work thus resolves longstanding open questions about the minimal failure‑detector power needed for many classic distributed problems and establishes a clear, unified theory linking wait‑free solvability, concurrency tolerance, and the weakest possible external advice.