Results 11  20
of
42
A tight RMR lower bound for randomized mutual exclusion
 In Proc. of 44th ACM STOC
, 2012
"... The Cache Coherent (CC) and the Distributed Shared Memory (DSM) models are standard shared memory models, and the Remote Memory Reference (RMR) complexity is considered to accurately predict the actual performance of mutual exclusion algorithms in shared memory systems. In this paper we prove a tig ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
(Show Context)
The Cache Coherent (CC) and the Distributed Shared Memory (DSM) models are standard shared memory models, and the Remote Memory Reference (RMR) complexity is considered to accurately predict the actual performance of mutual exclusion algorithms in shared memory systems. In this paper we prove a tight lower bound for the RMR complexity of deadlockfree randomized mutual exclusion algorithms in both the CC and the DSM model with atomic registers and compare&swap objects and an adaptive adversary. Our lower bound establishes that an adaptive adversary can schedule n processes in such a way that each enters the critical section once, and the total number of RMRs is Ω(n logn / log logn) in expectation. This matches an upper bound of Hendler and Woelfel [16].
ABSTRACT An Ω(n log n) Lower Bound on the Cost of Mutual Exclusion
"... We prove an Ω(n log n) lower bound on the number of nonbusywaiting memory accesses by any deterministic algorithm solving n process mutual exclusion that communicates via shared registers. The cost of the algorithm is measured in the state change cost model, a variation of the cache coherent model. ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
(Show Context)
We prove an Ω(n log n) lower bound on the number of nonbusywaiting memory accesses by any deterministic algorithm solving n process mutual exclusion that communicates via shared registers. The cost of the algorithm is measured in the state change cost model, a variation of the cache coherent model. Our bound is tight in this model. We introduce a novel information theoretic proof technique. We first establish a lower bound on the information needed by processes to solve mutual exclusion. Then we relate the amount of information processes can acquire through shared memory accesses to the cost they incur. We believe our proof technique is flexible and intuitive, and may be applied to a variety of other problems and system models.
A New FastPath Mechanism for Mutual Exclusion
 Distributed Computing
