Eli Gafni - Academia.edu (original) (raw)

Papers by Eli Gafni

Theoretical Computer Science, Sep 1, 2021

Abstract In the allocation problem, asynchronous processors must partition a set of items so that... more Abstract In the allocation problem, asynchronous processors must partition a set of items so that each processor leaves knowing all items exclusively allocated to it. We introduce a new variant of the allocation problem called the assignment problem, in which processors might leave having only partial knowledge of their assigned items. The missing items in a processor's assignment must eventually be announced by other processors. While allocation has consensus number 2, we show that the assignment problem is solvable read-write wait-free when k processors compete for at least 2 k − 1 items. Moreover, we propose a long-lived read-write wait-free assignment algorithm which is fair, allocating no more than 2 items per processor, and in which a slow processor may delay the assignment of at most n items, where n is the number of processors. The assignment problem and its read-write solution may be of practical interest for implementing resource allocators and work queues, which are pervasive concurrent programming patterns, as well as stream-processing systems.

HAL (Le Centre pour la Communication Scientifique Directe), Jul 1, 2012

We motivate and propose a new way of thinking about failure detectors which allows us to define, ... more 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 wait-free using a failure detector. In our model, the system is composed of computation processes that obtain inputs and are supposed to output in a finite number of steps and synchronization processes that are subject to failures and can query a failure detector. We assume that, under the condition that correct synchronization processes take sufficiently many steps, they provide the computation processes with enough 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 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.

arXiv (Cornell University), Oct 21, 2019

We think of a tournament T = ([n], E) as a communication network where in each round of communica... more 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 ∈ 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 ,. . ., so that in each round s = 1, 2,. . ., 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 .

arXiv (Cornell University), May 20, 2014

Are (set)-consensus objects necessary? This paper answer is negative. We show that the availabili... more 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.

arXiv (Cornell University), Aug 3, 2012

In the Musical Chairs game M C(n, m) a team of n players plays against an adversarial scheduler. ... more In the Musical Chairs game M C(n, m) a team of n players plays against an adversarial scheduler. The scheduler wins if the game proceeds indefinitely, while termination after a finite number of rounds is declared a win of the team. At each round of the game each player occupies one of the m available chairs. Termination (and a win of the team) is declared as soon as each player occupies a unique chair. Two players that simultaneously occupy the same chair are said to be in conflict. In other words, termination (and a win for the team) is reached as soon as there are no conflicts. The only means of communication throughout the game is this: At every round of the game, the scheduler selects an arbitrary nonempty set of players who are currently in conflict, and notifies each of them separately that it must move. A player who is thus notified changes its chair according to its deterministic program. As we show, for m ≥ 2n − 1 chairs the team has a winning strategy. Moreover, using topological arguments we show that this bound is tight. For m ≤ 2n − 2 the scheduler has a strategy that is guaranteed to make the game continue indefinitely and thus win. We also have some results on additional interesting questions. For example, if m ≥ 2n − 1 (so that the team can win), how quickly can they achieve victory?

International Conference of Distributed Computing and Networking, 2018

In the allocation problem, asynchronous processors must partition a set of items so that each pro... more In the allocation problem, asynchronous processors must partition a set of items so that each processor leave knowing all items exclusively allocated to it. We introduce a new variant of the allocation problem called the assignment problem, in which processors might leave having only partial knowledge of their assigned items. The missing items in a processor's assignment must eventually be announced by other processors. While allocation has consensus power 2, we show that the assignment problem is solvable read-write wait-free when k processors compete for at least 2k --1 items. Moreover, we propose a long-lived read-write wait-free assignment algorithm which is fair, allocating no more than 2 items per processor, and in which a slow processor may delay the assignment of at most n items, where n is the number of processors. The assignment problem and its read-write solution may be of practical interest for implementing resource allocators and work queues, which are pervasive concurrent programming patterns, as well as stream-processing systems.

The consensus hierarchy classifies shared an object according to its consensus number, which is t... more The consensus hierarchy classifies shared an object according to its consensus number, which is the maximum number of processes that can solve consensus wait-free using the object. The question of whether this hierarchy is precise enough to fully characterize the synchronization power of deterministic shared objects was open until 2016, when Afek et al. showed that there is an infinite hierarchy of deterministic objects, each weaker than the next, which is strictly between i and i + 1-processors consensus, for i ≥ 2. For i = 1, the question whether there exist a deterministic object whose power is strictly between read-write and 2-processors consensus, remained open. We resolve the question positively by exhibiting an infinite hierarchy of simple deterministic objects which are equivalent to set-consensus tasks, and thus are stronger than read-write registers, but they cannot implement consensus for two processes. Still our paper leaves a gap with open questions. 2012 ACM Subject Cl...

Structural Information and Communication Complexity, 2016

