arXiv subjects

Eli Gafni

Publications and source records attributed to Eli Gafni.

At least 19 recordsLinked to original sources

arXiv2024

Time is not a Healer, but it Sure Makes Hindsight 20:20

In the 1980s, three related impossibility results emerged in the field of distributed computing. First, Fischer, Lynch, and Paterson demonstrated that deterministic consensus is unattainable in an asynchronous message-passing system when a single process may crash-stop. Subsequently, Loui and Abu-Amara showed the infeasibility of achieving consensus in asynchronous shared-memory systems, given the possibility of one crash-stop failure. Lastly, Santoro and Widmayer established the impossibility of consensus in synchronous message-passing systems with a single process per round experiencing send-omission faults. In this paper, we revisit these seminal results. First, we observe that all these systems are equivalent in the sense of implementing each other. Then, we prove the impossibility of consensus in the synchronous system of Santoro and Widmayer, which is the easiest to reason about. Taking inspiration from Völzer's proof pearl and from the Borowski-Gafni simulation, we obtain a remarkably simple proof. We believe that a contemporary pedagogical approach to teaching these results should first address the equivalence of the systems before proving the consensus impossibility within the system where the result is most evident.

cs.DC↗

arXiv2024

Understanding Read-Write Wait-Free Coverings in the Fully-Anonymous Shared-Memory Model

In the fully-anonymous (shared-memory) model, inspired by a biological setting, processors have no identifiers and memory locations are anonymous. This means that there is no pre-existing agreement among processors on any naming of the memory locations. In this work, we ask fundamental questions about the fully-anonymous model in the hope to obtain a better understanding of the role of naming and anonymity in distributed computing. First, we ask what it means to solve a task under processor anonymity. With tasks such as renaming, the traditional notion obviously does not apply. Instead of restricting ourselves to colorless tasks, we propose using the notion of group solvability, which allows transferring any task to processor-anonymous models. Second, the difficulty with anonymity is that processors can hardly avoid covering and then overwriting each other's writes, erasing information written by their predecessors. To get to the bottom of this phenomenon, we ask what system configurations are stable when processors keep reading and writing ad infinitum. Resolving this question leads us to a wait-free solution to the snapshot task, which then allows us to solve renaming and obstruction-free consensus.

cs.DC↗

arXiv2023

Consensus in the Unknown-Participation Message-Adversary Model

We propose a new distributed-computing model, inspired by permissionless distributed systems such as Bitcoin and Ethereum, that allows studying permissionless consensus in a mathematically regular setting. Like in the sleepy model of Pass and Shi, we consider a synchronous, round-by-round message-passing system in which the set of online processors changes each round. Unlike the sleepy model, the set of processors may be infinite. Moreover, processors never fail; instead, an adversary can temporarily or permanently impersonate some processors. Finally, processors have access to a strong form of message-authentication that authenticates not only the sender of a message but also the round in which the message was sent. Assuming that, each round, the adversary impersonates less than 1/2 of the online processors, we present two consensus algorithms. The first ensures deterministic safety and constant latency in expectation, assuming a probabilistic leader-election oracle. The second ensures deterministic safety and deterministic liveness assuming irrevocable impersonation and eventually-stabilizing participation. The model is unrealistic in full generality. However, if we assume finitely many processes and that the set of faulty processes remains constant, the model coincides with a practically-motivated model: the static version of the sleepy model.

cs.DC↗

arXiv2023

Synchrony/Asynchrony vs. Stationary/Mobile? The Latter is Superior...in Theory

Like Asynchrony, Mobility of faults precludes consensus. Yet, a model M in which Consensus is solvable, has an analogue relaxed model in which Consensus is not solvable and for which we can ask, whether Consensus is solvable if the system initially behaves like the relaxed analogue model, but eventually morphs into M. We consider two relaxed analogues of M. The first is the traditional Asynchronous model, and the second to be defined, the Mobile analogue. While for some M we show that Consensus is not solvable in the Asynchronous analogue, it is solvable in all the Mobile analogues. Hence, from this perspective Mobility is superior to Asynchrony. The pie in the sky relationship we envision is: Consensus is solvable in M, if and only if binary Commit-Adopt is solvable in the mobile analogue. The ``only if'' is easy. Here we show case by case that the ``if'' holds for all the common faults types.

