Results 1  10
of
24
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 61 (6 self)
 Add to MetaCart
(Show Context)
* Exclusion: At most one process executes its critical section at any time.
An Improved Lower Bound for the Time Complexity of Mutual Exclusion (Extended Abstract)
 IN PROCEEDINGS OF THE 20TH ANNUAL ACM SYMPOSIUM ON PRINCIPLES OF DISTRIBUTED COMPUTING
, 2001
"... We establish a lower bound of 23 N= log log N) remote memory references for Nprocess mutual exclusion algorithms based on reads, writes, or comparison primitives such as testandset and compareand swap. Our bound improves an earlier lower bound of 32 log N= log log log N) established by Cyph ..."
Abstract

Cited by 45 (11 self)
 Add to MetaCart
(Show Context)
We establish a lower bound of 23 N= log log N) remote memory references for Nprocess mutual exclusion algorithms based on reads, writes, or comparison primitives such as testandset and compareand swap. Our bound improves an earlier lower bound of 32 log N= log log log N) established by Cypher. Our lower bound is of importance for two reasons. First, it almost matches the (log N) time complexity of the bestknown algorithms based on reads, writes, or comparison primitives. Second, our lower bound suggests that it is likely that, from an asymptotic standpoint, comparison primitives are no better than reads and writes when implementing localspin mutual exclusion algorithms. Thus, comparison primitives may not be the best choice to provide in hardware if one is interested in scalable synchronization.
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 ..."
Abstract

Cited by 41 (8 self)
 Add to MetaCart
(Show Context)
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...
A time complexity bound for adaptive mutual exclusion
 In Proceedings of the 15th International Symposium on Distributed Computing
, 2001
"... ..."
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 al ..."
Abstract

Cited by 16 (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 generic framework for reasoning about dynamic networks of infinitestate processes
 In TACAS’07, volume 4424 of Lecture Notes in Computer Science
, 2007
"... Abstract. We propose a framework for reasoning about unbounded dynamic networks of infinitestate processes. We propose Constrained Petri Nets (CPN) as generic models for these networks. They can be seen as Petri nets where tokens (representing occurrences of processes) are colored by values over so ..."
Abstract

Cited by 14 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We propose a framework for reasoning about unbounded dynamic networks of infinitestate processes. We propose Constrained Petri Nets (CPN) as generic models for these networks. They can be seen as Petri nets where tokens (representing occurrences of processes) are colored by values over some potentially infinite data domain such as integers, reals, etc. Furthermore, we define a logic, called CML (colored markings logic), for the description of CPN configurations. CML is a firstorder logic over tokens allowing to reason about their locations and their colors. Both CPNs and CML are parametrized by a color logic allowing to express constraints on the colors (data) associated with tokens. We investigate the decidability of the satisfiability problem of CML and its applications in the verification of CPNs. We identify a fragment of CML for which the satisfiability problem is decidable (whenever it is the case for the underlying color logic), and which is closed under the computations of post and pre images for CPNs. These results can be used for several kinds of analysis such as invariance checking, prepost condition reasoning, and bounded reachability analysis. 1.
Efficiency of Partial Synchrony, and Resource Allocation in Distributed Systems.
, 1994
"... This dissertation is in two parts, covering two distinct areas of distributed computing. The first part concerns timing models in distributed systems that lie between the synchronous and asynchronous models in terms of their assumption on synchrony. We study their time complexity for solving distrib ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
This dissertation is in two parts, covering two distinct areas of distributed computing. The first part concerns timing models in distributed systems that lie between the synchronous and asynchronous models in terms of their assumption on synchrony. We study their time complexity for solving distributed computing problems in shared memory (SM) and messagepassing (MP) systems. We consider four timing parameters: the upper and lower bounds on process step time and message delay. Timing models are obtained by considering independently whether each parameter is known (i.e., is hardwired into processes' code) or unknown, giving rise to four SM models and 16 MP models. We also study other timing models that are not covered by this framework. We show a general time complexity hierarchy indicating inherent time complexity gaps among the models. The time complexity gaps are introduced by the time complexity of the session problem, an abstraction of fundamental synchronization problems in dist...
On the power of shared object types to implement oneresilient Consensus
, 2000
"... In this paper we study the ability of shared object types to implement Consensus in asynchronous sharedmemory systems where at most one process may crash. More specifically, we consider the following question: Let n 3 and S be a set of object types that can be used to solve oneresilient Consen ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
In this paper we study the ability of shared object types to implement Consensus in asynchronous sharedmemory systems where at most one process may crash. More specifically, we consider the following question: Let n 3 and S be a set of object types that can be used to solve oneresilient Consensus among n processes. Can S always be used to solve oneresilient Consensus among n \Gamma 1 processes? We prove that for n = 3 the answer is negative, even if S consists only of deterministic types. (This strengthens an earlier result by the first author proving the same fact for nondeterministic types.) We also prove that, in contrast, for n ? 3 the answer to the above question is affirmative.
Timingbased mutual exclusion with local spinning
 In 17th international symposium on distributed computing, October 2003. LNCS 2848
, 2003
"... Abstract We consider the time complexity of sharedmemory mutual exclusion algorithms based on reads, writes, and comparison primitives under the remotememoryreference (RMR) time measure. For asynchronous systems, a lower bound of \Omega (log N / log log N) RMRs per criticalsection entry has been ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
Abstract We consider the time complexity of sharedmemory mutual exclusion algorithms based on reads, writes, and comparison primitives under the remotememoryreference (RMR) time measure. For asynchronous systems, a lower bound of \Omega (log N / log log N) RMRs per criticalsection entry has been established in previous work, where N is the number of processes. Also, algorithms with O(log N) time complexity are known. Thus, for algorithms in this class, logarithmic or nearlogarithmic RMR time complexity is fundamentally required.