In the classical consensus problem, each of n processors receives a private input value and produces a decision value which is one of the original input values, with the requirement that all processors decide the same value. A central result in distributed computing is that, in several standard models including the asynchronous shared-memory model, this problem has no deterministic solution. The k-set agreement problem is a generalization of the classical consensus proposed by Chaudhuri [ Inform. and Comput., 105 (1993), pp. 132--158], where the agreement condition is weakened so that the decision values produced may be different, as long as the number of distinct values is at most k. For $n>k\geq 2$ it was not known whether this problem is solvable deterministically in the asynchronous shared memory model. In this paper, we resolve this question by showing that for any k < n, there is no deterministic wait-free protocol for n processors that solves the k-set agreement problem. The proof technique is new: it is based on the development of a topological structure on the set of possible processor schedules of a protocol. This topological structure has a natural interpretation in terms of the knowledge of the processors of the state of the system. This structure reveals a close analogy between the impossibility of wait-free k-set agreement and the Brouwer fixed point theorem for the k-dimensional ball.

Wait-Free k -Set Agreement is Impossible: The Topology of Public Knowledge

We are interested in implementing data structures on shared memory multiprocessors. A natural model for these machines is an asynchronous parallel machine, in which the processors are subject to arbitrary delays. On such machines, it is desuable for algorithms to be loclc-free, that is, they must allow concurrent access to data without using mutual exclusion. Eflicient lock-free implementations are known ror some specific data structures, but these algorithms do not generalize weIl to other structures. For most data structures, the only previously known lock-free algorithm is due to Herlihy [12]. Herlihy presents a simple methodology to create a lock-free implementation of a general data structure, but his approach can be very expensive. We present a technique that provides the semantics of exclusive access to data without using mutual exclusion. Using this technique, we devise the caching method, a general method of implementing lock-free data structures that is provably bett er than Herlihy's methodology for many weIl-known data structures. The cost of one operation using the caching method is proportional to TlogT, where T is the sequential cost of the operation. Under Herlihy's methodology, the cost is proportional to T + C, where C is the time needed to make a logical copy of the data structure. For many data struetures, such as arrays and weil connected pointer-based structures (e.g., a doubly linked list), the best known value for Cis proportional to the size ofthe structure, making the copying time much larger than the sequential cost of an operation. The new method can also allow concurrent updates to the data structurej Herlihy's methodology cannot. A correct lock-free implementation can be derived from a correct sequential implementation in a straightforward manner using this method. The method is also fiexiblej a programmer can change many of the details of the default implementation to optimize for a particular pattern of data structure use.

/pdf/a-method-for-implementing-lock-free-shared-data-structures-5baiu7mt4p.pdf

A method for implementing lock-free shared-data structures

Harnessing the massively parallel architectures soon to become available into efficient algorithmic cooperation is one of the most important intellectual challenges facing Computer Science today. To the theoretician, the task seems similar to thiat of understanding the issues involved in the performance of sequential algorithms (which motivated Knuth’s books, among other important works), only mfinitely more complex. In sequential computation, th.e design process involves (a) choosing an algorithm and (b) analyzing it (mostly, counting its steps). In the parallel context, however, we have at least four stages: (1) Choose the algorithm (say, a directed acyclic graph (dag) indicating the elementary computations and their interdependence, a model in which evaluation of sequential performance is trivial). (2) Choose a particular multiprocessor architecture. (3) Find a schedule whereby the algorithm is executed on the processors (so that all necessary data a:re available at the appropriate processor at the time of each computation). (4) Only now can we talk about the performance of the algorithm, measured as the makespan of the schedule (elapsed time for computing the last result). In our opinion, it is this multi-layered nature of the problem that lies at the heart of the difficulties encountered in the development of the necessary ideas, principles, and tools for the design of parallel algorithms. Is there a way to shortcut the process, thus improving our chances of finally gaining some insight into parallel algorithms? It would be very interesting if we could combine stages (3) and (4) into a single step whereby the performance of the algorithm cho-

Towards an Architecture-Independent Analysis of Parallel Algorithms (Extended Abstract)

We are interested in designing efficient data structures for a shared memory multiprocessor. In this paper we focus on the union-find data structure. Our machine model is asynchronous and allows stopping faults. Thus we require our solutions to the data structure problem have the wait-free property, meaning that each thread continues to make progress on its operations, independent of the speeds of the other threads. In this model efficiency is best measured in terms of the total number of instructions used to perform a sequence of data structure operations, the work performed by the processors. We give a wait-free implementation of an efficient algorithm for union-find. In addition we show that the worst case performance of the algorithm can be improved by simulating a synchronized algorithm, or by simulating a larger machine if the data structure requests support sufficient parallelism. Our solutions apply to a much more general adversary model than has been considered by other

Wait-free parallel algorithms for the union-find problem

The time complexity of wait-free algorithms in “normal” executions, where no failures occur and processes operate at approximately the same speed, is considered. A lower bound of log n on the time complexity of any wait-free algorithm that achieves approximate agreement among n processes is proved. In contrast, there exists a non-wait-free algorithm that solves this problem in constant time. This implies an O(log n) time separation between the wait-free and non-wait-free computation models. On the positive side, we present an O(log n) time wait-free approximate agreement algorithm; the complexity of this algorithm is within a small constant of the lower bound.

Are wait-free algorithms fast?

This paper studies the implicit costs of synchronization and the possible gains arising from avoiding synchronization in asynchronous environments. An asynchronous generalization of the PRAM model called the APRAM model is used and appropriate complexity measures are defined. The advantage that asynchrony provides is illustrated by analyzing two algorithms: a parallel summation algorithm which proceeds along an implicit complete binary tree and a recursive doubling algorithm which proceeds along a linked list.

O. Zajicek

Papers

The Expected Advantage of Asynchrony

The Expected Advantage of Asynchrony