Adaptive renaming can be viewed as a coordination task involving a set of asynchronous agents, ea... more Adaptive renaming can be viewed as a coordination task involving a set of asynchronous agents, each aiming at grabbing a single resource out of a set of resources totally ordered by their desirability. Similarly, musical chairs is also defined as a coordination task involving a set of asynchronous agents, each aiming at picking one of a set of available resources, where every agent comes with an a priori preference for some resource. We foresee instances in which some combinations of resources are allowed, while others are disallowed. We model these constraints, i.e., the restrictions on the ability to use some combinations of resources, as an undirected graph whose nodes represent the resources, and an edge between two resources indicates that these two resources cannot be used simultaneously. In other words, the sets of resources that are allowed are those which form independent sets in the graph. E.g., renaming and musical chairs are specific cases where the graph is stable (i.e., it the empty graph containing no edges). As for musical chairs, we assume that each agent comes with an a priori preference for some resource. If an agent's preference is not in conflict with the preferences of the other agents, then this preference can be grabbed by the agent. Otherwise, the agents must coordinate to resolve their conflicts, and potentially choose non preferred resources. We investigate the following problem: given a graph, what is the maximum number of agents that can be accommodated subject to non-altruistic behaviors of early arriving agents? We entirely solve this problem under the restriction that agents which cannot grab their preferred resources must then choose a resource among the nodes of a predefined independent set. However, the general case, where agents which cannot grab their preferred resource are then free to choose any resource, is shown to be far more complex. In particular, just for cyclic constraints, the problem is surprisingly difficult. Indeed, we show that, intriguingly, the natural algorithm inspired from optimal solutions to adaptive renaming or musical chairs is sub-optimal for cycles, but proven to be at most 1 to the optimal. The main message of this paper is that finding optimal solutions to the coordination with constraints and preferences task requires to design "dynamic" algorithms, that is, algorithms of a completely different nature than the "static" algorithms used for, e.g., renaming.

Proceedings of the 17th International Conference on Distributed Computing and Networking, 2016

We present two algorithms for the Group Mutual Exclusion (GME) Problem that satisfy the propertie... more 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.

The 43rd Annual IEEE Symposium on Foundations of Computer Science, 2002. Proceedings.

The Herlihy-Shavit (HS) conditions characterizing the solvability of asynchronous tasks over n pr... more The Herlihy-Shavit (HS) conditions characterizing the solvability of asynchronous tasks over n processors have been a milestone in the development of the theory of distributed computing. Yet, they were of no help when researcher sought algorithms that do not depend on n. To help in this pursuit we investigate the uniform solvability of an infinite uniform sequence of tasks T 0 ; T 1 ; T 2 ; :::, where T i is a task over processors p 0 ; p 1 ; :::; p i , and T i extends T i?1. We say that such a sequence is uniformly solvable if there exit protocols to solve each T i and the protocol for T i extends the protocol for T i?1. This paper establishes that although each T i may be solvable, the uniform sequence is not necessarily uniformly solvable. We show this by proposing a novel uniform sequence of solvable tasks and proving that the sequence is not amenable to a uniform solution. We then extend the HS conditions for a task over n processors, to uniform solvability in a natural way. The technique we use to accomplish this is to generalize the alternative algorithmic proof, by Borowsky and Gafni, of the HS conditions, by showing that the infinite uniform sequence of task of Immediate Snapshots is uniformly solvable. A side benefit of the technique is a widely applicable methodology for the development of uniform protocols.

Proceedings of the twentieth annual ACM symposium on Principles of distributed computing, 2001

We study walt-free computation using (read/write) shared memory under a range of assumptions on t... more We study walt-free computation using (read/write) shared memory under a range of assumptions on the arrival pattern of processes. We distinguish first between bounded and infinite arrival patterns, and further distinguish these models by restricting the number of arrivals minus departures, the concurrency. Under the condition that no process takes infinitely many steps without terminating, for any finite bound k > 0, we show that bounding concurrency reveals a strict hierarchy of computational models: a model in which concurrency is bounded by k + 1 is strictly weaker than the model in which concurrency is bounded by k, for all k > 1. A model in which concurrency is bounded in each run, but no bound holds for all runs, is shown to be weaker than a k-bounded model for any k. The unbounded model is shown to be weaker still-in this model, finite prefixes of runs have bounded concurrency, but runs are admitted for which no finite bound holds over all prefixes. Hence, as the concurrency grows, the set of solvable problems strictly shrinks. Nevertheless, on the positive side, we demonstrate that many interesting problems (collect, snapshot, renaming) are solvable even in the infinite arrival, unbounded concurrency model. This investigation illuminates relations between notions of wait-free solvability distinguished by arrival pattern, and notions of adaptive, one-shot, and long-lived solvability.

Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing - PODC '96, 1996

Proceedings of the fourth annual ACM symposium on Principles of distributed computing - PODC '85, 1985

