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, fault-tolerance, 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.

We introduce a theory of competitive analysis for distributed algorithms. The first steps in this direction were made in the seminal papers of Bartal, Fiat, and Rabani [18], and of Awerbuch, Kutten, and Peleg [16], in the context of data management and job scheduling. In these papers, as well...

We define a novel measure of competitive performance for distributed algorithms based on throughput, the number of tasks that an algorithm can carry out in a fixed amount of work. This new measure complements the latency measure of Ajtai et al. [3], which measures how quickly an algorithm can finish tasks that start at specified times. An important property of the throughput measure is that it is modular: we define a notion of relative competitiveness with the property that a k-relatively competitive implementation of an object T using a subroutine U , combined with an l-competitive implementation of U , gives a kl-competitive algorithm for ...

The problem of performing t tasks in a distributed system on p failure-prone processors is one of the fundamental problems in distributed computing. If the tasks are similar and independent and the processors communicate by sending messages then the problem is called Do-All . In our work the communication is over a multiple-access channel, and the attached stations may fail by crashing. The measure of performance is work, defined as the number of the available processor steps. Algorithms are required to be reliable in that they perform all the tasks as long as at least one station remains operational. We show that each reliable algorithm always needs to perform at least the minimum amount t + p p t) of work. We develop an optimal deterministic algorithm for the channel with collision detection performing only the minimum work (t + p p t). Another algorithm is given for the channel without collision detection, it performs work O(t+p p t+p minff; tg), where f < p is the number of failures. It is proved to be optimal if the number of faults is the only restriction on the adversary. Finally we consider the question if randomization helps for the channel without collision detection against weaker adversaries. We develop a randomized algorithm which needs to perform only the expected minimum work if the adversary may fail a constant fraction of stations, but it has to select the failure-prone stations prior to the start of an algorithm.

The Collect problem for an asynchronous shared-memory system has the objective for the processors to learn all values of a collection of shared registers, while minimizing the total number of read and write operations. First abstracted by Saks, Shavit, and Woll [37], Collect is among the standard problems in distributed computing, The model consists of n asynchronous processes, each with a single-writer multi-reader register of a polynomial capacity. The best previously known deterministic solution performs O(n 3/2 log n) reads and writes, and it is due to Ajtai, Aspnes, Dwork, and Waarts [3]. This paper presents a new deterministic algorithm that performs O(n log 7 n) read/write operations, thus substantially improving the best previous upper bound. Using an approach based on epidemic rumor-spreading, the novelty of the new algorithm is in using a family of expander graphs and ensuring

Consider k particles, 1 red and k − 1 white, chasing each other on the nodes of a graph G. If the red one catches one of the white, it “infects ” it with its color. The newly red particles are now available to infect more white ones. When is it the case that all white will become red? It turns out that this simple question is an instance of information propagation between random walks and has important applications to mobile computing where a set of mobile hosts acts as an intermediary for the spread of information. In this paper we model this problem by k concurrent random walks, one corresponding to the red particle and k − 1 to the white ones. The infection time Tk of infecting all the white particles with red color is then a random variable that depends on k, the initial position of the particles, the number of nodes and edges of the graph, as well as on the structure of the graph. In this work we develop a set of probabilistic tools that we use to obtain upper bounds on the (worst case w.r.t. initial positions of particles) expected value of Tk for general graphs and important special cases. We easily get that an upper bound on the expected value of Tk is the worst case (over all initial positions) expected meeting time m ∗ of two random walks multiplied by Θ(log k). We demonstrate that this is, indeed, a tight bound; i.e. there is a graph G (a special case of the “lollipop ” graph), a range of values k < n (such that √ n − k = Θ ( √ n)) and an initial position of particles achieving this bound. When G is a clique or has nice expansion properties, we prove much smaller bounds for Tk. We have evaluated and validated all our results by large scale experiments which we also present and discuss here. In particular, the experiments demonstrate that our analytical results for these expander graphs are tight. Due to lack of space, an Appendix is added, to be read at the discreetion of the Program Committee members. 1

Consider a set of n processors that can communicate with each other. Assume that each processor can be either &quot;good &quot; or &quot;faulty&quot;. We wish to diagnose the system. That is, we use tests between the processors to determine the status of each processor. We suppose that good processors are accurate, but that faulty processors may be in error. We develop fast parallel diagnosis algorithms, and also use adversary arguments to prove that our algorithms are near optimal. Our models are based upon the system diagnosis model proposed by Preparata, Metze and Chien [46]. We consider three different models of diagnosis. First we have a static model in which each processor has a fixed status, there is an upper bound t on the number of faulty processors, and we wish to minimize the number of rounds of testing used to perform diagnosis. We prove that 4 rounds are necessary and sufficient when (8=3)pn ^ t ^ 0:03n (for n sufficiently large). Furthermore, at least 5 rounds are necessary when t * 0:42n (for n sufficiently large), and 10 rounds are sufficient when t! 0:5n (for all n). It is well known that no general solution is possible when t * 0:5n. Second we consider a dynamic model in which a processor may change status during the diagnosis. In each round up to t processors may break down, and we may direct that up to t processors are repaired. We show that it is possible to limit the number of faulty processors to O(t log t), even if the system is run indefinitely. We present an adversary which shows that this bound is optimal.

Abstract. This paper discusses the problem of efficient propagation of uncertain information in dynamic environments and critical situations. When a number of (distributed) agents have only partial access to information, the explanation(s) and conclusion(s) they can draw from their observations are inevitably uncertain. In this context, the efficient propagation of information is concerned with two interrelated aspects: spreading the information as quickly as possible, and refining the hypotheses at the same time. We describe a formal framework designed to investigate this class of problem, and we report on preliminary results and experiments using the described theory. 1

Rumor spreading algorithms are a useful way to disseminate information to a group of players in the presence of faults. Rumors are either spread by pushing, in which the players knowing the rumor call other players at random and spread the rumor, or by pulling, where players who do not know the rumor call other players and ask for any new rumors.