Results 1  10
of
30
Sharedmemory mutual exclusion: Major research trends since
 Distributed Computing
, 1986
"... * Exclusion: At most one process executes its critical section at any time. ..."
Abstract

Cited by 47 (7 self)
 Add to MetaCart
* Exclusion: At most one process executes its critical section at any time.
Adaptive mutual exclusion with local spinning
 In Proceedings of the 14th International Symposium on Distributed Computing
, 2000
"... Abstract We present an adaptive algorithm for Nprocess mutual exclusion under read/write atomicity in which all busy waiting is by local spinning. In our algorithm, each process p performs O(k) remote memory references to enter and exit its critical section, where k is the maximum "point conte ..."
Abstract

Cited by 43 (12 self)
 Add to MetaCart
Abstract We present an adaptive algorithm for Nprocess mutual exclusion under read/write atomicity in which all busy waiting is by local spinning. In our algorithm, each process p performs O(k) remote memory references to enter and exit its critical section, where k is the maximum "point contention " experienced by p. The space complexity of our algorithm is \Theta (N), which is clearly optimal. Our algorithm is the first mutual exclusion algorithm under read/write atomicity that is adaptive when time complexity is measured by counting remote memory references. All previous socalled adaptive mutual exclusion algorithms employ busywaiting loops that can generate an unbounded number of remote memory references. Thus, they have unbounded time complexity under this measure.
An Adaptive Collect Algorithm with Applications
 Distributed Computing
, 2001
"... In a sharedmemory distributed system, n independent asynchronous processes communicate by reading and writing to shared memory. An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number, k, of active processes in the execution; this number is unknown ..."
Abstract

Cited by 32 (10 self)
 Add to MetaCart
In a sharedmemory distributed system, n independent asynchronous processes communicate by reading and writing to shared memory. An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number, k, of active processes in the execution; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are inherently waitfree, providing faulttolerance in the presence of an arbitrary number of crash failures and different processes' speed. A waitfree adaptive collect algorithm with O(k) step complexity is presented, together with its applications in waitfree adaptive algorithms for atomic snapshots, immediate snapshots and renaming. Keywords: contentionsensitive complexity, waitfree algorithms, asynchronous sharedmemory systems, read/write registers, atomic snapshots, immediate atomic snapshots, renaming. Work supported by the fund for the promotion of research in the Technion. y Department of Computer Science, The Technion, Haifa 32000, Israel. hagit@cs.technion.ac.il. z Department of Computer Science, The Technion, Haifa 32000, Israel. leonf@cs.technion.ac.il. x Computer Science Department, UCLA. eli@cs.ucla.edu. 1
A time complexity bound for adaptive mutual exclusion
 In Proceedings of the 15th International Symposium on Distributed Computing
, 2001
"... ..."
Adaptive and Efficient Algorithms for Lattice Agreement and Renaming
 SIAM J. Comput
, 1998
"... In a sharedmemory system, n independent asynchronous processes, with distinct names in the range {0, ..., N  1}, communicate by reading and writing to shared registers. An algorithm is waitfree if a process completes its execution regardless of the behavior of other processes. This paper consider ..."
Abstract

Cited by 22 (7 self)
 Add to MetaCart
In a sharedmemory system, n independent asynchronous processes, with distinct names in the range {0, ..., N  1}, communicate by reading and writing to shared registers. An algorithm is waitfree if a process completes its execution regardless of the behavior of other processes. This paper considers waitfree algorithms whose complexity adjusts to the level of contention in the system: An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number of active processes, k; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are presented for two important decision problems, lattice agreement and (6k  1)renaming; the step complexity of both algorithms is O(k log k). An interesting component of the (6k  1)renaming algorithm is an O(N) algorithm for (2k  1)renaming; this improves on the best previously known (2k  1)renaming algorithm, which has O(Nnk) s...
Adaptive LongLived Renaming Using Bounded Memory (Extended Abstract)
 PROC. OF THE 40TH IEEE ANN. SYMP. ON FOUNDATIONS OF COMPUTER SCIENCE
, 1999
"... This paper addresses the properties and design of longlived adaptive algorithms in the read/write shared memory model. In particular we present adaptive and longlived algorithms that adapt to the point contention of an operation while using only a bounded amount of memory. We believe the techn ..."
Abstract

Cited by 19 (7 self)
 Add to MetaCart