, 1999
"... In 1993, Yang and Anderson presented an Nprocess algorithm for mutual exclusion under read/write atomicity that has \Theta(log N) time complexity, where "time" is measured by counting remote memory references. In this algorithm, instances of a twoprocess mutual exclusion algorithm are ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
(Show Context)
In 1993, Yang and Anderson presented an Nprocess algorithm for mutual exclusion under read/write atomicity that has \Theta(log N) time complexity, where "time" is measured by counting remote memory references. In this algorithm, instances of a twoprocess mutual exclusion algorithm are embedded within a binary arbitration tree. In the twoprocess algorithm that was used, all busywaiting is done by "local spinning." Performance studies presented by Yang and Anderson showed that their Nprocess algorithm exhibits scalable performance under heavy contention. One drawback of using an arbitration tree, however, is that each process is required to perform \Theta(log N) remote memory operations even when there is no contention. To remedy this problem, Yang and Anderson presented a variant of their algorithm that includes a "fastpath" mechanism that allows the arbitration tree to be bypassed in the absence of contention. This algorithm has the desirable property that contentionfre...
Operationvalency and the cost of coordination
 In Proceedings of the 22nd Annual ACM Symposium on Principles of Distributed Computing (PODC
, 2003
"... This paper introduces operationvalency, a generalization of the valency proof technique originated by Fischer, Lynch, and Paterson. By focusing on critical events that influence the return values of individual operations rather then on critical events that influence a protocol's single return ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
This paper introduces operationvalency, a generalization of the valency proof technique originated by Fischer, Lynch, and Paterson. By focusing on critical events that influence the return values of individual operations rather then on critical events that influence a protocol's single return value, the new technique allows us to derive a collection of realistic lower bounds for lockfree implementations of concurrent objects such as linearizable queues, stacks, sets, hash tables, shared counters, approximate agreement, and more. By realistic we mean that they follow the realworld model introduced by Dwork, Herlihy, and Waarts, counting both memoryreferences and memorystalls due to contention, and that they allow the combined use of read, write, and readmodifywrite operations available on current machines. By using the operationvalency technique, we derive an f~(X/~) noncached shared memory accesses lower bound on the worstcase time complexity of lockfree implementations of objects in Influence(n), a wide class of concurrent objects including all of those mentioned above, in which an individual operation can be influenced by all others. We also prove the existence of a fundamental relationship between the space complexity, latency, contention, and &quot;influence level &quot; of any lockfree object implementation. Our results are broad in that they hold for implementations combining read/write memory and any collection of readmodifywrite operations, and in that they apply even if shared memory words have unbounded size.
On the Inherent Weakness of Conditional Synchronization Primitives
 In Proceedings of the 23rd Annual ACM Symposium on Principles of Distributed Computing
, 2004
"... The “waitfree hierarchy ” classifies multiprocessor synchronization primitives according to their power to solve consensus. The classification is based on assigning a number n to each synchronization primitive, where n is the maximal number of processes for which deterministic waitfree consensus c ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
(Show Context)
The “waitfree hierarchy ” classifies multiprocessor synchronization primitives according to their power to solve consensus. The classification is based on assigning a number n to each synchronization primitive, where n is the maximal number of processes for which deterministic waitfree consensus can be solved using instances of the primitive and read write registers. Conditional synchronization primitives, such as compareandswap and loadlinked/storeconditional, can implement deterministic waitfree consensus for any number of processes (they have consensus number ∞), and are thus considered to be among the strongest synchronization primitives. To some extent because of that, compareandswap and loadlinked/storeconditional have became the synchronization primitives of choice, and have been implemented in hardware in many multiprocessor architectures. This paper shows that, though they are strong in the context of consensus, conditional synchronization primitives are not efficient in terms of memory space for implementing many key objects. Our results hold for starvationfree implementations of mutual exclusion, and for waitfree implementations of a large class of concurrent objects, that we call Visible(n). Roughly, Visible(n) is a class that includes all objects that support some operation that must perform a “visible”
ON THE INHERENT SEQUENTIALITY OF CONCURRENT OBJECTS
"... Abstract. We present Ω(n) lower bounds on the worst case time to perform a single instance of an operation in any nonblocking implementation of a large class of concurrent data structures shared by n processes. Time is measured by the number of stalls a process incurs as a result of contention with ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We present Ω(n) lower bounds on the worst case time to perform a single instance of an operation in any nonblocking implementation of a large class of concurrent data structures shared by n processes. Time is measured by the number of stalls a process incurs as a result of contention with other processes. For standard data structures such as counters, stacks, and queues, our bounds are tight. The implementations considered may apply any primitives to a base object. No upper bounds are assumed on either the number of base objects or their size.
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.
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 3 (0 self)
 Add to MetaCart
(Show Context)
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.
Group mutual exclusion in O(log n) RMR
 In Proceeding of the 29th ACM SIGACTSIGOPS symposium on Principles of distributed computing, PODC ’10
, 2010
"... We present an algorithm to solve the GROUP MUTUAL EXCLUSION problem in the cachecoherent (CC) model. For the same problem in the distributed shared memory (DSM) model, Danek and Hadzilacos presented algorithms of O(n) remote memory references (RMR) and proved a matching lower bound, where n is th ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We present an algorithm to solve the GROUP MUTUAL EXCLUSION problem in the cachecoherent (CC) model. For the same problem in the distributed shared memory (DSM) model, Danek and Hadzilacos presented algorithms of O(n) remote memory references (RMR) and proved a matching lower bound, where n is the number of processes. We show that in the CC model, using registers and LL/SC variables, our algorithm achievesO(min(logn, k)) RMR, where k is the point contention, which is so far the best. Moreover, given a recent result of Attiya, Hendler and Woelfel showing that exclusion problems have aΩ(logn)RMR lower bound using registers, comparison primitives and LL/SC variables, our algorithm thus achieves the best theoretical bound. Categories and Subject Descriptors D [Software]: Programming Techniques—Concurrent Programming