cs.DS↗

arXiv2019

A King in every two consecutive tournaments

We think of a tournament $T=([n], E)$ as a communication network where in each round of communication processor $P_i$ sends its information to $P_j$, for every directed edge $ij \in E(T)$. By Landau's theorem (1953) there is a King in $T$, i.e., a processor whose initial input reaches every other processor in two rounds or less. Namely, a processor $P_ν$ such that after two rounds of communication along $T$'s edges, the initial information of $P_ν$ reaches all other processors. Here we consider a more general scenario where an adversary selects an arbitrary series of tournaments $T_1, T_2,\ldots$, so that in each round $s=1, 2, \ldots$, communication is governed by the corresponding tournament $T_s$. We prove that for every series of tournaments that the adversary selects, it is still true that after two rounds of communication, the initial input of at least one processor reaches everyone. Concretely, we show that for every two tournaments $T_1, T_2$ there is a vertex in $[n]$ that can reach all vertices via (i) A step in $T_1$, or (ii) A step in $T_2$ or (iii) A step in $T_1$ followed by a step in $T_2$. }

math.CO↗

arXiv2017

The Life in 1-Consensus

This paper introduces the atomic Write and Read Next ($\text{WRN}_{k}$) deterministic shared memory object, that for any $k\ge3$, is stronger than read-write registers, but is unable to implement $2$-processor consensus. In particular, it refutes the conjecture claiming that every deterministic object of consensus number $1$ is computationally equivalent to read-write registers.

cs.DC↗

arXiv2017

An Algorithmic Approach to the Asynchronous Computability Theorem

The asynchronous computability theorem (ACT) uses concepts from combinatorial topology to characterize which tasks have wait-free solutions in read-write memory. A task can be expressed as a relation between two chromatic simplicial complexes. The theorem states that a task has a protocol (algorithm) if and only if there is a certain chromatic simplicial map compatible with that relation. While the original proof of the ACT relied on an involved combinatorial argument, Borowsky and Gafni later proposed an alternative proof that relied on a algorithmic construction, termed the "convergence algorithm". The description of this algorithm was incomplete, and presented without proof. In this paper, we give the first complete description, along with a proof of correctness.

cs.DC↗

arXiv2016

Set-Consensus Collections are Decidable

A natural way to measure the power of a distributed-computing model is to characterize the set of tasks that can be solved in it. %the model. In general, however, the question of whether a given task can be solved in a given model is undecidable, even if we only consider the wait-free shared-memory model. In this paper, we address this question for restricted classes of models and tasks. We show that the question of whether a collection $C$ of \emph{$(\ell,j)$-set consensus} objects, for various $\ell$ (the number of processes that can invoke the object) and $j$ (the number of distinct outputs the object returns), can be used by $n$ processes to solve wait-free $k$-set consensus is decidable. Moreover, we provide a simple $O(n^2)$ decision algorithm, based on a dynamic programming solution to the Knapsack optimization problem. We then present an \emph{adaptive} wait-free set-consensus algorithm that, for each set of participating processes, achieves the best level of agreement that is possible to achieve using $C$. Overall, this gives us a complete characterization of a read-write model defined by a collection of set-consensus objects through its \emph{set-consensus power}.

cs.DC↗

arXiv2016

Byzantine Processors and Cuckoo Birds: Confining Maliciousness to the Outset

Are there Byzantine Animals? A Fooling Behavior is exhibited by the Cuckoo bird. It sneakily replaces some of the eggs of other species with its own. Lest the Cuckoo extinct itself by destroying its host, it self-limits its power: It does not replace too large a fraction of the eggs. Here, we show that any Byzantine Behavior that does not destroy the system it attacks, i.e. allows the system to solve an easy task like epsilon-agreement, then its maliciousness can be confined to be the exact replica of the Cuckoo bird behavior: Undetectably replace an input of a processor and let the processor behave correctly thereafter with respect to the new input. In doing so we reduce the study of Byzantine behavior to fail-stop (benign) behavior with the Cuckoo caveat of a fraction of the inputs replaced. We establish a complete correspondence between the Byzantine and the Benign, modulo different thresholds, and replaced inputs. This work is yet another step in a line of work unifying seemingly distinct distributed system models, dispelling the Myth that Distributed Computing is a plethora of distinct isolated models, each requiring its specialized tools and ideas in order to determine solvability of tasks. Thus, hereafter, Byzantine Computability questions can be reduced to questions in the benign failure setting. We also show that the known results about correlated faults in the asynchronous benign setting can be imported verbatim to the asynchronous Byzantine setting. Finally, as in the benign case in which we have the property that a processor can output once its faulty behavior stops for long enough, we show this can be done in a similar manner in the Byzantine case. This necessitated the generalization of Reliable Broadcast to what we term Recoverable Reliable Broadcast.