This paper addresses the properties and design of longlived adaptive algorithms in the read/write shared memory model. In particular we present adaptive and longlived algorithms that adapt to the point contention of an operation while using only a bounded amount of memory. We believe the techniques and building blocks developed here to be of further use in the design of adaptive and longlived algorithms. We use the renaming problem as a testcase to demonstrate the new techniques and properties. Three new implementations of adaptive, waitfree, and longlived renaming in the read/write shared memory model are presented. Unlike previous algorithms [1] the three algorithms require a bounded number of registers and adapt to the point contention of an operation. The two previous algorithms presented in [1] either adapt to the point contention or use a bounded size memory...
LongLived and Adaptive Atomic Snapshot and Immediate Snapshot (Extended Abstract)
, 2000
"... Yehuda Afek TelAviv University and IDC Herzliya afek@math.tau.ac.il Gideon Stupp TelAviv University stupp@math.tau.ac.il Dan Touitou IBM Research Lab in Haifa Israel dant@il.ibm.com ABSTRACT Longlived and adaptive to point contention implementations of snapshot and immediate snapshot ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
Yehuda Afek TelAviv University and IDC Herzliya afek@math.tau.ac.il Gideon Stupp TelAviv University stupp@math.tau.ac.il Dan Touitou IBM Research Lab in Haifa Israel dant@il.ibm.com ABSTRACT Longlived and adaptive to point contention implementations of snapshot and immediate snapshot objects in the read/write sharedmemory model are presented. In [2] we presented adaptive algorithms for mutual exclusion, collect and snapshot. However, the collect and snapshot algorithms were adaptive only when the number of local primitive operations that a process performs are ignored, i.e., not counted. The number of primitive local steps (operations that do not access the shared memory) in the collect and snapshot operations presented in [2] is O(Nk ) and O(Nk ) respectively where N is the total number of processes in the system and k is the encountered contention. Here we developed new techniques that enabled us to achieve fully adaptive implementations in which the step complexity (combined local and shared) of any operation is bounded by a function of the number of processes that are concurrent with the operation, in particular, O(k ) for the snapshot implementation.
Nonatomic Mutual Exclusion with Local Spinning (Extended Abstract)
, 2002
"... We present an Nprocess localspin mutual exclusion algorithm, based on nonatomic reads and writes, in which each process performs \Theta (log N) remote memory references to enter and exit its critical section. This algorithm is derived from Yang and Anderson's atomic treebased localspin algorit ..."
Abstract

Cited by 13 (3 self)
 Add to MetaCart
We present an Nprocess localspin mutual exclusion algorithm, based on nonatomic reads and writes, in which each process performs \Theta (log N) remote memory references to enter and exit its critical section. This algorithm is derived from Yang and Anderson's atomic treebased localspin algorithm in a way that preserves its time complexity. No atomic read/write algorithm with better asymptotic worstcase time complexity (under the remotememoryreferences measure) is currently known. This suggests that atomic memory is not fundamentally required if one is interested in worstcase time complexity. The same cannot be said if one is interested in fastpath algorithms (in which contentionfree time complexity is required to be O(1)) or adaptive algorithms (in which time complexity is required to be proportional to the number of contending processes). We show that such algorithms fundamentally require memory accesses to be atomic. In particular, we show that for any Nprocess nonatomic algorithm, there exists a singleprocess execution in which the lone competing process executes \Omega (log N / log log N) remote operations to enter its critical section. Moreover, these operations must access \Omega (plog N / log log N) distinct variables, which implies that fast and adaptive algorithms are impossible even if caching techniques are used to avoid accessing the processorstomemory interconnection network.
A Simple Algorithmic Characterization of Uniform Solvability (Extended Abstract)
 Proceedings of the 43rd Annual IEEE Symposium on Foundations of Computer Science (FOCS 2002
, 2002
"... The HerlihyShavit (HS) conditions characterizing the solvability of asynchronous tasks over n processors have been a milestone in the development of the theory of distributed computing. Yet, they were of no help when researcher sought algorithms that do not depend on n. To help in this pursuit we i ..."
Abstract

Cited by 11 (6 self)
 Add to MetaCart
The HerlihyShavit (HS) conditions characterizing the solvability of asynchronous tasks over n processors have been a milestone in the development of the theory of distributed computing. Yet, they were of no help when researcher sought algorithms that do not depend on n. To help in this pursuit we investigate the uniform solvability of an infinite uniform sequence of tasks T 0 , T 1 , T 2 , ..., where T i is a task over processors p 0 , p 1 , ..., p i , and T i extends T i1 . We say that such a sequence is uniformly solvable if there exit protocols to solve each T i and the protocol for T i extends the protocol for T i1 . This paper establishes that although each T i may be solvable, the uniform sequence is not necessarily uniformly solvable. We show this by proposing a novel uniform sequence of solvable tasks and proving that the sequence is not amenable to a uniform solution. We then extend the HS conditions for a task over n processors, to uniform solvability in a natural way. The technique we use to accomplish this is to generalize the alternative algorithmic proof, by Borowsky and Gafni, of the HS conditions, by showing that the infinite uniform sequence of task of Immediate Snapshots is uniformly solvable. A side benefit of the technique is a widely applicable methodology for the development of uniform protocols.
FullyAdaptive Algorithms for LongLived Renaming
"... Abstract. Longlived renaming allows processes to repeatedly get distinct names from a small name space and release these names. This paper presents two longlived renaming algorithms in which the name a process gets is bounded above by the number of processes currently occupying a name or performing ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
Abstract. Longlived renaming allows processes to repeatedly get distinct names from a small name space and release these names. This paper presents two longlived renaming algorithms in which the name a process gets is bounded above by the number of processes currently occupying a name or performing one of these operations. The first is asynchronous, uses LL/SC objects, and has step complexity that is linear in the number of processes, c, currently getting or releasing a name. The second is synchronous, uses registers and counters, and has step complexity that is polylogarithmic in c. Both tolerate any number of process crashes. 1