Results 1  10
of
16
A Correctness Condition for HighPerformance Multiprocessors (Extended Abstract)
, 1992
"... Hybrid consistency, a new consistency condition for shared memory multiprocessors, attempts to cap ture the guarantees provided by contemporary highperformance architectures. It combines the expreasiveneas of strong consistency conditions (e.g., sequential consistency, linearizability) and the ef ..."
Abstract

Cited by 64 (7 self)
 Add to MetaCart
Hybrid consistency, a new consistency condition for shared memory multiprocessors, attempts to cap ture the guarantees provided by contemporary highperformance architectures. It combines the expreasiveneas of strong consistency conditions (e.g., sequential consistency, linearizability) and the efficiency of weak consistency conditions (e.g., Pipelined RAM, causal memory). Memory access operations are classified as either strong or weak. A global ordering of strong operations at different processes is guaranteed, but there is very little guarantee on the ordering of weak operations at different processes, except for what is implied by their interleaving with the strong operations. A formal and precise definition of this condition is given. An efficient implementation of hybrid consistency on distributed memory machines is presented. In this implementation, weak operations are executed instantaneously, while the response time for strong operations is linear in the network delay. (It is proven that this is within a constant factor of the optimal time bounds.) To motivate hybrid consistency it is shown that weakly consistent memories do not support noncooperative (in particular, noncentralized) alg~ rithms for mutual exclusion.
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...
Reading Many Variables in One Atomic Operation Solutions With Linear or Sublinear Complexity
 IN PROCEEDINGS OF THE 5TH INTERNATIONAL WORKSHOP ON DISTRIBUTED ALGORITHMS
, 1991
"... We address the problem of reading more than one variables (components) X 1 ; : : : ; X c , all in one atomic operation, by only one process called the reader, while each of these variables are being written by a set of writers. All operations (i.e. both reads and writes) are assumed to be totally ..."
Abstract

Cited by 25 (1 self)
 Add to MetaCart
We address the problem of reading more than one variables (components) X 1 ; : : : ; X c , all in one atomic operation, by only one process called the reader, while each of these variables are being written by a set of writers. All operations (i.e. both reads and writes) are assumed to be totally asynchronous and waitfree. For this problem, only algorithms that require at best quadratic time and space complexity can be derived from the existing literature (the time complexity of a construction is the number of suboperations of a highlevel operation and its space complexity is the number of atomic shared variables it needs). In this paper, we provide a deterministic protocol which has linear (in the number of processes) space complexity, linear time complexity for a read operation and constant time complexity for a write. Our solution does not make use of timestamps. Rather, it is the memory location where a write writes that differentiates it from the other writes. Also, ...
Randomized Naming Using WaitFree Shared Variables
 DISTRIBUTED COMPUTING
, 1998
"... A naming protocol assigns unique names (keys) to every process... ..."
Abstract

Cited by 18 (2 self)
 Add to MetaCart
A naming protocol assigns unique names (keys) to every process...
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.
A Completeness Theorem for a Class of Synchronization Objects
, 1993
"... ) Yehuda Afek Eytan Weisberger Hanan Weisman y Computer Science Department, TelAviv University, Israel 69978. Abstract We study a class of synchronization objects in shared memory concurrent systems, which we call common2. This class contains readmodifywrite objects that commute (e.g. fetch ..."
Abstract

Cited by 14 (6 self)
 Add to MetaCart
) Yehuda Afek Eytan Weisberger Hanan Weisman y Computer Science Department, TelAviv University, Israel 69978. Abstract We study a class of synchronization objects in shared memory concurrent systems, which we call common2. This class contains readmodifywrite objects that commute (e.g. fetchandadd), or overwrite (e.g. swap). It is known that this class is contained in the consensus number 2 class of objects [Her91a], and most of the commonly used objects with consensus number 2 are included in it. We show that any object in the common2 class can implement any other object in the class, in a system with an arbitrary number of processes. In fact we show that the objects in common2 are implementable from any object with consensus number 2. The common2 class is in particular interesting since the strongest objects most contemporary processors support are in this class, e.g. either testandset or swap while concurrent operating systems constructs installed on any machine may us...
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 ...
The Instancy of Snapshots and Commuting Objects
 Journal of Algorithms
, 1993
"... We present a sequence of constructions of commuting synchronization objects (e.g., fetchandincrement and fetchandadd) in a system of n processors from any two processor synchronization object whose consensus number is two or more [Her91a]. Each implementation in the sequence uses a particular t ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
We present a sequence of constructions of commuting synchronization objects (e.g., fetchandincrement and fetchandadd) in a system of n processors from any two processor synchronization object whose consensus number is two or more [Her91a]. Each implementation in the sequence uses a particular type of shared memory snapshot, as a building block. Later implementations in the sequence are based on higher quality snapshots. The first implementation of a fetchandincrement uses the standard atomic snapshot concept, introduced in [AAD + 93, And90], while the last construction in the sequence, of fetchandadd, is based on the immediate snapshot concept introduced in [BG93b]. This last construction also yields an implementation of a stronger snapshot which we call Writeandsnapshot. In addition this work solves an open question of Borowsky and Gafni by presenting an implementation of a multishot immediate snapshot object. Additional implications of our constructions are: (1) The ex...