Results 1  10
of
22
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 40 (11 self)
 Add to MetaCart
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.
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 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.
SpaceOptimal MultiWriter Snapshot Objects Are Slow
 In Proceedings of the 21st Annual ACM Symposium on Principles of Distributed Computing
, 2002
"... We consider the problem of waitfree implementation of a multiwriter snapshot object with m >= 2 components shared by n > m processes. It is known that this can be done using m multiwriter registers. We give a matching lower bound, slightly improving the previous space lower bound. The main ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
We consider the problem of waitfree implementation of a multiwriter snapshot object with m >= 2 components shared by n > m processes. It is known that this can be done using m multiwriter registers. We give a matching lower bound, slightly improving the previous space lower bound. The main focus of the paper, however, is on time complexity. The best known upper bound on the number of steps a process has to take to perform one operation of the snapshot is O(n). When m is much smaller than n, an implementation whose time complexity is a function of m rather than n would be better. We show that this cannot be achieved for any spaceoptimal implementation: We prove that \Omega\Gamma n) steps are required to perform a SCAN operation in the worst case, even if m = 2. This significantly improves previous \Omega\Gammavio (m; n)) lower bounds. Our proof also yields insight into the structure of any spaceoptimal implementation, showing that processes simulating the snapshot operations must access the registers in a very constrained way.
Uniform solvability with a finite number of mwmr registers
 In Proceedings of the 17th International Conference on Distributed Computing
, 2003
"... Abstract. This paper introduces a new interesting research question concerning tasks. The weaktestandset task has a uniform solution that requires only two MultiWriter MultiReader (MWMR) registers. Recently it was shown that if we take the longlived version and require a step complexity that i ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
Abstract. This paper introduces a new interesting research question concerning tasks. The weaktestandset task has a uniform solution that requires only two MultiWriter MultiReader (MWMR) registers. Recently it was shown that if we take the longlived version and require a step complexity that is adaptive to interval contention then, like mutual exclusion, no solution with finitely many MWMR registers is possible. Here we show that there are simple tasks which provably cannot be solved uniformly with finitely many MWMR registers. This opens up the research question of when a task is uniformly solvable using only finitely many MWMR registers. 1
A Tight Time Lower Bound for SpaceOptimal Implementations of MultiWriter Snapshots
 In Proceedings of the 35th ACM Symposium on Theory of Computing
, 2003
"... A snapshot object consists of a collection of m > 1 components, each capable of storing a value, shared by n processes in an asynchronous sharedmemory distributed system. It supports two operations: a process can UPDATE any individual component or atomically SCAN the entire collection to obtain ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
A snapshot object consists of a collection of m > 1 components, each capable of storing a value, shared by n processes in an asynchronous sharedmemory distributed system. It supports two operations: a process can UPDATE any individual component or atomically SCAN the entire collection to obtain the values of all the components. It is possible to implement a snapshot object using m registers so that each operation takes O(mn) time.
Lower bounds for adaptive collect and related objects
 In Proc. 23 Annual ACM Symp. on Principles of Distributed Computing
, 2004
"... An adaptive algorithm, whose step complexity adjusts to the number of active processes, is attractive for situations in which the number of participating processes is highly variable. This paper studies the number and type of multiwriter registers that are needed for adaptive algorithms. We prove th ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
An adaptive algorithm, whose step complexity adjusts to the number of active processes, is attractive for situations in which the number of participating processes is highly variable. This paper studies the number and type of multiwriter registers that are needed for adaptive algorithms. We prove that if a collect algorithm is fadaptive to total contention, namely, its step complexity is f(k), where k is the number of processes that ever tooka step, then it uses Ω(f −1 (n)) multiwriter registers, where n is the total number of processes in the system. Furthermore, we show that competition for the underlying registers is inherent for adaptive collect algorithms. We consider cwrite registers, to which at most c processes can be concurrently about to write. Special attention is given to exclusivewrite registers, the case c = 1 where no competition is allowed, and concurrentwrite registers, the case c = n where any amount of competition is allowed. A collect algorithm is fadaptive to point contention, if its step complexity is f(k), where k is the maximum number of simultaneously active processes. Such an algorithm is shown to require Ω(f −1 ( n c)) concurrentwrite registers, even if an unlimited number of cwrite registers are available. A smaller lower bound is also obtained in this situation for collect algorithms that are fadaptive to total contention. The lower bounds also hold for nondeterministic implementations of sensitive objects from historyless objects. Finally, we present lower bounds on the step complexity in solo executions (i.e., without any contention), when only cwrite registers are used: For weaktest&set objects, we log n present an Ω() lower bound. Our lower bound log c+log log n for collect and sensitive objects is Ω ( n−1 c).
Can Memory be used adaptively by Uniform Algorithms
 Proc. 9th International Conference on Principles of Distributed Systems (OPODIS
, 2005
"... Abstract. We introduce a novel term, memoryadaptive, that intuitively captures what it means for a distributed protocol to most efficiently make use of its shared memory. We also prove three results that relate to our memoryadaptive model. In our store/release protocols processors are required to ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Abstract. We introduce a novel term, memoryadaptive, that intuitively captures what it means for a distributed protocol to most efficiently make use of its shared memory. We also prove three results that relate to our memoryadaptive model. In our store/release protocols processors are required to store a value in shared MWMR memory so that it cannot be overwritten until it has been released by the processor. We show that there do not exist uniformly waitfree store/release protocols using only the basic operations read and write that are memoryadaptive to point contention. We further show that there exists a uniformly waitfree store/release protocol using only the basic operations read and write that is memoryadaptive to total contention. We finally show that there exists a uniformly waitfree store/release protocol using only the basic operations read, write, and writeplus that is memoryadaptive to interval contention and timeadaptive to total contention. 1
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 2 (0 self)
 Add to MetaCart
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.
A Time Complexity Lower Bound for Adaptive Mutual Exclusion ∗
, 2007
"... We consider the time complexity of adaptive mutual exclusion algorithms, where “time ” is measured by counting the number of remote memory references required per criticalsection access. For systems that support (only) read, write, and comparison primitives (such as compareandswap), we establish ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We consider the time complexity of adaptive mutual exclusion algorithms, where “time ” is measured by counting the number of remote memory references required per criticalsection access. For systems that support (only) read, write, and comparison primitives (such as compareandswap), we establish a lower bound that precludes a deterministic algorithm with o(k) time complexity, where k is point contention. In particular, it is impossible to construct a deterministic O(log k) algorithm based on such primitives.