cs.DC↗

arXiv2016

Read-Write Memory and k-Set Consensus as an Affine Task

The wait-free read-write memory model has been characterized as an iterated \emph{Immediate Snapshot} (IS) task. The IS task is \emph{affine}---it can be defined as a (sub)set of simplices of the standard chromatic subdivision. It is known that the task of \emph{Weak Symmetry Breaking} (WSB) cannot be represented as an affine task. In this paper, we highlight the phenomenon of a "natural" model that can be captured by an iterated affine task and, thus, by a subset of runs of the iterated immediate snapshot model. We show that the read-write memory model in which, additionally, $k$-set-consensus objects can be used is, unlike WSB, "natural" by presenting the corresponding simple affine task captured by a subset of $2$-round IS runs. Our results imply the first combinatorial characterization of models equipped with abstractions other than read-write memory that applies to generic tasks.

cs.DC↗

arXiv2016

Some Garbage In - Some Garbage Out: Asynchronous t-Byzantine as Asynchronous Benign t-resilient system with fixed t-Trojan-Horse Inputs

We show that asynchronous $t$ faults Byzantine system is equivalent to asynchronous $t$-resilient system, where unbeknownst to all, the private inputs of at most $t$ processors were altered and installed by a malicious oracle. The immediate ramification is that dealing with asynchronous Byzantine systems does not call for new topological methods, as was recently employed by various researchers: Asynchronous Byzantine is a standard asynchronous system with an input caveat. It also shows that two recent independent investigations of vector $ε$-agreement in the Byzantine model, and then in the fail-stop model, one was superfluous - in these problems the change of $t$ inputs allowed in the Byzantine has no effect compared to the fail-stop case. This result was motivated by the aim of casting any asynchronous system as a synchronous system where all processors are correct and it is the communication substrate in the form of message-adversary that misbehaves. Thus, in addition, we get such a characterization for the asynchronous Byzantine system.

cs.DC↗

arXiv2016

Synchronous Hybrid Message-Adversary

The theory of distributed computing, lagging in its development behind practice, has been biased in its modelling by employing mechanisms within the model mimicking reality. Reality means, processors can fail. But theory is about predicting consequences of reality, hence if we capture reality by "artificial models," but those nevertheless make analysis simpler, we should pursue the artificial models. Recently the idea was advocated to analyze distributed systems and view processors as infallible. It is the message delivery substrate that causes problems. This view not only can effectively emulate reality, but above all seems to allow to view any past models as \emph{synchronous} models. Synchronous models are easier to analyze than asynchronous ones. Furthermore, it gives rise to models we haven't contemplated in the past. One such model, presented here, is the Hybrid Message-Adversary. We motivate this model through the need to analyze Byzantine faults. The Hybrid model exhibits a phenomenon not seen in the past.

cs.DC↗

arXiv2015

Group Mutual Exclusion in Linear Time and Space

We present two algorithms for the Group Mutual Exclusion (GME) Problem that satisfy the properties of Mutual Exclusion, Starvation Freedom, Bounded Exit, Concurrent Entry and First Come First Served. Both our algorithms use only simple read and write instructions, have O(N) Shared Space complexity and O(N) Remote Memory Reference (RMR) complexity in the Cache Coherency (CC) model. Our first algorithm is developed by generalizing the well-known Lamport's Bakery Algorithm for the classical mutual exclusion problem, while preserving its simplicity and elegance. However, it uses unbounded shared registers. Our second algorithm uses only bounded registers and is developed by generalizing Taubenfeld's Black and White Bakery Algorithm to solve the classical mutual exclusion problem using only bounded shared registers. We show that contrary to common perception our algorithms are the first to achieve these properties with these combination of complexities.

cs.DC↗

