Results 1  10
of
154
Hundreds of Impossibility Results for Distributed Computing
 Distributed Computing
, 2003
"... We survey results from distributed computing that show tasks to be impossible, either outright or within given resource bounds, in various models. The parameters of the models considered include synchrony, faulttolerance, different communication media, and randomization. The resource bounds refe ..."
Abstract

Cited by 52 (5 self)
 Add to MetaCart
We survey results from distributed computing that show tasks to be impossible, either outright or within given resource bounds, in various models. The parameters of the models considered include synchrony, faulttolerance, different communication media, and randomization. The resource bounds refer to time, space and message complexity. These results are useful in understanding the inherent difficulty of individual problems and in studying the power of different models of distributed computing.
Detecting Deadlocks In Concurrent Systems
 IN CONCUR’98: CONCURRENCY THEORY (NICE
, 1998
"... We study deadlocks using geometric methods based on generalized process graphs [11], i.e., cubical complexes or HigherDimensional Automata (HDA) [23, 24, 30, 35], describing the semantics of the concurrent system of interest. A new algorithm is described and fully assessed, both theoretically a ..."
Abstract

Cited by 52 (12 self)
 Add to MetaCart
We study deadlocks using geometric methods based on generalized process graphs [11], i.e., cubical complexes or HigherDimensional Automata (HDA) [23, 24, 30, 35], describing the semantics of the concurrent system of interest. A new algorithm is described and fully assessed, both theoretically and practically and compared with more wellknown traversing techniques. An implementation is
Conditions on input vectors for consensus solvability in asynchronous distributed systems
 Journal of the ACM
, 2001
"... Abstract. This article introduces and explores the conditionbased approach to solve the consensus problem in asynchronous systems. The approach studies conditions that identify sets of input vectors for which it is possible to solve consensus despite the occurrence of up to f process crashes. The f ..."
Abstract

Cited by 39 (13 self)
 Add to MetaCart
Abstract. This article introduces and explores the conditionbased approach to solve the consensus problem in asynchronous systems. The approach studies conditions that identify sets of input vectors for which it is possible to solve consensus despite the occurrence of up to f process crashes. The first main result defines acceptable conditions and shows that these are exactly the conditions for which a consensus protocol exists. Two examples of realistic acceptable conditions are presented, and proved to be maximal, in the sense that they cannot be extended and remain acceptable. The second main result is a generic consensus sharedmemory protocol for any acceptable condition. The protocol always guarantees agreement and validity, and terminates (at least) when the inputs satisfy the condition with which the protocol has been instantiated, or when there are no crashes. An efficient version of the protocol is then designed for the message passing model that works when f < n/2, and it is shown that no such protocol exists when f ≥ n/2. It is also shown how the protocol’s safety can be traded for its liveness.
A Simple Algorithmically Reasoned Characterization of Waitfree Computations
 In Proceedings of the 16th Annual ACM Symposium on Principles of Distributed Computing
, 1996
"... ) Elizabeth Borowsky (borowsky@hpl.hp.com) HewlettPackard Laboratories PaloAlto, CA 94303 U.S.A. Eli Gafni (eli@cs.ucla.edu) Computer Science Department University of California, Los Angeles Los Angeles, CA 90024 U.S.A. July 1, 1996 Abstract In a sequence of two pioneering papers Herlihy and S ..."
Abstract

Cited by 37 (15 self)
 Add to MetaCart
) Elizabeth Borowsky (borowsky@hpl.hp.com) HewlettPackard Laboratories PaloAlto, CA 94303 U.S.A. Eli Gafni (eli@cs.ucla.edu) Computer Science Department University of California, Los Angeles Los Angeles, CA 90024 U.S.A. July 1, 1996 Abstract In a sequence of two pioneering papers Herlihy and Shavit characterized waitfree sharedmemory computations. The derivation of the characterization involves homology for the necessary conditions, and complex geometry arguments for the sufficiency. This paper gives an alternative proof of the conditions using familiar algorithmic arguments. Our only reliance on geometry is the use of a corollary to the simplicial approximation. Furthermore, this paper is the first to present another consequence of the relation between distributed algorithms and topology: that certain theorems in topology are naturally proven by distributed algorithms interpretations. Our techniques can be extended to characterize models that are more complex than the waitfree...
Algebraic spans
, 2000
"... Topological methods have yielded a variety of lower bounds and impossibility results for distributed computing. In this paper, we introduce a new tool for proving impossibility results, which is based on a core theorem of algebraic topology, the acyclic carrier theorem, and unifies, generalizes and ..."
Abstract

Cited by 35 (17 self)
 Add to MetaCart
Topological methods have yielded a variety of lower bounds and impossibility results for distributed computing. In this paper, we introduce a new tool for proving impossibility results, which is based on a core theorem of algebraic topology, the acyclic carrier theorem, and unifies, generalizes and extends earlier results.
Adaptive and Efficient Algorithms for Lattice Agreement and Renaming
 SIAM J. Comput
, 1998
"... In a sharedmemory system, n independent asynchronous processes, with distinct names in the range {0, ..., N  1}, communicate by reading and writing to shared registers. An algorithm is waitfree if a process completes its execution regardless of the behavior of other processes. This paper consider ..."
Abstract

Cited by 28 (8 self)
 Add to MetaCart
