Results 1  10
of
18
Contention in Shared Memory Algorithms
, 1993
"... 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 t ..."
Abstract

Cited by 63 (1 self)
 Add to MetaCart
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 sharedmemory 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 readmodifywrite 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) tradeoffs betwe...
On the Space Complexity of Randomized Synchronization
 Journal of the ACM
, 1993
"... The "waitfree hierarchy" provides a classification of multiprocessor synchronization primitives based on the values of n for which there are deterministic waitfree implementations of nprocess consensus using instances of these objects and readwrite registers. In a randomized waitfree setting, t ..."
Abstract

Cited by 39 (9 self)
 Add to MetaCart
The "waitfree hierarchy" provides a classification of multiprocessor synchronization primitives based on the values of n for which there are deterministic waitfree implementations of nprocess consensus using instances of these objects and readwrite registers. In a randomized waitfree setting, this classification is degenerate, since nprocess consensus can be solved using only O(n) readwrite registers. In this paper, we propose a classification of synchronization primitives based on the space complexity of randomized solutions to nprocess consensus. A historyless object, such as a readwrite 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 nprocess consensus. This lower bound holds even if the objects have unbounded size and the termination requirement is nondeterministi...
Concurrent Timestamping Made Simple
 Proceedings of Israel Symposium on Theory of Computing and Systems
, 1995
"... Concurrent Timestamp 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 m ..."
Abstract

Cited by 26 (1 self)
 Add to MetaCart
Concurrent Timestamp 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 multiwriter multireader atomic registers. Solutions to these problems all use an "unbounded number" based concurrent timestamp system (uctss), a construction which is as simple to use as it is to understand. A bounded "blackbox" 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 DolevShavit ctss axioms, which have been widely criticized as "hardtouse." 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...
Bounded Concurrent TimeStamping
 SIAM JOURNAL ON COMPUTING
, 1997
"... We introduce concurrent timestamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous sharedmemory system. Concurrent timestamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
We introduce concurrent timestamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous sharedmemory system. Concurrent timestamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, lexclusion, randomized consensus, and multiwriter multireader atomic registers. Unfortunately, all previously known methods for implementing concurrent timestamp systems have been theoretically unsatisfying since they require unboundedsize timestamps  in other words, unboundedsize memory. This work presents the first bounded implementation of a concurrent timestamp system, providing a modular unboundedtobounded 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 fifolexclusion problem of Fischer, Lynch, Burns and...
Spreading Rumors Rapidly Despite an Adversary
 J. ALGORITHMS
, 1998
"... In the collect problem [32], n processors in a sharedmemory 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 ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
In the collect problem [32], n processors in a sharedmemory 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 contentoblivious 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 multiuse 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.
Bounded Concurrent Timestamp Systems Using Vector Clocks
 J. ACM
, 2002
"... Shared registers are basic objects used as communication mediums in asynchronous concurrent computation. A concurrent timestamp system is a higher typed communication object, and has been shown to be a powerful tool to solve many concurrency control problems. It has turned out to be possible to cons ..."
Abstract

Cited by 14 (2 self)
 Add to MetaCart
Shared registers are basic objects used as communication mediums in asynchronous concurrent computation. A concurrent timestamp system is a higher typed communication object, and has been shown to be a powerful tool to solve many concurrency control problems. It has turned out to be possible to construct such higher typed objects from primitive lower typed ones. The next step is to find efficient constructions. We propose a very efficient waitfree construction of bounded concurrent timestamp systems from 1writer shared registers. This finalizes, corrects, and extends a preliminary bounded multiwriter construction proposed by the second author in 1986. That work partially initiated the current interest in waitfree concurrent objects, and introduced a notion of discrete vector clocks in distributed algorithms.
Modular Competitiveness for Distributed Algorithms
 In Proc. 28th ACM Symp. on Theory of Computing (STOC
, 2000
"... 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 ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
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 krelatively competitive implementation of an object T using a subroutine U , combined with an lcompetitive implementation of U , gives a klcompetitive algorithm for ...
Towards a practical snapshot algorithm
 Theoretical Computer Science
, 1995
"... Abrtraci An atomic rnaprhoi memory is an implementation of a multiple location shared memory that can be atomidly read in its entirety without having to prevent concurrent writing. The design of waitfree implementations of atomic ruaprht memoner has been the subject of extensive theoretical res ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
Abrtraci An atomic rnaprhoi memory is an implementation of a multiple location shared memory that can be atomidly read in its entirety without having to prevent concurrent writing. The design of waitfree implementations of atomic ruaprht memoner has been the subject of extensive theoretical research in recent years. This paper introducem the coordinatedcolleci algorithm, a novel waitfree atomic 8napshot construction which we believe b a flrst step in taking snapshots from theory to practice. Unlike former algorithms, it uses currently available multiproceasor 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 sharedmemory multiprocessor shows that coordinatedcollect outperforms all known waitfree, lockfree, and locking algorithms in terms of overall throughput and latency.
SelfStabilizing lExclusion
, 2001
"... Our work presents a selfstabilizing solution to the lexclusion problem. This problem is a wellknown generalization of the mutualexclusion problem in which up to l, but never more than l, processes are allowed simultaneously in their critical sections. Selfstabilization means that even when trans ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
Our work presents a selfstabilizing solution to the lexclusion problem. This problem is a wellknown generalization of the mutualexclusion 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 singlewriter multiplereader regular registers.
Binary Snapshots
 In Proc. of the 7th International Workshop on Distributed Algorithms
, 1993
"... This paper considers the shared memory waitfree 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 lineartime implementation of the general multibit atomic snapshot object ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
This paper considers the shared memory waitfree 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 lineartime 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) waitfree 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, waitfree implementations Note: Partially supported by the Dutch foundation for scientific research (NWO) through NFI Project ALADDIN, under contract number NF 62376 1. Introduction Consider a concurrent shared memory system. A snapshot memory object shared between n processes is a vector o...