Most complexitymeasures for concurrent algorithms for asynchronous sharedmemory architectures focus on process steps and memory consumption. In practice, however, performance of multiprocessor algorithms is heavily influenced by contention, the extent to which processes access the same location at the same time. Nevertheless, even though contention is one of the principal considerations affecting the performance of real algorithms on real multiprocessors, there are no formal tools for analyzing the contention of asynchronous shared-memory algorithms. This paper introduces the first formal complexity model for contention in multiprocessors. We focus on the standard multiprocessor architecture in which n asynchronous processes communicate by applying read, write, and read-modify-write operations to a shared memory. We use our model to derive two kinds of results: (1) lower bounds on contention for well known basic problems such as agreement and mutual exclusion, and (2) trade-offs betwe...

The "wait-free hierarchy" provides a classification of multiprocessor synchronization primitives based on the values of n for which there are deterministic wait-free implementations of n-process consensus using instances of these objects and read-write registers. In a randomized wait-free setting, this classification is degenerate, since n-process consensus can be solved using only O(n) read-write registers. In this paper, we propose a classification of synchronization primitives based on the space complexity of randomized solutions to n-process consensus. A historyless object, such as a read-write register, a swap register, or a test&set register, is an object whose state depends only on the last nontrivial operation that was applied to it. We show that, using historyless objects,\Omega\Gamma p n) object instances are necessary to solve n-process consensus. This lower bound holds even if the objects have unbounded size and the termination requirement is non-deterministi...

Concurrent Time-stamp Systems (ctss) allow processes to temporally order concurrent events in an asynchronous shared memory system, a powerful tool for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, `-exclusion, randomized consensus, and multi-writer multi-reader atomic registers. Solutions to these problems all use an "unbounded number" based concurrent time-stamp system (uctss), a construction which is as simple to use as it is to understand. A bounded "black-box" replacement of uctss would imply equally simple bounded solutions to most of these extensively researched problems. Unfortunately, while all know applications use uctss, all existing solution algorithms are only proven to implement the Dolev-Shavit ctss axioms, which have been widely criticized as "hard-to-use." While it is easy to show that a uctss implements the ctss axioms, there is no proof that a system meeting the ctss axioms implements uctss. Thus, the pro...

In the collect problem [32], n processors in a shared-memory system must each learn the values of n registers. We give a randomized algorithm that solves the collect problem in O(n log 3 n) total read and write operations with high probability, even if timing is under the control of a content-oblivious adversary (a slight weakening of the usual adaptive adversary). This improves on both the trivial upper bound of O(n 2 ) steps and the best previously known bound of O(n 3=2 log n) steps, and is close to the lower bound of \Omega\Gamma n log n) steps. Furthermore, we show how this algorithm can be used to obtain a multi-use cooperative collect protocol that is O(log 3 n)-competitive in the latency model of Ajtai et al.[3] and O(n 1=2 log 3=2 n)-competitive in the throughput model of Aspnes and Waarts [10]; in both cases the competitive ratios are within a polylogarithmic factor of optimal.

We introduce concurrent time-stamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous shared-memory system. Concurrent time-stamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, l-exclusion, randomized consensus, and multiwriter multireader atomic registers. Unfortunately, all previously known methods for implementing concurrent timestamp systems have been theoretically unsatisfying since they require unbounded-size time-stamps -- in other words, unbounded-size memory. This work presents the first bounded implementation of a concurrent time-stamp system, providing a modular unbounded-to-bounded transformation of the simple unbounded solutions to problems such as those mentioned above. It allows solutions to two formerly open problems, the boundedprobabilistic -consensus problem of Abrahamson and the fifo-l-exclusion problem of Fischer, Lynch, Burns and...

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 ...

Our work presents a self-stabilizing solution to the l-exclusion problem. This problem is a well-known generalization of the mutual-exclusion problem in which up to l, but never more than l, processes are allowed simultaneously in their critical sections. Selfstabilization means that even when transient failures occur and some processes crash, the system finally resumes its regular and correct behavior. The model of communication assumed here is that of shared memory, in which processes use single-writer multiple-reader regular registers.

Abrtraci- An atomic rnaprhoi memory is an implementation of a multiple location shared memory that can be atom-idly read in its entirety without having to prevent con-current writing. The design of wait-free implementations of atomic ruaprht memoner has been the subject of exten-sive theoretical research in recent years. This paper in-troducem the coordinated-colleci algorithm, a novel wait-free atomic 8napshot construction which we believe b a flrst step in taking snapshots from theory to practice. Unlike former algorithms, it uses currently available multiprocea-sor syncbronuation operations to provide an algorithm that has only 0(1) update complexity and O(n) scan complexity, with very small constants. Empirical evidence collected on a simulated dmtributed shared-memory multiprocessor shows that coordinated-collect outperforms all known wait-free, lock-free, and locking algorithms in terms of overall throughput and latency.

This paper considers the shared memory wait-free atomic snapshot object in its simplest form where each cell contains a single bit. We demonstrate the `universality' of this binary snapshot object by presenting an efficient linear-time implementation of the general multibit atomic snapshot object using an atomic binary snapshot object as a primitive. Thus, the search for an efficient (subquadratic or linear time) wait-free atomic snapshot implementation may be restricted to the binary case. AMS Subject Classification (1991): 68M10, 68Q22, 68Q25 CR Subject Classification (1991): B.3.2, B.4.3, C.1.2, D.1.3, D.4.1, E.1 Keywords & Phrases: snapshot, shared memory, atomicity, linearisability, wait-free implementations Note: Partially supported by the Dutch foundation for scientific research (NWO) through NFI Project ALADDIN, under contract number NF 62-376 1. Introduction Consider a concurrent shared memory system. A snapshot memory object shared between n processes is a vector o...

This paper presents a solution to the first-come, first-enabled `-exclusion problem of [?]. Unlike the solution in [?], this solution does not use powerful read-modify-write synchronization primitives, and requires only bounded shared memory. Use of the concurrent timestamp system of [?] is key in solving the problem within bounded shared memory. Categories and Subject Descriptors: D.4.1 [Operating Systems]: Process Management---Mutual