In a sharedmemory system, n independent asynchronous processes, with distinct names in the range {0, ..., N  1}, communicate by reading and writing to shared registers. An algorithm is waitfree if a process completes its execution regardless of the behavior of other processes. This paper considers waitfree algorithms whose complexity adjusts to the level of contention in the system: An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number of active processes, k; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are presented for two important decision problems, lattice agreement and (6k  1)renaming; the step complexity of both algorithms is O(k log k). An interesting component of the (6k  1)renaming algorithm is an O(N) algorithm for (2k  1)renaming; this improves on the best previously known (2k  1)renaming algorithm, which has O(Nnk) s...
Tight bounds for kset agreement
 Journal of the ACM
, 2000
"... The Cambridge Research Laboratory was founded in 1987 to advance the state of the art in both core computing and humancomputer interaction, and to use the knowledge so gained to support the Company’s corporate objectives. We believe this is best accomplished through interconnected pursuits in techn ..."
Abstract

Cited by 22 (5 self)
 Add to MetaCart
The Cambridge Research Laboratory was founded in 1987 to advance the state of the art in both core computing and humancomputer interaction, and to use the knowledge so gained to support the Company’s corporate objectives. We believe this is best accomplished through interconnected pursuits in technology creation, advanced systems engineering, and business development. We are actively investigating scalable computing; mobile computing; visionbased human and scene sensing; speech interaction; computeranimated synthetic persona; intelligent information appliances; and the capture, coding, storage, indexing, retrieval, decoding, and rendering of multimedia data. We recognize and embrace a technology creation model which is characterized by three major phases: Freedom: The life blood of the Laboratory comes from the observations and imaginations of our research staff. It is here that challenging research problems are uncovered (through discussions with customers, through interactions with others in the Corporation, through other professional interactions, through reading, and the like) or that new ideas are born. For any such problem or idea, this phase culminates in the nucleation of a project team around a well articulated central research question and the outlining of a research plan. Focus: Once a team is formed, we aggressively pursue the creation of new technology based on
The Complexity of Renaming
"... We study the complexity of renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct names from a given namespace. We prove an individual lower bound of Ω(k) process steps for deterministic renaming into any namespace of size subexponential in k, whe ..."
Abstract

Cited by 15 (10 self)
 Add to MetaCart
(Show Context)
We study the complexity of renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct names from a given namespace. We prove an individual lower bound of Ω(k) process steps for deterministic renaming into any namespace of size subexponential in k, where k is the number of participants. This bound is tight: it draws an exponential separation between deterministic and randomized solutions, and implies new tight bounds for deterministic fetchandincrement registers, queues and stacks. The proof of the bound is interesting in its own right, for it relies on the first reduction from renaming to another fundamental problem in distributed computing: mutual exclusion. We complement our individual bound with a global lower bound of Ω(k log(k/c)) on the total step complexity of renaming into a namespace of size ck, for any c ≥ 1. This applies to randomized algorithms against a strong adversary, and helps derive new global lower bounds for randomized approximate counter and fetchandincrement implementations, all tight within logarithmic factors. 1
The Price of Anonymity: Optimal Consensus despite Asynchrony, Crash and Anonymity
, 2008
"... This paper addresses the consensus problem in asynchronous systems prone to process crashes, where additionally the processes are anonymous (they cannot be distinguished one from the other: they have no name and execute the same code). To circumvent the three computational adversaries (asynchrony, f ..."
Abstract

Cited by 14 (3 self)
 Add to MetaCart
This paper addresses the consensus problem in asynchronous systems prone to process crashes, where additionally the processes are anonymous (they cannot be distinguished one from the other: they have no name and execute the same code). To circumvent the three computational adversaries (asynchrony, failures and anonymity) each process is provided with a failure detector of a class denoted ψ, that gives it an upper bound on the number of processes that are currently alive (in a nonanonymous system, the classes ψ and Pthe class of perfect failure detectors are equivalent). The paper first presents a simple ψbased consensus algorithm where the processes decide in 2t + 1 asynchronous rounds (where t is an upper bound on the number of faulty processes). It then shows one of its main results, namely, 2t + 1 is a lower bound for consensus in the anonymous systems equipped with ψ. The second contribution addresses earlydecision. The paper presents and proves correct an earlydeciding algorithm where the processes decide in min(2f + 2, 2t + 1) asynchronous rounds (where f is the actual number of process failures). This leads to think that anonymity doubles the cost (wrt synchronous systems) and it is conjectured that min(2f + 2, 2t + 1) is the corresponding lower bound. The paper finally considers the kset agreement problem in anonymous systems. It first shows that the
Fast Randomized TestandSet and Renaming
"... Most people believe that renaming is easy: simply choose a name at random; if more than one process selects the same name, then try again. We highlight the issues that occur when trying to implement such a scheme and shed new light on the readwrite complexity of randomized renaming in an asynchron ..."
Abstract

Cited by 14 (8 self)
 Add to MetaCart
(Show Context)
Most people believe that renaming is easy: simply choose a name at random; if more than one process selects the same name, then try again. We highlight the issues that occur when trying to implement such a scheme and shed new light on the readwrite complexity of randomized renaming in an asynchronous environment. At the heart of our new perspective stands an adaptive implementation of a randomized testandset object, that has polylogarithmic step complexity per operation, with high probability. Interestingly, our implementation is anonymous, as it does not require process identifiers. Based on this implementation, we present two new randomized renaming algorithms. The first ensures a tight namespace of n names using O(n log 4 n) total steps, with high probability. This significantly improves on the complexity of the best previously known namespaceoptimal algorithms. The second algorithm achieves a namespace of size k(1 + ɛ) using O(k log 4 k / log 2 (1 + ɛ)) total steps, both with high probability, where k is the total contention in the execution. It is the first adaptive randomized renaming algorithm, and it improves on existing deterministic solutions by providing a smaller namespace, and by lowering step complexity.