Gadi Taubenfeld

Computing with Infinitely Many Processes

We explore four classic problems in concurrent computing (election, mutual exclusion, consensus, and naming) when the number of processes which may participate is infinite. Partial information about the number of actually participating processes and the concurrency level is shown to affect the possibility and complexity of solving these problems. We survey and generalize work carried out in models with finite bounds on the number of processes, and prove several new results. These include improved bounds for election when participation is required and a new adaptive algorithm for starvation-free mutual exclusion in a model with unbounded concurrency. We also explore models where objects stronger than atomic registers, such as test&set bits, semaphores or read-modify-write registers, are used.

The concurrency hierarchy, and algorithms for unbounded concurrency

We study wait-free computation using (read/write) shared memory under a range of assumptions on the arrival pattern of processes. We distinguish first between bounded and infinite arrival patterns, and further distinguish these models by restricting the number of arrivals minus departures, the concurrency. Under the condition that no process takes infinitely many steps without terminating, for any finite bound k > 0, we show that bounding concurrency reveals a strict hierarchy of computational models: a model in which concurrency is bounded by k + 1 is strictly weaker than the model in which concurrency is bounded by k, for all k ≱ 1. A model in which concurrency is bounded in each run, but no bound holds for all runs, is shown to be weaker than a k-bounded model for any k. The unbounded model is shown to be weaker still—in this model, finite prefixes of runs have bounded concurrency, but runs are admitted for which no finite bound holds over all prefixes. Hence, as the concurrency grows, the set of solvable problems strictly shrinks. Nevertheless, on the positive side, we demonstrate that many interesting problems (collect, snapshot, renaming) are solvable even in the infinite arrival, unbounded concurrency model. This investigation illuminates relations between notions of wait-free solvability distinguished by arrival pattern, and notions of adaptive, one-shot, and long-lived solvability.

Results about fast mutual exclusion

A fast mutual exclusion algorithm where only five accesses to the shared memory are needed in order to enter a critical section in the absence of contention is presented. In the presence of contention, the winning process may need to delay itself for 3* Delta time units, where Delta is an upper bound on the time taken by the slowest process to execute a statement involving an access to the shared memory. It is also proven that there is not two (or more) process mutual exclusion algorithm with an upper bound on the number of times a winning process needs to access the shared memory in order to enter its critical section in the presence of contention. However, under the assumption that busy-waiting counts as just one step, the authors present, for every fixed parameter k, an algorithm with the property that from a state where no process tries to enter its critical section, as long as the number of contenders does not exceed k, the time complexity of the winning process is a linear function of k. Finally, the ideas from the mutual exclusion algorithm are used to implement a fast and simple consensus algorithm.<<ETX>>

Speeding Lamport's fast mutual exclusion algorithm

Abstract A linked list is used to speed up a mutual exclusion algorithm. This optimization permits additional concurrency by allowing scans of the list to be concurrent with insertions and deletions of list entries.

Computing with infinitely many processes

We explore four classic problems in concurrent computing (election, mutual exclusion, consensus, and naming) when the number of processes which may participate is unbounded. Partial information about the number of processes actually participating and the concurrency level is shown to affect the computability and complexity of solving these problems when using only atomic registers. We survey and generalize work carried out in models with known bounds on the number of processes, and prove several new results. These include improved bounds for election when participation is required and a new adaptive starvation-free mutual exclusion algorithm for unbounded concurrency. We also survey results in models with shared objects stronger than atomic registers, such as test&set bits, semaphores or read-modify-write registers, and update them for the unbounded case.

Computing with faulty shared memory

This paper addresses problems which arise in the synchronization and coordination of distributed systems which employ unreliable shared memory. We present algorithms which solve the consensus problem, and which simulate reliable shared-memory objects, despite the fact that the available memory objects (e.g. read/write registers, test-and-set registers, read-modify-write registers) may be faulty.

Computing with faulty shared objects

This paper investigates the effects of the failure of shared objects on distributed systems. First the notion of a faulty shared object is introduced. Then upper and lower bounds on the space complexity of implementing reliable shared objects are provided, Shared object failures are modeled as instantaneous and arbitraty changes to the state of the object. Several constructions of nonfaulty wait-free shared objects from a set of shared objects, some of which may suffer any number of faults, are presented. Three of these constructions are: (1) A reliable atomic read/write register from 20~ + 8 atomic read/write registers ~ of which may be faulty, (2) a reliable test& set register for n processes from n + 10 primitive test & set registers, one of which may be faulty, and 3n + 13 reliable atomic registers, and (3) a reliable consensus object from 2f + 1read-modify-write registers when f of these may be faulty. Using these constructions a universal construction of any linearizable shared object from a set of either A preliminary version of the results presented in this paper appeared in Proceedings of the llth Annual ACM Symposium on Principles of Distributed Computing (Vancouver, B. C., Canada, Aug.

Possibility and impossibility results in a shared memory environment

We focus on unreliable asynchronous shared memory model which support only atomic read and write operations. For such a model we provide a necessary condition for the solvability of problems in the presence of multiple undetectable crash failures. Also, by using game-theoretical notions, a necessary and sufficient condition is provided, for the solvability of problems in the presence of multiple undetectable initial failures (i.e., processes may fail only prior to the execution).Our results imply that many problems such as consensus, choosing a leader, ranking, matching and sorting are unsolvable in the presence of a single crash failure, and that variants of these problems are solvable in the presence of a single crash failure, and that variants of these problems are solvable in the presence of t-1 crash failures but not in the presence of t crash failures.We show that a shared memory model can simulate various message passing models, and hence our impossibility results hold also for those message passing models. Our results extend and generalize previously known impossibility results for various asynchronous models.

Automatic discovery of mutual exclusion algorithms

We present a methodology for automatic discovery of synchronization algorithms. We built a tool and used it to automatically discover hundreds of new algorithms for the well-known problem of mutual exclusion. The methodology is rather simple and the fact that it is computationally feasible is surprising. Our brute force approach may require (even for short algorithms) the mechanical verification of hundreds of millions of incorrect algorithms before a correct algorithm is found. Although many new interesting algorithms have been found, we think the main contribution of this work is in demonstrating that the approach suggested for automatic discovery of (correct) synchronization algorithms is feasible.

The Black-White Bakery Algorithm and Related Bounded-Space, Adaptive, Local-Spinning and FIFO Algorithms

A mutual exclusion algorithm is presented that has four desired properties: (1) it satisfies FIFO fairness, (2) it satisfies local-spinning, (3) it is adaptive, and (4) it uses finite number of bounded size atomic registers. No previously published algorithm satisfies all these properties. In fact, it is the first algorithm (using only atomic registers) which satisfies both FIFO and local-spinning, and it is the first bounded space algorithm which satisfies both FIFO and adaptivity.