Results 1 
7 of
7
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 67 (6 self)
 Add to MetaCart
(Show Context)
* Exclusion: At most one process executes its critical section at any time.
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 17 (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.
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.
Algorithms, Performance
"... Lockfreedom is a progress guarantee that ensures overall program progress. Waitfreedom is a stronger progress guarantee that ensures the progress of each thread in the program. While many practical lockfree algorithms exist, waitfree algorithms are typically inefficient and hardly used in practi ..."
Abstract
 Add to MetaCart
Lockfreedom is a progress guarantee that ensures overall program progress. Waitfreedom is a stronger progress guarantee that ensures the progress of each thread in the program. While many practical lockfree algorithms exist, waitfree algorithms are typically inefficient and hardly used in practice. In this paper, we propose a methodology called fastpathslowpath for creating efficient waitfree algorithms. The idea is to execute the efficient lockfree version most of the time and revert to the waitfree version only when things go wrong. The generality and effectiveness of this methodology is demonstrated by two examples. In this paper, we apply this idea to a recent construction of a waitfree queue, bringing the waitfree implementation to perform in practice as efficient as the lockfree implementation. In another work, the fastpathslowpath methodology has been used for (dramatically) improving the performance of a waitfree linkedlist.
Appendix A
, 61
"... or AED 512 color graphics terminal arch2rad  convert Architrion text file to RADIANCE description calc  calculator cnt  index counter dayfact  compute illuminance and daylight factor on workplane ev  evaluate expressions falsecolor  make a false color RADIANCE picture findglare  locate glare ..."
Abstract
 Add to MetaCart
or AED 512 color graphics terminal arch2rad  convert Architrion text file to RADIANCE description calc  calculator cnt  index counter dayfact  compute illuminance and daylight factor on workplane ev  evaluate expressions falsecolor  make a false color RADIANCE picture findglare  locate glare sources in a RADIANCE scene genbox  generate a RADIANCE description of a box genprism  generate a RADIANCE description of a prism genrev  generate a RADIANCE description of surface of revolution gensky  generate a RADIANCE description of the sky gensurf  generate a RADIANCE description of a functional surface genworm  generate a RADIANCE description of a functional worm getbbox  compute bounding box for RADIANCE scene getinfo  get header information from a RADIANCE file glare  perform glare and visual comfort calculations glarendx  calculate glare index ies2rad  convert IES luminaire data to RADIANCE description lam  laminate lines of multiple files lampcolor  compute spectral r
Time Complexity Bounds for Sharedmemory Mutual Exclusion
, 2001
"... The primary goal of my work is to close the gap between lower and upper bounds on the time complexity of the mutual exclusion problem in sharedmemory multiprocessor systems. Mutual exclusion algorithms are used to resolve conicting accesses to shared resources by asynchronous, concurrent process ..."
Abstract
 Add to MetaCart
(Show Context)
The primary goal of my work is to close the gap between lower and upper bounds on the time complexity of the mutual exclusion problem in sharedmemory multiprocessor systems. Mutual exclusion algorithms are used to resolve conicting accesses to shared resources by asynchronous, concurrent processes. The problem of designing such an algorithm is widely regarded as the preeminent \classic" problem in concurrent programming. In this proposal, the time complexity of a mutual exclusion algorithm is dened as the number of remote memory references generated by a process to enter and exit its critical section. Under this measure, constanttime algorithms are known that use primitives such as fetchandadd and fetchandstore. However, it has been shown that no such constanttime algorithm is possible that uses reads, writes, and comparison primitives. My dissertation aims to provide optimal time bounds for algorithms based on such primitives. 1
A Practical SingleRegister WaitFree Mutual Exclusion Algorithm on Asynchronous Networks
"... Abstract. This paper is motivated by a need of practical asynchronous network systems, i.e., a waitfree distributed mutual exclusion algorithm (WDME). The WDME algorithm is very appealing when a process runs on asynchronous network systems and its timing constraint is so restricted that the process ..."
Abstract
 Add to MetaCart
Abstract. This paper is motivated by a need of practical asynchronous network systems, i.e., a waitfree distributed mutual exclusion algorithm (WDME). The WDME algorithm is very appealing when a process runs on asynchronous network systems and its timing constraint is so restricted that the process cannot perform a localspin in a waitqueue, which forces it to abort whenever it cannot access the critical region immediately. The WDME algorithm proposed in this paper is devised to eliminate the need for processes to send messages to determine whether the critical region has been entered by another process, an unfavorable drawback of a naive transformation of the sharedmemory mutual exclusion algorithm to an asynchronous network model. This drawback leads to an unbounded message explosion, and it is very critical in real network systems. Design of the WDME algorithm is simple, and the algorithm is practical enough to be used in current distributed systems. The algorithm has O(1) message complexity which is suboptimal between two consecutive runs of critical section. 1