Results 1  10
of
36
Contention in Shared Memory Algorithms
, 1993
"... Most complexitymeasures for concurrent algorithms for asynchronous sharedmemory architectures focus on process steps and memory consumption. In practice, however, performance of multiprocessor algorithms is heavily influenced by contention, the extent to which processes access the same location at t ..."
Abstract

Cited by 63 (1 self)
 Add to MetaCart
Most complexitymeasures for concurrent algorithms for asynchronous sharedmemory architectures focus on process steps and memory consumption. In practice, however, performance of multiprocessor algorithms is heavily influenced by contention, the extent to which processes access the same location at the same time. Nevertheless, even though contention is one of the principal considerations affecting the performance of real algorithms on real multiprocessors, there are no formal tools for analyzing the contention of asynchronous sharedmemory algorithms. This paper introduces the first formal complexity model for contention in multiprocessors. We focus on the standard multiprocessor architecture in which n asynchronous processes communicate by applying read, write, and readmodifywrite operations to a shared memory. We use our model to derive two kinds of results: (1) lower bounds on contention for well known basic problems such as agreement and mutual exclusion, and (2) tradeoffs betwe...
Reactive Synchronization Algorithms for Multiprocessors
"... Synchronization algorithms that are efficient across a wide range of applications and operating conditions are hard to design because their performance depends on unpredictable runtime factors. The designer of a synchronization algorithm has a choice of protocols to use for implementing the synchro ..."
Abstract

Cited by 50 (2 self)
 Add to MetaCart
Synchronization algorithms that are efficient across a wide range of applications and operating conditions are hard to design because their performance depends on unpredictable runtime factors. The designer of a synchronization algorithm has a choice of protocols to use for implementing the synchronization operation. For example, candidate protocols for locks include testandset protocols and queueing protocols. Frequently, the best choice of protocols depends on the level of contention: previous research has shown that testandset protocols for locks outperform queueing protocols at low contention, while the opposite is true at high contention. This paper investigates reactive synchronization algorithms that dynamically choose protocols in response to the level of contention. We describe reactive algorithms for spin locks and fetchandop that choose among several sharedmemory and messagepassing protocols. Dynamically choosing protocols presents a challenge: a reactive algorithm needs to select and change protocols efficiently, and has to allow for the possibility that multiple processes may be executing different protocols at the same time. We describe the notion of consensus objects that the reactive algorithms use to preserve correctness in the face of dynamic protocol changes. Experimental measurements demonstrate that reactive algorithms perform close to the best static choice of protocols at all levels of contention. Furthermore, with mixed levels of contention, reactive algorithms outperform passive algorithms with fixed protocols, provided that contention levels do not change too frequently. Measurements of several parallel applications show that reactive algorithms result in modest performance gains for spin locks and significant gains for fetchandop.
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 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 41 (12 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.
Adaptive Waitfree Algorithms for Lattice Agreement and Renaming (Extended Abstract)
 In Proceedings of the 17th Annual ACM Symposium on Principles of Distributed Computing
, 1998
"... ) Hagit Attiya and Arie Fouren Department of Computer Science The Technion, Haifa 32000, Israel Abstract This paper considers waitfree algorithms whose complexity is constant in the absence of contention, and grows gradually as the number of active processes increases. An algorithm is fast if its ..."
Abstract

Cited by 37 (8 self)
 Add to MetaCart
) Hagit Attiya and Arie Fouren Department of Computer Science The Technion, Haifa 32000, Israel Abstract This paper considers waitfree algorithms whose complexity is constant in the absence of contention, and grows gradually as the number of active processes increases. An algorithm is fast if its complexity depends on the maximal number of active processes, K, and not on the total number of processes in the system, n. An algorithm is adaptive if its complexity depends only on the actual number of active processes, k, which is unknown in advance and may change in different executions of the algorithm. It is shown that two important decision problems, lattice agreement and renaming with linear name space, have adaptive solutions using only read and write operations. An O(k log k) adaptive algorithm for lattice agreement and an O(k log k) adaptive algorithm for (6k \Gamma 1)renaming are presented. These algorithms are constructed from several subalgorithms, which are interesting in t...
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
TimeAdaptive Algorithms for Synchronization
 SIAM J. Comput
, 1994
"... We consider concurrent systems in which there is an unknown upper bound on memory access time. Such a model is inherently different from asynchronous model where no such bound exists, and also from timingbased models where such a bound exists and is known a priori. The appeal of our model lies in t ..."
Abstract

Cited by 27 (6 self)
 Add to MetaCart
We consider concurrent systems in which there is an unknown upper bound on memory access time. Such a model is inherently different from asynchronous model where no such bound exists, and also from timingbased models where such a bound exists and is known a priori. The appeal of our model lies in the fact that while it abstracts from implementation details, it is a better approximation of real concurrent systems compared to the asynchronous model. Furthermore, it is stronger than the asynchronous model enabling us to design algorithms for problems that are unsolvable in the asynchronous model. Two basic synchronization problems, consensus and mutual exclusion, are investigated in a shared memory environment that supports atomic read/write registers. We show that \Theta(\Delta log \Delta log log \Delta ) is an upper and lower bound on the time complexity of consensus, where \Delta is the (unknown) upper bound on memory access time. For the mutual exclusion problem, we design an effic...
Backoff protocols for distributed mutual exclusion and ordering
 Proceedings of the 21st International Conference on Distributed Computing Systems
, 2001
"... We present a simple and efficient protocol for mutual exclusion in synchronous, messagepassing distributed systems subject to failures. Our protocol borrows design principles from prior work in backoff protocols for multiple access channels such as Ethernet. Our protocol is adaptive in that the exp ..."
Abstract

Cited by 27 (11 self)
 Add to MetaCart
We present a simple and efficient protocol for mutual exclusion in synchronous, messagepassing distributed systems subject to failures. Our protocol borrows design principles from prior work in backoff protocols for multiple access channels such as Ethernet. Our protocol is adaptive in that the expected amortized system response time— informally, the average time a process waits before entering the critical section—is a function only of the number of clients currently contending and is independent of the maximum number of processes who might contend. In particular, in the contentionfree case, a process can enter the critical section after only one roundtrip message delay. We use this protocol to derive a protocol for ordering operations on a replicated object in an asynchronous distributed system subject to failures. This protocol is always safe, is probabilistically live during periods of stability, and is suitable for deployment in practical systems. 1
A time complexity bound for adaptive mutual exclusion
 In Proceedings of the 15th International Symposium on Distributed Computing
, 2001
"... ..."