This article is intended to provide some new insights about concurrency theory using ideas from geometry, and more specifically from algebraic topology. The aim of the paper is two-fold: we justify applications of geometrical methods in concurrency through some chosen examples and we give the mathematical foundations needed to understand the geometric phenomenon that we identify. In particular we show that the usual notion of homotopy has to be refined to take into account some partial ordering describing the way time goes. This gives rise to some new interesting mathematical problems as well as give some common grounds to computer-scientific problems that have not been precisely related otherwise in the past. The organization of the paper is as follows. In Section 2 we explain to which extent we can use some geometrical ideas in computer science: we list a few of the potential or well known areas of application and try to exemplify some of the properties of concurrent (and distributed) systems we are interested in. We first explain the interest of using some geometric ideas for semantical reasons. Then we take the example of concurrent databases with the problem of finding deadlocks and with some aspects of serializability theory. More general questions about schedules can be asked as well and related to some geometric considerations, even for scheduling micro-instructions (and not only coarse-grained transactions as for databases). The final example is the one of fault-tolerant protocols for distributed systems, where subtle scheduling properties go into play. In Section 3 we give the first few definitions needed for modeling the topological spaces arising from Section 2. Basically, we need to define a topological space containing all traces of executions of the concu...

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.

A snapshot shared memory algorithm is presented, allowing a set off+1processes, anyfof which may exhibit stopping failures, to “simulate ” a larger numbernof processes, also with at mostffailures. One application of this simulation algorithm is to convert an arbitraryk-fault-tolerantn-process solution for thek-set-agreement problem into a wait-freek+1-process solution for the same problem. Since thek+1-process k-set-agreement problem has been shown to have no wait-free solution [4, 16, 24], this transformation implies that there is nok-fault-tolerant solution to then-processk-set-agreement problem, for anyn. More generally, the algorithm satisfies the requirements of a fault-tolerant distributed simulation. The distributed simulation implements a notion of fault-tolerant reducibility between decision problems. These notions are defined, and examples of their use are provided. The algorithm is presented and verified in terms of I/O automata. The presentation has a great deal of interesting modularity, expressed by I/O automaton composition and both forward and backward simulation relations. Composition is used to include a safe agreement module as a subroutine. Forward and backward simulation relations are used to view the algorithm as implementing a multi-try snapshot strategy. The main algorithm works in snapshot shared memory systems; a simple modification of the algorithm that works in read/write shared memory systems is also presented.

) Elizabeth Borowsky (borowsky@hpl.hp.com) Hewlett-Packard Laboratories Palo-Alto, 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 shared-memory 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 wait-free...

In a shared-memory distributed system, n independent asynchronous processes communicate by reading and writing to shared memory. An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number, k, of active processes in the execution; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are inherently wait-free, providing fault-tolerance in the presence of an arbitrary number of crash failures and different processes' speed. A wait-free adaptive collect algorithm with O(k) step complexity is presented, together with its applications in wait-free adaptive algorithms for atomic snapshots, immediate snapshots and renaming. Keywords: contention-sensitive complexity, wait-free algorithms, asynchronous sharedmemory systems, read/write registers, atomic snapshots, immediate atomic snapshots, renaming. Work supported by the fund for the promotion of research in the Technion. y Department of Computer Science, The Technion, Haifa 32000, Israel. hagit@cs.technion.ac.il. z Department of Computer Science, The Technion, Haifa 32000, Israel. leonf@cs.technion.ac.il. x Computer Science Department, UCLA. eli@cs.ucla.edu. 1

We show that no algorithm exists for deciding whether a finite task for three or more processors is wait-free solvable in the asynchronous read-write shared-memory model. This impossibility result implies that there is no constructive (recursive) characterization of wait-free solvable tasks. It also applies to other shared-memory models of distributed computing, such as the comparison-based model. Key words: asynchronous distributed computation, task-solvability, wait-free computation, contractibility problem AMS subject classification: 68Q05, 68Q22 1 Introduction A fundamental area in the theory of distributed computation is the study of asynchronous wait-free shared-memory distributed algorithms. Characterizing the class of distributed tasks that can be solved, no matter how "inefficiently", is an important step towards a complexity theory for distributed computation. A breakthrough was the demonstation by Fisher, Lynch, and Paterson [FLP85] that certain simple tasks, such as cons...

Yehuda Afek Tel-Aviv University and IDC Herzliya afek@math.tau.ac.il Gideon Stupp Tel-Aviv University stupp@math.tau.ac.il Dan Touitou IBM Research Lab in Haifa Israel dant@il.ibm.com ABSTRACT Long-lived and adaptive to point contention implementations of snapshot and immediate snapshot objects in the read/write shared-memory model are presented. In [2] we presented adaptive algorithms for mutual exclusion, collect and snapshot. However, the collect and snapshot algorithms were adaptive only when the number of local primitive operations that a process performs are ignored, i.e., not counted. The number of primitive local steps (operations that do not access the shared memory) in the collect and snapshot operations presented in [2] is O(Nk ) and O(Nk ) respectively where N is the total number of processes in the system and k is the encountered contention. Here we developed new techniques that enabled us to achieve fully adaptive implementations in which the step complexity (combined local and shared) of any operation is bounded by a function of the number of processes that are concurrent with the operation, in particular, O(k ) for the snapshot implementation.

) Maurice Herlihy Computer Science Department Brown University, Providence RI 02912 herlihy@cs.brown.edu Sergio Rajsbaum y Instituto de Matem'aticas U.N.A.M., D.F. 04510, M'exico rajsbaum@servidor.unam.mx Abstract A task is a distributed coordination problem in which each process starts with a private input value taken from a finite set, communicates with the other processes by applying operations to shared objects, and eventually halts with a private output value, also taken from a finite set. A protocol is a distributed program that solves a task. A protocol is t-resilient if it tolerates failures by t or fewer processes. A task is solvable in a given model of computation if it has a t-resilient protocol in that model. A set of tasks is decidable in a given model of computation if there exists an effective procedure for deciding whether any task in that set has a t-resilient protocol. This paper gives the first necessary and sufficient conditions for task decidability in ...

. The consensus hierarchy characterizes the strength of a shared object by its ability to solve the consensus problem in a waitfree manner. A robust hierarchy has the additional property that objects at lower levels cannot be combined in any way to construct objects at higher levels of the hierarchy. Several variations of the consensus hierarchy have appeared in the literature, and it has been shown that if there is a robust hierarchy it is either Jayanti's hierarchy h r m or a coarsening of h r m . This paper shows that if non-deterministic objects are permitted to make choices drawn from the set of natural numbers and protocols are restricted to those with running times bounded by a function of input size, then the consensus hierarchy h r m is not robust. 1. Introduction The notion of consensus number, introduced by Herlihy (1991), provides a framework for comparing the power of different models of shared memory wait-free computation. Herlihy defined the consensus number of an o...

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.