Algorithms for election in asynchronous general networks and in synchronous rings are presented. ... more Algorithms for election in asynchronous general networks and in synchronous rings are presented. The algorithms are message-optimal, and their time behavior is significantly improved over currently available algorithms. In asynchronous general networks we, present a O([W]+nlogn)-messages, O(n log n)-time algorithm, where n is the number of nodes, and IE] is the number of links in the network. For synchronous rings, we propose two algorithms. The first works in O(n)-messages, and O(n2n+lTI 2) time, where IT[ is the cardinality of the set of the node identifiers. The second works in O(n log*n) messages and O(o~-l(log*n)[ T[),time, where oF10 is the functional inverse of log. By contrast, the time behavior of previously known algorithms is exponential in ]T], for fixed n. 1. Introduction Most distributed algorithms strive for message economy, usually at the expense of running time. This may be justified for algorithms whose timely termination is not of great consequence. But for many algorithms, especially those that are part of the network control, time might be at a premium. One such algorithm is the election algorithm. This algorithm could for example be 1"This research was supported by an IBM Faculty Development Award.

Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing - PODC '96, 1996

Proceedings of the seventeenth annual ACM symposium on Principles of distributed computing - PODC '98, 1998

This paper presents a new family of models of distributed-computation which combines features fro... more This paper presents a new family of models of distributed-computation which combines features from synchronous, asynchronous, and failure-detectoraugmented systems. Like synchronous systems, computation in this family of models evolves in rounds, and communication missed at a round is lost. Unlike synchronous systems, information that is missed at a round does not necessarily imply a real process failure. The features of a specific model is captured in an abstract module called the round-by-round fault detector. The abstraction of system features into such a module facilitates the comparison of different systems, by contrasting their associated fault detectors. We show that this family of models unifies the study of synchrony, asynchrony, message-passing and shared memory. We further show that this approach leads to the development of shorter and simpler proofs of important results such as a lower bound on the number of rounds to achieve k-set agreement in a synchronous system. We believe that studying distributed systems through the proposed unifying framework will lead to new results and insights.

Proceedings of the forty-first annual ACM symposium on Theory of computing, 2009

A distributed task T on n processors is an input/output relation between a collection of processo... more A distributed task T on n processors is an input/output relation between a collection of processors' inputs and outputs. While all tasks are solvable if no processor may ever crash, the FLP result revealed that the possibility of a failure of just a single processor precludes a solution to the task of consensus. That is consensus is not solvable 1-resiliently. Yet, some nontrivial tasks are wait-free solvable, i.e. n − 1resiliently. What tasks are solvable if at most t < n processors may crash? I.e. what tasks are solvable t-resiliently? The Herlihy-Shavit condition characterizes wait-free solvability, i.e., when t = n − 1. The Borowsky-Gafni (BG) simulation extends this characterization to the t-resilient case for the case "colorless" tasks-tasks like consensus in which one processor can adopt the output of any other processor. It does this by reducing questions about t-resilient solvability, to a question of wait-free solvability. The latter question has been characterized. In this paper, we amend the BG-simulation to result in the Extended-BG-simulation, an extension that yields a full characterization of t-resilient solvability: A task T on n processors is solvable t-resiliently iff all tasks T on t + 1 simulators s0,. .. , st created as follows are wait-free solvable. Simulator si is given an input of processor pi as well as the input to a set of processors of size n − (t + 1) with ids higher than i. Simulator si outputs for pi as well as for a (possibly different) set of processors of size n − (t + 1) with ids higher than i. The input/output of the t + 1 simulators have to be a projection of a single original input/output tuple-pair in T. We demonstrate the convenience that the characterization provides, in two ways. First, we prove a new equivalence result: We show that n processes can solve t-resiliently weak renaming with n + (t + 1) − 2 names, where n > 1 and 0 < t < n, iff weak-renaming on t + 1 processors is wait-free solvable with 2t names. Second, we reproduce the result that the solvability of n-processors tasks, t-resiliently, for t > 1 and n > 2, is undecidable, by a simple reduction to Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee.

MILCOM 1986 - IEEE Military Communications Conference: Communications-Computers: Teamed for the 90's, 1986

Although it is common practice to design large systems by decomposition, it does not seem to be t... more Although it is common practice to design large systems by decomposition, it does not seem to be the case in the design of "small" distributed protocols, especially when the network is assumed reliable. Many such protocols share common features, yet are designed and proved as isolated cases, which makes them difficult to understand and even more difficult to validate. In this paper, a building-block approach to the design of distributed protocols is advocated. We take a few simple and rather basic protocols proposed by various researchers, and assert that these protocols are suitable to serve as building blocks. We then go through the exercise of designing several protocols employing these building blocks. We illustrate how such a design can lead to better understanding and clarity of the protocols, and even to improvement in performance.

Lecture Notes in Computer Science, 2015

This paper proposes a free-for-all execution scheme for read-write code, whether wait-free, t-res... more This paper proposes a free-for-all execution scheme for read-write code, whether wait-free, t-resilient, or one that utilizes set-consensus. It employs two new novel simulating techniques: Extended-BG-Simulation, and Simulation-by-Value. Its architecture consists of 3 layers: At the bottom, real processors just signal their participation, at the middle layer, virtual Extended-BG-simulators execute the active codes free-for-all, and at the top layer, the original processors cooperatively use Simulation-by-Value to simulate the virtual BG-simulators. The Extended-BG-simulation removes a drawback from the BG-simulation. In the BG-simulation each simulator may be interested in the output of a particular code, but the simulation guarantees an output of some code, rather than a specific one. The modified simulation removes this drawback. The Simulation-by-Value which subsumes the BG-simulation, allows us to show that if in run-time disagreement happens at some point to be low it can be ke...