arXiv2014

Simple CHT: A New Derivation of the Weakest Failure Detector for Consensus

The paper proposes an alternative proof that Omega, an oracle that outputs a process identifier and guarantees that eventually the same correct process identifier is output at all correct processes, provides minimal information about failures for solving consensus in read-write shared-memory systems: every oracle that gives enough failure information to solve consensus can be used to implement Omega. Unlike the original proof by Chandra, Hadzilacos and Toueg (CHT), the proof presented in this paper builds upon the very fact that 2-process wait-free consensus is impossible. Also, since the oracle that is used to implement can solve consensus, the implementation is allowed to directly access consensus objects. As a result, the proposed proof is shorter and conceptually simpler than the original one.

cs.DC↗

arXiv2014

Snapshot for Time: The One-Shot Case

We show that for one-shot problems - problems where a processor executes a single operation-execution - timing constraints can be captured by conditions on the relation between original outputs and supplementary snapshots. In addition to the dictionary definition of the word snapshot, in distributed computing snapshots also stand for a task that imposes relation among sets which are output of processors. Hence, constrains relating the timing between operation-executions of processors can be captured by the sets relation representing a task. This allows to bring to bear techniques developed for tasks, to one-shot objects. In particular, for the one-shot case the question of linearizability is moot. Nevertheless, current proof techniques of object implementation require the prover to provide linearization-points even in the one shot case. Transforming the object into a task relieves the prover of an implementation from the burden of finding the "linearization-points," since if the task is solvable, linearization points are guaranteed to exist. We exhibit this advantage with a new algorithm to implement MWMR register in a SWMR system.

cs.DC↗

arXiv2014

A generalized asynchronous computability theorem

We consider the models of distributed computation defined as subsets of the runs of the iterated immediate snapshot model. Given a task $T$ and a model $M$, we provide topological conditions for $T$ to be solvable in $M$. When applied to the wait-free model, our conditions result in the celebrated Asynchronous Computability Theorem (ACT) of Herlihy and Shavit. To demonstrate the utility of our characterization, we consider a task that has been shown earlier to admit only a very complex $t$-resilient solution. In contrast, our generalized computability theorem confirms its $t$-resilient solvability in a straightforward manner.

cs.DC↗

arXiv2014

Strong Equivalence Relations for Iterated Models

The Iterated Immediate Snapshot model (IIS), due to its elegant geometrical representation, has become standard for applying topological reasoning to distributed computing. Its modular structure makes it easier to analyze than the more realistic (non-iterated) read-write Atomic-Snapshot memory model (AS). It is known that AS and IIS are equivalent with respect to \emph{wait-free task} computability: a distributed task is solvable in AS if and only if it solvable in IIS. We observe, however, that this equivalence is not sufficient in order to explore solvability of tasks in \emph{sub-models} of AS (i.e. proper subsets of its runs) or computability of \emph{long-lived} objects, and a stronger equivalence relation is needed. In this paper, we consider \emph{adversarial} sub-models of AS and IIS specified by the sets of processes that can be \emph{correct} in a model run. We show that AS and IIS are equivalent in a strong way: a (possibly long-lived) object is implementable in AS under a given adversary if and only if it is implementable in IIS under the same adversary. %This holds whether the object is one-shot or long-lived. Therefore, the computability of any object in shared memory under an adversarial AS scheduler can be equivalently investigated in IIS.

cs.DC↗

arXiv2014

Set Consensus: Captured by a Set of Runs with Ramifications

Are (set)-consensus objects necessary? This paper answer is negative. We show that the availability of consensus objects can be replaced by restricting the set of runs we consider. In particular we concentrate of the set of runs of the Immediate-Snapshot-Model (IIS), and given the object we identify this restricted subset of IIS runs. We further show that given an $(m,k)$-set consensus, an object that provides $k$-set consensus among $m$ processors, in a system of $n$, $n>m$ processors, we do not need to use the precise power of the objects but rather their effective cumulative set consensus power. E.g. when $n=3, m=2,$ and $k=1$ and all the 3 processors are active then we only use 2-set consensus among the 3 processors, as if 2-processors consensus is not available. We do this until at least one of the 3 processors obtains an output. We show that this suggests a new direction in the design of algorithms when consensus objects are involved.

cs.DC↗