) Hagit Attiya and Arie Fouren Department of Computer Science The Technion, Haifa 32000, Israel Abstract This paper considers wait-free algorithms whose complexity is constant in the absence of contention, and grows gradually as the number of active processes increases. An algorithm is fast if its complexity depends on the maximal number of active processes, K, and not on the total number of processes in the system, n. An algorithm is adaptive if its complexity depends only on the actual number of active processes, k, which is unknown in advance and may change in different executions of the algorithm. It is shown that two important decision problems, lattice agreement and renaming with linear name space, have adaptive solutions using only read and write operations. An O(k log k) adaptive algorithm for lattice agreement and an O(k log k) adaptive algorithm for (6k \Gamma 1)-renaming are presented. These algorithms are constructed from several subalgorithms, which are interesting in t...

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.

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

In the long-lived renaming problem --- a generalization of the classical one-time renaming problem --- n processors with unique names ranging over a source name space f0; : : : ; S \Gamma 1g repeatedly acquire and release unique names from a (smaller) destination name space f0; : : : ; D \Gamma 1g. It is assumed that at most k out of n processors concurrently request or hold names. An efficient renaming protocol provides a useful front-end for protocols whose time complexity depends on the size of the name space containing the participating processes. We consider long-lived renaming in the context of asynchronous, shared-memory multiprocessing systems that provide only read and write operations. A renaming protocol is fast iff the time complexity of acquiring and releasing a name is polynomial in k and independent of n and S. We present a wait-free, read/write protocol for long-lived renaming that achieves a destination name space of size O(k 2 ) with time complexity O(k 3 ). If ...

This paper addresses the properties and design of long-lived adaptive algorithms in the read/write shared memory model. In particular we present adaptive and long-lived algorithms that adapt to the point contention of an operation while using only a bounded amount of memory. We believe the techniques and building blocks developed here to be of further use in the design of adaptive and long-lived algorithms. We use the renaming problem as a test-case to demonstrate the new techniques and properties. Three new implementations of adaptive, wait-free, and long-lived renaming in the read/write shared memory model are presented. Unlike previous algorithms [1] the three algorithms require a bounded number of registers and adapt to the point contention of an operation. The two previous algorithms presented in [1] either adapt to the point contention or use a bounded size memory...

This paper presents an adaptive algorithm for long-lived renaming using only read and write operations. A process p i obtains a new name in the range f1; : : : ; k(2k \Gamma 1)g, where k is the maximal number of processes simultaneously participating with p i ; the number of steps performed by p i is O(k 2 log k). The range of names is reduced to f1; : : : ; 6k \Gamma 1g, by employing the algorithm of Burns and Peterson. 1 Introduction Distributed coordination algorithms are designed to accommodate a large number of processes, each with a distinct identifier; in order to coordinate, processes must obtain up-to-date information from each other. A wait-free algorithm guarantee that a process completes its operation within a finite number of its own steps regardless of the behavior of other processes; in a typical wait-free algorithm, information is collected by reading from an array indexed with process' identifiers. This scheme is an over-kill in a well-designed system where often ...

In a shared-memory 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 wait-free if a process completes its execution regardless of the behavior of other processes. This paper considers wait-free 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...

We present the first shared-memory algorithms for k-exclusion in which all process blocking is achieved through the use of "local-spin" busy waiting. Such algorithms are designed to reduce interconnect traffic, which is important for good performance. Our k-exclusion algorithms are starvation-free, and are designed to be fast in the absence of contention, and to exhibit scalable performance as contention rises. In contrast, all previous starvation-free k-exclusion algorithms require unrealistic operations or generate excessive interconnect traffic under contention. We also show that efficient, starvation-free k-exclusion algorithms can be used to reduce the time and space overhead associated with existing wait-free shared object implementations, while still providing some resilience to delays and failures. The resulting "hybrid" object implementations combine the advantages of local-spin spin locks, which perform well in the absence of process delays (caused, for example, by preemptio...

In the long-lived M-renaming problem, N processes repeatedly acquire and release names ranging over f0; :::; M \Gamma 1g, where M ! N . It is assumed that at most k M processes concurrently request or hold names. Efficient solutions to the long-lived renaming problem can be used to improve the performance of applications in which processes repeatedly perform computations whose time complexity depends on the size of the name space containing the processes that participate concurrently. In this paper, we consider wait-free solutions to the long-lived M-renaming problem that use only read and write instructions in an asynchronous, shared-memory multiprocessor. A solution to long-lived renaming is fast if the time complexity of acquiring and releasing a name once is independent of N . We present a new fast, longlived (k(k +1)=2)-renaming algorithm that significantly improves upon the time and space complexity of similar previous algorithms, while providing a much simpler solution. We al...

this paper we were able to define and implement a variant of the Moir-Anderson splitter that does not have all the properties that their splitter has but on the other hand, has an adaptive and long-lived implementation. Furthermore, we use this splitter as a building block in constructions other than a grid (for example a row of splitters or a tree of splitters) and in this way implement diverse applications such as mutual exclusion and optimal name space renaming